Nell'esercizio precedente,
abbiamo appreso due nuovi aspetti di JavaScript, il
loro supporto per funzioni e chiusure di prima classe.
Abbiamo anche visto come Node gestisce l'aspetto di programmazione asincrona e come Node
supporta l'esecuzione asincrona del codice con
l'uso di callback e anche la gestione degli errori.
Diamo un'occhiata a un esempio di come facciamo uso di questo
all'interno della nostra applicazione Node in questo esercizio.
Continuando con il punto in cui abbiamo interrotto nell'esercizio precedente,
ora andrò a modificare il modulo nodo rettangolo,
in modo che possa prendere l'aiuto dei callback.
Quindi ho intenzione di rimuovere queste esportazioni qui,
e invece, stanno andando a modificare questa funzione.
Farò uso di queste due funzioni un po 'più tardi,
quindi è per questo che le sto salvando in basso.
Quindi lascia che li tenga da parte.
E poi modificherò questo modulo rettangolo come segue.
Quindi diremo module.export.
Quindi stiamo usando il modo standard in cui viene gestito il modulo.
E questo sta per esportare questa funzione che prende questi tre parametri,
x e y e callback.
Il callback è una funzione che verrà fornita in quando questo modulo viene chiamato.
Quindi questo è l'uso delle funzioni di prima classe di cui abbiamo parlato in precedenza.
Quindi all'interno di questo callback,
così puoi vedere che stai ottenendo due parametri, x e y.
In questo caso, per
il rettangolo, la x e y corrispondono alla lunghezza e all'ampiezza
del rettangolo che viene passato come i due valori.
Quindi qui dentro, stiamo andando a controllare per vedere
se x è minore o uguale a zero o y è minore o uguale a zero.
Abbiamo scritto codice come questo qui.
Quindi ho intenzione di copiare questo codice da qui
e poi portarlo qui e poi modificheremo.
Quindi in questo caso, questo è se x è
minore o uguale a zero o y è minore o uguale a zero.
In questo caso, cosa facciamo?
In questo caso, notiamo che
le dimensioni del rettangolo sono inferiori o uguali a zero.
Quindi dobbiamo gestirlo in modo diverso,
e faremo l'altra parte di esso.
L' altra parte in cui gestiamo la situazione in cui il rettangolo è un rettangolo valido.
Quindi, in questo caso,
quello che faremo è quindi utilizzare un setTimeout.
Quindi qui, sto simulando il fatto che qualsiasi cosa
venga fatta in questo rettangolo richiederà del tempo.
Quindi questa è l'elaborazione asincrona.
Ora, dal momento che non ho molto lavoro da fare in background,
quindi ho intenzione di simularlo semplicemente usando
la funzione setTimeout di JavaScript e quindi
ritardare prima che venga chiamata la funzione di callback.
Quindi il modo in cui organizzo questo è il seguente.
Quindi all'interno di setTimeout,
chiamerò questa funzione lì
e organizzerò un ritardo di
2.000 millisecondi o due secondi dopo di che questa funzione verrà chiamata.
Quindi, se si ricorda,
il setTimeout supportato in JavaScript,
prende come primo parametro una funzione e
il secondo parametro sarebbe il periodo di tempo per il quale questo verrà ritardato.
Quindi fammi rientrare in questo.
Ora, ho bisogno di compilare questa funzione qui.
Quindi ho iniziato con la funzione freccia qui
che non accetta parametri e poi quando viene chiamato,
emetterò una chiamata al callback.
Questo callback è una funzione di callback
che verrà passata come terzo parametro qui.
Questa funzione di callback, come hai notato, accetta due parametri.
Il primo è l'errore e il secondo è il valore restituito.
Quindi, in questo caso, dal momento che abbiamo un errore,
perché x è minore o uguale a zero e y è minore o uguale a zero,
quindi il primo valore che passerò come nuovo errore,
e questo errore è esattamente questa stringa che stavo usando nel console.log quindi,
e questo è ciò che passerò come l'errore qui.
Permettetemi ora di cancellare quel console.log,
non ne ho più bisogno.
Quindi, per il callback,
genererò un nuovo oggetto errore e quindi lo passerò
come valore restituito per la funzione di callback, il primo parametro.
Quindi dirò che le dimensioni rettangolari dovrebbero essere maggiori di zero.
Quindi diremo l,
questo è il valore x e y che abbiamo ottenuto come valori di input lì.
Quindi questo è il callback.
E la seconda parte di questo callback,
passerò come null perché questo restituirà un errore.
Quindi, quando si restituisce un errore come primo parametro,
il secondo parametro verrà ignorato quando quel callback è stato appena ricevuto
dal modulo nodo da dove stiamo chiamando questa particolare funzione lì.
Quindi, con questa disposizione,
quindi meno di zero,
quindi lasciatemi dare un po' di spazio qui in modo che sia correttamente rientrato qui.
Quindi, il modo in cui sto organizzando questo
qui è che se x è inferiore a zero e y è inferiore
a zero, ho intenzione di richiamare la funzione di callback che è stata passata,
ma il primo parametro passerà per
errore perché qui notiamo che c'è un errore
e il secondo parametro sarà nullo.
Se questo non è il caso,
chiamerò lo stesso callback,
ma con il primo parametro.
Quindi fammi copiare quel codice qui dentro.
Ho ancora intenzione di utilizzare setTimeout qui.
Ma quella prima parte non sarà un errore,
invece, la prima parte,
in questo caso, non c'è errore.
Quindi ho intenzione di passare indietro quel valore come null.
Quindi ciò significa che l'errore è impostato su null.
Quindi questo è un rettangolo valido.
Quindi possiamo calcolare i valori per il rettangolo.
Ma invece, passerò semplicemente in
un oggetto JavaScript contenente le due funzioni
come i due valori all'interno di questo oggetto JavaScript.
Quindi, qui ho intenzione di prendere questo due,
il perimetro e l'area,
e poi questi due saranno passati come i due valori qui,
perimetro e area.
E questi due, dal momento che capita di essere un oggetto JavaScript,
quindi perimetro e area saranno
le due proprietà che passerò all'interno di quegli oggetti JavaScript,
e basta.
Quindi qui, nel secondo caso,
l'errore è impostato su null perché non c'è errore,
ma la seconda parte,
nota che sto passando in un oggetto JavaScript contenente due proprietà,
perimetro e area, che sono due funzioni qui.
Quindi le due funzioni sono la funzione perimetrale e la funzione area.
Quindi questo oggetto JavaScript verrà passato come
valore restituito per il callback qui, il secondo valore.
E ancora, ho intenzione di ritardare questo di
un intervallo di due secondi prima che il valore venga passato da questa funzione.
Il motivo per cui sto usando setTimeout è simulare
un ritardo prima che il callback arrivi dall'altra parte.
Quindi questo tipo di rappresenta situazioni in cui, ad esempio,
si emette una chiamata al database
e il database deve essere letto prima che il valore venga restituito a voi.
Quindi ci vorrà un certo lasso di tempo.
Quindi sto praticamente simulando questo in questo momento usando la funzione setTimeout qui.
Più tardi, vedrai che quando integreremo il MongoDB con
il nostro Express negli esercizi successivi,
quel ritardo dovrebbe essere simulato,
sarà automaticamente causato dal fatto che
è necessario eseguire operazioni di database dietro le quinte prima che i dati vengano ottenuti.
Quindi qui, dopo aver completato questo aggiornamento dei moduli rettangolari,
quindi qui vedi che il modulo rettangolo accetta
tre parametri poiché è una chiamata di input qui,
x, y e callback.
E così, il callback è la funzione di callback che viene fornita qui.
E questa funzione di callback verrà chiamata qui dentro,
e quando viene chiamata la funzione di
callback, o si passa indietro un errore o si passa indietro
una funzione che consente di calcolare il perimetro e l'area del rettangolo.
Ora, questo modello di chiamata e passaggio in una funzione di callback
da un modulo Node e quindi il secondo modulo Node che una volta completato,
passerà indietro il risultato utilizzando la funzione di callback è
esattamente il modello che vedrai spesso ripetuto nelle applicazioni Node.
Quindi e' questo il motivo per cui lo sto illustrando.
Naturalmente, questo è un esempio inventato che sto illustrando qui, ma mostra
tutti i modelli standard che userai con le
funzioni di nodo e callback e anche la gestione degli errori.
Ora, abbiamo aggiornato il modulo rettangolo qui.
Andiamo a riparare quel file index.js in modo che possa passare nella funzione di callback e
quindi gestire il valore restituito dal modulo rettangolo.
Tornando a index.js,
ora ci accingiamo ad aggiornare il file index.js come segue.
Ho intenzione di rimuovere questo dal file index.js invece.
Qui, quello che finirà per fare è chiamare
questo modulo rettangolo e
poi passare il l e la b come i due parametri.
E il terzo parametro che passerò è quella funzione di callback.
Quindi la funzione di callback ha due parametri, err e rettangolo.
E questa funzione di callback è implementata come segue qui.
Quindi qui, vedi che sto chiamando
questo modulo del nodo rettangolo e sto
passando la lunghezza e l'ampiezza dei primi due parametri.
E il terzo parametro è, ovviamente,
una funzione di callback che sto implementando qui.
Quindi, questa è una funzione freccia che sto implementando qui.
Quindi, all'interno di questa funzione di callback,
come gestisco il valore restituito?
Quindi qui dirò se (err),
quindi se il valore di errore ti viene restituito,
allora farò semplicemente console.log e dirò
«ERRORE» e quindi il secondo valore è err.message.
Ricordiamo che nel rettangolo,
avevamo creato questo nuovo oggetto errore
e poi passato in questa stringa all'interno di questo oggetto errore.
Questa stringa verrà allegata
all'oggetto error alla proprietà message dell'oggetto error qui.
Quindi, nel file index.js,
quindi sto recuperando la proprietà message dell'oggetto error
e quindi stampandola sulla mia console qui.
Quindi, se si verifica un errore,
ho intenzione di stampare il messaggio di errore usando questo.
E così, questo è il modo in cui gestirei l'errore restituito da una funzione di callback.
Altrimenti, ovviamente in questo caso,
il modulo rettangolo ha restituito la funzione rettangolo,
l'oggetto che contiene il perimetro e le funzioni area,
quindi posso andare avanti e stampare quel valore.
Quindi qui, dirò l'area del rettangolo
di dimensioni l uguale a,
quindi dirò,
e b uguale a.
Il motivo per cui lo sto identificando
esplicitamente diventerà molto chiaro quando eseguiamo questo esempio.
Dirò è rettangolo.area.
Ora, nota che per quest'area,
non sto inviando alcun parametro qui perché va ai valori,
la lunghezza e il respiro sono stati passati già qui in l e b,
e quelli sarebbero già disponibili per questo
e qui a causa della chiusura che JavaScript supporta.
Poiché questi x e y sono entrati come parametri,
quindi quelli saranno accessibili proprio lì in questa funzione di callback.
Quindi questi x_y saranno automaticamente disponibili per noi qui.
Quindi, in effetti,
non ho bisogno di fornire questi parametri x e y qui perché
quelli x e y saranno recuperati da questo x e y proprio lì.
Quindi non ho nemmeno bisogno di passare quei due valori qui dentro.
Ecco perché, proprio lì,
posso chiamare rettangle.area.
E questo calcolo dell'area otterrà automaticamente l e b che sono stati passati
dalla chiamata rettangolo al modulo nodo diretto in precedenza.
Quindi questa è la chiusura di JavaScript che opera qui.
Quindi, questo è il primo.
Sto stampando l'area del rettangolo.
La stessa cosa, fammi anche stampare i perimetri.
Quindi per stampare i perimetri,
quindi dirò console.log.
Il perimetro del rettangolo sarà il perimetro del rettangolo.
Ora, devo dirti che questo tipo di approccio per l'implementazione richiede un po 'di
sforzo per capire e interiorizzare l'abilità della funzione asincrona.
Ci vuole un po 'di tempo per capire completamente come funziona davvero.
Ora per illustrare il fatto che
questa chiamata di funzione si tradurrà in una chiamata al modulo Node,
ma questa parte verrà eseguita solo dopo
un ritardo di due secondi a causa del fatto che stiamo usando il segno di tempo impostato.
Ora, come abbiamo studiato in operazioni asincrone,
perché abbiamo spostato l'elaborazione sul retro,
permettetemi di introdurre anche un altro console.log qui per fare un punto.
Quindi diremo che questa affermazione è
dopo la chiamata a rect.
Il motivo per cui sto illustrando questo punto è che quando si emette questa chiamata,
questo codice non verrà eseguito fino a dopo un ritardo di due secondi.
Quindi, nel frattempo, la
tua funzione, la funzione principale qui,
continuerà e quindi eseguirà la riga successiva di codice che vedi qui.
Quindi questa è la continuazione che vedrete qui.
Quindi, con queste modifiche,
salviamo le modifiche e poi guardiamo come questa applicazione viene eseguita ora.
Quindi, salvando le modifiche.
Andiamo al terminale ed eseguiamo questa applicazione nodo.
Ora, andando al terminale, aggiungi il prompt.
Permettetemi di digitare npm start e noterete immediatamente
che la soluzione e questa affermazione sono state stampate in precedenza.
E dopo questo certo ritardo,
l'area e il perimetro sono stati stampati.
Quindi questo è un ritardo di due secondi che abbiamo introdotto usando il timeout impostato.
Quindi, hai notato che nella versione precedente,
questo è stato stampato e immediatamente l'area e il perimetro sono stati stampati proprio sotto quello.
Ma ora, notate che quei valori sono stampati un po 'più tardi.
Quindi, nel mezzo, la loro funzione chiama con i diversi parametri che sono già
entrati e quindi i callback vengono richiamati dopo due secondi di ritardo per ciascuno di essi.
E a causa del fatto che c'è la chiusura che supporta il JavaScript,
quindi i valori che vengono passati vengono conservati.
E così quando viene chiamata la funzione di callback,
viene stampato il valore appropriato.
Ecco perché vedi che l'area e
il perimetro sono stampati correttamente e questi due qui,
queste due affermazioni qui,
corrispondono a questa particolare chiamata a dirigere
con l è uguale a due e b è uguale a quattro.
E poi questi due,
il prossimo a due, ovviamente,
corrispondono a questo particolare e a quelli rimanenti come vedete qui.
Quindi, quello che volevo illustrare è il fatto che quando si esegue il calcolo asincrono,
il calcolo asincrono richiede il suo tempo
per restituire il valore mentre il calcolo principale
procederà in avanti senza attendere il completamento del callback.
Quindi, quando hai bisogno di fare una certa quantità di lavoro,
hai passato come callback a quell'altro modulo.
E quando quell'altro modulo completa il suo lavoro,
sta per richiamare e quindi quel codice verrà eseguito.
Quindi questo è il punto che ho illustrato usando questo esempio.
Ancora una volta, come ho detto,
questo richiede un po 'di immaginazione e comprensione
per voi per interiorizzare il modo in cui funziona,
ma vedrete che con Node e anche Express e quando usiamo MongoDB,
vedrete questo tipo di modello che si ripete molto spesso nel modo in cui scriviamo il nostro codice.
Quindi, con questa semplice illustrazione di callback e gestione degli errori,
completiamo questo esercizio.
Questo è un buon momento per fare un commento get con quel messaggio,
nodo, callback e gestione degli errori.