Promise.resolve()

Baseline Large disponibilité

Cette fonctionnalité est bien établie et fonctionne sur de nombreux appareils et versions de navigateurs. Elle est disponible sur tous les navigateurs depuis juillet 2015.

La méthode Promise.resolve(valeur) renvoie un objet Promise qui est résolu avec la valeur donnée. Si cette valeur est une promesse, la promesse est renvoyée, si la valeur possède une méthode then, la promesse renvoyée « suivra » cette méthode et prendra son état ; sinon, la promesse renvoyée sera tenue avec la valeur.

Dans cet article

Exemple interactif

const promise1 = Promise.resolve(123);

promise1.then((value) => {
  console.log(value);
  // Expected output: 123
});

Attention : Promise.resolve() ne doit pas être appelée sur un objet thenable qui se résout en lui-même. Cela provoquera une récursion infinie et resolve() tentera d'aplatir ce qui ressemble à une promesse imbriquée à l'infini.

Syntaxe

js
Promise.resolve(valeur);
Promise.resolve(promesse);
Promise.resolve(suivant);

js
Promise.resolve("Succès").then(
  function (valeur) {
    console.log(valeur); // "Succès"
  },
  function (valeur) {
    // n'est pas appelée
  },
);

Résoudre un tableau

js
var p = Promise.resolve([1, 2, 3]);
p.then(function (v) {
  console.log(v[0]); // 1
});

Résoudre une autre Promise

js
var original = Promise.resolve(33);
var cast = Promise.resolve(original);
cast.then(function (value) {
  console.log("value: " + value);
});
console.log("original === cast ? " + (original === cast));

// affiche ceci dans la console (dans cet ordre) :
// original === cast ? true
// value: 33

L'ordre des traces dans la console est dû au fait que les gestionnaires then() sont appelés de façon asynchrone (plus de détails sur then dans cet article).

Résoudre des objets avec then et renvoyer des erreurs

js
// Résoudre un objet avec then
var p1 = Promise.resolve({
  then: function (onFulfill, onReject) {
    onFulfill("tenue !");
  },
});
console.log(p1 instanceof Promise); // true, l'objet est transformée en une Promise

p1.then(
  function (v) {
    console.log(v); // "tenue !"
  },
  function (e) {
    // n'est pas appelée
  },
);

// L'objet avec then renvoie une erreur avant le callback
// La promesse n'est pas tenue
var thenable = {
  then: function (resolve) {
    throw new TypeError("Renvoi d'erreur");
    resolve("Résolution ");
  },
};

var p2 = Promise.resolve(thenable);
p2.then(
  function (v) {
    // n'est pas appelée
  },
  function (e) {
    console.log(e); // TypeError : Renvoi d'erreur
  },
);

// L'objet avec then renvoie une erreur après le callback
// La promesse est tenue
var thenable = {
  then: function (resolve) {
    resolve("Résolue");
    throw new TypeError("Erreur");
  },
};

var p3 = Promise.resolve(thenable);
p3.then(
  function (v) {
    console.log(v); // "Résolue"
  },
  function (e) {
    // n'est pas appelée
  },
);