[[234989]]

那天我正在學(xué)習(xí) Promise,突然家里打電話過來說，家里蓋房子要錢。我工作這么多年了，從事著別人眼中高薪工作，于是滿口答應(yīng)下來。但是由于我并沒有錢，于是我跟家里說，等過幾天我再打錢過去。我也好乘著這幾天想想辦法。

首先我找到我的同學(xué)李雷，他現(xiàn)在一個部門經(jīng)理了，我想應(yīng)該他應(yīng)該有錢。我跟他說明了借錢的意向，李雷二話不說就答應(yīng)借我300，不過同時表示要回家跟老婆商量商量，我說好。此時我想起來答應(yīng)或者說承諾的英文單詞就是 Promise 。承諾的結(jié)果是錢，錢是數(shù)值(number 類型)。于是我想把我要借錢的這一行為寫成一個 TypeScript 函數(shù)如下：

// 向李雷借錢，李雷丟給我一個承諾 
function borrowMoneyFromLiLei(): Promise<number> { 
  return new Promise<number>(function(fulfill, reject) { 
     // 李雷跟老婆商量中 
  }); 
} 

此時，我在想李雷老婆會答應(yīng)給我借300塊嗎?我不確定，就像薛定諤的貓。借還是不借，這是一個問題。然后我發(fā)現(xiàn)這也可以寫成一個函數(shù)。借或者不借用布爾值來表示 (boolean 類型)。函數(shù)如下：

// 李雷的老婆是否會答應(yīng)給我借錢？ 
function willLiLeiWifeLendMeMoeny(): Promise<boolean> { 
  return new Promise<boolean>(function(lend, reject) { 
    // 借還是不借 
  }); 
} 

如果李雷借我錢了，我就轉(zhuǎn)錢給家里，沒有，我應(yīng)該要再去找別人借了。可以用下面的函數(shù)描述我此時的處境。

function transferMoneyToHome(money: number) { 
    // 給家里轉(zhuǎn)錢 
} 
function mySituation(){ 
    borrowMoneyFromLiLei() 
    .then((money:number) => { 
        // 如果李雷借我錢了，我就轉(zhuǎn)錢給家里. 
        transferMoneyToHome(money) 
    }).catch((reason) => { 
        // 李雷老婆拒絕借錢給我。 那我應(yīng)該考慮向其他人借了。 
        borrowMoneyFromOthers() 
    }) 
} 

找其他人借，我能想到就(張三，李四，五五)這三個人了，其他的朋友很少聯(lián)系，突然說借錢也不好。于是我嘗試向他們借錢。用代碼表示是這樣子的：

function borrowMoneyFromOthers() { 
  // 我先試著向張三借 
  tryBorrowMoneyFromZhangshan() 
    .then(money => { 
      transferMoneyToHome(money); 
    }) 
    .catch(reason => { 
      // 如果張三不借，并丟給我一個理由 
      // 試著向李四借 
      tryBorrowMoneyFromLisi() 
        .then(money => { 
          transferMoneyToHome(money); 
        }) 
        .catch(reason2 => { 
          // 如果 李四也不肯錯 
          // 再試試向王五借 
          tryBorrowMoneyFromWangwu() 
            .then(money => { 
              transferMoneyToHome(money); 
            }) 
            .catch(reason => { 
              // 沒有人肯借 
              throw new Error("我該怎么辦呢？"); 
            }); 
        }); 
    }); 
} 

由于借著錢之后都是向家里轉(zhuǎn)錢，所以上面的代碼應(yīng)該簡化一下。簡化后如下：

function borrowMoneyFromOthers() { 
  // 我先試著向張三借 
  tryBorrowMoneyFromZhangshan() 
    .then(transferMoneyToHome) 
    .catch(reason => { 
      // 如果張三不借，并丟給我一個理由 
      // 試著向李四借 
      tryBorrowMoneyFromLisi() 
        .then(transferMoneyToHome) 
        .catch(reason2 => { 
          // 如果 李四也不肯錯 
          // 再試試向王五借 
          tryBorrowMoneyFromWangwu() 
            .then(transferMoneyToHome) 
            .catch(reason => { 
              // 沒有人肯借 
              throw new Error("我該怎么辦呢？"); 
            }); 
        }); 
    }); 
} 

