Cet article vous apporte une introduction aux associations polymorphes de Laravel (avec code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.
Qu'est-ce que la promesse
Le site officiel explique que la promesse représente le résultat final d'une opération asynchrone.
Traduction == La promesse peut être comprise comme une machine à états ==, elle a trois états différents, et il ne peut y avoir qu'un seul état à un certain moment
en attente signifie que la résolution est toujours en cours exécuté Exécution réussie rejetée Échec de l'exécution
Une promesse est une encapsulation d'une opération asynchrone L'opération asynchrone a trois résultats possibles d'attente d'achèvement, de succès et d'échec, correspondant aux trois états de promesse.
L'état de promesse ne peut avoir que le bit de conversion en attente résolu ou en attente converti en rejeté. Une fois la conversion d'état terminée, il ne peut pas être modifié.
Supposons que nous utilisions une promesse pour sceller une opération asynchrone, elle sera alors dans l'état en attente lors de sa création. Lorsque l'opération asynchrone sera terminée avec succès,
nous convertirons l'état en résolu, si. une erreur se produit lors de l'exécution, convertissez le statut en rejeté.
var promise=new Promise(function(resolve,reject){
// code
if(){
/*异步操作成功 */
resolve(value)
}else{
reject(error)
}
})Utilisez la méthode then pour obtenir le résultat
var fs=require('fs')
function readFile_promise(path){
return new Promise(function(resolve,reject){
fs.readFile(path, 'utf-8',function(err,data){
if(data){
resolve(data)
}else{
reject(err)
}
})
})
}
var result=readFile_promise('./1.txt')
result.then(function(value){
//success
console.log('success', value)
},function(error){
//failure
console.log('failure',error)
})
// 将一个异步函数封装成promise，只要在回调函数中针对不同的返回结果调用resolve或者reject方法。
// resolve函数会在异步操作成功完成时被调用，并将异步操作的返回值作为参数传递到外部。
// reject是在异步操作出现异常时被调用，会将错误信息作为参数传递出去。La valeur de retour de la méthode then
La méthode then renvoie toujours un nouvel objet de promesse, et la méthode then est appelée plusieurs fois et renvoie un objet de promesse vide par défaut
Utilisez return pour revenir.
var promise=readFile_promise('./foo.txt')
promise.then(function(value){
//success
console.log('success', value) // foo
return readFile_promise('./bar.txt')
},function(error){
//failure
console.log('failure',error)
}).then(function(value){
console.log('then', value) // bar
})var promise=new Promise((resolve, reject)=>{
console.log('begin')
resolve()
})
setTimeout(()=>{
promise.then(()=>{
console.log('end')
})
},5000)
// 开始begin 5s后end
// 运行顺序是，当promise从被创建的那一刻起就开始执行了，then方法只是提供了访问promise状态的接口，与promise的执行无关。 // 如果有多个promise需要执行，可以使用promise.all()
// 方法统一声明，改方法可以将多个promise对象包装成一个promise
// 该方法接收一个数组作为参数，数据的元素如果不是promise对象，则回先调用resolve方法转换。
// 如果中间有一个promise状态是reject，那么转换后的promise也会变成reject，并且将错误信息传给catch方法
var promises=['foo.txt','bar.txt','baz.txt']
promises.map(function(path){
// console.log(path)
return readFile_promise(path)
})
Promise.all(promises).then(function(results){
console.log(results) // [ 'foo.txt', 'bar.txt', 'baz.txt' ] 顺序排列的
}).catch(function(err){
//
})// 例子； 有三个文本文件需要顺序读取
var lists=['foo.txt','bar.txt','baz.txt']
var count=0;
readFile_promise('foo.txt').then(readCB).then(readCB).then(readCB);
function readCB(data){
console.log(data) // foo bar baz
if(++count>2){
return
}
return readFile_promise(lists[count])
}Après le mot-clé wait C'est souvent une promesse. Sinon, promise.resolve est implicitement appelé pour la convertir en promesse.
await attend que la promesse suivante soit exécutée avant de passer à l'étape suivante.
var asyncReadFile=async function(){
var result1=await readFile_promise('./foo.txt')
console.log(result1.toString()) // foo
}
asyncReadFile()La fonction asynchrone renvoie toujours un objet de promesse. Si le mot-clé return n'est pas suivi d'une promesse, alors la promesse est appelée par défaut
. méthode de résolution pour la conversion.
async function asyncFunc(){
return 'hello Node'
}
asyncFunc().then(function(data){
console.log(data) // hello Node
})Si le mot-clé wait est rencontré, l'exécution sera suspendue après. wait L'exécution de l'opération asynchrone reprendra une fois que
async function asyncFunc(){
console.log('begin')
return 'hello Node'
}
asyncFunc().then(function(data){
console.log(data) // hello Node
console.log('end')
})
// begin
// hello
// endawait sera renvoyée. Il est déterminé par le résultat de l'opération de l'objet de promesse suivant. Si l'objet de promesse suivant est résolu, la valeur renvoyée par l'opérateur
await est la valeur résolue si l'état de l'objet de promesse est rejeté, alors wait sera également déterminé ; jeter la valeur de rejet.
async function readFile(){
var result=await readFile_promise('./foo.txt')
console.log(result) // foo
}
readFile()
// 等价于
readFile_promise('foo.txt').then(function(data){
console.log(data) // foo
})attendre attendra que la promesse suivante se termine avant d'entreprendre l'action suivante, ce qui signifie que lorsque plusieurs opérations d'attente sont effectuées, le programme deviendra complet
Fonctionnement en série.
Lorsqu'il n'y a pas de dépendances entre les opérations asynchrones, promise.all peut être utilisé pour réaliser le parallélisme.
async function readFile(){
const [result1, result2]=await Promise.all([
readFile_promise('./foo.txt'),
readFile_promise('./bar.txt')
])
console.log(result1, result2) // foo bar
}
readFile()
// 等价于
function readFile(){
return Promise.all([
readFile_promise('./foo.txt'),
readFile_promise('./baz.txt')
]).then((result)=>{
console.log(result) // [ 'foo', 'baz' ]
})
}
readFile()Certains points clés de l'utilisation du mot-clé wait
Cet article est terminé ici. Pour un contenu plus passionnant, vous pouvez faire attention à la colonne Tutoriel vidéo JavaScript du site Web PHP chinois !
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
