Le vrai problème avec la fonction de rappel est qu'elle nous enlève la possibilité d'utiliser les mots-clés return et throw. Et Promise résout très bien tout cela.
En juin 2015, la version officielle d'ECMAScript 6 a finalement été publiée.
ECMAScript est la norme internationale pour le langage JavaScript, et JavaScript est l'implémentation d'ECMAScript. L'objectif d'ES6 est de permettre au langage JavaScript d'être utilisé pour écrire des applications volumineuses et complexes et de devenir un langage de développement au niveau de l'entreprise.
ES6 fournit nativement des objets Promise.
La soi-disant Promise est un objet utilisé pour transmettre des messages pour des opérations asynchrones. Il représente un événement (généralement une opération asynchrone) dont le résultat n'est connu que dans le futur, et cet événement fournit une API unifiée pour un traitement ultérieur.
Les objets Promise ont les deux caractéristiques suivantes.
(1) L'état de l'objet n'est pas affecté par le monde extérieur. L'objet Promise représente une opération asynchrone et a trois états : En attente (en cours), Résolu (terminé, également appelé Réalisé) et Rejeté (échec). Seul le résultat de l’opération asynchrone peut déterminer l’état actuel, et aucune autre opération ne peut modifier cet état. C'est aussi l'origine du nom Promise, qui signifie « engagement » en anglais et signifie qu'il ne peut pas être modifié par d'autres moyens.
(2) Une fois le statut modifié, il ne changera plus, et ce résultat peut être obtenu à tout moment. Il n’existe que deux possibilités pour que l’état d’un objet Promise change : de En attente à Résolu et de En attente à Rejeté. Tant que ces deux situations se produiront, l’État se solidifiera et ne changera plus, et maintiendra ce résultat. Même si le changement a déjà eu lieu, si vous ajoutez une fonction de rappel à l'objet Promise, vous obtiendrez le résultat immédiatement. C'est complètement différent d'un événement. La caractéristique d'un événement est que si vous le manquez et l'écoutez à nouveau, vous n'obtiendrez pas le résultat.
Avec l'objet Promise, les opérations asynchrones peuvent être exprimées comme un processus d'opération synchrone, évitant ainsi les couches de fonctions de rappel imbriquées. De plus, les objets Promise fournissent une interface unifiée, facilitant le contrôle des opérations asynchrones.
La promesse présente également certains inconvénients. Tout d’abord, la promesse ne peut pas être annulée. Une fois créée, elle sera exécutée immédiatement et ne pourra pas être annulée à mi-chemin. Deuxièmement, si la fonction de rappel n'est pas définie, les erreurs générées en interne par Promise ne seront pas reflétées en externe. Troisièmement, à l’état En attente, il est impossible de savoir à quelle étape se situe la progression actuelle (tout juste commencée ou sur le point d’être terminée).
var promise = new Promise(function(resolve, reject) { if (/* 异步操作成功 */){
resolve(value);
} else {
reject(error);
}
});
promise.then(function(value) { // success
}, function(value) { // failure
});Le constructeur Promise accepte une fonction comme paramètre. Les deux paramètres de la fonction sont la méthode de résolution et la méthode de rejet.
Si l'opération asynchrone réussit, utilisez la méthode de résolution pour changer l'état de l'objet Promise de « inachevé » à « réussi » (c'est-à-dire de en attente à résolu
Si le) ; l'opération asynchrone échoue , puis utilisez la méthode de rejet pour modifier l'état de l'objet Promise de « inachevé » à « échoué » (c'est-à-dire de en attente à rejeté).
Promise.resolve()
Promise.reject()
Promise.prototype.then()
Promise.prototype.catch()
Promise.all() // Tous terminé
var p = Promise.all([p1,p2,p3]);
Promise.race() // Course, il suffit d'en terminer un
La merveille de promesses est que compte tenu de notre retour et de notre lancer précédents, chaque promesse fournira une fonction then() et une catch(), qui est en fait une fonction then(null, ...),
somePromise().then(functoin(){ // do something
});Nous pouvons faire trois choses,
1. return 另一个 promise2. return 一个同步的值 (或者 undefined)3. throw 一个同步异常 ` throw new Eror('');`
"
new Promise(function (resolve, reject) {
resolve(someValue);
});
"
写成
"
Promise.resolve(someValue);
" new Promise(function (resolve, reject) { throw new Error('悲剧了，又出 bug 了');
}).catch(function(err){ console.log(err);
});S'il s'agit de code synchrone, qui peut être écrit comme
Promise.reject(new Error("什么鬼"));somePromise.then(function() { return a.b.c.d();
}).catch(TypeError, function(e) {
//If a is defined, will end up here because //it is a type error to reference property of undefined
}).catch(ReferenceError, function(e) { //Will end up here if a wasn't defined at all
}).catch(function(e) { //Generic catch-the rest, error wasn't TypeError nor //ReferenceError
});1. .then 方式顺序调用2. 设定更高层的作用域3. spread
任何情况下都会执行的，一般写在 catch 之后
somethingAsync().bind({})
.spread(function (aValue, bValue) { this.aValue = aValue; this.bValue = bValue; return somethingElseAsync(aValue, bValue);
})
.then(function (cValue) { return this.aValue + this.bValue + cValue;
});Ou vous pouvez le faire
var scope = {};
somethingAsync()
.spread(function (aValue, bValue) { scope.aValue = aValue; scope.bValue = bValue;
return somethingElseAsync(aValue, bValue);
})
.then(function (cValue) {
return scope.aValue + scope.bValue + cValue;
});Cependant, il y a beaucoup de différences,
Vous devez d'abord déclarer, il y a un risque de gaspillage de ressources et de fuites de mémoire
ne peut pas être utilisé dans le contexte d'une expression
Moins efficace
"var join = Promise.join;join(getPictures(), getComments(), getTweets(),
function(pictures, comments, tweets) {
console.log("in total: " + pictures.length + comments.length + tweets.length);
});
""
Promise.props({ pictures: getPictures(),
comments: getComments(),
tweets: getTweets()
}).then(function(result) {
console.log(result.tweets, result.pictures, result.comments);
});
""Promise.some([
ping("ns1.example.com"),
ping("ns2.example.com"),
ping("ns3.example.com"),
ping("ns4.example.com")
], 2).spread(function(first, second) { console.log(first, second);
}).catch(AggregateError, function(err) {err.forEach(function(e) {
console.error (e. stack);
});
});;
" 有可能，失败的 promise 比较多，导致，Promsie 永远不会 fulfilled
用于处理一个数组，或者 promise 数组，
Option : concurrence et trouvé
map(..., {concurrency: 1});Ce qui suit est un nombre illimité de simultanéités, lisant les informations du fichier
var Promise = require("bluebird");
var join = Promise.join;
var fs = Promise.promisifyAll(require("fs"));
var concurrency = parseFloat(process.argv[2] || "Infinity");
var fileNames = ["file1.json", "file2.json"];
Promise.map(fileNames, function(fileName) {
return fs.readFileAsync(fileName)
.then(JSON.parse)
.catch(SyntaxError, function(e) {
e.fileName = fileName; throw e;
})
}, {concurrency: concurrency}).then(function(parsedJSONs) { console.log(parsedJSONs);
}).catch(SyntaxError, function(e) { console.log("Invalid JSON in file " + e.fileName + ": " + e.message);
});résultat
$ sync && echo 3 > /proc/sys/vm/drop_caches $ node test.js 1reading files 35ms $ sync && echo 3 > /proc/sys/vm/drop_caches $ node test.js Infinity reading files: 9ms
Promise.reduce(["file1.txt", "file2.txt", "file3.txt"],
function(total, fileName) {
return fs.readFileAsync(fileName, "utf8").then(
function(contents) {
return total + parseInt(contents, 10);
});
}, 0).then(function(total) { //Total is 30
});.delay(int ms) -> 🎜>
.timeout(int ms [, String message]) -> PromesseLa fonction asynchrone, comme les fonctions Promise et Generator, est une méthode utilisée pour remplacer les fonctions de rappel et résoudre les opérations asynchrones. Il s’agit essentiellement d’un sucre syntaxique pour la fonction Générateur. Les fonctions asynchrones ne font pas partie d'ES6, mais sont incluses dans ES7.
Ce qui précède est le contenu de Promise, l'artefact en Javascript. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
