2020node(11-18)

最新推荐文章于 2023-04-13 15:12:34 发布
最新推荐文章于 2023-04-13 15:12:34 发布
阅读量148 收藏
点赞数
分类专栏： js 文章标签： js
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/better1166/article/details/106991447
版权 
//11、promise2和x引用的同一个变量

const Promise = require('./promise');
let p = new Promise((resolve,reject)=>{
	resolve(1);
});

let promise2 = p.then(data=>{

}).then(data=>{

});

//promise执行then两次之后的promise
//这两种写法不一致(上与下)
//promise执行then一次之后的promise
let promise2 = p.then(data=>{

});
promise2.then(data=>{

});
/***********************************/
let p = new Promise((resolve,reject)=>{
	resolve(1);
});

let promise2 = p.then(data=>{
	return promise2;           //promise2等待promise2完成(死循环)
});

promise2.then(()=>{

},err=>{
	console.log(err);//TypeError:Chaining cycle detected for Promise #<Promise>
})

/***************************************/
//promise.js
const RESOLVED = 'RESOLVED';//成功
const REJECTED = 'REJECTED';//失败
const PENDING = 'PENDING';//等待态
//resolvePromise 所有的promise都要坚持  bluebird q es6-promise
const resolvePromise=(promise2,x,resolve,reject)=>{
	//1、循环引用 自己等待自己完成 错误的实现
	if(promise2 === x){  //用一个错误类型 结束掉promise
		return reject(new TypeError('chaining cycle detected for promise #<Promise>'));
	}
	//后续的条件要严格判断，保证代码能和别的库一起使用
	let called;
	if ((typeof x=== 'object' && x != null) || typeof x === 'function') //有可能是一个promise
	{
		//要继续判断
		try{
			let then = x.then;
			if(typeof then === 'function')//只能认为是一个promise了
			{
				//不要写成x.then，直接then.call就可以了，因为x.then会再次取值
				then.call(x, y=>{  //根据promise的状态决定是成功还是失败
					if(called)return; //防止别人的promise影响
					called = true;
					//resolve(y);
					resolvePromise(promise2,y,resolve,reject);//递归解析的过程
				},err=>{
					if(called)return;
					called = true;
					reject(err);
				});
			}
			else        //{then:'23'}
			{
				resolve(x);
			}

		}catch(e){ //防止失败了再次进入成功
			if(called)return;
			called = true;
			reject(e);//取值出错
		}
	}
	else
	{
		resolve(x);
	}
};

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;

//12、根据x值来判断是成功还是失败

//别人定义的promise
Object.defineProperty(x,'then',{
	get(){
		throw new Error();
	}
});

const Promise = require('./promise');
let p = new Promise((resolve,reject)=>{
	resolve(1);
});

let promise2= p.then(data=>{
	return new Promise((resolve,reject)=>{
		setTimeout(()=>{
			resolve('错误');
		},1000);
	})
});
promise2.then((data)=>{
	console.log('成功',data);
},err=>{
	console.log('fail',err); //TypeError:Chaining cycle detected for promise #<Promise>
});
//成功 错误



//13、promise的状态更改问题
const Promise = require('./promise');
let p = new Promise((resolve,reject)=>{
	resolve(1);
});
let promise2 = p.then(data=>{
	return new Promise((resolve,reject)=>{
		setTimeout(()=>{
			resolve(new Promise((resolve,reject)=>{
				setTimeout(()=>{
					resolve(2000);
				},1000);
			}))
		},1000);
	})
});
promise2.then((data)=>{
	console.log('成功',data);
},err=>{
	console.log('fail',err);
});
//成功 2000

//14、规范测试
const Promise=require('./promise');
let p = new Promise((resolve,reject)=>{
	resolve(1);
	//reject(1);
});

