faits amusants sur les promesses Javascript

Les promesses sont toujours asynchrones

Le rappel de la promesse sera toujours exécuté après le code synchrone

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

//sync
//async

---

Les promesses enchaînées renvoient de nouvelles promesses

Promise renvoie ensuite une nouvelle promesse à chaque fois qu'elle est invoquée

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

---

Pour toujours alors()

Support des promesses chaînage infini

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

---

Vous pouvez convertir les rappels en promesses

Vous pouvez envelopper un code plus ancien qui utilise le rappel dans la promesse de fonctionner avec l'async/await moderne

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() ne crée pas toujours une nouvelle promesse

Si vous transmettez une valeur non-Promise, Promise.resolve() l'enveloppe dans une promesse résolue. Mais si vous passez une promesse, elle renvoie simplement cette même promesse.

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

---

Vous pouvez gérer les erreurs n’importe où dans la chaîne

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

---

enfin() ne transmet pas les valeurs

La méthode enfin() ne reçoit ni ne modifie les valeurs résolues. Il est utilisé pour nettoyer les ressources et s'exécute que la promesse soit résolue ou rejetée.

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

//resolved
//cleanup

---

Les promesses sont immuables une fois réglées

Une fois qu'une promesse est réglée (résolue ou rejetée), son état est immuable. Il ne peut plus être modifié par la suite, même si vous essayez à nouveau de le résoudre/rejeter.

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

---

Vous pouvez chaîner catch() pour gérer des erreurs spécifiques

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

---

Vous pouvez utiliser wait avec des valeurs non promises

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

C'est ça ! Merci d'avoir lu jusqu'ici. À la prochaine fois !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!