2020-node-promise（6-10）

最新推荐文章于 2022-10-19 20:22:39 发布
最新推荐文章于 2022-10-19 20:22:39 发布
阅读量159 收藏
点赞数
分类专栏： js
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/better1166/article/details/106961417
版权 
//6、简单的promise
//promise的特点以及概念
//https://promisesaplus.com/ promisea+规范，都通过这个规范来实现的
//promise es6内部已经实现了 ie不支持promise，需要polyfill es6-promise
           
//promise为什么会产生解决异步问题
//1、多个异步请求并发（希望同步最终的结果） Promise.all
//2、链式异步请求的问题  上一个人的输出是下一个人的输入  Promise的链式调用可以解决这个问题
//3、缺陷：还是基于回调的
//promise就是一个类
//1、promise有三个状态：成功态(resolve)、失败态(reject)、等待态(pending 不成功又不失败)
//2、用户自己决定失败的原因和成功的原因   成功和失败也是用户定义的
//3、promise默认执行器是立即执行
//4、promise的实例都拥有一个then方法，一个参数是成功的回调，另一个是失败的回调
//5、如果执行函数时发生了异常也会执行失败逻辑
//6、如果promise一但成功了就不能失败，反过来也是一样的(只有等待态的时候才能去更改状态)
           
           let promise = new Promise((resolve,reject)=>{
             reject('没发工资');
           })
           console.log(promise);

           let promise = new Promise((resolve,reject)=>{
                console.log(1);
           });
           console.log(2);   // 1->2

           //调用promise
           let Promise = require('./promise');
           let promise = new Promise((resolve,reject)=>{
             console.log(1);
             resolve('成功');
             throw new Error('失败了');   //成功了就不会走失败，失败了就不会走成功
             //resolve('成功');
           });
           promise.then((data)=>{
              console.log('success',data);
           },(err)=>{
              console.log('fail',err);
           });

           //promise就是一个类
           //1、promise有三个状态：成功态(resolve)、失败态(reject)、等待态(pending 不成功又不失败)
           //2、用户自己决定失败的原因和成功的原因   成功和失败也是用户定义的
           //3、promise默认执行器是立即执行
           //4、promise的实例都拥有一个then方法，一个参数是成功的回调，另一个是失败的回调
           //5、如果执行函数时发生了异常也会执行失败逻辑
           //6、如果promise一但成功了就不能失败，反过来也是一样的(只有等待态的时候才能去更改状态)
           const RESOLVED = 'RESOLVED';
           const REJECTED = 'REJECTED';
           const PENDING = 'PENDING';

           class Promise{
                constructor(executor){
                    this.status = PENDING;
                    this.value = undefined;
                    this.reason = undefined;
                    let resolve = (value) =>{  //调用此方法就是成功
                        if(this.status === PENDING)
                        {
                            this.value = value;
                            this.status = RESOLVED;
                        }
                    }

                    let reject = (reason)=>{
                        if(this.status === PENDING)
                        {
                            this.reason = reason;
                            this.status = REJECTED;
                        }
                    }

                    try{
                        executor(resolve,reject); //立即执行
                    }catch(e){   //错误处理，需要直接走错误逻辑
                        console.log(e);
                        reject(e);
                    }

                }

                then(onFulfilled,onRejected){
                    if(this.status === RESOLVED)
                    {
                        onFulfilled(this.value);
                    }
                    if(this.status === REJECTED)
                    {
                        onRejected(this.reason);
                    }
                    if(this.status === PENDING)
                    {
                        console.log('等待');
                    }
                }

           }

           module.exports = Promise;

//7、promise的then方法
let Promise = require('./promise');
let promise = new Promise((resolve,reject)=>{
	setTimeout(()=>{
		//resolve('成功');
		reject('不成功');
	},1000);
});

//1、promise调用then方法时可能当前的promise并没有成功， pending
promise.then((data)=>{
	console.log('success',data);
},(err)=>{
	console.log('failed',err);
});

//2、发布订阅模式，如果当前状态是pending时，我们需要将成功的回调和
//失败的回调存放起来，稍后调用resolve和reject的时候重新执行
promise.then((data)=>{
	console.log('success1',data);
},(err)=>{
	console.log('failed1',err);
});

//promise.js
const RESOLVED = 'RESOLVED';//成功
const REJECTED = 'REJECTED';//失败
const PENDING = 'PENDING';//等待态

