promise学习，多看几次。含node，ES6知识

一、引出promise解决回调地狱

需求：你要封装一个方法，我给你一个要读取文件的路径，你这个方法能帮我读取文件，并把内容返回给我

目录图片

三个txt里面的内容分别是111,222,333

1、模块调用声明：

Node-核心模块（fs、path）

const fs = require('fs')//fs为文件模块
const path = require('path')//path为系统路径模块

2、使用readFile方法，进行文件数据的读取。

fs.readFile(filename, [options], callback)

filename为文件路径及名称，

[options]为具体选项配置，包括数据的编码方式，

callback为回调函数，进行相应的错误处理及提示。

①普通读取文件的方式

//__dirname :表示当前执行js文件的所属目录的绝对路径 ，通过拼接可以获得要操作文件的绝对路径。
 fs.readFile(path.join(__dirname, './files/1.txt'),
 utf-8',
 (err, dataStr) => {
  if (err) throw err
  console.log(dataStr)
}) 

终端命令输：node 首个文件名字-再按Tab键能自动补全

②使用回调得到方法内部的返回值

function getFileByPath(fpath){
  fs.readFile(fpath,'utf-8',(err,dataStr) => {
    if(err) throw err
    console.log(dataStr) //=>undefined
  })
}
 var result = getFileByPath(path.join(__dirname, './files/1.txt'))
console.log(result)  //=>111

主程序跑到19行，发现没有return，一个方法没有return会返回undefined。拿不到方法内部异步函数的返回值。

function getFileByPath(fpath,callback){
  fs.readFile(fpath,'utf-8',(err,dataStr) => {
    if(err) throw err
    callback(dataStr)
  })
}
getFileByPath(path.join(__dirname,'./files/1.txt'),(dataStr)=>{
  console.log(dataStr+'---') //----> 111---
})

但是以上方法并不是很好，如果路径错误就会终止，无论结果如何都要告诉用户。

---

我们可以规定一下， callback 中，有两个参数，第一个参数，是 失败的结果；第二个参数是成功的结果；
同时，我们规定了： 如果成功后，返回的结果，应该位于 callback 参数的第二个位置，此时， 第一个位置 由于没有出错，所以，放一个 null；  如果失败了，则 第一个位置放 Error对象，第二个位置防止一个 undefined

function getFileByPath(fpath,callback){
  fs.readFile(fpath,'utf-8',(err,dataStr) => {
    //如果报错，进入if分支后，if后面的代码就没有必要执行了
    if(err) return callback(err)//先调用这个函数，函数执行完立结束
    callback(null,dataStr)
  })
}
getFileByPath(path.join(__dirname,'./files/1.txt'),(err,dataStr)=>{
  if(err) return console.log(err.message)
  console.log(dataStr)
})

③封装读取文件方法提高版

把刚才的回调分成两个

function getFileByPath(fpath,succcCb,errCb){
  fs.readFile(fpath,'utf-8',(err,dataStr) => {
    //如果报错，进入if分支后，if后面的代码就没有必要执行了
    if(err) return errCb(err)//先调用这个函数，函数执行完立结束
    succcCb(dataStr)
  })
}
getFileByPath(path.join(__dirname,'./files/1eee.txt'),function(data){
  console.log(data+'成功！');
},function(err){
  console.log('使用回调函数处理失败的结果：'+err.message);
})

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

// 回调地狱
// 使用 ES6 中的 Promise，来解决 回调地狱的问题；
// 问： Promise 的本质是要干什么的：就是单纯的为了解决回调地狱问题；并不能帮我们减少代码量；
getFileByPath(path.join(__dirname, './files/1.txt'), function (data) {
  console.log(data)
  getFileByPath(path.join(__dirname, './files/2.txt'), function (data) {
    console.log(data)
    getFileByPath(path.join(__dirname, './files/3.txt'), function (data) {
      console.log(data)
    })
  })
})

回调地狱如图所示：

