let promise = new Promise(function(resolve, reject) {
  console.log('Promise');
  resolve();
});

promise.then(function() {
  console.log('resolved.');
});

console.log('Hi!');

// Promise
// Hi!
// resolved

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

const p2 = new Promise(function (resolve, reject) {
  setTimeout(() => resolve(p1), 1000)
})

p2.then(result => console.log(result)).catch(error => console.log(error))
// Error: fail

new Promise((resolve, reject) => {
  resolve(1);
  console.log(2);
}).then(console.log);
// 2
// 1

new Promise((resolve, reject) => {
  return resolve(1);
  // 后面的语句不会执行
  console.log(2);
})

getJSON("/posts.json").then(function(json) {
  return json.post;
}).then(function(post) {
  // ... 此时的post 就是 json.post
},function(err){

});

p.then((val) => console.log('fulfilled:', val))
  .catch((err) => console.log('rejected', err));

// 等同于
p.then((val) => console.log('fulfilled:', val))
  .then(null, (err) => console.log("rejected:", err));

// 并不等同于
p.then((val) => console.log('fulfilled:', val), err => console.log("rejected:", err))

getJSON('/post/1.json').then(function(post) {
  return getJSON(post.commentURL);
}).then(function(comments) {
  // some code
}).catch(function(error) {
  // 一个由getJSON产生，两个由then产生。
  // 处理前面三个Promise产生的错误
});

const someAsyncThing = function() {
  return new Promise(function(resolve, reject) {
    // 下面一行会报错，因为x没有声明
    resolve(x + 2);
  });
};

someAsyncThing().then(function() {
  console.log('everything is great');
  // 不会执行，因为要执行也执行catch 而catch没有定义。
});

setTimeout(() => { console.log(123) }, 2000);
// Uncaught (in promise) ReferenceError: x is not defined
// 123

process.on('unhandledRejection', function (err, p) {
  throw err;
  // 第一个是错误对象
  // 第二个是报错的 Promise 实例，它可以用来了解发生错误的环境信息。
});

const promise = new Promise(function (resolve, reject) {
  resolve('ok');
  setTimeout(function () { throw new Error('test') }, 0)
});

promise.then(function (value) { console.log(value) })
.catch(err => {
  console.log('err', err);
  // 不会执行
});
// ok
// Uncaught Error: test

promise
.then(result => {···})
.catch(error => {···})
.finally(() => {···});

Promise.prototype.finally = function (callback) {
  let P = this.constructor;
  return this.then(
    value  => P.resolve(callback()).then(() => value), 
    // 这个then的参数其实就是callback的返回值，但是这里没有使用这个参数，而是返回了上一个Promise的值
    reason => P.resolve(callback()).then(() => { throw reason })
  );
};

new Promise(function(resolve){
  resolve();
})
.then(result => {})
.catch(error => {})
.finally(() => {console.log('finally')}) // finally
.then(val => {
  console.log(val); // undefined
});

const p = Promise.all([p1, p2, p3]);

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

Promise.all(promises).then(function (posts) {
  // 如果promises数组所有的getJSON异步操作都成功
  // 则posts是一个数组，里面包含6个异步操作成功的结果。
}).catch(function(reason){
  // 如果promises数组只要有一个getJSON异步操作都失败
  // 就会将错误返回给catch
});

const p1 = new Promise((resolve, reject) => {
  resolve('hello');
})
.then(result => result)
.catch(e => e);

const p2 = new Promise((resolve, reject) => {
  throw new Error('报错了');
})
.then(result => result)
.catch(e => e);

// p2定义的Promise会执行reject，然后触发catch方法，
// catch方法返回一个新的Promise实例给了p2变量，该实例即此时的p2的状态也会变成resolved 

Promise.all([p1, p2]) 
.then(result => console.log(result)) // ["hello", Error: 报错了]
.catch(e => console.log(e)); // 不会触发Promise.all的catch

const p = Promise.race([p1, p2, p3]);

const p = Promise.race([
  fetch('/resource-that-may-take-a-while'),
  new Promise(function (resolve, reject) {
    setTimeout(() => reject(new Error('request timeout')), 5000)
  })
]);

p
.then(console.log)
.catch(console.error);
// 如果 5 秒之内fetch方法无法返回结果，则setTimeout就会执行并抛出错误，率先改变状态
// 变量p的状态就会变为rejected，从而触发catch方法指定的回调函数。

// 将 jQuery 生成的deferred对象，转为一个新的 Promise 对象。
const jsPromise = Promise.resolve($.ajax('/whatever.json'));

Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))

let thenable = {
  then: function(resolve, reject) {
    console.log('直接被执行了')
    resolve('传递参数供p1的then调用')
  }
};

let p1 = Promise.resolve(thenable); // 直接被执行了
p1.then(function(value) {
  console.log(value);  // 传递参数供p1的then调用
});

const p = Promise.resolve('Hello'); // 相当于将参数作为 thenable对象 的then方法 resolve出来的结果

p.then(function (s){
  console.log(s)
});
// Hello

const p = Promise.resolve();

p.then(function () {
  // 会在下一个事件循环被执行 因为 p 注定会被 resolve
  console.log('hello'); // 'hello' 
  // ...即then回调中也接受不到参数
});

const p = Promise.reject('出错了');

// 等同于

const p = new Promise((resolve, reject) => reject('出错了'))


p.then(null, function (s) {
  console.log(s) // 出错了
});

const thenable = {
  then(resolve, reject) {
    reject('出错了');
  }
};

Promise.reject(thenable)
.catch(e => {
  console.log(e === thenable)
})
// true
// Promise.reject方法的参数是一个thenable对象，执行以后
// 后面catch方法的参数不是reject抛出的“出错了”这个字符串，而是thenable对象。

const f = () => console.log('now');
Promise.resolve().then(f);
console.log('next');
// next
// now

const f = () => console.log('now');
(async () => f())()
.then(...)
.catch(...);
console.log('next');
// now
// next
// 因为async函数总是返回一个Promise
// 如果async函数的执行有返回值，那么这个返回这就会被传递到then方法的参数中

// 同时如果f是同步函数，那么就会async 函数中同步执行
// 如若是异步，那么在then方法中的代码也能正确处理这种情况

const f = () => console.log('now');
(
  () => new Promise(
    resolve => resolve(f()) 
    // Promise 新建后的参数（传入的函数）就会立即执行，是同步队列， resolve(f())就会被立即执行
    // 如果是异步，就会将f()函数调用之后的返回值传递给then函数正确处理
  )
)();
console.log('next');
// now
// next

const f = () => console.log('now');
Promise.try(f);
console.log('next');
// now
// next

function getUsername(userId) {
  return database.users.get({id: userId})
  .then(function(user) {
    return user.name;
  });
}

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

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

Promise.try(() => database.users.get({id: userId}))
  .then(...)
  .catch(...)