深刻 Promise(三)——命名 Promise

咱們常常會遇到這種狀況：好比經過用戶名查找並返回該用戶信息和他的關注者。一般有兩種方法：
一、定義一個外部變量：

var user
getUserByName('nswbmw')
  .then((_user) => {
    user = _user
    return getFollowersByUserId(user._id)
  })
  .then((followers) => {
    return {
      user,
      followers
    }
  })

二、使用閉包：

getUserByName('nswbmw')
  .then((user) => {
    return getFollowersByUserId(user._id).then((followers) => {
      return {
        user,
        followers
      }
    })
  })

兩種實現均可以，但都不太美觀。因而我以前產生了一個想法：同一層的 then 的參數是以前全部 then 結果的逆序。體如今代碼上就是：

Promise.resolve()
  .then(function () {
    return getUserByName('nswbmw')
  })
  .then(function (user) {
    return getFollowersByUserId(user._id)
  })
  .then((followers, user) => {
    return {
      user,
      followers
    }
  })

第 3 個 then 的參數是前兩個 then 結果的逆序，即 followers 和 user。更復雜好比嵌套 promise 的我就不列了，這種實現的要點在於：如何區分 then 的層級。從 appoint 的實現咱們知道，每一個 then 返回一個新的 promise，這致使了沒法知道當前 then 來自以前嵌套多深的 promise。因此這個想法沒法實現。

命名 Promise

後來，我又想出了一種比上面更好的一種解決方法，即命名 Promise：當前 then 的第一個參數仍然是上個 promise 的返回值（即兼容 Promise/A+ 規範），後面的參數使用依賴注入。體如今代碼上就是：

Promise.resolve()
  .then(function user() {
    return getUserByName('nswbmw')
  })
  .then(function followers(_, user) {
    return getFollowersByUserId(user._id)
  })
  .then((_, user, followers) => {
    return {
      user,
      followers
    }
  })

上面經過給 then 的回調函數命名（如：user），該回調函數的返回值掛載到 promise 內部變量上（如：values: { user: 'xxx'} ），並把父 promise 的 values 往子 promise 傳遞。then 的第二個以後的參數經過依賴注入實現注入，這就是命名 Promise 實現的基本思路。咱們能夠給 Promise 構造函數的參數、then 回調函數和 catch 回調函數命名。

因而，我在 appoint 包基礎上修改併發布了 named-appoint 包。

named-appoint 原理：給 promise 添加了 name 和 values 屬性，name 是該 promise 的標識（取 Promise 構造函數的參數、then 回調函數或 catch 回調函數的名字），values 是個對象存儲了全部祖先 promise 的 name 和 value。當父 promise 狀態改變時，設置父 promise 的 value 和 values（ this.values[this.name] = value），而後將 values 拷貝到子 promise 的 values，依次往下傳遞。再看個例子：

const assert = require('assert')
const Promise = require('named-appoint')
new Promise(function username(resolve, reject) {
  setTimeout(() => {
    resolve('nswbmw')
  })
})
.then(function user(_, username) {
  assert(_ === 'nswbmw')
  assert(username === 'nswbmw')
  return {
    name: 'nswbmw',
    age: '17'
  }
})
.then(function followers(_, username, user) {
  assert.deepEqual(_, { name: 'nswbmw', age: '17' })
  assert(username === 'nswbmw')
  assert.deepEqual(user, { name: 'nswbmw', age: '17' })
  return [
    {
      name: 'zhangsan',
      age: '17'
    },
    {
      name: 'lisi',
      age: '18'
    }
  ]
})
.then((_, user, followers, username) => {
  assert.deepEqual(_, [ { name: 'zhangsan', age: '17' }, { name: 'lisi', age: '18' } ])
  assert(username === 'nswbmw')
  assert.deepEqual(user, { name: 'nswbmw', age: '17' })
  assert.deepEqual(followers, [ { name: 'zhangsan', age: '17' }, { name: 'lisi', age: '18' } ])
})
.catch(console.error)

很明顯，命名 Promise 有個前提條件是：在同一條 promise 鏈上。以下代碼：

