/*****************************/
//19、promisify
//promise可以解决的问题：
//1、回调嵌套的问题 .then.then
//2、可以同步多个异步请求的结果
function read()
{
return new Promise((resolve,reject)=>{
fs.readFile(name.txt,data,function(err,data){
if(err)reject(err);
resolve(data);
})
})
}
function write()
{
return new Promise((resolve,reject)=>{
fs.readFile(name.txt,data,function(err,data){
if(err)reject(err);
resolve(data);
})
})
}
/**我没有打印出结果*/
const fs = require("fs").promises;
const util = require('util');
let read = util.promisify(fs.readFile);
let write = util.promisify(fs.writeFile);
read('name.txt','utf8').then((data)=>{
console.log(data);
})
/*********************/
//将node的api快速的转换成promise的形式
//fs.readFile()
const fs = require('fs');
const promisify = fn=>(...args)=>{
return new Promise((resolve,reject)=>{
fn(...args,function(err,data){
if(err)reject(err);
resolve(data);
})
})
}
/*另一种写法
const promisify = function(fn){
return function(...args){
return new Promise((resolve,reject)=>{
fn(...args,function(err,data){
if(err)reject(err);
resolve(data);
})
})
}
}
*/
let read = promisify(fs.readFile);
read('name.txt','utf8').then((data)=>{
console.log(data);
})
/*****************************/
//20、promise-all
const fs = require('fs').promises;
//将node的api快速的转换成promise的形式
const isPromise = value => typeof value.then === 'function';
Promise.all = function(promises){ //全部成功才成功
return new Promise((resolve,reject)=>{
//遍历数组，一次拿到执行结果
let arr = [];
let index = 0;
const processData = (key,data)=>{
arr[key]=data;
//不能使用数组的长度来计算(执行顺序不一致，可能会造成[undefined,undefine,1]的结果)
if(++index === promises.length)
{
resolve(arr);
}
};
for(let i=0; i <promises.length; i++)
{
let result = promises[i];
if(isPromise(result))
{
result.then((data)=>{
processData(i,data);
},reject);
}
else
{
processData(i,result);
}
}
});
}
Promise.all([fs.readFile('name.txt','utf8'),fs.readFile('age.txt','utf8')]).then(data=>{
console.log(data);
}).catch(err=>console.log(err));
//promise缺陷默认无法中断，只是不采用返回的结果， fetch api
//
//异步：并发(使用for循环迭代执行)和串行（借助回调，第一个完成后调用第二个）
//21、promise race
const fs = require('fs').promises;
const isPromise = value => typeof value.then === 'function';
Promise.race = function(promises){
return new Promise((resolve,reject)=>{
for(let i = 0; i < promises.length; i++)
{
let result = promises[i];
if(isPromise(result)){
result.then(resolve,reject);
}
else
{
resolve(result);
}
}
});
}
//赛跑 谁跑的快用谁的(多个接口请求，我希望采用快的那个)
/*
Promise.race([fs.readFile('name.txt','utf8'),fs.readFile('age.txt','utf8')]).then(data=>{
console.log(data);
}).catch(err=>console.log(err));
*/
//中断promise 一个promise正在走向成功 3000之后成功，如果超过2s就认为失败了
let promise = new Promise((resolve,reject)=>{
setTimeout(()=>{
resolve('ok 成功了');
},3000);
});
const wrap = promise =>{
let abort;
let myP = new Promise((resolve,reject)=>{
abort = reject;
});
let p = Promise.race([promise,myP]);
p.abort = abort;
return p;
}
let p = wrap(promise);
p.then(data=>{
console.log(data);
},(err)=>{
console.log("失败了",err);
})
setTimeout(()=>{
p.abort('promise 超时');//中断请求
},2000)
//22、中断promise链
Promise.resolve(100).then().then(()=>{
return new Promise((resolve,reject)=>{});
}).then(data=>{
console.log(data);
},err=>{
console.log(err);
});
//什么都打印不出来，promise处于pending状态
Promise.resolve(100).then().then(()=>{
return function(){};
}).then(data=>{
console.log(data);
},err=>{
console.log(err);
});
//[Function (anonymous)]即使返回的是空函数，也会向下传递
//23、generator的使用
//co库
//generator.js
//generator生成器=》遍历器（需要有一个next方法）=>数组=》类数组（长得像数组）
//原理就是遍历这个对象，将结果放到数组中，这个数据必须有个遍历器。[...new Set()] for of
const likeArray = {0:'a',1:'b',2:'c',3:'d',length:4};
console.log([...likeArray]); //报错likeArray is not iterable
//将类数组转成数组 Array.from(likeArray);
const likeArray = {0:'a',1:'b',2:'c',3:'d',length:4};
console.log(Array.from(likeArray));//["a", "b", "c", "d"]
const likeArray = {0:'a',1:'b',2:'c',3:'d',length:4};
likeArray[Symbol.iterator]=function(){
let i = 0;
return { //遍历器
next:()=>{ //使用箭头函数确保this不变化
return {value:this[i],done:i++ === this.length}
}
}
}
console.log([...likeArray]);
//["a", "b", "c", "d"]
//换成generator实现：
//"元编程" 自己改写js 原因的功能
const likeArray = {0:'a',1:'b',2:'c',3:'d',length:4};
likeArray[Symbol.iterator] = function *(){ //generator函数可以生产遍历器
let i=0;
while(i !== this.length)
{
yield this[i++];
}
}
console.log([...likeArray]); //["a", "b", "c", "d"]
//一旦遇到 yield 表达式，生成器的代码将被暂停运行，直到生成器的 next() 方法被调用。
//普通函数默认会从头到尾执行没有暂停的功能
//generator函数是es6提供的语法，如果碰到yield就会“暂停”执行(redux-sage,koa1中)
function * read(){
yield 1;
yield 2;
yield 3;
return undefined;
}
let it = read();
console.log(it.next()); //{value: 1, done: false}
console.log(it.next()); //{value: 2, done: false}
console.log(it.next()); //{value: 3, done: false}
console.log(it.next()); //{value: undefined, done: true}
function * read(){
yield 1;
yield 2;
yield 3;
return undefined;
}
let it = read(); //it就是迭代器，迭代器上有个next方法
console.dir(it);
/*************/
function * read(){
yield 1;
yield 2;
yield 3;
return undefined;
}
let it = read();
let flag = false;
do{
let {value,done} = it.next();
console.log(value);
flag = done;
}while(!flag);
/**************/
//蛇形执行，除了第一次之外的next()方法，都是把next中的参数传递给上一次yield的返回结果
function * read(){
let a = yield 1;
console.log('a=',a);
let b = yield 2;
console.log('b=',b);
let c = yield 3;
console.log('c=',c);
return c;
}
let it = read();
it.next(); //第一次的next传递参数没有任何意义
it.next('2');
it.next('3');
//a= 2
//b= 3
/*************************/
name.txt:age.txt
age.txt:10
const fs = require('fs').promises;
function * read() //代码编写更像是同步的（执行还是异步的）
{
let name = yield fs.readFile('name.txt','utf8');
let age = yield fs.readFile('age.txt','utf8'); //async await
return age;
}
//read().then(data=>{
//console.log(data);
//})
//优化这段代码
let it = read();
let {value,done} = it.next();
console.log(1,value,done);
value.then(data=>{
console.log(2,data);
let {value,done} = it.next(data);
console.log(3,value,done);
value.then(data=>{
let {value,done} = it.next(data);
console.log(4,value);
})
})
//1 Promise { <pending> } false
//2 age.txt
//3 Promise { <pending> } false
//4 10
/****************/
const fs = require('fs').promises;
function * read(){
try{
let name = yield fs.readFile('name.txt','utf8');
let age = yield fs.readFile('age.txt','utf8');
return age;
}catch(e)
{
console.log(e);
}
}
let it = read();
let {value, done} = it.next();
console.log(1,value,done);
value.then(data=>{
let {value,done} = it.next(data);
console.log(2,value,done);
value.then(data=>{
it.throw('error');
console.log(3);
})
})
//1 Promise { <pending> } false
//2 Promise { <pending> } false
//error
//3
//24、co库的实现
const fs = require('fs').promises;
function * read(){
let name = yield fs.readFile('name.txt','utf8');
let age = yield fs.readFile('age.txt','utf8');
return age;
}
const co = it =>{
return new Promise((resolve,reject)=>{
//异步迭代靠的是回调函数
function next(data)
{
let {value,done} = it.next(data);
if(!done){
Promise.resolve(value).then(data=>{
console.log(data,done);
next(data);
},reject);
}else{
resolve(value);
}
}
next();
})
}
co(read()).then(data=>{
console.log(data);
})
//age.txt false
//10 false
//10
const fs = require('fs').promises;
function * read(){
let name = yield fs.readFile('name.txt','utf8');
let age = yield fs.readFile('age.txt','utf8');
return age;
}
const co = it =>{
return new Promise((resolve,reject)=>{
//异步迭代靠的是回调函数
function next(data)
{
let {value,done} = it.next(data);
if(!done){
Promise.resolve(value).then(next,reject);
}else{
resolve(value);
}
}
next();
})
}
co(read()).then(data=>{
console.log(data);
})
//10
//async + await = generator + co
//async await 替换到了 generator 和 co 默认async函数执行后返回的就是一个promise
const fs = require('fs').promises;
async function read(){
let name = await fs.readFile('name.txt','utf8');
let age = await fs.readFile('age.txt','utf8');
return age;
}
read().then(data=>{
console.log(data);
})
//10
//25、eventloop执行顺序
//微任务执行完->GUI渲染页面->取出一个宏任务执行
/*
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<script type="text/javascript">
document.body.style.background = 'green';
console.log(1);
Promise.resolve().then(()=>{
console.log(2);
document.body.style.background = 'red';
});
console.log(3);
//1 3 2 'red'
</script>
</body>
</html>
*/
/*
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<script type="text/javascript">
document.body.style.background = 'green';
console.log(1);
setTimeout(()=>{
document.body.style.background = 'red';
},0);
console.log(3);
//1 3 由green变成red
</script>
</body>
</html>
*/
//进程是计算机调度的基本单位
//进程中包含着线程
//26、eventloop的执行顺序
//es6内部是一个微任务
/*
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<script type="text/javascript">
Promise.resolve().then(()=>{
console.log('Promise');
setTimeout(()=>{
console.log('setTimeout2');
},0);
})
setTimeout(()=>{
console.log('setTimeout');
Promise.resolve().then(()=>{
console.log('Promise2');
})
},0);
//Promise
//setTimeout
//Promise2
//setTimeout2
</script>
</body>
</html>
*/
