Versprechen sind immer asynchron

Der Rückruf von Promise wird immer nach synchronem Code ausgeführt

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

//sync
//async

Verkettete Versprechen geben neue Versprechen zurück

Promise gibt dann bei jedem Aufruf ein neues Versprechen zurück

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

Für immer dann()

Promises unterstützen unendliche Verkettung

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

Sie können Rückrufe in Versprechen umwandeln

Sie können älteren Code, der Callback verwendet, in das Versprechen einschließen, mit modernem Async/Await zu funktionieren

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() erstellt nicht immer ein neues Versprechen

Wenn Sie einen Nicht-Promise-Wert übergeben, verpackt Promise.resolve() ihn in ein aufgelöstes Versprechen. Aber wenn Sie ein Versprechen bestehen, gibt es einfach dasselbe Versprechen zurück.

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

Sie können Fehler überall in der Kette behandeln

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

„final()“ übergibt keine Werte

Die Methode „final()“ empfängt oder ändert keine aufgelösten Werte. Es wird zum Bereinigen von Ressourcen verwendet und wird unabhängig davon ausgeführt, ob das Versprechen aufgelöst oder abgelehnt wird.

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

//resolved
//cleanup

Versprechen sind unveränderlich, sobald sie erfüllt sind

Sobald ein Versprechen erfüllt (gelöst oder abgelehnt) ist, ist sein Zustand unveränderlich. Danach kann es nicht mehr geändert werden, auch wenn Sie erneut versuchen, es aufzulösen/ablehnen.

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

Sie können Catch() verketten, um bestimmte Fehler zu behandeln

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

Sie können „await“ mit nicht versprechenden Werten verwenden

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

Das ist es! Vielen Dank, dass Sie bis hierher gelesen haben. Bis zum nächsten Mal!