[Node.js] mySQL数据库 -- promise

promise介绍

promise就是用来解决回调地狱的

• 1、主要用于异步计算
• 2、可以将异步操作队列化，按照期望的顺序执行，返回符合预期的结果
• 3、可以在对象之间传递和操作promise，帮助我们处理队列

回调地狱:回调函数中嵌套了回调函数，代码的阅读性低，维护不便,让人看着害怕

 
 

promise工作流程

• Promise对象是一个构造函数，用来生成Promise实例。
• Promise构造函数接受一个函数作为参数
• 这个作为参数的函数，又有2个参数,这两个参数分别是resolve和reject
• 这两个参数也是函数，只不过这两个函数由JavaScript 引擎提供，不用自己部署

异步操作成功后调用resolve()方法，他内部调用了then()里面的第一个参数函数
异步操作失败后调用reject()方法，他内部调用了then()里面的第二个参数函数.

const fs = require('fs');
//调用Promise构造函数，创建一个promise的实例
let p= new Promise((resolve,reject)=>{
    //写异步操作(读文件)
    //读a文件
    fs.readFile(`${__dirname}/etc/a.txt`,'utf-8',(err, data)=> {
        if (!err) {
            //操作成功(读文件成功)
            resolve (data)//调用resolve方法
                          //调用then()里面的第一个参数函数
        } else {
            //操作失败(读文件失败)
            reject(err)//调用reject方法
                       //调用了then()里 面的第二个参数函数
        }
    })
})
p.then((data)=> {
    console.log(data);
},(err)=>{
    console.log(err);
})

 
 

promise原理

• Promise对象代表一个异步操作，有三种状态: pending( 进行中)、fulfilled ( 已成功)和rejected (已失败)
• Promise对象的状态改变，只有两种可能:从pending变为fulfilled和从pending变为rejected。
• 只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态

如果异步操作成功了(读文件成功了),从pending (进行中)变为fulfilled (已成功)
如果异步操作失败了(读文件失败了),从pending (进行中)变为rejected (已失败)
状态如果已经确定了，就不会再去改变这个状态了

const fs = require('fs');
//调用Promise构造函数，创建一个promise的实例
let p= new Promise((resolve,reject)=>{
    //写异步操作(读文件)
    //读a文件
    fs.readFile(`${__dirname}/etc/a.txt`,'utf-8',(err, data)=> {
        if (!err) {
            //异步操作成功(读文件成功)
            resolve (data)//调用resolve方法
                          //调用then()里面的第一个参数函数
                          //将Promise对象的状态从pending (进行中)变为fulfilled (已成功)
        } else {
            //异步操作失败(读文件失败)
            reject(err)//调用reject方法
                       //调用了then()里 面的第二个参数函数
                       //将Promise对象的状态从pending (进行中)变为rejected (已失败)
        }
    })
})
p.then((data)=> {
    //Promise对象的状态变为resolved时调用
    console.log(data);
},(err)=>{
    //Promise对 象的状态变为rejected时调用
    //第二个函数是可选的，不一定要提供
    console.log(err);
})

 
 

promise特点以及封装

Promise新建后就会立即执行

const fs = require('fs');

function getPromise(filename){
    //调用Promise构造函数，创建一个promise的实例
    return new Promise((resolve,reject)=>{
        //写异步操作(读文件)
        fs.readFile(`${__dirname}/etc/${ filename }.txt`,'utf-8',(err, data)=> {
            if (!err) {
                //异步操作成功(读文件成功)
                resolve (data)
            } else {
                //异步操作失败(读文件失败)
                reject(err)
            }
        })
    })
}
getPromise('b').then((data)=> {
    console.log(data);
},(err)=>{
    console.log(err);
})

 
 

promise如何解决回调地狱

• 我们用promise解决的问题:让异步操作有顺序，并且不能有回调地狱.
• 让异步操作有顺序本质是
  • 异步操作实际上是没有顺序的.
  • 在异步操作成功后的回调函数里返回另外的promise,调用他的then方法.