3、可以使用writeFile方法，将数据写入文件到某个文件夹下。

fs.writeFile(filename, data, [options], callback)

filename为具体的文件保存路径地址,

data为具体要写入文件的数据对象,

[options]为具体的保存文件配置，编码格式等,

callback为具体的回调函数，进行相应的错误捕捉及提示。

二、promise基本概念

在JavaScript的世界中，所有代码都是单线程执行的。由于这个“缺陷”，导致JavaScript的所有网络操作，浏览器事件，都必须是异步执行。异步执行可以用回调函数实现

console窗口输入console.dir(promise)


1. Promise 是一个 构造函数，既然是构造函数， 那么，我们就可以  new Promise() 得到一个 Promise 的实例；

2. 在 Promise 上，有两个函数，分别叫做 resolve（成功之后的回调函数） 和 reject（失败之后的回调函数）

3. 在 Promise 构造函数的 Prototype 属性上，有一个 .then() 方法，也就说，只要是 Promise 构造函数创建的实例，都可以访问到 .then() 方法

4. Promise 表示一个 异步操作；每当我们 new 一个 Promise 的实例，这个实例，就表示一个具体的异步操作；

5. 既然 Promise 创建的实例，是一个异步操作，那么，这个 异步操作的结果，只能有两种状态：

   5.1 状态1： 异步执行成功了，需要在内部调用 成功的回调函数 resolve 把结果返回给调用者；
5.2 状态2： 异步执行失败了，需要在内部调用 失败的回调函数 reject 把结果返回给调用者；
5.3 由于 Promise 的实例，是一个异步操作，所以，内部拿到 操作的结果后，无法使用 return 把操作的结果返回给调用者； 这时候，只能使用回调函数的形式，来把 成功 或 失败的结果，返回给调用者；

6. 我们可以在 new 出来的 Promise 实例上，调用 .then() 方法，【预先】 为 这个 Promise 异步操作，指定 成功（resolve） 和 失败（reject） 回调函数；
var promise = new Promise()
 注意：这里 new 出来的 promise， 只是代表 【形式上】的一个异步操作；
什么是形式上的异步操作：就是说，我们只知道它是一个异步操作，但是做什么具体的异步事情，目前还不清楚。
下面是一个具体的异步操作，其中，使用 function 指定一个具体的异步操作

var promise = new Promise(function(){
    //这个 function 内部写的就是具体的异步操作！！！
})

new 的时候，除了能够得到 一个 promise 实例之外，还会立即调用 我们为 Promise 构造函数传递的那个 function，执行这个 function 中的 异步操作代码；

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不会执行

const fs = require('fs')
  function getFileByPath (fpath){//没有被调用，promise不会执行
    var promise =new Promise(function(resolve, reject) {
      fs.readFile(fpath,'utf-8',(err,dataStr) => {
        if(err) throw err
        console.log(dataStr)
      })
    })
  }
  getFileByPath('./files/2.txt')

但是以上的代码并没有给用户返回值，失败直接throw，成功直接输出了。直接return也不行，因为是异步操作。然而我们想要的是： 给路径，返回读取到的内容
函数内部的变量没有return出去，外部是访问不到的

function getFileByPath(fpath) {
  return new Promise(function (resolve, reject) {//resolve, reject是形参
    fs.readFile(fpath, 'utf-8', (err, dataStr) => {
      if (err) return reject(err)
      resolve(dataStr)
    })
  })
}
getFileByPath('./files/2.txt')
  .then(function (data) {
    console.log(data + '-------')
  }, function (err) {
    console.log(err.message)
  }) 

三、使用promise解决回调地狱