在上面的思路中，我是一個一個找他們借錢的，一個借不著再找另一個。我為什么不同時找他們借呢?誰借我了，我就轉(zhuǎn)錢給家里。此時我想起了剛學(xué)的 Promise.race 方法，也許這個方法可以幫助我表達(dá)我的這一決策需求.

function borrowMoneyFromOthers() { 
  // 同時向張三，李四，王五借錢，只要有人借我錢了，我就轉(zhuǎn)錢給家里。 
  Promise.race([ 
    tryBorrowMoneyFromZhangshan(), 
    tryBorrowMoneyFromLisi(), 
    tryBorrowMoneyFromWangwu() 
  ]) 
    .then(transferMoneyToHome) 
    .catch(reasons => { 
      console.warn("沒一個人愿意給我借錢，他們理由是：", reasons); 
    }); 
} 

我用timeout 模擬一下他們給我答復(fù)的，代碼如下：

// 嘗試找張三借 
function tryBorrowMoneyFromZhangshan(): Promise<number> { 
  return new Promise(function(fulfill, reject) { 
    setTimeout(() => { 
      fulfill(300); 
    }, 100); 
  }); 
} 
// 嘗試找李四借 
function tryBorrowMoneyFromLisi(): Promise<number> { 
  return new Promise(function(fulfill, reject) { 
    setTimeout(() => { 
      reject("對不起我也沒錢"); 
    }, 50); 
  }); 
} 
// 嘗試找王五借 
function tryBorrowMoneyFromWangwu(): Promise<number> { 
  return new Promise(function(fulfill, reject) { 
    setTimeout(() => { 
      fulfill(300); 
    }, 500); 
  }); 
} 

結(jié)果運行之后，控制臺輸出的是：

沒一個人愿意給我借錢，他們理由是： 對不起我也沒錢

看來 Promise.race 適用用來模擬搶答，而不是選擇最優(yōu)解。 比如多人搶答一個問題，第一個搶答之后不論他回答的是否是正確，這個題都過了。

不過沒關(guān)系。也許我可以自己寫一個來叫做 promiseOne 的函數(shù)來實現(xiàn)這個功能。代碼如下：

/** 
 * 當(dāng)其中一個 Promise 兌現(xiàn)時，返回的 Promise 即被兌現(xiàn) 
 * @param promises Promise<T> 的數(shù)組 
 */ 
function promiseOne<T>(promises: Promise<T>[]): Promise<T> { 
  const promiseCount = promises.length; 
  return new Promise<T>(function(resolve, reject) { 
    const reasons: any[] = []; 
    let rejectedCount = 0; 
    promises.forEach((promise, index) => { 
      promise.then(resolve).catch(reason => { 
        reasons[index] = reason; 
        rejectedCount++; 
        if (rejectedCount === promiseCount) { 
          reject(reasons); 
        } 
      }); 
    }); 
  }); 
} 

正當(dāng)我寫完了上面的代碼，他們?nèi)齻€給我回話了，說是現(xiàn)在手上也沒有那么多錢，但是可以給我借100. 于是我現(xiàn)在需要處理這樣的事情，就是當(dāng)他們?nèi)齻€人把錢都轉(zhuǎn)給我之后我再轉(zhuǎn)給家里。 當(dāng)他們?nèi)齻€都兌換借我100塊錢的承諾時，可以用 Promise.all 來表示，代碼如下：

function borrowMoneyFromOthers() { 
  // 同時向張三，李四，王五借錢， 借到之后，我就轉(zhuǎn)錢給家里。 
  Promise.all([ 
    tryBorrowMoneyFromZhangshan(), 
    tryBorrowMoneyFromLisi(), 
    tryBorrowMoneyFromWangwu() 
  ]) 
    .then(moneyArray => { 
      console.info("借到錢啦：", moneyArray); 
      const totalMoney = moneyArray.reduce((acc, cur) => acc + cur); 
      transferMoneyToHome(totalMoney); 
    }) 
    .catch(reasons => { 
      console.warn("有人不愿意給我借錢，理由是：", reasons); 
    }); 
} 

