深入理解es6-Promise对象 (2)

通常情况下，then方法作为成功时的回调方法，catch方法作为失败时回调方法。catch()在后面,可以理解为then方法中的reject参数

let promise = new Promise((resolve, rejected)=>{ if(2<3){ resolve() }else{ rejected() } }) promise.then(resolve=>{ console.log('right') }).catch(reject=>{ console.log('error') })

ps: then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。

var aPromise = new Promise(function (resolve) { resolve(100); }); var thenPromise = aPromise.then(function (value) { console.log(value); }); var catchPromise = thenPromise.catch(function (error) { console.error(error); }); console.log(aPromise !== thenPromise); // => true console.log(thenPromise !== catchPromise);// => true

所以每一个then()方法就是一个新promise对象。因此可以采用链式写法，即then方法后面再调用另一个then方法。这样必须要传一个参数过去。
promise的链式编程，就是第一个的Promise实例的返回的值作为下一个Promise实例的参数。

function start() { return new Promise((resolve, reject) => { resolve('start'); }); } start() .then(data => { // promise start console.log(data); return Promise.resolve(1); // 1 }) .then(data => { // promise 1 console.log(data); }) // start // 1

从上面例子可知：

start函数里resolve里传了一个参数‘start’

第一个then方法接受了start,然后return 一个成功的值 1

第二个then方法接受上一个then传来的值 1

Promise.catch()

catch()和then()都是挂载在promise对象的原型上的。
Promise.prototype.catch方法是promise.then(null, rejection)或promise.then(undefined, rejection)的别名，用于指定发生错误时的回调函数。
一般是等价于：（在遇到失败的情况下）
Promise.catch() <=> promise.then(null,e=>reject())
如果异步操作抛出错误，状态就会变为rejected，就会调用catch方法指定的回调函数，处理这个错误。另外，then方法指定的回调函数，如果运行中抛出错误，也会被catch方法捕获。

const promise = new Promise(function(resolve, reject) { throw new Error('test'); }); promise.catch(function(error) { console.log(error); }); // Error: test

Promise 对象的错误具有“冒泡”性质，会一直向后传递，直到被捕获为止。也就是说，错误总是会被下一个catch语句捕获。

function throwError(value) { // 抛出异常 throw new Error(value); } // <1> onRejected不会被调用 function badMain(onRejected) { return Promise.resolve(42).then(throwError, onRejected); } // <2> 有异常发生时onRejected会被调用 function goodMain(onRejected) { return Promise.resolve(42).then(throwError).catch(onRejected); } // 运行示例 badMain(function(){ console.log("BAD"); }); goodMain(function(){ console.log("GOOD"); }); // GOOD

在上面的代码中， badMain 是一个不太好的实现方式（但也不是说它有多坏）， goodMain 则是一个能非常好的进行错误处理的版本。
为什么说 badMain 不好呢？，因为虽然我们在 .then 的第二个参数中指定了用来错误处理的函数，但实际上它却不能捕获第一个参数 onFulfilled 指定的函数（本例为 throwError ）里面出现的错误。也就是说，这时候即使 throwError 抛出了异常，onRejected 指定的函数也不会被调用（即不会输出"BAD"字样）。
与此相对的是， goodMain 的代码则遵循了 throwError→onRejected 的调用流程。 这时候 throwError 中出现异常的话，在会被方法链中的下一个方法，即 .catch 所捕获，进行相应的错误处理。
.then 方法中的onRejected参数所指定的回调函数，实际上针对的是其promise对象或者之前的promise对象，而不是针对 .then 方法里面指定的第一个参数，即onFulfilled所指向的对象，这也是 then 和 catch 表现不同的原因。（详见Javascript Promise 迷你版）
这个是从别人的博客拿来的代码和解释，了那么多，总结为，catch能够捕获它之前的异常，而在then()方法中第二个参数是没办法捕获到的，因为实行了resolve方法。

Promise.resolve()

看字面量的意思，是返回一个成功的promise实例。
Promise.resolve() <=> new Promise((resolve,rejected)=>resolve())
最常见的就是将不是promise对象的异步操作转化为promise对象。
该方法有四个参数：

无参数
直接返回一个resolved状态的 Promise 对象，所谓的字面量意思。

参数是一个 Promise 实例
Promise.resolve将不做任何修改、原封不动地返回这个实例。