Обещания всегда асинхронны

Обратный вызов Promise всегда выполняется после синхронного кода

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

//sync
//async

Связанные обещания возвращают новые обещания

Затем Promise возвращает новое обещание каждый раз при его вызове

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

Тогда навсегда()

Обещания поддерживают бесконечную цепочку

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

Вы можете конвертировать обратные вызовы в обещания

Вы можете обернуть старый код, который использует обратный вызов в обещании, для работы с современными async/await

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() не всегда создает новое обещание

Если вы передаете непромисное значение, Promise.resolve() превращает его в разрешенное обещание. Но если вы передадите обещание, оно просто вернет то же самое обещание.

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

Вы можете обрабатывать ошибки в любом месте цепочки

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'));

finally() не передает значения

Метод Final() не получает и не изменяет разрешенные значения. Он используется для очистки ресурсов и запускается независимо от того, разрешается или отклоняется промис.

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

//resolved
//cleanup

Обещания являются неизменными после урегулирования

После того как обещание решено (разрешено или отклонено), его состояние становится неизменным. После этого его нельзя будет изменить, даже если вы попытаетесь разрешить/отклонить его еще раз.

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

Вы можете связать catch() для обработки конкретных ошибок.

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;
  })

Вы можете использовать await с необещающими значениями

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

Вот и все! Спасибо, что дочитали до этого места. До следующего раза!