Promise对象

Promise对象

ES6新增的，该对象允许对延迟个异步操作流程进行控制。
一个promise对象就是一个代表了异步操作最终完成或者失败的对象。
开发人员可以使用由其他函数创建并返回的promise对象。
promise对象本质上就是一个绑定回调的对象，而不是将回调传进函数内部

promise的状态：

• pending：初始状态，即不成功，也不是失败
• fulfilled：操作成功完成
• rejected：操作失败

创建Promise对象

构造函数Promise对象接收一个回调函数

new Promise(function(resolve,reject){函数体});

resolve:表示成功 将Promise的状态改为fulfilled

reject：表示失败 将Promise的状态改为rejected

let promise = new Promise((resolve,reject) => {
    setTimeout(function(){
        resolve('xxxx....');
    },200);
});
//.then是状态改变的回调函数
promise.then(result => {
    console.log(result);//xxxx....
});

//一般用的时候都是在其他函数基础上用 把他作为一个返回值
function fn() {
    return new Promise((resolve,reject) => {
        setTimeout(function(){
            resolve('xxxx....');
        },200);
    });
}

var promise1 = fn()
promise1.then(result => {
    console.log(result);//xxxx....
});

Promise对象的约定

Promise对象的约定：

• 在JavaScript事件队列的当前事件运行完成之前，回调函数永远不会被调用
• 通过.then形式添加的回调函数
• 通过多次.then，可以添加多个回调函数，它们会按照插入顺序并且独立运行，支持链式调用

Promise对象的链式操作

每次调用.then 他返回的对象都是一个新的Promise对象

function fn() {
    return new Promise((resolve,reject) => {
        setTimeout(function(){
            resolve('xxxx....');
        },200);
    });
}

var promise1 = fn()
promise1.then(result => {
    console.log(result);//xxxx....
    return result +1;
}).then(result => {
    console.log(result);//xxxx....1
});

Promise对象原型的方法

then()方法

then()方法用于Promise对象添加状态改变时的回调函数。

第一个参数是成功时的回调函数，回调函数参数是成功时返回的内容

第二个参数是失败时的回调函数，回调函数参数是失败时返回的内容 可选

let promise = new Promise((resolve,reject) => {
    setTimeout(function(){
        resolve('xxxx....');
    },200);
}).then(result => {
    console.log(result);//xxxx....
}).catch(result => {
    console.log('catch'+result);
});

catch()方法

catch()方法返回Promise对象，并且处理拒绝的情况。它的行为、调用跟then一样

状态为失败就是拒绝，即rejected

let promise = new Promise((resolve,reject) => {
    setTimeout(function(){
        reject('xxxx....');
    },200);
}).then(result => {
    console.log(result);
}).catch(result => {
    console.log('catch'+result);//catchxxxx....
});

finally()方法

catch()方法返回Promise对象,在执行then和catch后，都会执行finally指定的回调函数。为了避免在catch和then有重复的逻辑，有finally只需要写一遍

let promise = new Promise((resolve,reject) => {
    setTimeout(function(){
        reject('xxxx....');
    },200);
}).then(result => {
    console.log(result);
}).catch(result => {
    console.log('catch'+result);//catchxxxx....
}).finally(() => {
	console.log('finally');//finally
});

Promise对象的方法

Promise.all()

Promise.all()方法用于将多个Promise对象，整合成一个新的Promise对象

它只接受一个参数 ，是一个可迭代的参数 比如Array 、String

返回值就是那个新的Promise对象

let promise1 = new Promise((resolve,reject) => {
    setTimeout(resolve,100,'one');
});
let promise2 = new Promise((resolve,reject) => {
    setTimeout(resolve,50,'two');
});
let promise3 = new Promise((resolve,reject) => {
    setTimeout(resolve,200,'three');
});
let promise = Promise.all([promise1,promise2,promise3]).then((value) => {
    console.log(value);//[ 'one', 'two', 'three' ]
    //这个整合是以最慢的为基准  会等到所有的都指向完毕  状态都改变了的
    //用所有的Promise对象的成功或者失败 为基准
});;