class Promise{
	constructor(executor){
		this.status = PENDING;
		this.value = undefined;
		this.reason = undefined;
		this.onResolvedCallbacks=[];//专门用来存放成功的回调
		this.onRejectedCallbacks=[];//专门用来存放失败的回调

		let resolve = (value)=>{
			if(this.status === PENDING){
				this.value = value;
				this.status = RESOLVED;
				this.onResolvedCallbacks.forEach(fn=>fn());
			}
		}

		let reject = (reason)=>{
			if(this.status === PENDING){
				this.reason = reason;
				this.status = REJECTED;
				this.onRejectedCallbacks.forEach(fn=>fn());
			}
		}

		try{
			executor(resolve,reject);//立即执行
		}catch(e){
			reject(e);
		}
	}

	then(onFulfilled, onRejected){
		if(this.status === RESOLVED){
			onFulfilled(this.value);
		}
		if(this.status === REJECTED){
			onRejected(this.reason);
		}
		if(this.status === PENDING){
			this.onResolvedCallbacks.push(()=>{  //为什么要写成这样？
				//todo...
				onFulfilled(this.value);
			});
			this.onRejectedCallbacks.push(()=>{
				//todo...
				onRejected(this.reason);
			});
		}
	}
}

module.exports = Promise;

//8、链式调用

name.txt
内容：age.txt

age.txt
内容:10

let fs = require('fs');

//error first 错误第一 异步方法无法通过try catch捕获异常
fs.readFile('./name.txt','utf8',(err,data)=>{
	fs.readFile(data,'utf8',(err,data)=>{
		console.log(data);
	})
});

//变成promise
function read(filename){
	return new Promise((resolve,reject)=>{
		fs.readFile(filename,'utf8',(err,data)=>{
			if(err)return reject(err);
			resolve(data);
		})
	})
}

//1、promise成功和失败的回调的返回值，可以传递到外层的下一个then
//2、如果返回的是普通值的话(传递到下一次的成功中，不是错误不是promise就是普通值),可能还要promise的情况
//(会采用promise的状态，决定走下一次的成功还是失败)、出错的情况（一定会走到下一次的失败）
//3、错误处理 如果离自己最近的then没有错误处理（没有写错误函数）会向下找
//4、每次执行完promise.then方法后返回的都是一个“新的promise”（promise一旦成功或者失败就不能修改状态）
read('./name.txt').then((data)=>{
	return 100;
},(err)=>{
	return 200;
}).then((data)=>{
	console.log('--------------',data);
},(err)=>{
	console.log('---------------',err+'错误');
});
//D>node test.js
//--------------- 10


read('./name.txt').then((data)=>{
	return read(data);
},(err)=>{
	console.log("******",err);
}).then((data)=>{
	console.log('---------------',data);
},(err)=>{
	console.log('---------------',err+'错误');
});
//>node test.js
//--------------- 10

read('./name.txt').then((data)=>{
	return data;
}).then((data)=>{
	console.log('-------------',data);
},err=>{
	console.log('-------------',err+'错误');
});
//>node test.js
//------------- age.txt
//>node test.js
//------------- Error: ENOENT: no such file or directory, open 'D:\important_file\笔记\name1.txt'错误


//9、普通值处理

let fs = require('fs');
let Promise = require('./promise');

function read(filename)
{
	return new Promise((resolve,reject)=>{
		fs.readFile(filename,'utf8',(err,data)=>{
			if(err)reject(err);
			resolve(data);
		})
	})
}

read('./name.txt').then((data)=>{
	return 1;
}).then((data)=>{

});

//或者改写成：
let fs = require('fs');
let Promise = require('./promise');

let p1 = new Promise((resolve,reject)=>{ //调用p1.resolve(100)=>p1.then(data=)  p2.resolve(1)=>p2.then(data)
	resolve(100);
})

let promise2 = p1.then((data)=>{
	return 1;
})

promise2.then((data)=>{
	console.log(data);//1
})

//promise.js
const RESOLVED = 'RESOLVED';//成功
const REJECTED = 'REJECTED';//失败
const PENDING = 'PENDING';//等待态

class Promise{
	constructor(executor){
		this.status = PENDING;
		this.value = undefined;
		this.reason = undefined;
		this.onResolvedCallbacks=[];//专门用来存放成功的回调
		this.onRejectedCallbacks=[];//专门用来存放失败的回调

		let resolve = (value)=>{
			if(this.status === PENDING){
				this.value = value;
				this.status = RESOLVED;
				this.onResolvedCallbacks.forEach(fn=>fn());
			}
		}

		let reject = (reason)=>{
			if(this.status === PENDING){
				this.reason = reason;
				this.status = REJECTED;
				this.onRejectedCallbacks.forEach(fn=>fn());
			}
		}

		try{
			executor(resolve,reject);//立即执行
		}catch(e){
			reject(e);
		}
	}
//1、promise成功和失败的回调的返回值，可以传递到外层的下一个then
//2、如果返回的是普通值的话(传递到下一次的成功中，不是错误不是promise就是普通值),可能还要promise的情况
//(会采用promise的状态，决定走下一次的成功还是失败)、出错的情况（一定会走到下一次的失败）
//3、错误处理 如果离自己最近的then没有错误处理（没有写错误函数）会向下找
//4、每次执行完promise.then方法后返回的都是一个“新的promise”（promise一旦成功或者失败就不能修改状态）