p.then().then().then(data=>{
	console.log(data);
},err=>{
	console.log(err,'err');
});
/*****************************/
//promise.js
const RESOLVED = 'RESOLVED';//成功
const REJECTED = 'REJECTED';//失败
const PENDING = 'PENDING';//等待态
//resolvePromise 所有的promise都要坚持  bluebird q es6-promise
const resolvePromise=(promise2,x,resolve,reject)=>{
	//1、循环引用 自己等待自己完成 错误的实现
	if(promise2 === x){  //用一个错误类型 结束掉promise
		return reject(new TypeError('chaining cycle detected for promise #<Promise>'));
	}
	//后续的条件要严格判断，保证代码能和别的库一起使用
	let called;
	if ((typeof x=== 'object' && x != null) || typeof x === 'function') //有可能是一个promise
	{
		//要继续判断
		try{
			let then = x.then;
			if(typeof then === 'function')//只能认为是一个promise了
			{
				//不要写成x.then，直接then.call就可以了，因为x.then会再次取值
				then.call(x, y=>{  //根据promise的状态决定是成功还是失败
					if(called)return; //防止别人的promise影响
					called = true;
					//resolve(y);
					resolvePromise(promise2,y,resolve,reject);//递归解析的过程
				},err=>{
					if(called)return;
					called = true;
					reject(err);
				});
			}
			else        //{then:'23'}
			{
				resolve(x);
			}

		}catch(e){ //防止失败了再次进入成功
			if(called)return;
			called = true;
			reject(e);//取值出错
		}
	}
	else
	{
		resolve(x);
	}
};

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){
		onFulfilled = typeof onFulfilled === 'function'?onFulfilled:v=>v;
		onRejected = typeof onRejected === 'function'?onRejected:err=>{throw err};

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

//promise测试
//promise的延迟对象
Promise.defer=Promise.deferred = function(){
	let dfd ={};
	dfd.promise = new Promise((resolve,reject)=>{
		dfd.resolve = resolve;
		dfd.reject = reject;
	});

	return dfd;
}

module.exports = Promise;

//测试命令
//npm install promises-aplus-tests -g
//promises-aplus-tests promise.js


//15、延迟对象的作用(没有测试通过)
const fs = require('fs');
const Promise = require('./promise');
let p = new Promise((resolve,reject)=>{
function read(filename){
	let dfd = Promise.defer();
	fs.readFile(filename,'utf8',(err,data)=>{
		if(err)dfd.reject(err);
		dfd.resolve(data);
	});
	return dfd.promise;
}

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

//16、catch方法的实现
const fs = require('fs');
const Promise = require('./promise');
new Promise((resolve,reject)=>{
	reject(1);
}).then((data)=>{
	console.log(data);
}).catch(err=>{
	console.log(err);
});

//用then实现
const fs = require('fs');
const Promise = require('./promise');
new Promise((resolve,reject)=>{
	reject(1);
}).then((data)=>{
	console.log(data);
}).then(null,err=>{
	console.log(err,'------');
});

/***************************/
//promise.js
const RESOLVED = 'RESOLVED';//成功
const REJECTED = 'REJECTED';//失败
const PENDING = 'PENDING';//等待态
//resolvePromise 所有的promise都要坚持  bluebird q es6-promise
const resolvePromise=(promise2,x,resolve,reject)=>{
	//1、循环引用 自己等待自己完成 错误的实现
	if(promise2 === x){  //用一个错误类型 结束掉promise
		return reject(new TypeError('chaining cycle detected for promise #<Promise>'));
	}
	//后续的条件要严格判断，保证代码能和别的库一起使用
	let called;
	if ((typeof x=== 'object' && x != null) || typeof x === 'function') //有可能是一个promise
	{
		//要继续判断
		try{
			let then = x.then;
			if(typeof then === 'function')//只能认为是一个promise了
			{
				//不要写成x.then，直接then.call就可以了，因为x.then会再次取值
				then.call(x, y=>{  //根据promise的状态决定是成功还是失败
					if(called)return; //防止别人的promise影响
					called = true;
					//resolve(y);
					resolvePromise(promise2,y,resolve,reject);//递归解析的过程
				},err=>{
					if(called)return;
					called = true;
					reject(err);
				});
			}
			else        //{then:'23'}
			{
				resolve(x);
			}

		}catch(e){ //防止失败了再次进入成功
			if(called)return;
			called = true;
			reject(e);//取值出错
		}
	}
	else
	{
		resolve(x);
	}
};

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){
		onFulfilled = typeof onFulfilled === 'function'?onFulfilled:v=>v;
		onRejected = typeof onRejected === 'function'?onRejected:err=>{throw err};

		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;	
	}
	catch(errCallback)
	{
		return this.then(null,errCallback);
	}
	static resolve(data){
		return new Promise((resolve,reject)=>{
			resolve(data);
		})
	}
	static reject(reason){
		return new Promise((resolve,reject)=>{
			reject(reason);
		})
	}
}

//promise测试
//promise的延迟对象
Promise.defer=Promise.deferred = function(){
	let dfd ={};
	dfd.promise = new Promise((resolve,reject)=>{
		dfd.resolve = resolve;
		dfd.reject = reject;
	});

	return dfd;
}

module.exports = Promise;

//17、resolve和reject方法区别
//Promise.resolve();//快速创建一个成功的promise
//Promise.reject();快速的创建一个失败的promise
//区别在于resolve会等待里面的promise执行完毕，reject不会有等待效果

new Promise((resolve,reject)=>{
	resolve(111);
}).then(data=>{
	console.log(data);
};

Promise.resolve(new Promise((resolve,reject)=>{
	setTimeout(()=>{
		resolve('ok');
	},1000);
})).then(data=>{
	console.log(data);
});

/***************************/
//promise.js
const RESOLVED = 'RESOLVED';//成功
const REJECTED = 'REJECTED';//失败
const PENDING = 'PENDING';//等待态
//resolvePromise 所有的promise都要坚持  bluebird q es6-promise
const resolvePromise=(promise2,x,resolve,reject)=>{
	//1、循环引用 自己等待自己完成 错误的实现
	if(promise2 === x){  //用一个错误类型 结束掉promise
		return reject(new TypeError('chaining cycle detected for promise #<Promise>'));
	}
	//后续的条件要严格判断，保证代码能和别的库一起使用
	let called;
	if ((typeof x=== 'object' && x != null) || typeof x === 'function') //有可能是一个promise
	{
		//要继续判断
		try{
			let then = x.then;
			if(typeof then === 'function')//只能认为是一个promise了
			{
				//不要写成x.then，直接then.call就可以了，因为x.then会再次取值
				then.call(x, y=>{  //根据promise的状态决定是成功还是失败
					if(called)return; //防止别人的promise影响
					called = true;
					//resolve(y);
					resolvePromise(promise2,y,resolve,reject);//递归解析的过程
				},err=>{
					if(called)return;
					called = true;
					reject(err);
				});
			}
			else        //{then:'23'}
			{
				resolve(x);
			}

		}catch(e){ //防止失败了再次进入成功
			if(called)return;
			called = true;
			reject(e);//取值出错
		}
	}
	else
	{
		resolve(x);
	}
};

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

		let resolve = (value)=>{
			if(value instanceof Promise)
			{
				return value.then(resolve,reject);//递归解析resolve中的参数，直到这个值是普通值
			}
			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){
		onFulfilled = typeof onFulfilled === 'function'?onFulfilled:v=>v;
		onRejected = typeof onRejected === 'function'?onRejected:err=>{throw err};

		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;	
	}
	catch(errCallback)
	{
		return this.then(null,errCallback);
	}
	static resolve(data){
		return new Promise((resolve,reject)=>{
			resolve(data);
		})
	}
	static reject(reason){
		return new Promise((resolve,reject)=>{
			reject(reason);
		})
	}
}

//promise测试
//promise的延迟对象
Promise.defer=Promise.deferred = function(){
	let dfd ={};
	dfd.promise = new Promise((resolve,reject)=>{
		dfd.resolve = resolve;
		dfd.reject = reject;
	});

	return dfd;
}

module.exports = Promise;

//18、finally的实现原理
//finally:es10的语法
Promise.resolve().finally(()=>{
	console.log('finally');
});
//finally表示不是最终的意思而是无论如何都会执行的意思
Promise.resolve(123).finally(()=>{
	console.log('finally');
});
Promise.reject(123).finally(()=>{
	console.log('finally');
}).catch(err=>{
	console.log(err);
});
//finally  123

Promise.resolve(123).finally(()=>{
	console.log('finally');
}).then(data=>{
	console.log(data,'success');
}).catch(err=>{
	console.log(err,'error')
});
//finally 123 'success'
//如果返回一个promise，会等待这个promise也执行完毕，（如果是失败的promise，会用他的失败原因传给下一个人）
Promise.prototype.finally = function(callback){
	return this.then((value)=>{
		return Promise.resolve(callback()).then(()=>value);
	},(reason)=>{
		return Promise.resolve(callback()).then(()=>{throw reason});
	});
}
Promise.resolve(123).finally(()=>{
	console.log('finally');
	return new Promise((resolve,reject)=>{
		setTimeout(()=>{
			//resolve('ok');
			reject('ok');
		},3000);
	})
}).then(data=>{
	console.log(data,'success');
}).catch(err=>{
	console.log(err,'error');
});

 

Better1166
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2020-11-18 同步和异步 async 和await 和跨域
html_xiaojiu的博客
11-18 257
一，同步和异步得个人简述 1.什么是同步？ 任务有很多个但是后面的任务需要等待上一个任务执行完成之后才可以继续的执行 2.什么是异步？ 任务有很多个但是任务是各自执行各自的不需要谁等待谁，执行结束就返回 3.什么是阻塞？ 我没有结束你就不可以执行 4.什么是非阻塞？ 我没有结束但是你也可以做你自己的事 5.什么是同步阻塞？ 任务很多个我结束后返回数据你就可以用了 后面程序要等待我 6.什么是同步非阻塞？ 任务很多
kubernetes mysql多主_2020-11-02 使用K8s部署MySQL 双主集群
weixin_36054508的博客
02-26 1396
机器角色mysql-0master\slavemysql-1slave\master最近对线上集群做高可用升级，在对比了几个集群策略之后，综合现有资源、复杂度、可用度之后，选择了两个：MySQL双主的互为备份的2节点集群MySQL基于wsrep协议的Galera Cluster的mysql多主集群初步处于复杂度考虑，选择了方案一。方案一又有两个版本：利用keepalived做活跃监督利用k8s s...
promise源码从零开始编写记录之二（编写then与异步处理）
qq_34258791的博客
06-17 244
关于Then的处理，还需要从resolve说起 从使用方式开始 let promise = new Promise((resolve, rejected) => {//我已经习惯了写rejected，个人使用风格 // todo.... resolve('data') }) promise.then(data => { console.log(data) //成功 }, error => { console.log(error) //失败 }) .
20212022最新Web前端经典面试题笔试题之前端手写功能(含答案)史上最全【笔试题】
南北极之间
02-24 838
前端面试中常见的手写功能
Promise学习笔记（尚硅谷）
Ch_ensf的博客
05-16 1314
一、Promise 的理解和使用 二、手写 Promise
这 10 个片段，有助于你理解 ES 中的 Promise
高先生的猫
08-03 747
在开发中，了解JavaScript和 Promise 基础，有助于提高我们的编码技能，今天，我们一起来看看下面的 10 片段，相信看完这 10 个片段有助于我们对 Promise 的理解。 片段1： const prom = new Promise((res, rej) => { console.log('first'); res(); console.log('second'); }); prom.then(() => { console.log('third'); ..
完整实现原生Promise
m0_46269977的博客
04-08 666
手写前需要了解这些 1.什么是宏任务 我们都知道JS是单线程的，但是一些高耗时操作就带来了进程阻塞的问题，为了解决这个问题，JS有两种任务的执行模式，同步模式和异步模式。 在异步模式下，创建异步任务主要分为宏任务和微任务两种，宏任务是由宿主（浏览器、Node）发起的，而微任务由JS自身发起。 宏任务与微任务的几种创建方式 ???? 宏任务（Macrotask）微任务（Microtask）setTimeoutrequestAnimationFrame（有争议）setIntervalMutationObserv
nodemcu-release-18-modules-2021-06-04-02-03-43-integer.bin
06-04
You selected the following 18 modules: adc dht file gpio http i2c mqtt net node ow pwm sjson spi tmr u8g2 uart websocket wifi. We'll keep you posted by email about the progress of your build. In ...
5DK5 物聯網實作：Node-RED萬物聯網視覺化 範例內容.zip
06-29
内容如下： E:\portal\IOTDataCollector_Node-RED\5DK5 物聯網實作：Node-RED萬物聯網視覺化 範例內...2017-07-17 22:19 11,507 chap18_nodered.txt 1 个文件 11,507 字节 5DK5 物聯網實作：Node-RED萬物聯網視覺化
node-next-gae-demo:UniversalIsomorphic React Next.js应用程序，旨在与Google App Engine的Node.js标准环境配合使用
04-29
v0.3.4-2020-07-18 各种软件包的安全性升级 v0.3.3-2019-11-02 在添加Google App Engine的构建和部署支持 v0.3.2-2019-10-27 添加Google Cloud Build和Google Container Registry支持ala v0.3.1-2019-10-27 在...
2021-05-27
weixin_44194685的博客
05-28 157
目录 es6若干方法总结 对象扩展方法 1.Object.assign() 该方法可以将多个源对象属性复制到一个目标对象中 const obj1 = { a: 123, b: 234 } const obj2 = { a: 456, c: 234 } const result = Object.assign(obj1, obj2) console.log(result) // { a:456, b:234, c:234 } console.log(r...
手动实现Promise
最新发布
qq_33715850的博客
04-13 107
手动实现Promise
JSTL中foreach与fn表达式
weixin_34226706的博客
11-10 130
2019独角兽企业重金招聘Python工程师标准>>> ...
JSTL中foreach与fn表达式的详细使用说明
唯品衣秀
11-13 386
在jstl中的fn标签也是我们在网页设计中经常要用到的很关键的标签，在使用的时候要先加上头 &lt;%@ taglib uri=" http://java.sun.com/jsp/jstl/functions " prefix="fn"%&gt;就可以使用fn标签了。 具体使用方法请参见下表： 函数 描述 fn:co...
手写前端面试题（一）
yubaibai2233的博客
03-09 246
https://blog.csdn.net/yubaibai2233/article/details/123458749https://blog.csdn.net/yubaibai2233/article/details/123458749 目录 手写eventEmitter类，包括on()、off()、once()、emit()方法 手写Promise封装Ajax 手写bind、apply、call 手写instanceof 手写Promise 手写Promise.all 手写Promis
实现一个TS版，符合 Promise/A+规范的 Promise
zz_jesse的博客
02-27 1219
本文授权转载自：Col0ring，http://juejin.cn/post/6886360224308035598，主旨：本文使用 typescript，根据类型定义从零开始实现了一个 ...
es6 promise 源码解析
qq_42389674的博客
07-17 383
promise 源码解析
详解Promise的实现
zl13015214442的博客
09-25 813
1. 初级版 首先要确定promise有什么特点： promise是一个类； 每次new 一个promise 都需要传递一个执行器 执行器是立即执行的； 执行器函数中有两个参数 resolve reject； 默认promise有三个状态 pending => fulfilled 表示成功了， pending => rejected 表示失败了； 如果一旦成功了，不能变成失败；一旦失...
使用promise解决回调地狱_promise 的那些事
weixin_32463071的博客
12-29 721
1. promise 的由来1.1 异步我们都知道 js 是单线程的，也就是说一次只能完成一件任务。如果有多个任务，就必须排队，等待前面一个任务完成，再执行后面一个任务。这种方式虽然实现起来比较简单，执行环境相对单纯，但是只要有一个任务耗时很长，后面的任务都必须排队等着，会拖延整个程序的执行。常见的浏览器无响应（假死），往往就是因为某一段 js 代码长时间运行（比如死循环），导致整个页面卡在这个地...
NodeMCU-API中文详细指南
"NodeMCU-API中文说明 .pdf" NodeMCU是一种基于Lua脚本语言的开源硬件平台，常用于物联网(IoT)项目。它的API是开发者与硬件交互的主要工具，提供了丰富的功能来控制和配置硬件资源。这篇中文说明详细介绍了NodeMCU ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值