Promise.race()

Promise.race()返回一个Promise对象，一旦迭代器中的某个Promise解决或者拒绝，返回的Promise就会解决或拒绝

let promise1 = new Promise((resolve,reject) => {
    setTimeout(resolve,100,'one');
});
let promise2 = new Promise((resolve,reject) => {
    setTimeout(resolve,50,'two');
});
let promise3 = new Promise((resolve,reject) => {
    setTimeout(resolve,200,'three');
});
let promise = Promise.all([promise1,promise2,promise3]);

Promise.race([promise1,promise2]).then((value) => {
    console.log(value);//two
    //这个整合是看要整合的Promise对象中那个先执行玩 这就是那个
    //就是只要有一个执行完了  就结束了 不管其他的 结果以先执行完的结果
});

Promise.resolve()

Promise.resolve()方法 法返回一个Promise对象 就是之前讲的那个resolve，可以通过Promise直接访问成功的函数

Promise.reject()

Promise.reject()方法 法返回一个Promise对象 就是之前讲的那个reject，可以通过Promise直接访问失败的函数

Promise的执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VarA96XQ-1604391514118)(Promise的流程.png)]

promise

promise作用可以用来解决回调地狱的

回调地狱

/**
 * promise作用是什么
 *  可以用来解决回调地狱的   
 *      比如：要求依次的去执行异步代码  
 *      做法：就是在一个异步请求成功后 在他的回调函数里执行下一个异步请求
 *      这样就会形成回调地狱  回调地狱：阅读性差 维护性差
 *     
 * 
 * promise工作流程
 * 
 * promise原理
 * 
 * promise特点
 * 
 * promise正切写法
 * 
 * promise的其他的方法
 */


//依次读abc三个文件
const fs = require('fs');

fs.readFile(`${__dirname}/etc/a.txt`,'utf-8',(err,data) => {
    if(err){
        console.log(err);
    }
    else{
        console.log(data);
        fs.readFile(`${__dirname}/etc/b.txt`,'utf-8',(err,data) => {
            if(err){
                console.log(err);
            }
            else{//这样一次一次的回调 就叫回调地狱
                console.log(data);
                fs.readFile(`${__dirname}/etc/c.txt`,'utf-8',(err,data) => {
                    if(err){
                        console.log(err);
                    }
                    else{
                        console.log(data);
                    }
                });
            }
        });
    }
});

/**
 * promise作用是什么
 *  用来解决回调地狱的   
 *      比如：要求依次的去执行异步代码  
 *      做法：就是在一个异步请求成功后 在他的回调函数里执行下一个异步请求
 *      这样就会形成回调地狱  回调地狱：阅读性差 维护性差
 *     
 * 
 * promise工作流程 es6语法      es6.ruanyifeng.com
 *      
 *      promise对象是个构造函数，用来生成promise实例
 *      promise构造函数 接收一个函数作为参数
 *      
 * 
 * promise原理
 * 
 * promise特点
 * 
 * promise正切写法
 * 
 * promise的其他的方法
 */

//创建Promise实例  参数为函数
//传入的函数有两个参数（分别是resolve和reject） 他们也是函数 但是他们不需要我们自己部署(不需要我们定义) 由js引擎提供

let p = new Promise((resolve,reject) => {
    //传入的函数的函数体  函数体写异步操作
    //写异步操作(读文件)
    fs.readFile(`${__dirname}/etc/a.txt`,'utf-8',(err,data) => {
        if(err){
            //操作成功 调用resolve
            resolve(data);//他会调用该对象的then的第一个参数（函数） resolve括号中传入的参数会是then的第一个参数(函数)的实参
        }
        else{
            //操作失败  调用reject
            reject(err);//他会调用该对象的then的第二个参数（函数） reject括号中传入的参数会是then的第二个参数(函数)的实参
        }
    });
});
//then方法传入两个参数 都是函数 
p.then((data) => {
    console.log(data);
},
(err) => {
    console.log(err);
    
})