关于promise的总结

关于promise的总结

promise是什么？

• promise从语法上来说是一个类，可以创建实例（new Promise）。
• promise是异步编程的一种解决方案。比传统的回调函数去解决异步要更合理。
• promise还是一个容器，里面保存着一个异步操作的最终结果。

promise解决了什么问题？

解决了地狱回调的问题

new Promise(请求1) 
   .then(请求2(请求结果1))
   .then(请求3(请求结果2))
   .then(请求4(请求结果3))
   .then(请求5(请求结果4))
   .catch(处理异常(异常信息)) 
  // 对比于回调地狱，Promise 的写法更为直观，
 // 并且能够在外层捕获异步函数的异常信息。
// then方法的执行结果也会返回一个Promise对象。因此我们可以进行then的链式执行，这也是解决回调地狱的主要方式。

如何创建一个promise对象？

以下创建方法都会返回一个 Promise 对象
1、let obj = new Promise(fn) // 方法一
2、let obj2 = Promise.resolve(fn) // 方法二

promise常用的API有哪些呢？

1. Promise.resolve（value）

1.1该方法返回一个以 value 值解析后的 Promise 对象
1.2如果value是一个thenable(即有then方法)对象，Promise.resolve(value）会返回promise对象，并且采用thenable的最终状态。
1.3如果value是一个promise对象，Promise.resolve(value)会返回该对象。
1.4其他情况以该值为成功状态返回一个 Promise 对象。
—————  举例 ———————
let p0 = new Promise(fn); // 写法一
let p1 = Promise.resolve(p0); // 写法二
console.log(p0 === p1);
// 返回为true，返回的Promise即是 入参的Promise 对象。

2.Promise.reject （value）

2.1 reject与resolve 唯一不同的是，返回的 promise 对象的状态为 rejected。

3.Promise.prototype.then（注册then回调函数）

1.这是实例方法，是Promise 注册的回调函数，函数形式：fn(vlaue){}，value 是上一个任务的返回结果，then 中的函数一定要 return 一个结果或者一个新的 Promise 对象，才可以让之后的then 回调接收。
2.then 中的回调函数可以有一个参数，也可以不带参数.如果 then中的回调函数依赖上一步的返回结果，那么要带上参数。比如

   new Promise(fn)
   .then(fn1(value）{        
  //处理value
   })

4.Promise.prototype.catch

1.实例方法，捕获异常，函数形式：fn(err){}, err 是 catch 注册之前的回调抛出的异常信息
2.最后注册 catch 异常处理函数，处理前面回调中可能抛出的异常。

5.Promise.all(iterable)方法：(promises) =>{}

promise的特点？

1. Promise对象有三种状态，他们分别是：
   1. pending (初始态): 等待中，或者进行中，表示还没有得到结果
   2. resolved(Fulfilled): 已经完成，表示得到了我们想要的结果
   3. rejected: 也表示得到原因，但是由于原因并非我们所愿，因此拒绝执行

这三种状态不受外界影响，而且状态只能从pending改变为resolved或者rejected，并且不可逆。

手写一个promise

1. 定义一个promise类，给构造函数传递一个参数为executor的函数，
2. 在构造函数中初始化状态pending，成功的值value和失败的值reason。
3. 定义resolve和reject函数表达式，改变状态，并且让状态唯一，再将对应的值赋值。
4. 在构造函数中调用executor函数，传入resolve和reject函数

class _Promise{
    constructor(exector){
        if(typeof exector !=='function'){
            throw new Error(`promise resolve ${exector} is not a functiom`)
        };
        this.state = 'pending';
        this.value= null;
        this.reason= null;
        let resolve = (value)=>{
         if(this.state==='pending'){
            this.state='fullfill';
            this.value = value;
             }
           }
        let reject = (reason)=>{
            if(this.state==='pending'){
               this.state= 'reject';
               this.reason = reason;
             }
           }
        try{
            exector(resolve,reject)
        }catch(e){
            reject(e)
        }

    }
    // 注册回调函数
    then(onFulfilled,onReject){
        if(typeof onFulfilled !=='function'){
            onFulfilled = value => value
        }
        if(typeof onReject !=='function'){
            onReject = reason => {throw reason}
        }
        setTimeout(()=>{
            if(this.state==='fullfill'){
                onFulfilled(this.value)
            }
            
            if(this.state==='reject '){
                onReject(this.reason)
            }
        })
    }
}

使用手写的promise

console.log(1)
new _Promise((resolve,reject)=>{
    console.log(2)
    resolve('Chenggong')
}).then((value)=>{
    console.log(3);
    console.log(value);
}})
console.log(4)
 1
 2
 4
 3
 Chenggong

直接使用promise对象？

1. 在Promise对象的构造函数中，第一个参数是一个函数executor，这个函数有两个参数resolve和 reject，用来改变Promise的状态。
2. Promise对象中的then方法，可以接收构造函数中处理后的状态，并分别对应执行。
   then方法有2个参数，第一个函数接收resolved状态的执行，第二个参数接收reject状态的执行。then方法的执行结果也会返回一个Promise对象，也就是说promise通过将函数传入到它的then方法中从而获取到promise最终的值（resolve、reject）。

function fn(num) {
    return new Promise(function(resolve, reject) {
        if (typeof num == 'number') {
            resolve();
        } else {
            reject();
        }
    }).then(function() {
        console.log('参数是一个number值');
    }, function() {
        console.log('参数不是一个number值');
    })
}

fn('hahha');
fn(1234);