Share
Koa.js è una struttura web espressiva di prossima generazione scritta per Node.js dalle persone dietro i framework Express e Connect. Koa.js sfrutta i generatori, che sono una funzionalità all'avanguardia di JavaScript e non sono ancora stati trasformati in versioni stabili di Node.js. Koa punta a utilizzare i generatori per salvare gli sviluppatori dagli spaghetti di callback, rendendoli meno soggetti a errori e quindi più gestibili.
Con solo 550 linee di codice, Koa è una struttura estremamente leggera. Anche dopo, Koa racchiude in un'elegante suite di metodi come la negoziazione dei contenuti, i reindirizzamenti, il supporto proxy, ecc., Offrendo facilità e velocità di sviluppo insieme al controllo granulare sull'applicazione del nodo.
Ora prima di iniziare, è necessario avere almeno la versione del nodo 0.11.x o maggiore.
Puoi installare l'ultima versione di Node usando il modulo N:
sudo npm install -g n sudo n stable
Puoi anche usare altri moduli della comunità come nvm o costruirlo dal sorgente. Si noti che N è anche un modulo di comunità.
Per eseguire un file JS che fa uso di generatori, è necessario fornire il file --armonia bandiera quando lo esegui.
Ad esempio, per correre app.js, inserisci il seguente comando:
node --harmony app.js
O per evitare che tu possa inserire questo flag ogni volta, puoi creare un alias usando il seguente comando:
alias node = "node --harmony"
Ora per eseguire l'applicazione utilizzando i generatori, inserisci:
nodo app.js
Molto buona! Tieni inoltre presente che tutto il codice in questo articolo è disponibile su GitHub. Sentiti libero di giocare e giocare con esso.
Ora per capire Koa, devi prima capire i generatori che formano la spina dorsale della struttura.
Con ES-6, i generatori sono finalmente atterrati nella magica terra di JavaScript. Se hai precedenti esperienze con generatori in Lua, Python, Scheme, Smalltalk ecc., Allora saresti felice di sapere che una cosa molto simile è stata implementata in JavaScript.
I generatori sono delle co-routines di prima classe in JavaScript che, in poche parole, introducono un'interfaccia di pausa e di gioco nella lingua. Prima dei generatori, l'intero script era solito generalmente eseguire in un ordine dall'alto al basso, senza un modo semplice per fermare l'esecuzione del codice e riprendere con lo stesso stack più tardi. Ora ci sporchiamo le mani con alcuni esempi.
In base all'attuale progetto di specifiche ES-6, è necessario utilizzare una versione diversa della definizione della funzione per creare una funzione generatore. Sembra questo:
var generator_func = function * () ;
Qui generator_func è solo una funzione di generatore vuota.
Quindi quello che possiamo fare è usare il dare la precedenza parola chiave nella funzione per interrompere l'esecuzione e salvare lo stack corrente.
Ecco un semplice esempio che dimostra la somma di un AP infinito:
var r = 3; function * infinite_ap (a) for (;;) a = a + r; cedere a; var sum = infinite_ap (5); console.log (sum.next ()); // restituisce valore: 8, fatto: falso console.log (sum.next ()); // restituisce valore: 11, fatto: falso
Nel codice precedente, inizialmente creiamo un'istanza iteratore chiamata infinite_ap che include un ciclo infinito e se eseguito in condizioni normali, può bloccare l'esecuzione.
Successivamente memorizziamo un'istanza iteratore nel somma variabile.
Ora quando chiamiamo sum.next (), ritorna valore: 8, fatto: falso il che significa che ha interrotto la sua esecuzione sul dare la precedenza dichiarazione che restituisce il valore come 'a' e fatto come 'falso' .
Qui fatto restituisce false fino a quando l'esecuzione non è terminata. Una volta completata l'esecuzione (nel caso precedente, non succede mai) la funzione ritorna value: undefined, done: true .
Ecco una piccola modifica del codice precedente per dimostrare la fine dell'esecuzione:
var r = 3; function * infinite_ap (a) for (var i = 0; i < 3 ; i++) a = a + r ; yield a; var sum = infinite_ap(5); console.log(sum.next()); // returns value : 8, done : false console.log(sum.next()); // returns value : 11, done: false console.log(sum.next()); // returns value : 14, done: false console.log(sum.next()); //return value: undefined, done: true
Nei programmi più complessi, verificherai e utilizzerai i valori restituiti e fatto stato.
Nota: Uso dare la precedenza senza funzione* porterebbe a un errore precoce.
Ecco alcuni metodi comuni che ti torneranno utili quando gestisci i generatori di vaniglia.
Ciascuno dei metodi seguenti è disponibile solo in una funzione di generatore e genererebbe un errore in caso contrario.
Accentsconagua
Il prossimo()Questo è usato per riprendere l'esecuzione e passare un argomento. Se non viene passato nulla, allora viene passato un indefinito come primo argomento.
Esempio: sum.next (5);
gettare()Viene utilizzato per generare un errore o un'eccezione in qualsiasi passaggio. Rende molto più semplice la gestione degli errori. Lanciare un errore può comportare l'interruzione dell'esecuzione del file, se non viene gestito da qualche parte. Il modo più semplice per gestire un errore è utilizzare un'istruzione try and catch. Questo metodo accetta un singolo argomento che può essere qualsiasi cosa.
Esempio: sum.throw (new Error ("questo è un errore"));
dare la precedenzaLa delega del generatore viene utilizzata per generare un generatore da un generatore esistente e può essere utilizzato per comporre generatori o anche iterare su un generatore.
In caso di delega a un altro generatore, il generatore di corrente smette di produrre un valore stesso e inizia a generare i valori del generatore delegato finché non viene esaurito. All'esaurimento del generatore delegato, il generatore riprende a restituire il proprio valore.
È molto simile all'utilizzo di a per-in loop su un generatore, ma le eccezioni del generatore delegato vengono propagate e generate attraverso il generatore esterno gettare metodo e dovrebbe essere gestito allo stesso modo. Ecco un esempio:
var consoleLogThunk = function (msg) return function () console.log (msg); var generator = function * () yield consoleLogThunk ("Yo"); yield consoleLogThunk ("Dawg"); yield consoleLogThunk ("!!!"); var delegator_function = function * () yield consoleLogThunk ("I yielded before yield delegated"); yield * generator (); yield consoleLogThunk ("I yielded after yield delegated"); var k = delegator_function (); k.next () valore ().; k.next () valore ().; k.next () valore ().; console.log (k.next ()); // Se chiami k.next (), genererà un errore di tipo, poiché il valore non è definito che non è una funzione Ora che hai una breve comprensione dei generatori in Javascript, puoi usarli per scrivere applicazioni molto più chiare e meno soggette a errori in cui puoi bloccare l'I / O, senza in realtà bloccare il processo.
Passiamo ora all'installazione di Koa e ad un'applicazione molto semplice basata su Koa.js.
Koa è un oggetto che contiene una serie di funzioni di generatore di middleware, che sono tutte composte ed eseguite in modo simile a una pila per ogni richiesta.
Nella directory del progetto, eseguire il seguente comando.
npm install koa --save
Koa verrà automaticamente scaricato e salvato in a package.json file, se esiste.
Nonostante l'ingombro ridotto di Koa, include metodi per attività quali la freschezza della cache, la negoziazione del contenuto, i reindirizzamenti, il supporto proxy ecc., Senza il middleware incluso.
Ecco un esempio di applicazione ciao-mondo:
var koa = require ('koa'); var app = koa (); app.use (function * () this.body = "Hello World !!!";); app.listen (3000);Adesso, Koa implementa anche downstreaming seguito da upstreaming del flusso di controllo. All'inizio può essere difficile rimanere senza fiato, ma una volta che si segue l'esempio di seguito, le cose diventeranno più chiare.
Ecco un esempio del flusso di controllo in Koa:
var koa = require ('koa') (); koa.use (function * (next) // fa qualcosa prima di cedere / passare alla prossima funzione generator in linea che sarà il 1 ° evento in downstream console.log ("A"); yield next; // fare qualcosa quando l'esecuzione restituisce upstream, questo sarà l'ultimo evento in upstream console.log ("B");); koa.use (funzione * (successivo) // fa qualcosa prima di cedere / passare alla successiva funzione generatore in linea, questo sarà il 2 ° evento downstream console.log ("C"); resa successiva; // fare qualcosa quando il l'esecuzione ritorna a monte e questo sarebbe il 2 ° evento upstream console.log ("D");); koa.use (funzione * () // fa qualcosa prima di cedere / passare alla prossima funzione generatore in linea. Qui sarebbe l'ultima funzione downstream console.log ("E"); this.body = "hey guys"; console .log ("F"); // Primo evento di upstream (dall'ultimo al primo)); koa.listen (3000); Il codice sopra è piuttosto semplice. Nota che non tutti console.log sono richieste istruzioni ma ti aiuteranno a comprendere chiaramente il flusso di esecuzione downstream ed upstream di Koa.js .
Quando eseguiamo questa applicazione e apriamo localhost: 3000 nel browser, possiamo osservare che il console.logs nel terminale non sono nell'ordine di A B C D E F. Né sono nell'ordine di A-C-E-B-D-F.
L'ordine è in realtà A-C-E-F-D-B che descrive il downstream dei rendimenti e il comportamento a monte dell'esecuzione in un'app Koa.
Potresti notare che è stampato due volte. Ciò è dovuto ad una doppia richiesta inviata dal browser per recuperare la favicon.
Mancia: Il koa.use (funzione) aggiunge la funzione middleware all'applicazione.
Questo è tutto per la prima parte di questo tutorial sui generatori JavaScript e Koa.js. Hai imparato a conoscere la maggior parte dei prerequisiti quali i generatori, come utilizzarli, come utilizzare la delega della resa e come funziona il flusso di controllo in Koa.js.
Nella parte successiva di questo tutorial, approfondiremo Koa e impareremo come creare un'applicazione CRUD. Se avete domande o commenti, non esitate a contattarmi o semplicemente lasciare un commento qui sotto.
