Promise

Promise(承诺)

• promise对象(是一个容器)中通常会包含异步操作 . 其实现了异步操作和异步结果处理的分离. 其有两个特点:
  1. 对象的状态不受外界影响. promise初始为pending状态. 但异步请求成功, 会调用resolve() , 状态变为fulfilled(已成功) ; 请求失败 , 会调用reject() , 状态变为rejected(已失败) . 只有异步操作的结果 , 可决定当前是哪种状态 . 外部是无法影响的.
  2. 一旦状态改变 , 就不会再变. 任何时候都可以得到这个结果 . 这意味着, 我们可以去随意的处理异步操作的结果. 且这个结果不会改变 .

	const p =new Promise((resolve,reject)=>{
            if(成功){
                resolve(value)
            }else{
                reject(error)
            }
        })

• 用法:
  • promise构造函数是同步执行. 有一个executor函数,其参数是resolve 和 reject (由JS提供.可修改名称).
  • promsie实例生成后,可以用then方法指定成功和失败状态的回调函数.
    接受两个参数,但都是可选的. 他们都接受promise对象传出的值
  • 之所以说是可选的. 因为then方法默认会把第一个位置的参数当作成功后的回调函数 ; 把第二个位置的参数当作失败后的回调函数
  • 调用resolve和reject只是确定了状态 , 而不会终结函数的执行.但不应该确认状态后再放语句 , 而应该放在then方法的处理函数种.
  • 如果resolve()的参数是另一个promise的实例.

	const p = new Promise((resolve, reject) => {
            resolve('成功了')
        })
        console.log(p)
        p.then(function(res) {
                console.log(res)
            }, function(err) {
                console.log(err)
            })
        //p.then(result => console.log(result))

	 const p = new Promise((resolve, reject) => {
            reject('失败了')
        })
        console.log(p)
        p.then(function(res) {
            console.log("fulfilled：" + res)
        }, function(err) {
            console.log("rejected" + err)
        })

	const p = new Promise((resolve, reject) => {
            reject('失败了')
        })
        console.log(p)
        p.then(result => console.log(result))

	const p = new Promise((resolve, reject) => {
            console.log('承诺1')
            resolve('成功了')
            /*
				return resolve('成功了') 
				这样后面的代码就不会执行了. 
			*/
            console.log('承诺2')
        })
        console.log(p)
        p.then(res => {
            console.log(res)
            console.log('处理中')
        })

	  const p1 = new Promise((resolve, reject) => {
            reject('失败了')
        })
        const p2 = new Promise((resolve, reject) => {
            resolve(p1)
        })
        console.log(p2)
        p2.then(null, function(result) {
            console.log(result)
        })

		const p1 = function() {
            console.log('p1')
            return;
        }
        const p2 = new Promise((resolve, reject) => {
            resolve(p1)
        })
        console.log(p2)

• Promise的方法.
  • Promise.all() :
    • 参数: 一个数组 / 具有iterator接口. 且数组中的每一个成员都是promis实例.
    • 返回值:
      • 参数中的状态都为成功 . 其状态才会为成功 . 且 参数中的每个放回值组成一个数组 . 交给其回调函数.
      • 只有有一个参数会失败 . 其状态为失败. 第一个失败的返回值 , 交给其回调函数.

	 const p1 = Promise.resolve('成功1')
        const p2 = Promise.resolve('成功2')
        const p3 = Promise.resolve('成功3')
        const arr_p = [p1, p2, p3]
        let all = Promise.all(arr_p)
        console.log(all)
        all.then(result => {
            console.log(result)
        })

	 const p1 = Promise.resolve('成功1')
        const p2 = Promise.reject('失败2')
        const p3 = Promise.resolve('成功3')
        const arr_p = [p1, p2, p3]
        let all = Promise.all(arr_p)
        console.log(all)
        all.then(result => {
                console.log(result)
            })
            .catch(err => {
                console.log(err)
            })

• Promise.race() :
  - 基本同上. 只是其是只用有一个先改变 . 状态就会改变 . 返回值就是先改变的值.

	const p1 = new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve('成功了')
            }, 100)
        })
        const p2 = new Promise((resolve, reject) => {
            setTimeout(() => {
                reject('失败了')
            }, 0)
        })
        const arr_p = [p1, p2]
        let race = Promise.race(arr_p)
        console.log(race)
        race.then(result => {
            console.log(result)
        }).catch(err => {
            console.log(err)
        })

• Promise.allSettled() :
  - 只有等到等到参数中所用promise对象发生变化. 才确定其状态 . 且状态必为成功
  - 回调函数接受到的数据 . 是之前参数传入的promise对象的状态.返回的是一个数组.
  - 成功的: {status: ‘fulfilled’, value: value}
  - 失败的: {status: ‘rejected’, reason: reason}

• Promise.any() :
  - 类似于" 与 "运算. 有一个成功 , 则最终结果为成功 ; 只有全部为失败 , 最终结果才是失败 .

• Promise.resolve()

  • 将不是promise对象 . 转为promise对象 .
  • 放回一个新的promise实例

	Promise.resolve('成功了')
	相当于 
	new Promise(resolve => resolve('成功了'))

• Promise.reject()
  • 将不是promise对象 . 转为promise对象 .
  • 放回一个新的promise实例

	Promise.reject('失败了')
	相当于 
	new Promise((resolve,reject) => reject('成功了'))

• Promise.prototype.then()
  • 为Promise 实例添加状态改变时的回调函数. 其第一个参数是成功状态的回调. 第二个参数是失败状态的回调. 且都是可选的.
  • 放回的是一个新的promise实例 . 因此可以采用链式写法.

	let p = Promise.resolve('成功了')
        let p1 = p.then(res => {
            console.log(res)
            return '第一次处理'
        })
        console.log(p) 
        console.log(p1) //then方法返回的promise对象
        p1.then(data => console.log(data)))

• Promise.prototype.catch()
  • 相当于 then(null , reject) .
  • then方法中如果抛出错误 . 也会被catch方法捕获 . 第一个catch方法抛出的错误也会被第二个catch方法捕获.
  • 没有catch方法捕获的错误,不会影响外部代码的执行.

	 let p = Promise.reject('失败了')
        p.then(res => {
            console.log(res)
        })
        console.log('还执行吗？')

• Promise.prototype.finally()
  • 不管promise对象最后状态如何,都会执行的操作.
  • 其回调函数不接受任何参数. 也就不会知道,前面的promise的状态. 同时也说明finally方法中的操作, 是与状态无关的 . 不依赖于promise的执行结果.

	promise
	.finally(() => {
	  // 语句
	});
	
	// 等同于
	promise
	.then(
	  result => {
	    // 语句
	    return result;
	  },
	  error => {
	    // 语句
	    throw error;
	  }
	);

---

参考文章:

阮一峰es6入门