As promessas são sempre assíncronas

O retorno de chamada do Promise sempre será executado após o código síncrono

const promise = Promise.resolve(); 
promise.then(() => console.log('async')); 
console.log('sync');

//sync
//async

Promessas acorrentadas retornam novas promessas

Promise então retorna uma nova promessa cada vez que é invocada

const p = Promise.resolve(); 
const chain = p.then(() => {}); 
console.log(p === chain); //false

Para sempre então()

Promessas de suporte encadeamento infinito

Promise.resolve(1) 
    .then(value => value   1) 
    .then(value => value   1) 
    .then(value => console.log(value)); // 3

Você pode converter retornos de chamada em promessas

Você pode agrupar código antigo que usa retorno de chamada com a promessa de funcionar com async/await moderno

function asyncOperation(callback) { 
    setTimeout(() => callback(null, 'Im a callback'), 1000); 
} 

const promisified = () => new Promise((resolve, reject) => { 
    asyncOperation((err, result) => { 
        if (err) reject(err); 
        else resolve(result); 
    }); 
});

promisified().then(result => console.log(result)); // "Im a callback"

Promise.resolve() nem sempre cria uma nova promessa

Se você passar um valor non-Promise, Promise.resolve() o agrupa em uma promessa resolvida. Mas se você passar uma promessa, ela simplesmente retorna a mesma promessa.

const p1 = Promise.resolve('Hello'); 
const p2 = Promise.resolve(p1); 
console.log(p1 === p2); // true

Você pode lidar com erros em qualquer lugar da cadeia

Promise.reject('Error!')
  .then(() => console.log('This will not run'))
  .then(() => console.log('This will also not run'))
  .catch(err => console.log('Caught:', err))
  .then(() => console.log('This will run'));

finalmente() não passa valores

O método finalmente() não recebe ou modifica valores resolvidos. É usado para limpar recursos e é executado independentemente de a promessa ser resolvida ou rejeitada.

Promise.resolve('resolved')
  .then(value => console.log(value))
  .finally(() => console.log('Cleanup'))

//resolved
//cleanup

As promessas são imutáveis ​​uma vez resolvidas

Uma vez que uma promessa é cumprida (resolvida ou rejeitada), seu estado é imutável. Ele não poderá ser alterado depois disso, mesmo se você tentar resolvê-lo/rejeitá-lo novamente.

const p = new Promise((resolve, reject) => {
  resolve('First');
  resolve('Second');
});
p.then(value => console.log(value));  //"First" (only the first value is used)

Você pode encadear catch() para lidar com erros específicos

Promise.reject('type C error')
  .catch(err => {
    if (err === 'type A error') console.log('handle type A');
    throw err;
  })
  .catch(err => {
    if (err === 'type B error') console.log('handle type B');
    throw err;
  })
  .catch(err => {
    if (err === 'type C error') console.log('handle type C');
    throw err;
  })

Você pode usar wait com valores não promissores

async function demo() {
  const result = await 42; //not a promise
  console.log(result);      
}
demo(); //42

É isso! Obrigado por ler até aqui. Até a próxima!