L'artefact en Javascript - Promesse

Promesse en js

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.

Concept

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é).

API de base

1. Promise.resolve()

2. Promise.reject()

3. Promise.prototype.then()

4. Promise.prototype.catch()

5. Promise.all() // Tous terminé

    var p = Promise.all([p1,p2,p3]);

6. Promise.race() // Course, il suffit d'en terminer un

Avancé

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

1. Encapsuler le code synchrone et asynchrone

"
new Promise(function (resolve, reject) {
 resolve(someValue);
 });
"
写成

"
Promise.resolve(someValue);
"

2. Capturer les exceptions synchrones

 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("什么鬼"));

3. Capture d'exceptions multiples, capture plus précise

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

4 Obtenez la valeur de retour de deux Promesse

1. .then 方式顺序调用2. 设定更高层的作用域3. spread

5. . enfin

任何情况下都会执行的，一般写在 catch 之后

6. lier

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,

1. Vous devez d'abord déclarer, il y a un risque de gaspillage de ressources et de fuites de mémoire

2. ne peut pas être utilisé dans le contexte d'une expression

3. Moins efficace

7. Très utile pour traiter une jointure de liste de promesses de taille dynamique

8. Idéal pour manipuler plusieurs accessoires détachés Promise

"var join = Promise.join;join(getPictures(), getComments(), getTweets(),
 function(pictures, comments, tweets) {
 console.log("in total: " + pictures.length + comments.length + tweets.length);
});
"

9. Gérez une collection de cartes de promesses. Un seul échoue et toutes les exécutions se terminent

"
Promise.props({ pictures: getPictures(),
 comments: getComments(),
 tweets: getTweets()
}).then(function(result) {
 console.log(result.tweets, result.pictures, result.comments);
});
"

10 n'importe lequel, certains, race

"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

11.map(Function mapper [, Object options])

用于处理一个数组，或者 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

11.reduce(Fonction réducteur [ , valeur initiale dynamique]) -> Promesse

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

12. Temps

1. .delay(int ms) -> 🎜>

   .timeout(int ms [, String message]) -> Promesse

2. Mise en œuvre de la promesse

q

1. oiseau bleu

2. co

3. quand

ASYNC

La 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) !