	then(onFulfilled, onRejected){
		let promise2 = new Promise((resolve,reject)=>{ //为了实现链式调用
			if(this.status === RESOLVED){
				let x = onFulfilled(this.value);
				resolve(x);
			}
			if(this.status === REJECTED){
				onRejected(this.reason);
			}
			if(this.status === PENDING){
				this.onResolvedCallbacks.push(()=>{  
					//todo...
					onFulfilled(this.value);
				});
				this.onRejectedCallbacks.push(()=>{
					//todo...
					onRejected(this.reason);
				});
			}
		});
		return promise2;	
	}
}

module.exports = Promise;


//10、promise2状态的处理
let fs = require('fs');
let Promise = require('./promise');

//调用p1.resolve(100)=>p1.then(data)
//p2.resolve(1)=>p2.then(data)

let p1 = new Promise((resolve,reject)=>{
	reject(100);
});

let p2 = p1.then((data)=>{
	return 1;
},err=>{
	return '失败';
});
p2.then((data)=>{
	console.log(data,"******");
});


//promise.js
const RESOLVED = 'RESOLVED';//成功
const REJECTED = 'REJECTED';//失败
const PENDING = 'PENDING';//等待态

class Promise{
	constructor(executor){
		this.status = PENDING;
		this.value = undefined;
		this.reason = undefined;
		this.onResolvedCallbacks=[];//专门用来存放成功的回调
		this.onRejectedCallbacks=[];//专门用来存放失败的回调

		let resolve = (value)=>{
			if(this.status === PENDING){
				this.value = value;
				this.status = RESOLVED;
				this.onResolvedCallbacks.forEach(fn=>fn());
			}
		}

		let reject = (reason)=>{
			if(this.status === PENDING){
				this.reason = reason;
				this.status = REJECTED;
				this.onRejectedCallbacks.forEach(fn=>fn());
			}
		}

		try{
			executor(resolve,reject);//立即执行
		}catch(e){
			reject(e);
		}
	}
//1、promise成功和失败的回调的返回值，可以传递到外层的下一个then
//2、如果返回的是普通值的话(传递到下一次的成功中，不是错误不是promise就是普通值),可能还要promise的情况
//(会采用promise的状态，决定走下一次的成功还是失败)、出错的情况（一定会走到下一次的失败）
//3、错误处理 如果离自己最近的then没有错误处理（没有写错误函数）会向下找
//4、每次执行完promise.then方法后返回的都是一个“新的promise”（promise一旦成功或者失败就不能修改状态）

	then(onFulfilled, onRejected){
		let promise2 = new Promise((resolve,reject)=>{ //为了实现链式调用
			if(this.status === RESOLVED){
				let x = onFulfilled(this.value);
				resolve(x);
			}
			if(this.status === REJECTED){
				let x = onRejected(this.reason);
				resolve(x);
			}
			if(this.status === PENDING){
				this.onResolvedCallbacks.push(()=>{  
					//todo...
					let x = onFulfilled(this.value);
					resolve(x);
				});
				this.onRejectedCallbacks.push(()=>{
					//todo...
					let x = onRejected(this.reason);
					resolve(x);
				});
			}
		});
		return promise2;	
	}
}

module.exports = Promise;

//如果返回的是一个promise呢？
let fs = require('fs');
let Promise = require('./promise');

let p1 = new Promise((resolve,reject)=>{
	resolve(100);
});

let p2 = p1.then((data)=>{
	return new Promise((resolve,reject)=>{//也有可能是throw new Error()
		setTimeout(()=>{
			resolve('OK');
		},1000);
	})
},err=>{
	return '失败';
});
p2.then((data)=>{
	console.log(data,"******");
},err=>{

});

//promise.js
const RESOLVED = 'RESOLVED';//成功
const REJECTED = 'REJECTED';//失败
const PENDING = 'PENDING';//等待态
const resolvePromise=(promise2,x,resolve,reject)=>{

};

