Il linguaggio JavaScript è un linguaggio di programmazione ricco di funzionalità e feature molto versatili per i web developers. Una di queste è il costrutto promise e, se aspiri a programmare in Javascript, non puoi non conoscerlo.. Dal 2015 le promise sono integrate nativamente nel linguaggio JavaScript senza l’ausilio di librerie da importare.
Quando scriviamo istruzioni in JavaScript, queste vengono eseguite in sequenze, ossia una riga alla volta.
Ciò vuol dire che ogni riga di codice deve essere interamente eseguita prima di procedere a quella successiva: stiamo parlando di programmazione sincrona.
Cos’è una promise nel linguaggio JavaScript?
Le promise sono definite anche grazie al loro stato. Introducono per certi versi la programmazione asincrona. Per intenderci, è come se nel programma che stiamo compilando inserissimo un riferimento con la “promessa di seguirlo” il prima possibile con un dato, ed in cambio, il programma, ci fornisse la possibilità di proseguire con le righe successive.
Le promise sono state concepite per rappresentare operazioni incomplete in un preciso momento a runtime, che saranno però complete in futuro. Si tratta di un componente adottato nel caso di elaborazioni asincrone. Gli stati del promise sono tre:
- Resolved: una promise si definisce resolved quando il valore che rappresenta diviene disponibile, cioè quando restituisce il valore.
- Rejected: Una promise si definisce rejected quando l'attività asincrona associata non restituisce un valore o nel caso in cui si verifica un'eccezione perché il valore restituito non è considerato valido.
- Pending: Una promise è pending quando non è né risolta né rigettata, cioè la richiesta di esecuzione di un'attività asincrona è partita ma non abbiamo ancora ricevuto un risultato.
Una promise può passare da uno stato pending ad uno solo degli altri due. Non ci sono altri passaggi di stato possibili.
Il concetto di promise in JavaScript è simile a quello di callback function in JavaScript. Se ricordi un pochino la questione delle funzioni in Javascript, saprai che una callback function è una funzione passata come argomento a un'altra funzione.
Per quanto riguarda la sintassi Javascript della promise, questa è molto semplice; per istanziarla basta scrivere:
var promise = new Promise(handler);
Il costruttore Promise prevede un solo argomento. Ha il compito di gestire la risoluzione dell’istanza della promise stessa. Il promise handler invece può essere definito in questo modo:
var promise = new Promise(function(resolve, reject) {
if (statement) {
resolve(value);
} else {
reject(reason);
}
});
Il promise handler agisce su due canali, prendendo due funzioni come argomenti. Il primo parametro corrisponde alla funzione da chiamare quando il valore restituito dall'operazione asincrona è disponibile. Il valore restituito dall’attività asincrona viene passato alla funzione in questione.
Il secondo corrisponde alla funzione da invocare quando la promise non può essere risolta, ad esempio se si è verificato un errore o se il valore restituito non è considerato valido. In questo caso alla funzione viene passato il motivo del reject, come ad esempio l'eccezione che si è verificata.
Possiamo affermare che le promise portano due esiti da gestire, il primo per la restituzione del risultato, il secondo per gli errori, se si verificano. Il risultato verrà restituito attraverso la clausola then, mentre l'errore è gestibile tramite catch.
Il metodo JavaScript then() una volta assegnata la promise a una variabile, possiamo elaborare il risultato asincrono che verrà restituito tramite il metodo stesso.
image(img).then(
(data) => { showImg(data) }
)
Il metodo then() sarà utilizzabile solamente se la funzione image restituisca una promise in quanto il suddetto metodo viene fornito dalla classe Promise. Il metodo then() in JavaScript può avere diverse valenze. Nel caso del promise può prendere due funzioni come parametri, ed è la procedura consigliata, specialmente se si vuole gestire il rigetto della promise considerandola come eccezione. Then() permette proprio di avere una maggiore versatilità nella gestione dei promise e vedere sotto diversi punti di vista il risultato asincrono restituito dalla funzione.
Una promise viene eseguita immediatamente e si risolve in un singolo valore o viene rigettata con un oggetto errore. Se la promessa viene rifiutata, il valore restituito passa attraverso qualsiasi then() e viene prelevato dal JavaScript catch() che ha il compito di gestire l’errore, trasformandolo in eccezione.
getUser()
.then(getName)
.then(displayName)
.catch(manageError);
In questo caso il catch funge da singolo gestore del rifiuto della promise, evitare di passare lo stesso gestore per ciascun metodo then() e utilizzare il metodo catch().
Il metodo JavaScript finally() viene sempre eseguito indipendentemente dal fatto che la promise sia soddisfatta o rigettata. In altre parole, il metodo finally() viene eseguito quando la promessa è istanziata.
Nel metodo JavaScritp finally(), puoi inserire il codice che ripulisce la risorsa quando la promessa viene istanziata, indipendentemente dal suo esito.
Usando il metodo finally(), puoi evitare il codice ridondante nei metodi then() e catch() come questo:
promise
.then(result => {
// process the result
})
.catch(error => {
// handle the error
})
.finally(() => {
// clean up the resources
});
Ha la stessa valenza del finally che troviamo in un banale blocco try…catch…finally. Nel codice sincrono, il blocco finally ripulisce le risorse. Nel codice asincrono si usa invece il metodo finally(). Nel caso di finally l’esito della promise non conta. Catch() invece viene chiamato in causa solo nel momento in cui viene chiamata un’eccezione per gestire un errore e quindi dipende dallo stato della promise nel codice asincrono che è stato scritto.
Se leggere delle Promise in Javascript ti ha incuriosito e il linguaggio Javascript ti appassiona, tieniti pronto: abbiamo preparato per te una guida Javascript online in italiano per addentrarti in questo mondo e prepararti a imparare Javascript. Stay tuned
