ES6-19【promise的使用方法和自定义promisify】

一.promise的使用方法

(1).resolve中报错

会来不及执行就被捕获到reject

let promise = new Promise(function(resolve,reject){
  resolve(a);
})
promise.then((val)=>{
    console.log(val)
    
},(reason)=>{
    console.log(reason)
   
})

a is not defined

(2).catch捕获

catch也可以捕获异常reject

let promise = new Promise(function(resolve,reject){
  resolve(a);
})
promise.catch(function(reason){
    console.log(reason)
})//a is not fined

(3).语义化写法

promise.then(()=>{}).catch(()=>{})

(4).Promise固化

一旦状态被固化则不会被catch捕获

let promise = new Promise(function(resolve,reject){
  resolve('ok');
  console.log(a)
})
promise.then((val)=>{
    console.log(val);
    
}).catch((err)=>{
    console.log(err);

})//ok

(5).then()忽略

let promise = new Promise(function(resolve,reject){
  resolve(a);
  
})
promise.then((val)=>{
    console.log(val);
    
}).then().then().catch((err)=>{
    console.log(err);

})
//正常打印错误    then()会被忽略

(6).状态依赖

一个Promise的状态为另一个Promise的时候

let promise = new Promise(function(resolve,reject){
  setTimeout(function(){
      reject(new Error('fail'))
  },3000)
  
})
let promise2 = new Promise(function(resolve,reject){
  setTimeout(function(){
      resolve(promise)
  },3000)
  
})
promise2.then((val)=>{
    console.log(val);
    
}).then().then().catch((err)=>{
    console.log(err);

})
//Error: fail
    at index.html:51

一秒时会导致p2状态无效，等待两秒后捕获，P2的状态会取决于p1的状态，只有p1拿到结果p2才能执行

resolve也就顺理成章了

let promise = new Promise(function(resolve,reject){
  setTimeout(function(){
      resolve('ok')
  },3000)
  
})
let promise2 = new Promise(function(resolve,reject){
  setTimeout(function(){
      resolve(promise)
  },3000)
  
})
promise2.then((val)=>{
    console.log(val);
    
}).then().then().catch((err)=>{
    console.log(err);

})//3秒后出现ok

(7).resolve/reject不会终结函数的执行

resolve

let p1 = new Promise((resolve,reject)=>{
    resolve(1);
    console.log(2);
})
p1.then(res=>console.log(res)
)
console.log(3);//2 3 1

reject

let p1 = new Promise((resolve,reject)=>{
    reject(new Error());
    console.log(2);
})
p1.then(res=>console.log(res)
).catch((error)=>{
    console.log(error);
    
})
console.log(3);
2
3
Error

(8).race/all管理异步的关系

Promise.all()批量处理多个异步操作

let p1 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        resolve('1:2000ms')
    },2000)
})
let p2 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        resolve('2:1000ms')
    },1000)
})
let p3 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        resolve('3:2000ms')
    },3000)
})
let p = Promise.all([p1,p2,p3]);
p.then(res=>console.log(res)
).catch((error)=>{
    console.log(error);
    
})
["1:2000ms", "2:1000ms", "3:2000ms"]

其实all就是用来批量处理异步操作的

这三个异步中只要有一个失败了，就会被catch拦截,其余不响应

let p1 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        reject('1:2000ms')
    },2000)
})
let p2 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        resolve('2:1000ms')
    },1000)
})
let p3 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        resolve('3:2000ms')
    },3000)
})
let p = Promise.all([p1,p2,p3]);
p.then(res=>console.log(res)
).catch((error)=>{
    console.log(error);
    
})
1:2000ms

如果都为错误，则触发最快的那个程序

let p1 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        reject('1:2000ms')
    },2000)
})
let p2 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        reject('2:1000ms')
    },1000)
})
let p3 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        reject('3:2000ms')
    },3000)
})
let p = Promise.all([p1,p2,p3]);
p.then(res=>console.log(res)
).catch((error)=>{
    console.log(error);
    
})
2：1000ms

Promise.race()

不管成功和失败返回响应最快的

let p1 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        resolve('1:2000ms')
    },2000)
})
let p2 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        resolve('2:1000ms')
    },1000)
})
let p3 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        resolve('3:2000ms')
    },3000)
})
let p = Promise.race([p1,p2,p3]);
p.then(res=>console.log(res)
).catch((error)=>{
    console.log(error);
    
})
2：1000ms reject一致

reject和resolve混用

let p1 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        resolve('1:2000ms')
    },2000)
})
let p2 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        reject('2:1000ms')
    },1000)
})
let p3 = new Promise((resolve,reject)=>{
    setTimeout(function(){
        reject('3:2000ms')
    },3000)
})
let p = Promise.race([p1,p2,p3]);
p.then(res=>console.log(res)
).catch((error)=>{
    console.log(error);
    
})
2：1000ms 

也就是说Promise.race([p1, p2, p3])里面的结果哪个获取的快，就返回哪个结果，不管结果本身是成功还是失败

thenable

将对象转换为promise

let obj = {
    then:function(resolve,reject){
        resolve(42);
    }
}
let p1 = Promise.resolve(obj);
p1.then(function(value){
    console.log(value);
    
})//42
let p1 = Promise.resolve('hello');
p1.then(res=>{
    console.log(res)
})
//hello


let p1 = Promise.reject('hello');
p1.then(null,res=>{
    console.log(res)
})
//hello

函数Promise化

const fs = require('fs');
function readFile(path){
    return new Promise((resolve,reject)=>{
        fs.readFile(path,'utf-8',(err,data)=>{
            if(data){
                resolve(data);
            }
        })
    })
}
readFile('./name.txt')
    .then(data => readFile(data))
    .then(data => readFile(data))
    .then(data => console.log(data))
    //99

这就是让一个异步函数promise化

二.promisify

能够针对所有函数promise化

(1).手写

function promisify(func){
    return function(...arg){
        return new Promise((resolve,reject)=>{
            func(...arg,(err,data)=>{
                if(err){
                    reject(err);
                }else{
                    resolve(data)
                }
            })
        })
    }
}
let readFile = promisify(fs.readFile);
readFile('./name.txt','utf-8')
    .then(data=>readFile(data,'utf-8'))
    .then(data=>readFile(data,'utf-8'))
    .then(data=>console.log(data))//99

(2).node实现

node在util模块钟已经实现

const util = require('util')
let readFile = util.promisify(fs.readFile);

(3).让fs模块上的属性添加自定义的方法

function promisifyAll(obj){
    for(let [key,fn] of Object.entries(obj)){
        if(typeof fn === 'function' ){
            obj[key+'Async'] = promisify(fn);
        }
    }
}
promisifyAll(fs)
fs.readFileAsync('./name.txt','utf-8')
    .then(data=>readFileAsync(data,'utf-8'))
    .then(data=>readFileAsync(data,'utf-8'))
    .then(data=>console.log(data))//99