14Promise

promise 的含义

promise 是异步编程的方式，有以下特点

1. 对象的状态不受外界影响
2. 一旦状态改变，就不会改变

promise 的缺点

1. promise 一旦建立就会执行，无法取消
2. promise 没有回调函数，则内部抛出的错误不会反应到外部
3. 在pending时，无法得知目前进展到哪一个阶段

基本用法

1. 基本用法

// 生成一个promise对象
// 在新版的jQuery中将ajax请求
var promise = new Promise(function (resolve,reject) {
  // 注意，value就是自己定义的，当成功时，then中函数的默认参数
  // error 也是自己定义的，当失败时，catch中函数的默认参数
    if () {
        resolve(value);
    } else {
        reject(error);
    }
});
// 在此进行异步编程
promise.then(function (value) {
    // success
},function (error) {
    // failure 
});

2. 生成promise对象的另一种方式

// 生成某种状态的promise对象
Promise.resolve(value);
Promise.reject(error);

3. 当p1的 resolve() 的参数是个 promies 对象，p1的状态将由该 promise 对象决定

var p1 = new Promise(function (resolve, reject) {
  setTimeout(() => reject(new Error('fail')), 3000)
})

// 这里，resolve 的参数是 promise 对象，所以，p2 的状态由 p1 进行确定。3000 毫秒时，p1 改变成
var p2 = new Promise(function (resolve, reject) {
  setTimeout(() => resolve(p1), 1000)
})

p2
  .then(result => console.log(result))
  .catch(error => console.log(error))

4. resolve()后的语句依旧会执行，可以使用return resolve()

then

1. 有两个参数

• 第一个参数，当resolve的时候调用
• 第二个参数，当reject的时候调用

2. 当then返回的是一个promise对象，第二个then方法会等到返回的 promise 对象状态改变的时候调用
3. 当then返回的是一个非promise对象或者不返回值（undefined），返回值会作为第二then的参数
4. then可以连用，不论前边的then返回的是什么类型的值

catch

1. 其实相当于then(null,fn)
2. promise 对象的错误有'冒泡'性质，会一直向后传递，直到被捕获
3. catch 其实返回的还是一个 promise 对象，因此可以继续链式编程

// 冒泡一
// 注意 then 中参数
getJSON('/get/1.json').then(function (post) {
    return getJSON(post.commentURL);
}).then(function (comments) {
    // some coede 
}).catch(function (err) {
    // 处理前面三个 promise 产生的错误
});


// 冒泡二
// 注意这种错误，不会被捕获，会报错
var promise = new Promise(function (resolve, reject) {
  resolve('ok');
  setTimeout(function () { throw new Error('test') }, 0)
});
promise.then(function (value) { console.log(value) });

all

当所有 promise 都为 fulfilled， p 对象才会为 fulfilled。 当有一个 promise 为 rejected, p 对象为 rejected，并且该 promise 对象将被传递给回调函数。

1. 示例

// 生成一个Promise对象的数组
var promises = [2, 3, 5, 7, 11, 13].map(function (id) {
  return getJSON('/post/' + id + ".json");
});

Promise.all(promises).then(function (posts) {
  // ...
}).catch(function(reason){
  // ...
});

2. 单个 promise 对象有catch方法，就不会触发Promise.all()的catch方法

race

只要有个 promise 对象率先改变状态，p 的状态就跟着变化

// 应用： 5000 秒内没有响应，就会报错
const p = Promise.race([
    fetch('/resource-that-may'),
    new Promise(function (resolve,reject) {
        setTimeout(() => reject(new Error('request timeout')),5000);
    })
]);
p.then(response => console.log(response));
p.catch(error => console.log(error));

resolve

将参数转变成 promise 对象

1. 参数是一个 promise 对象，不做改变
2. 参数是一个 thenable 对象（含有 then 方法的对象），将该对象转变成 promise 对象，并立即调用该对象的 then 方法
3. 不是 thenable 的对象或者根本就不是对象

• 生成一个新的 promise 对象，标记成 resolved
• 并将 resolve 的参数传递给then

4. 无参，返回一个被标记成 resolved 的 promise 对象

reject

返回一个标记为rejected状态的 promise 对象

1. 参数是一个 thenabel 对象，会被作为参数传递给catch
2. 参数是一个字符串，会直接传递给catch方法

两个自定义方法

1. done(),保证抛出任何可能出现的错误

Promise.prototype.done = function (onFulfilled,onRejected) {
    this.then(onFulfilled,onRejected)
      .catch(function (reason) {
          setTimeout(() => {throw reason},0);
      });
}

2. finally(),无论 promise 对象状态如何，都会执行该操作

Promise.prototype.finally = function (callback) {
  let P = this.constructor;
  return this.then(
    value  => P.resolve(callback()).then(() => value),
    reason => P.resolve(callback()).then(() => { throw reason })
  );
};

提案try

1. 当无法得知操作是异步还是同步，没有promise.try方法的解决办法

try {
  database.users.get({id: userId})
  .then(...)
  .catch(...)
} catch (e) {
  // ...
}