const fs = require('fs');

function getPromise(filename){
    //调用Promise构造函数，创建一个promise的实例
    return new Promise((resolve,reject)=>{
        //写异步操作(读文件)
        fs.readFile(`${__dirname}/etc/${ filename }.txt`,'utf-8',(err, data)=> {
            if (!err) {
                //异步操作成功(读文件成功)
                resolve (data)
            } else {
                //异步操作失败(读文件失败)
                reject(err)
            }
        })
    })
}
getPromise('a').then((data)=> {
    console.log(data);
    //调用函数得到一个读b文件的promise对象并返回
    return getPromise('b')
}).then((data)=> {
        console.log(data);
    //调用函数得到一个读c文件的promise对象并返回
    return getPromise('c')
}).then((data)=> {
    console.log(data);
})
//如果这个then方法，他能给你返回一个promise对象，那是不是可以继续点出then方法来.

 
 

promise的其他方法

catch

catch()能够抓取错误的.

const fs = require('fs');

function getPromise(filename){
    //调用Promise构造函数，创建一个promise的实例
    return new Promise((resolve,reject)=>{
        //写异步操作(读文件)
        fs.readFile(`${__dirname}/etc/${ filename }.txt`,'utf-8',(err, data)=> {
            if (!err) {
                //异步操作成功(读文件成功)
                resolve (data)
            } else {
                //异步操作失败(读文件失败)
                reject(err)
            }
        })
    })
}

getPromise('a').then((data)=> {
    console.log(data);
    //调用函数得到一个读b文件的promise对象并返回
    return getPromise('b')
}).then((data)=> {
    console.log(data);
    //调用函数得到一个读c文件的promise对象并返回
    return getPromise('c')
}).then((data)=> {
    console.log(data);
}).catch((err)=>{
    console.log(err);
})

 

all

all()方法用于将多个Promise实例，包装成一个新的Promise 实例(一个都不能少,每一个promise都要读取成功才会成功，相当于是并且.)

const fs = require('fs');

function getPromise(filename){
    //调用Promise构造函数，创建一个promise的实例
    return new Promise((resolve,reject)=>{
        //写异步操作(读文件)
        fs.readFile(`${__dirname}/etc/${ filename }.txt`,'utf-8',(err, data)=> {
            if (!err) {
                //异步操作成功(读文件成功)
                resolve (data)
            } else {
                //异步操作失败(读文件失败)
                reject(err)
            }
        })
    })
}

let p1 = getPromise('a')
let p2 = getPromise('b')
let p3 = getPromise('c')

//Promise.all()方法用于将多个Promise实例，包装成一个新的Promise 实例
let pA11 = Promise.all([p1,p2,p3]);
//一个都不能少,每一个promise都要读取成功才会成功，相当于是并且.
pA11.then((data)=>{
    console.log(data);//[ '我是a文件 -- 床前明月光', '我是b文件 -- 疑是地下霜', '我是c文件 -- 举头望明月，低头思阿香' ]
})

 

race

race()方法用于将多个Promise实例，包装成一个新的Promise 实例(只要有一个promise执行成功，那这个pRace就成功，相当于是或者.)

const fs = require('fs');

function getPromise(filename){
    //调用Promise构造函数，创建一个promise的实例
    return new Promise((resolve,reject)=>{
        //写异步操作(读文件)
        fs.readFile(`${__dirname}/etc/${ filename }.txt`,'utf-8',(err, data)=> {
            if (!err) {
                //异步操作成功(读文件成功)
                resolve (data)
            } else {
                //异步操作失败(读文件失败)
                reject(err)
            }
        })
    })
}

let p1 = getPromise('a')
let p2 = getPromise('b')
let p3 = getPromise('c')

//Promise.race()方法用于将多个Promise实例，包装成一个新的Promise 实例
let pRace = Promise.race([p1,p2,p3]);
// 只要有一个promise执行成功，那这个pRace就成功，相当于是或者.
pRace.then((data)=>{
    console.log(data);
})