var promise = new Promise(function (resolve, reject) {
    console.log('我是promise里的同步代码');
    setTimeout(() => {
        console.log('我是promise里的异步代码');
        resolve('我是promise里的异步代码执行完成')
    }, 2000);
})
console.log('我是promise外的同步代码');

setTimeout(() => {
    console.log('定时器1s');
}, 1000);
promise.then(res => {
    console.log(res);
})

/**
 * 打印顺序：
 * 1.先执行promise里的同步代码，打印：我是promise里的同步代码
 * 2.遇到定时器，加入宏任务，promise里没有同步代码了，返回promise外部
 * 3.遇到同步代码，打印：我是promise外的同步代码
 * 4.又遇到定时器，加入宏任务
 * 5.遇到promise.then，加入微任务
 * 6.此时主线程代码执行完毕，先去微任务队列查看，即5，没有任务
 * 7.查看宏任务队列，4先执行完成，打印：定时器1s
 * 8.再查看微任务任务队列，还是没有，再执行宏任务队列，即执行5，打印：我是promise里的异步代码
 * 9.然后执行resolve，加入微任务队列，然后宏任务队列执行完毕，执行微任务队列，打印：我是promise里的异步代码执行完成
 * 结果：
 * 我是promise里的同步代码
 * 我是promise外的同步代码
 * 定时器1s
 * 我是promise里的异步代码
 * 我是promise里的异步代码执行完成
*/

setTimeout(function () {
    console.log('1')
});

new Promise(function (resolve) {
    console.log('2');
    resolve();
}).then(function () {
    console.log('3')
});

console.log('4');

// 2,4,3,1

/**
 * 根据Promise/A+规范实现Promise
 * Promise/A+为了简便，以下简称为规范
*/
function _Promise(executor) {

    var _this = this // 先保存this
    _this.status = 'pending' //规范要求的状态
    _this.value = undefined //规范要求成功返回的值
    _this.season = undefined //规范要求失败返回的原因
    _this.exception = undefined //规范要求异常抛出的值

    // 成功执行的函数
    function resolve(value) {
        // 规范规定，只能从pending变成fulfilled或者从pending变成rejected
        // 比如：如果当前status从pending变成fulfilled，
        // 则不能再次对status进行修改成pending或者reject。
        if (_this.status == 'pending') {
            _this.status = 'fulfilled'
            _this.value = value
        }
    }
    // 失败执行的函数
    function reject(season) {
        // 规范规定，只能从pending变成fulfilled或者从pending变成rejected
        // 比如：如果当前status从pending变成fulfilled，
        // 则不能再次对status进行修改成pending或者reject。
        if (_this.status == 'pending') {
            _this.status = 'rejected'
            _this.season = season
        }
    }
    // 因为new Promise(fn)时，会立即执行fn
    // 所以实现_Promise时，也要立即执行传进来的executor函数
    executor(resolve, reject)
}

var p = new _Promise(function (resolve, reject) {
    console.log('_Promise里的同步代码')
    resolve(200)
    // reject(500)
})
console.log(p)
// 打印顺序：
// _Promise里的同步代码
// _Promise {status: "fulfilled", value: 200, season: undefined, exception: undefined}

/**
 * Promise执行完成有结果的时候，会调用的then方法，该方法接收两个参数，
 * 第一个是成功时候的回调函数，第二个是失败时候的回调函数，
 * 所以实现_Promise时，也要实现这个then方法
 */

_Promise.prototype.then = function (onFulfilled, onRejected) {
    if (_this.status == 'fulfilled') {
        onFulfilled(_this.value)
    }
    if (_this.status == 'rejected') {
        onRejected(_this.season)
    }
}

var p = new _Promise(function (resolve, reject) {
    console.log('_Promise里的同步代码')
    // resolve(200)
    reject(500)
})
p.then((res) => {
    console.log(res)
    console.log(p)
}, (err) => {
    console.log(err)
    console.log(p)
})
console.log(111);

// 打印顺序：
// _Promise里的同步代码
// 500
// _Promise {status: "rejected", value: null, season: 500, exception: null}
// 111

_Promise.prototype.then = function (onFulfilled, onRejected) {
    if (_this.status == 'fulfilled') {
        setTimeout(() => {
            onFulfilled(_this.value)
        }, 0);

    }
    if (_this.status == 'rejected') {
        setTimeout(() => {
            onRejected(_this.season)
        }, 0);
    }
}
var p = new _Promise(function (resolve, reject) {
    console.log('_Promise里的同步代码')
    // resolve(200)
    reject(500)
})

p.then((res) => {
    console.log(res)
    console.log(p)
}, (err) => {
    console.log(err)
    console.log(p)
})
console.log(111);

// 打印顺序：
// _Promise里的同步代码
// 111
// 500
// _Promise {status: "rejected", value: null, season: 500, exception: null}

// executor函数里面的代码有错误，但是没有被then的reject捕获，会修改Promise的状态为rejected，并抛出错误
var p = new Promise((resolve, reject) => {
    throw new Error('xxx')
})
console.log(p);

// 打印顺序：
// Promise {<rejected>: Error: xxx at file:///E:/hss/my-study-notes/%E9%87%8D%E5%AD%A6js/promise/promise%E9%94%99%E8%AF…}
// 报错：Uncaught (in promise) Error: xxx