要求：先读取文件1，在读取2，最后读取3 注意： 通过 .then 指定 回调函数的时候，成功的 回调函数，必须传，但是，失败的回调，可以省略不传
①标准使用方法：通过3个.then的串联解决了回调地狱，在上一个 .then 中，返回一个新的 promise 实例，可以继续用下一个 .then 来处理

 const fs = require('fs')
 function getFileByPath(fpath){
   return new Promise(function (resolve,reject){
     fs.readFile(fpath,'utf-8',(err,dataStr)=>{
       if(err) return reject(err)
       resolve(dataStr)
     })
   })
 }
 getFileByPath('./files/1.txt')
 .then(function(data){
   console.log(data)
   //读取文件2
   return getFileByPath('./files/2.txt')
 })
 .then(function(data){
   console.log(data)
   return getFileByPath('./files/3.txt')
 })
 .then(function(data){
   console.log(data)
 })

标准使用

但是上面的代码还存在着一些问题，如果第一个promise执行失败了，后面会影响到，所以如果 ，前面的 Promise 执行失败，我们不想让后续的Promise 操作被终止，可以为 每个 promise 指定 失败的回调

const fs = require('fs')
function getFileByPath(fpath){
  return new Promise(function (resolve,reject){
    fs.readFile(fpath,'utf-8',(err,dataStr)=>{
      if(err) return reject(err)
      resolve(dataStr)
    })
  })
}
getFileByPath('./files/2221.txt')
.then(function(data){
  console.log(data)
  //读取文件2
  return getFileByPath('./files/2.txt')
},function(err){
  if (err) console.log(err.message)
  return getFileByPath('./files/2.txt')
})
.then(function( data){
  console.log(data)
  return getFileByPath('./files/3.txt')
})
.then(function(data){
  console.log(data)
})
console.log("assdsd")

执行结果

aaarticlea/png;base64,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" alt="75bbc66cd7cb5110803446bb2384c0b5.png" />

有时候，我们有这样的需求，个上面的需求刚好相反：如果 后续的Promise 执行，依赖于 前面 Promise 执行的结果，如果前面的失败了，则后面的就没有继续执行下去的意义了，此时，我们想要实现，一旦有报错，则立即终止所有 Promise的执行；
getFileByPath方法和上面一样

getFileByPath('./files/1.txt')
.then(function(data){
  console.log(data)
  //读取文件2
  return getFileByPath('./files/2.txt')
})
.then(function( data){
  console.log(data)
  return getFileByPath('./files/3.txt')
})
.then(function(data){
  console.log(data)
})
.catch(function(err){
  console.log("这是catch捕获到的异常："+err.message)
})

执行结果

ptomise还有all和race方法

四、jQuery中Ajax使用ptomise

1、装包 npm init -y
2、cnpm i jquery -S
新建html文件，同时进行相应的配置

使用服务器启动，ctrl+shift+p调出命令栏，输express（也可以直接文件内右键选择“open with live server”）

---

（PS:什么是Express，express是node.js的快速、非选择性、简约的web框架。使用express就可以轻松快速的创建强大的API。）
Express安装步骤：
①  在VSC编辑器中选择打开自己的项目文件夹
②  Ctrl+shift+x  打开扩展商店搜索express并下载安装
③ Ctrl+` 打开调试控制台里的终端，输入  npm install express-generator -g
④ 创建一个自己命名的目录，输入： express 文件名(如果要在创建时使用ejs模板就在中间加一个-e。如：express -e 文件名)
⑤cd 文件名 进入到文件夹下 npm install
⑥npm start启动，打开localhost:3000，出现如下图3页面就代表安装成功

---

回到正题
ctrl+shift+p调出命令栏，输express，选择如下图所示的选项

跳转到如下页面，就ok了

接着复制html的相对路径，粘贴到之前的路径上，可以看到效果

高级操作：


 <input type="button" value="获取数据" id="btn">
     <script src="./node_modules//jquery/dist/jquery.min.js"></script>
     <script>
         //入口函数
         $(function(){
             $('#btn').on('click',function(){
                 $.ajax({
                     url:'./data.json',
                     type:'get',
                     dataType:'json',
                     // success:function(data){
                     //     console.log(data)
                     // }
                 })
                 .then(function(data){
                     console.log(data)
                 })
             })
         })
     </script>

高级写法