現(xiàn)在有三個人愿意給我借錢了，嗯，也就是說我借到了 300 塊。然而這錢用來建房還是杯水車薪。所以我還得想辦法。我想我要不要試試用這300塊來買一下彩票。如果中了，說不定這事就成了。

function buyLottery(bet: number): Promise<number> { 
  return new Promise(function(fulfill, resolve) { 
    // 投注 
    // 等待開獎 
    setTimeout(() => { 
      resolve("很遺憾你沒有買中"); 
    }, 100); 
  }); 
} 
 
function borrowMoneyFromOthers() { 
  // 同時向張三，李四，王五借錢，  
  Promise.all([ 
    tryBorrowMoneyFromZhangshan(), 
    tryBorrowMoneyFromLisi(), 
    tryBorrowMoneyFromWangwu() 
  ]) 
    .then(moneyArray => { 
      console.info("借到錢啦：", moneyArray); 
      const totalMoney = moneyArray.reduce((acc, cur) => acc + cur); 
      // 購買彩票 
      buyLottery(totalMoney) 
        .then(transferMoneyToHome) 
        .catch(reason => { 
          console.log("沒中，", reason); 
        }); 
    }) 
    .catch(reasons => { 
      console.warn("有人不愿意給我借錢，理由是：", reasons); 
    }); 
} 

我知道很大概率我是買不中的，最近世界杯開賽了，我幻想著壓注世界杯，而且世界杯場次多，一天好幾場，一場買中的盈利還可以投入到下一場。我把我的幻想寫成代碼，大概就是下面這樣。

function betWorldCup() { 
  // 初始資金 300 塊 
  Promise.resolve(300) 
    .then(moeny => { 
      // 投西班牙 
      return new Promise<number>(function(fulfil, reject) { 
        setTimeout(() => { 
          // 假假設(shè) 賠率 1.2 
          fulfil(moeny * 1.2); 
        }, 100); 
      }); 
    }) 
    .then(ret => { 
      // 投英格蘭 
      return ret * 1.2; 
    }) 
    .then(ret => { 
      // 投巴西 
      return new Promise<number>(function(fulfil, reject) { 
        setTimeout(() => { 
          fulfil(ret * 1.2); 
        }, 92); 
      }); 
    }) 
    .then(ret => { 
      console.log("現(xiàn)在收益加本金共有: ", ret); 
    }); 
} 

我想，如果第一場投失敗了，應(yīng)該再給自己一次機(jī)會。于是將代碼修改如下：

function betWorldCup() { 
  // 初始資金 300 塊 
  Promise.resolve(300) 
    .then(moeny => { 
      // 投西班牙 
      return new Promise<number>(function(fulfil, reject) { 
        setTimeout(() => { 
          // 假假設(shè) 賠率 1.2 
          // fulfil(moeny * 1.2); 
          reject("莊家跑跑路了"); 
        }, 100); 
      }); 
    }) 
    .then( 
      ret => { 
        // 投英格蘭 
        return ret * 1.2; 
      }, 
      reason => { 
        console.info("第一次投注失敗，再給一次機(jī)會好不好?, 失敗原因: ", reason); 
        // 再投 300 
        return 300; 
      } 
    ) 
    .then(ret => { 
      // 投巴西 
      return new Promise<number>(function(fulfil, reject) { 
        setTimeout(() => { 
          fulfil(ret * 1.2); 
        }, 92); 
      }); 
    }) 
    .then(ret => { 
      console.log("現(xiàn)在收益加本金共有: ", ret); 
      throw new Error("不要再買了"); 
    }) 
    .then(ret => { 
      console.info("準(zhǔn)備再買嗎？"); 
    }) 
    .catch(reason => { 
      console.log("出錯了：", reason); 
    }); 
} 

此時如下運行上面的函數(shù)會得到如下輸出：

• 第一次投注失敗，再給一次機(jī)會好不好?, 失敗原因: 莊家跑跑路了
• 現(xiàn)在收益加本金共有: 360
• 出錯了：
• Error: 不要再買了

然而，幻想結(jié)束之后，我依然得苦苦思考怎么樣籌錢。