Es6中的Promise

异步方法调用

主程序调用异步方法时，把其交给子程序，继续执行下面代码
导致获取不到异步方法的返回值

function getFileByPath(fpath){
       fs.getFile(fpath,'utf-8',(err,dataStr)=>{
                if(err) throw err;
                return dataStr;
        })
}

getFilePath(path.join(__dirname,'./files/1.txt'));

添加回调函数，将结果返回给调用者

function getFileByPath(fpath，callback){
       fs.getFile(fpath,'utf-8',(err,dataStr)=>{
                //if(err) throw err;
                //return dataStr;
                if(err) return callback(err);
                callback(datastr);
        })
}
getFilePath(path.join(__dirname,'./files/1.txt'),(datastr)=>{
   console.log(datastr+'_________')
});

调用者回调函数只能传递一个参数，导致不知道是否是成功还是失败结果
所以规定：callback中的两个参数，第一个是失败结果，第二个是成功结果
若成功后，第一个参数null,第二个参数为成功结果对象
若失败后，第一个参数为err对象，第二个参数为undefine

getFilePath(path.join(__dirname,'./files/1.txt'),(error,datastr)=>{
   if(err) return console.log(err.message)
   console.log(datastr+'_________')
});

异步方法提高版

function getFileByPath(fpath，succCb,errCb){
       fs.getFile(fpath,'utf-8',(err,dataStr)=>{
                //if(err) throw err;
                //return dataStr;
                if(err) return errCb(err);
                succCb(datastr);
        })
}
getFilePath(path.join(__dirname,'./files/1.txt'),function(data){
  console.log(data+"成功了")
},function(err){
  console.log(err+"失败了")
});

用异步方法同步读取三个文件

同级方法不能保证顺序，使用异步回调嵌套保证同步———回调地狱

使用ES6中的Promise来解决回调地狱问题——解决回调地狱问题

1. Promise表示一个异步操作，每当new一个Promise实例，表示一个具体的异步操作
   异步执行成功了。异步执行失败了
   因为Promise是一个异步操作，所以无法使用return返回给调用者，只能通过回调函数返回给调用者
2. resolve()成功回调函数
3. reject()失败回调函数

每当new一个Promise实例，就会立即执行这个异步操作中的代码

const fs=require('fs')
var promise=new Promise(function(){
     //编写具体的异步操作
     fs.readFile('./files/2.txt','utf-8',(err,datastr)=>{
             if(err) throw err;
             console.log(dataStr) ;
     })
})

使用方法封装这个Promise，实现：调用它就会立即执行的效果

function getFilePath(fpath){
var promise=new Promise(function(){
     //编写具体的异步操作
     fs.readFile(fpath,'utf-8',(err,datastr)=>{
             if(err) throw err;
             console.log(dataStr) ;
     })
})
}

promise实现回调函数

function getFilePath(fpath){
var promise=new Promise(function(resolve,reject){
     //编写具体的异步操作
     fs.readFile(fpath,'utf-8',(err,datastr)=>{
             if(err) return reject(err); //通过return组织下面执行
             resolve(datastr);
     })
})
}

通过.then方法为Promise预先指定成功失败方法

function getFilePath(fpath){
var promise=new Promise(function(resolve,reject){
     //编写具体的异步操作
     fs.readFile(fpath,'utf-8',(err,datastr)=>{
             if(err) return reject(err); //通过return组织下面执行
             resolve(datastr);
     })
})
return promise;
}

getFilePath('./files/2.txt').then(function(data){
         //成功了
},function(err){
         //失败了
})

使用Promse同步调用异步方法

先读取文件1，再读取文件2，最后读取文件3

## 成功必须传，失败可省略
## 若Promise执行失败不想阻止后面继续执行，则指定失败的回调
getFilePath('./files/2.txt').then(function(data){
     console.log(data)
     return getFilePath('./files/2.txt')
}，function(err){
      console.log(data+"err")
      return getFilePath('./files/2.txt')
})
.then(function(data){
      console.log(data)
     return getFilePath('./files/2.txt')
})      
.then(function(data){
      console.log(data)
     return getFilePath('./files/3.txt')
})