Promise.resolve()
=================

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.

Exemple interactif
------------------

**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);
```

### Paramètres

`valeur`

L'argument qu'on souhaite résoudre avec cette promesse (`Promise`). Cet argument peut être un objet `Promise` ou un objet avec une méthode `then` à résoudre à la suite.

### Valeur de retour

Une promesse (`Promise`) qui est résolue avec la valeur indiquée en argument ou la promesse passée en argument si celui-ci est une promesse.

Description
-----------

La fonction statique `Promise.resolve` renvoie un objet `Promise` qui est résolu.

Exemples
--------

### Utilisation de la méthode statique `Promise.resolve`


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

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.resolve |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Promise`