class Promise{
	constructor(executor){
		this.status = PENDING;
		this.value = undefined;
		this.reason = undefined;
		this.onResolvedCallbacks=[];//专门用来存放成功的回调
		this.onRejectedCallbacks=[];//专门用来存放失败的回调

		let resolve = (value)=>{
			if(this.status === PENDING){
				this.value = value;
				this.status = RESOLVED;
				this.onResolvedCallbacks.forEach(fn=>fn());
			}
		}

		let reject = (reason)=>{
			if(this.status === PENDING){
				this.reason = reason;
				this.status = REJECTED;
				this.onRejectedCallbacks.forEach(fn=>fn());
			}
		}

		try{
			executor(resolve,reject);//立即执行
		}catch(e){
			reject(e);
		}
	}
//1、promise成功和失败的回调的返回值，可以传递到外层的下一个then
//2、如果返回的是普通值的话(传递到下一次的成功中，不是错误不是promise就是普通值),可能还要promise的情况
//(会采用promise的状态，决定走下一次的成功还是失败)、出错的情况（一定会走到下一次的失败）
//3、错误处理 如果离自己最近的then没有错误处理（没有写错误函数）会向下找
//4、每次执行完promise.then方法后返回的都是一个“新的promise”（promise一旦成功或者失败就不能修改状态）

	then(onFulfilled, onRejected){
		let promise2 = new Promise((resolve,reject)=>{ //为了实现链式调用
			if(this.status === RESOLVED){
				setTimeout(()=>{
					try{
						let x = onFulfilled(this.value);
						//x可能是一个promise,加上setTimeout的原因是等待promise2执行完毕，获取到promise2
						resolvePromise(promise2,x,resolve,reject);
					}catch(e){
						reject(e);
					}
				},0);
			}
			if(this.status === REJECTED){
				setTimeout(()=>{
					try{
						let x = onRejected(this.reason);
						resolvePromise(promise2,x,resolve,reject);
					}catch(e){
						reject(e);
					}
				},0);
			}
			if(this.status === PENDING){
				this.onResolvedCallbacks.push(()=>{  
					//todo...
					setTimeout({
						try{
							let x = onFulfilled(this.value);
							resolvePromise(promise2,x,resolve,reject);
						}catch(e){
							reject(e);
						}
					},0);
				});
				this.onRejectedCallbacks.push(()=>{
					//todo...
					setTimeout({
						try{
							let x = onRejected(this.reason);
							resolvePromise(promise2,x,resolve,reject);
						}catch(e){
							reject(e);
						}
					},0);
				});
			}
		});
		return promise2;	
	}
}

module.exports = Promise;

 

