[MUSIC]
Quando stavamo parlando di servizi nel modulo precedente, avevo menzionato delle
promesse e poi ho promesso che tornerò alle promesse in questo modulo.
Quindi, eccoci qui, sto per adempiere la mia promessa che ti ho fatto.
Un calcolo sincrono è dappertutto nel world wide web.
E come funziona il web.
Se vieni dal mondo della programmazione sequenziale,
avvolgere la testa attorno a un calcolo sincrono richiede un bel po 'di sforzo.
Ci sono stati molti tentativi di rendere il calcolo asincrono il più indolore
possibile per le persone che transitano in esso dal libro di calcolo sequenziale.
Uno di questi tentativi è quello di rendere il calcolo asincrono
più facile da realizzare sono le promesse.
Come ci rendiamo conto, quando facciamo qualsiasi richiesta a qualsiasi
servizio o a un server di back-end, ci
vorrà del tempo perché i risultati diventino disponibili per noi.
Se facciamo una tale richiesta mentre stiamo procedendo con il nostro lavoro,
allora c'è un'alta probabilità che il nostro calcolo rimanga bloccato nel punto, in
attesa dei risultati.
Questo è un no-no in termini di fare una buona esperienza utente.
Quindi è importante che ogni volta che i risultati stanno per prendere tempo
si dovrebbe essere in grado di procedere avanti senza attendere le regole.
Ed è qui che il calcolo asincrono viene a tuo vantaggio.
Nel calcolo asincrono quando invii una richiesta,
ti aspetti che i risultati tornino in un secondo momento e
dovresti essere in grado di gestire il fatto, i risultati di base tornano in un momento
molto più tardi rispetto a dove ti trovavi nel punto in cui hai fatto la richiesta.
Le promesse ci forniscono un modo per affrontare questo problema.
Diamo un'occhiata alle promesse in un po 'più in dettaglio in questa lezione.
E poi vedremo anche l'uso delle promesse
nella nostra applicazione angolare un po 'più tardi.
Promesse, il concetto generale è un'area molto vasta di per sé.
E in questo corso, non ho tempo di passare attraverso i dettagli delle promesse.
Questo diventerà un intero corso di per sé.
Vi darò solo l'essenziale delle promesse che sono necessarie per
capire come fare uso delle promesse all'interno della nostra applicazione angolare.
Ti fornisco un sacco di cavi per
risorse aggiuntive dove puoi andare ed esaminare le promesse in modo più dettagliato.
Quindi, venendo a questa domanda, cos'e' esattamente una promessa?
Una promessa è un meccanismo che supporta il calcolo asincrono.
Ho appena dato una lunga spiegazione del perché il calcolo asincrono
è essenziale per il funzionamento del web.
Ora, usando una promessa, la promessa fornisce un meccanismo o
un proxy per un valore che non è disponibile nel momento in cui lo chiedi.
Quindi una promessa ti restituirà una promessa, dicendo che
quando il risultato sarà disponibile, tornerà e ti consegnerà i risultati.
Quindi una promessa ti restituisce un oggetto proxy e ti aggrappi all'oggetto proxy.
E quell'oggetto proxy ti darà accesso ai risultati quando diventano disponibili.
E c'è un metodo in come aspetti i risultati.
In realtà non sospendi il tuo calcolo a quel punto invece
configuri un modo per accettare i risultati quando ritorna da quella promessa.
Per dirla in poche parole,
promessa rappresenta un valore che sarà disponibile in un momento futuro.
Potrebbe anche essere immediatamente disponibile,
nel qual caso la promessa restituirà immediatamente il valore.
Ma nel caso in cui debba restituire un valore in una data futura, ti dà
la promessa che quel valore quando diventa disponibile ti verrà restituito.
C' è sempre la possibilità che la promessa non possa essere soddisfatta,
perché i risultati non sono disponibili per qualsiasi motivo.
In tal caso, ti verrà consegnato un errore o ti verrà consegnato un rifiuto
, e spetta a te affrontare il fatto che la promessa è stata respinta.
Esaminiamo come affrontiamo questo nella prossima diapositiva.
Come abbiamo appreso in precedenza, una promessa è un proxy per
qualcosa che sarebbe accaduto in futuro o che potrebbe non accadere mai in futuro.
Quindi una promessa quando ti verrà data, sarà nello stato in sospeso.
Ora, quando la promessa si risolve, cioè i risultati diventano disponibili e
la promessa è in grado di consegnare i risultati a voi, allora la promessa si
risolverà o soddisferà.
E in tal caso la promessa passerà dallo stato in sospeso alla risoluzione o
allo stato di adempimento.
Quindi a quel punto i tuoi risultati sono a tua disposizione.
C' è una piccola possibilità che la promessa possa essere rifiutata a causa di un errore,
o qualunque sia la ragione.
In tale circostanza remota,
ti verrà consegnato un rifiuto e in tal caso, la promessa sarà
considerata nello stato rifiutato al momento della consegna del rifiuto.
Quindi, quando generi una promessa, come ho detto,
una promessa è un oggetto proxy che ti viene consegnato.
Quindi, quando si consegna una promessa a qualcuno, la promessa internamente avrà
una funzione che si occuperà sia della risoluzione che
delle opzioni di rifiuto all'interno.
Quando scrivi codice,
vedrai che scriverai il codice come nuova promessa (funzione (risolvi, rifiuta).
Quindi, che si risolva o venga rifiutato, dobbiamo essere in grado di
restituire le informazioni a chiunque abbiamo promesso.
Come facciamo a farlo nel codice?
Diamo un'occhiata a questo nella diapositiva successiva.
Ecco un esempio di come la promessa è configurata nel codice.
In effetti, questo esempio è derivato dall'esercizio che farai
un po 'più tardi.
Quindi qui, quando configuriamo il nostro servizio, possiamo fare in modo che il nostro servizio
restituisca una promessa a un componente che richiede i dati dal servizio.
Quindi, quando viene restituita la promessa,
la promessa di ritorno è disponibile come oggetto.
E questa promessa fornisce due metodi, il metodo then e il metodo catch.
Ora, allora, la promessa è risolta con successo.
Quindi la promessa comporterà la
chiamata di una risoluzione.
Come hai visto, la promessa è costruita, e all'interno della promessa,
hai la funzione, la risoluzione e il rifiuto, come i due parametri.
Quindi, se la promessa è in grado di fornire con successo il risultato,
chiamerà il metodo di risoluzione e quindi restituirà il risultato a te.
Dove ottiene il risultato realtà?
Quando si scrive il codice in attesa
della promessa, è necessario specificare cosa fare quando la promessa restituisce il risultato
nell'opzione then per quella promessa.
Quindi diciamo per esempio, si direbbe getdishes.Then e all'interno di allora
si dovrebbe fornire la funzione che si occuperà del risultato quando si arriva in.
Se la promessa non è in grado di risolvere correttamente, si rifiuterà
con l'errore che ti viene inviato di nuovo.
L' errore è un oggetto errore che ti verrà inviato di nuovo.
Quindi, quando la loro promessa viene rifiutata, ti occupi
del rifiuto usando un fermo all'interno del tuo codice.
Quindi all'interno della cattura, fornirai una funzione che gestirà l'errore.
Ad esempio, puoi semplicemente emettere il messaggio di errore,
il registro della console e gestire l'errore in questo modo.
Oppure potresti avere un modo più elaborato di gestire l'errore.
Ciò sarebbe fornito nell'opzione catch che fornisci per quel codice di promessa
dalla tua parte quando la promessa ti offre un rifiuto.
Quindi è così che le due facce della medaglia affrontano le promesse.
Da un lato, ti viene inviato un oggetto promessa, e
quando ricevi l'oggetto promessa, con l'oggetto promessa, dovresti fare
il then e il catch, quindi dovresti implementare sia le
metriche then che quelle catch modificate in quell'oggetto promessa.
E poi, da quella promessa a parte, se la promessa risulta correttamente,
allora la risoluzione sarà chiamata e quindi, il risultato sarà consegnato
nel metodo allora della tua promessa.
Se la promessa viene rifiutata,
la chiamata di rifiuto invierà l'errore nella cattura.
Quindi questo è il modo in cui implementeresti il codice usando le promesse.
Ci occuperemo dell'esempio nell'esercizio che segue questa lezione.
Ora, ovviamente, la domanda che chiedo è perché promesse?
Più tardi, quando ci occupiamo di Node JS,
ci occuperemo di come possiamo costruire callback.
E spiegherò i dettagli dei callback e il modo di gestire i
callback quando copriamo il Node JS nell'ultimo corso di questa specializzazione.
I callback hanno un problema di creare ciò che viene definito inferno di callback.
Quindi hai un codice di callback pesantemente annidato
che è molto complicato per essere in grado di capire cosa sta cercando di fare.
Le promesse forniscono un modo per affrontare questo problema dell'inferno di callback.
Ma per il momento ci stiamo concentrando su Angular, parlerò solo di questo punto.
E poi torneremo per affrontare questa domanda nell'ultimo corso.
L' altro vantaggio dell'uso delle promesse è che le promesse possono essere modificate.
Una promessa quando fornisce il risultato nel bin,
puoi generare un'altra promessa e restituire, e
quella promessa può essere gestita concatenando un altro metodo a quello e così via.
Quindi puoi concatenare un insieme di metodi allora per gestire le
promesse uno dietro l'altro.
Se il risultato è immediatamente disponibile o se hai intenzione di rifiutare immediatamente,
prometti fornisce un metodo per tornare immediatamente senza attendere che
la promessa si risolva o rifiuta.
In tal caso, sarà semplicemente dire promessa con un p.resolve capitale e
promise.Reject e quindi restituire immediatamente il risultato o l'errore.
Nel primo esercizio, ci occuperemo di questo metodo per restituire il valore
dal nostro servizio ai nostri componenti.
Nella seconda parte dell'esercizio, ci occuperemo
della situazione in cui la promessa si risolverà dopo un periodo di tempo.
E anche all'interno del nostro componente, dovremmo essere in grado di affrontare il fatto che
i risultati tornano un po 'più tardi rispetto a quando chiedi il risultato.
Con questa rapida comprensione delle promesse,
passiamo al prossimo esercizio in cui tratteremo le promesse.
[ MUSIC]