promise

[ 函数对象 ]

• 小括号左边一定是函数，小数点左边一定是对象，具备二者特性的对象是函数对象

  function Fn(){} // 函数
  Fn.prototype // 函数对象
  Fn.bind({}) // 函数对象
  const fn = new Fn() // Fn 前方有 new 关键字，此时 Fn 为构造函数，fn为实例对象，简称对象

• 只有函数对象才有 call apply bind 方法
• 实例对象实际上是指向构造函数的原型对象，所以构造函数所构造的是自己的原型
• 函数对象本身调用的方法添加到函数本身
• 实例对象调用的方法添加到构造函数的原型上
• 函数对象和构造函数并不冲突

  function Fn() {}
  Fn.a = 'a'
  Fn.say = function(){console.log('say')}
  const fn = new Fn()
  console.log(fn.a) // undefined, 因为Fn的原型对象无法访问Fn的属性和方法
  Fn.prototype.b = 'b'
  Fn.prototype.sing = function() {console.log('sing')}
  const nf = new Fn()
  console.log(nf.b) // b 
  nf.sing() // sing

[ 同步回调 与 异步回调 ]

• 同步回调函数结束后，主函数才会继续往后执行
• 异步回调函数会被加入到回调函数队列，不会阻碍主函数的继续执行

[ error 错误处理 挖坑 ]

• https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Error

[ Promise 是什么 ]

• Promise 是一个构造函数，接受一个包含 resolve 和 reject 两个执行器函数作为参数的回调函数，这个回调函数是同步回调。
• Promise 是一种实现异步编程的解决方案
• Promise 可以解决传统纯回调方式实现异步编程导致的回调地狱问题
• Promise 的异步结果处理函数可以在得到结果后去定义，而纯回调方式必须在启动异步任务之前就定义好。
• Promise 可以实现链式调用，让代码更易阅读和简洁。

[ Promise 语法 ]

• https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise#构造函数

  new Promise((resolve, rejectj) => {
    // if ok
    resolve(value)
    // not ok
    reject(reason)
  }).then(value=> { }, reason => { })

• 失败后的处理函数也可以单独拿出来写

  new Promise(...)
    .then(value => { })
    .catch(reason => { })

• 如果抛出异常，则执行reject，reason 为抛出的异常对象，或者抛出的其他内容

  new Promise((res, rej) => {
    throw new Error('error msg')
    // or
    throw 3
  }).catch(reason => {}) // reason 是 error对象 或者 3

• 链式调用与分别调用

  const p = new Promise((res, rej) => {
    res(3)
  })
  p.then(value => { return value + 1})
    .then(value => {console.log(value)}) // 4, 链式调用，值会被链式传递
  p.then(value => {console.log(value)}) // 3

• 链式传递

  p.then(
    value => return Promise.resolve('val')
  ).then(value => {console.log(value)}) // val
  // 如果没有return，则相当于return undefined, 结果为成功
  // 如果 throw ..., 或者 return Promise.reject(reason), 则视为失败

• 如果要返回确定了结果的promise对象，可以使用 Promise 函数对象的静态方法

const p = new Promise((res, rej) => {
  res(value)
})
// 可以简写为
const p = Promise.resolve(value)
// 同样的
const p = Promise.reject(reason)

• Promise.all() 传入一个 promise 组成的数组，执行这些 promise，所有成功返回成功，发现失败返回失败

  const pAll = Promise.all([p1, p2, p3])
  // pAll 是一个 promise 对象，p1-p3都是 promise对象
  pAll.then(aValue => {}) // aValue 是所有成功的结果组成的数组
      .catch(reason => {}) 

• Promise.race() 传入一个 promise 组成的数组，执行这些 promise，最快返回结果的promise 的结果就是该方法返回的结果

  const winPromise = Promise.race([p1, p2, p3])
  winPromise.then(winvalue => {}, winReason => {})