Better1166
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Node开发（六）Promise
weixin_43933148的博客
09-26 350
Promise是一种异步编程的解决方案。 现在经常使用回调函数来解决异步通信(传参)的问题,若回调函数层次过深，就会出现回调地狱问题(逻辑不够清晰，可维护性差) Promise是一个对象，通过new Promise来创建对象 1.创建Promise对象 1）Promise对象需要接收一个函数作为参数，这个作为参数的函数有两个参数，resolve，reject 2）resolve和reject本身也是函数 let p=new Promise((resolve,reject)=>{ }); P
node中Promise使用
Wollens Blogs
07-27 1129
node中Promise使用实例 需求：现有三个文件需要依次读取文件内容 // a.json { "next": "b.json", "massage": "this is a file content" } b.json { "next": "c.json", "massage": "this b file content" } c.json { "n...
js promise
xinxin_zhu的博客
03-24 135
<html> <head> <title>promise</title> <meta charset="utf-8"> <style> </style> </head> <body> <h1>同步和异步 </h1> ...
(精华)2020年7月5日 JavaScript高级篇 ES6(Promise)
热门推荐
时光隧道
07-05 56万+
Promise 是什么 是一种异步解决的方案 比es5传统的解决异步的方案（回调函数） es6提供了promise对象 以前处理异步的方式 // 后者要等待前者执行的结果 f2 要等待 f1执行完 function f1(callback){ setTimeout(()=>{ var res = 'f1' console.log('我先执行从后台获取到了f1'); callback(res) },1000) } function f2(v
JS - Promise的各种面试问题及分析
kelly0721的博客
10-19 1102
Promise的各种面试问题及分析
如何在Node中使用Promise
Welkin_qing的博客
10-27 658
如何在Node中使用Promise
promise-polyfill, 轻量级ES6承诺为浏览器和 node 提供 polyfill 符合 A .zip
09-18
promise-polyfill, 轻量级ES6承诺为浏览器和 node 提供 polyfill 符合 A 承诺 Polyfill 轻量级ES6承诺为浏览器和 node 提供 polyfill 。 严格遵循规范。 它是一个完美的polyfill IE，Firefox 或者任何其他不支持本机承诺的浏览器。有关承诺的API信息，请参阅本文 H
milvus-sdk-node:Milvus 节点 SDK
07-24
all 函数将返回一个 promise，因此我们可以使用 async await 来获取结果。 依赖关系 Milvus：v2.x 节点：v12+ 安装 npm install @ zilliz / milvus2 - sdk - node 先决条件 在我们开始之前，有一些先决条件。 ...
node-mysql-promise
04-12
node-mysql-promise 修复异步查询bug版本 Install $ npm i -D git+https://github.com/gofancyever/node-mysql-promise.git Introduction node mysql操作封装类，基于promise，借鉴75team开源项目thinkjs中model操作...
Node.js-Karin-基于promise的HTTP客户端支持浏览器和node.js
08-10
Karin 是一个专门针对Node.js设计的基于Promise的HTTP客户端库，它不仅适用于Node.js环境，还能够无缝地在浏览器环境中运行。Promise是ES6引入的一种处理异步操作的新方法，它解决了回调地狱的问题，提供了更加清晰...
前端开源库-node-promise.zip
10-05
"前端开源库-node-promise.zip"这个压缩包文件很可能包含了一个或多个与Promise相关的开源库，这些库可能用于在Node.js环境中增强Promise的功能，提供更高效的异步操作管理。 Promise 对象在 ES6 中被正式引入，它...
前端开源库-node-promise
08-29
在压缩包文件名`node-promise-master`中，“master”通常表示这是项目的主分支，包含了最新的稳定版本源代码。解压后，开发者可以查看源码，了解其实现方式，或者直接在项目中使用这个库，通过阅读文档或示例来学习...
【Unity精品插件】Easy Save v3.5.16 最新版
09-08
Easy Save：简化 Unity 游戏数据存储与加载 一、Easy Save 简介 Easy Save 是专门为 Unity 开发者设计的一款数据存储和加载工具。它旨在简化数据保存和恢复的过程，使开发者能够专注于游戏的核心逻辑，而不必在数据管理上花费过多的精力。 二、主要特点 （一）多种数据类型支持 支持几乎所有常见的数据类型，包括整数、浮点数、字符串、数组、字典、自定义类等。 例如，可以轻松保存玩家的得分、等级、装备信息以及游戏中的各种配置参数。 （二）简单易用的 API 提供了简洁直观的 API 接口，只需几行代码就能实现数据的保存和加载。 （三）跨平台兼容性 能够在不同的平台上（如 Windows、Mac、Android、iOS 等）保持一致的性能和功能，确保玩家在不同设备上的游戏体验连贯。 （四）加密选项 提供数据加密功能，保障玩家数据的安全性和隐私性。
中南财经政法大学在广东2021-2024各专业最低录取分数及位次表.pdf
09-08
全国各大学在广东省2021~2024年各专业最低录取分数及位次
广西森林（人工和分人工林）30m分辨率.tif
最新发布
09-09
广西森林（人工林和原始森林）.tif 人工林是人为种植的森林，是经过人工干预和管理的，旨在获得经济和生态效益的森林。人工林通常是由一种或几种快速生长的树种组成，种植密度较高，树木生长规律和结构比较均匀。目前，人工林主要用于木材、纸浆和能源木等商业目的。 原始森林是指未受过人类干扰、保持自然生态系统的森林。原始森林具有高度复杂的生态系统，拥有丰富的植物和动物物种，同时还对全球气候具有重要作用。原始森林通常被视为生物多样性的宝库，具有重要的科研和保护价值。 人工林和原始森林在多方面存在差异。人工林是经过人为种植和管理的，树种组成和生长规律比较单一，而原始森林则是自然形成的，具有更高的生物多样性。人工林主要追求经济效益，而原始森林更注重生态系统的保护和科学研究。此外，人工林可以通过种植和砍伐进行经营和利用，而原始森林则需要进行保护和管理以维持其自然状态。
5G中级认证-5G小区搜索.pptx
09-08
5G网络优化
5G中级认证-4G和5G互操作原理及共建共享方案.pptx
09-08
5G网络优化
TicketConcert-main.zip
09-08
TicketConcert-main
接口测试（requests）
09-08
接口测试（requests）
es6-promise依赖下载
06-09
ES6-Promise是一个用于在JavaScript中实现Promise功能的库，它为浏览器和Node.js环境提供了对Promise规范的支持，特别适用于那些不直接支持ES6 Promise特性的环境。它解决了早期浏览器对Promise的不完全支持问题。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值