const assert = require('assert')
const Promise = require('named-appoint')
new Promise(function username(resolve, reject) {
  setTimeout(() => {
    resolve('nswbmw')
  })
})
.then(() => {
  return Promise.resolve()
    .then(function user(_, username) {
      assert(username === undefined)
      return {
        name: 'nswbmw',
        age: '17'
      }
    })
})
.then(function (_, username, user) {
  assert.deepEqual(_, { name: 'nswbmw', age: '17' })
  assert(username === 'nswbmw')
  assert(user === undefined)
})
.catch(console.error)

最後一個 then 打印 undefined，由於內部產生了一條新的 promise 鏈分支。

結合 co 使用

與 co 結合使用是沒有什麼變化的，如：

const Promise = require('named-appoint')
const co = require('co')

const promise = Promise.resolve()
  .then(function user() {
    return 'nswbmw'
  })
  .then(function followers() {
    return [{ name: 'zhangsan' }, { name: 'lisi' }]
  })
  .then((_, user, followers) => {
    return {
      user,
      followers
    }
  })
co(function *() {
  console.log(yield promise)
  /*
  { user: 'nswbmw',
    followers: [ { name: 'zhangsan' }, { name: 'lisi' } ] }
  */
}).catch(console.error)

順便擅自制定了一個 Promise/A++ 規範。

『挑剔的』錯誤處理

咱們繼續腦洞一下。Swift 中錯誤處理是這樣的：

do {
  try getFollowers("nswbmw")
} catch AccountError.No_User {
  print("No user")
} catch AccountError.No_followers {
  print("No followers")
} catch {
  print("Other error")
}

能夠設定 catch 只捕獲特定異常的錯誤，若是以前的 catch 沒有捕獲錯誤，那麼錯誤將會被最後那個 catch 捕獲。經過命名 catch 回調函數 JavaScript 也能夠實現相似的功能，我在 appoint 的基礎上修改併發布了 condition-appoint 包。看個例子：

var Promise = require('condition-appoint')
Promise.reject(new TypeError('type error'))
  .catch(function SyntaxError(e) {
    console.error('SyntaxError: ', e)
  })
  .catch(function TypeError(e) {
    console.error('TypeError: ', e)
  })
  .catch(function (e) {
    console.error('default: ', e)
  })

將會被第二個 catch 捕獲，即打印：

TypeError: [TypeError: type error]
修改一下：

var Promise = require('condition-appoint')
Promise.reject(new TypeError('type error'))
  .catch(function SyntaxError(e) {
    console.error('SyntaxError: ', e)
  })
  .catch(function ReferenceError(e) {
    console.error('ReferenceError: ', e)
  })
  .catch(function (e) {
    console.error('default: ', e)
  })

將會被第三個 catch 捕獲，即打印：

default:  [TypeError: type error]

由於沒有對應的錯誤 catch 函數，因此最終被一個匿名的 catch 捕獲。再修改一下：

var Promise = require('condition-appoint')
Promise.reject(new TypeError('type error'))
  .catch(function SyntaxError(e) {
    console.error('SyntaxError: ', e)
  })
  .catch(function (e) {
    console.error('default: ', e)
  })
  .catch(function TypeError(e) {
    console.error('TypeError: ', e)
  })

將會被第二個 catch 捕獲，即打印：

default:  [TypeError: type error]

由於提早被匿名的 catch 方法捕獲。

condition-appoint 實現原理很簡單，就在 appoint 的 then 里加了 3 行代碼：

Promise.prototype.then = function (onFulfilled, onRejected) {
  ...
  if (isFunction(onRejected) && this.state === REJECTED) {
    if (onRejected.name && ((this.value && this.value.name) !== onRejected.name)) {
      return this;
    }
  }
  ...
};

判斷傳入的回調函數名和錯誤名是否相等，不是匿名函數且不相等則經過 return this 跳過這個 catch 語句，即實現值穿透。

固然，condition-appoint 對自定義錯誤也有效，只要自定義錯誤設置了 name 屬性。