/* Promise.resolve() */
// 1、Promise.resolve() 执行顺序
// setTimeout(function() {
// console.log('1、settimeout')
// },0)
// Promise.resolve().then(() => {
// console.log('2、promise.resolve')
// })
// console.log('3、log')
// 2、Promise.resolve(),如果传入的value本身就是Promise对象，则该对象作为Promise.resolve方法返回值返回
// function fn(resolve) {
// setTimeout(function(){
// resolve(123)
// },300)
// }
// let p0 = new Promise(fn)
// let p1 = Promise.resolve(p0)
// console.log(p0) // Promise对象
// console.log(p0 === p1) // true
// Promise.resolve()，如果传入一个thenable对象，返回的Promise对象会跟随thenable对象的最终状态。
// let promise = Promise.resolve($.ajax('*****')) // promise对象
// promise.then(function(value){
// console.log(value)
// })
var p1 = new Promise(function(resolve, reject){
resolve(Promise.resolve('resolve'))
})
var p2 = new Promise(function(resolve, reject){
resolve(Promise.reject('reject'))
})
var p3 = new Promise(function(resolve, reject){
reject(Promise.resolve('resolve'))
})
// p1.then(
// function fulfilled(value){
// console.log('p1fulfilled:', value)
// },
// function rejected(err){
// console.log('p1rejected:', err)
// })
// p2.then(
// function fulfilled(value){
// console.log('p2fulfilled:', value)
// },
// function rejected(err){
// console.log('p2rejected:', err)
// })
// p3.then(
// function fulfilled(value){
// console.log('p3fulfilled:', value)
// },
// function rejected(err){
// console.log('p3rejected:', err)
// })
// 依次打印输出：
// p3rejected:, [object Promise]
// p1fulfilled:, resolve
// p2rejected:, reject
// 说明：
/*
Promise回调函数中的第一个参数resolve，会对Promise执行”拆箱”动作。即当resolve的参数是一个Promise对象时，resolve会”拆箱”获取这个Promise对象的状态和值，但这个过程是异步的。
p1”拆箱”后，获取到Promise对象的状态是resolved，因此fulfilled回调被执行；p2”拆箱”后，获取到Promise对象的状态是rejected，因此rejected回调被执行。
但Promise回调函数中的第二个参数reject不具备”拆箱“的能力，reject的参数会直接传递给then方法中的rejected回调。
因此，即使p3 reject接收了一个resolved状态的Promise，then方法中被调用的依然是rejected，并且参数就是reject接收到的Promise对象。
*/
/*
注意区分：
promise.then(…).catch(…);与promise.then(…, …);并不等价，
尤其注意当promise.then(…).catch(…);中的then会抛异常的情况下。
promise
.then(...) // 返回一个新的promise，
.catch(...) // 又返回一个新的promise
promise
// 返回一个新的promise
// 如果then之前的promise是resolved，则由一个参数返回
// 如果then之前的promise是rejected，则由第二个参数返回
.then(() => {}, () => {})
*/
// 例子 对应区别
// const fn = () => {
// throw 2;
// }
// // promise.then(…).catch(…);
// Promise.resolve(1) // 返回promise对象，状态为resolved，值为1
// .then(val => { // 1
// fn() // 抛出异常，then返回一个rejected的promise
// console.log('then1:',val) // 后面不执行
// return 3 // 不执行
// })
// .catch(val => {
// console.log('catch1:',val) // 接收异常的 2
// return 4 // catch返回一个resolved且值为4的promise
// })
// .then(val => {
// console.log('catch后面的then:', val) // 4
// return 5
// })
// .catch(val => { // 不执行
// console.log('catchcatch:',val)
// })
// // promise.then(() => {}, () => {})
// Promise.resolve(1) // 返回promise对象，状态为resolved，值为1
// .then(
// val => {
// console.log('val:',val) // 1
// fn() // 抛出异常，then返回一个rejected的promise
// console.log('then2:',val) // 后面不执行
// return 3 // 后面不执行
// },
// val => { // 这里之前then之前是rejected才执行
// console.log('catch2:',val) // 不执行
// return 4 // 不执行
// }
// )
// .then(val => {
// console.log('22222val:', val)
// })
// .catch(val => { // 接收上一个then抛出的rejected且值为2的promise
// console.log('222222catchval:', val)
// })
/* 多节点控制流程 */
var p = new Promise(function(resolve, reject){
resolve(1)
})
p.then(val => {
console.log('第一个then：',val) // 1
return 2*val // 返回一个resolved 且值为2的promise
})
.then(val => {
console.log('第二个then：',val) // 2
})
.then(val => {
console.log('第三个then：', val) // undefined
return Promise.resolve('resolve') // 返回一个resolved 且值为'返回一个resolve'的promise
})
.then(val => {
console.log('第四个then：', val) // 'resolve'
return Promise.reject('reject') // 返回一个rejected且值为'reject'的promise
})
.then(val => {
console.log('第五个then：', val) // 不执行
})
.catch(val => {
console.log('reject：', val) // 接收第4个then 返回的rejected且值为'reject'的promise
})
<h4>Promise</h4>
<p>解决的问题：</p>
<ol>
<li>回调地狱</li>
</ol>
<p>回调地狱的危害：</p>
<ol>
<li>代码臃肿</li>
<li>可读性差</li>
<li>耦合度过高，可维护性差</li>
<li>代码复用性差</li>
<li>容易滋生bug</li>
<li>只能在回调里处理异常</li>
</ol>
<p>注意点：</p>
<ul>
<li>1、catch返回的也是一个promise，后面可以继续接then方法</li>
<li>2、fianlly方法的回调函数不接受任何参数，这里的操作与前面的状态没有关系，不依赖于Promise的执行结果</li>
<li>3、Promise.resolve()方法允许调用时不带参数，直接返回一个resolved状态的Promise对象。立即resolve()的 Promise 对象，是在本轮“事件循环”（event loop）的结束时执行，而不是在下一轮“事件循环”的开始时</li>
</ul>