Qual è l'equivalente di ES6 Promise di jQuery Deferred's 'always`?

Question

ho qualcosa di simile alla seguente:

getUser("foo").then(handleSuccess, handleError).always(tidyUp); 

getUser restituisce un oggetto differite jQuery.

Ho capito da this article che posso convertire l'oggetto differita ad una promessa nativa utilizzando Promise.resolve, così posso scrivere

Promise.resolve(getUser("foo")) 
    .then(handleSuccess) 
    .catch(handleError) 

Il Promise API non offre un metodo always però, così mi chiedo come che dovrebbe essere gestito

È come segue?

Promise.resolve(getUser("foo")) 
    .then(handleSuccess) 
    .then(tidyUp) 
    .catch(handleError) 
    .then(tidyUp) 

Answer 1

Credo che quanto segue è quello che stai cercando:

Promise.resolve(getUser("foo")) 
    .then(handleSuccess, handleError) 
    .then(tidyUp) 

TidyUp verrà sempre chiamato. Vedere il seguente jsbin per l'esempio completo: http://jsbin.com/lujubu/edit?html,js,console,output

Answer 2

Utilizzare la funzione always come il gestore per resolveereject per assicurare che possa sempre essere chiamato.

function getUser(result) { 
    switch (result) { 
     case 'good': 
      return Promise.resolve(); 

     case 'bad': 
      return Promise.reject(); 

     case 'ugly': 
      return new Promise(() => { throw new Error() }) 
    } 
} 

function handleSuccess() { console.log('success') } 
function handleError() { console.log('error') } 
function tidyUp() { console.log('all tidy now') } 


Promise.resolve(getUser('good')) 
    .then(handleSuccess) 
    .catch(handleError) 
    .then(tidyUp, tidyUp); 

Promise.resolve(getUser('bad')) 
    .then(handleSuccess) 
    .catch(handleError) 
    .then(tidyUp, tidyUp); 

Promise.resolve(getUser('ugly')) 
    .then(handleSuccess) 
    .catch(handleError) 
    .then(tidyUp, tidyUp); 

// success 
// error 
// error 
// all tidy now 
// all tidy now 
// all tidy now 

Promise API Reference