代碼不會全部按照我們的預期運行，可能會有意料之外的情況，為了保證程序的健壯性，要進行異常處理。

比如一個對象的所有方法，都應該做異常處理，但是，如果每個方法都加 try catch 又太麻煩：

const obj = { aaa() { try { // aaa } catch(e) { // xxxx } }, bbb() { try { // bbb } catch(e) { // xxxx } }, ccc() { try { // ccc } catch(e) { // xxxx } } }

有沒有一種方式既能對所有方法做異常處理，又不用重復寫這么多次呢?

有，就是代理模式。

代理模式是通過對目標對象做一層包裝，提供和目標對象同名的方法，最終的功能實現還是調用目標對象的方法，但可以額外添加一些職責，比如日志、權限等，可以透明的對目標對象做一些擴充。

比如 React 里的高階組件就是代理模式的實現，可以透明的擴展被包裝的組件的功能。

很明顯，這里的異常處理，也可以用代理的方式來做。但不用完全自己實現，ES6 提供了 Proxy，可以基于它來實現。

定義 createProxy 方法來實現代理，創建一個 Proxy 對象，對目標對象 target 做一層包裝，定義 get、set 時的處理：

function createProxy(target) { const proxy = createExceptionProxy(); return new Proxy(target, { get: proxy, set: proxy }); } function createExceptionProxy() { return (target, prop) => { if (!(prop in target)) { return; } if (typeof target[prop] === 'function') { return createExceptionZone(target, prop); } return target[prop]; } }

如果 target 不包含 prop，就返回空，否則返回對應的屬性值 target[prop]。

如果屬性值是函數，則做一層包裝：

function createExceptionZone(target, prop) { return (...args) => { let result; ExceptionsZone.run(() => { result = target[prop](...args); }); return result; }; }

最終的功能實現還是調用 target，傳入參數，把調用結果作為代理方法的結果返回。

包裝這一層的目的是為了做異常處理，也就是 ExceptionsZone.run 做的事情：

class ExceptionsZone { static exceptionHandler = new ExceptionHandler(); static run(callback) { try { callback(); } catch (e) { this.exceptionHandler.handle(e); } } }

調用目標方法，并做 try catch，當出現異常的時候，用 ExceptionHandler 來處理。

這里的異常處理我們就簡單打印下日志：

class ExceptionHandler { handle(exception) { console.log('記錄錯誤：',exception.message, exception.stack); } }

這樣就實現了給目標對象的所有方法添加異常處理的目的。

測試下：

const obj = { name: 'guang', say() { console.log('Hi, I\'m ' + this.name); }, coding() { //xxx
        throw new Error('bug'); } coding2() { //xxx
        throw new Error('bug2'); } } const proxy = createProxy(obj); proxy.say(); proxy.coding();

這里的 coding、coding2 方法都會拋出異常，但并沒有做異常處理，我們用代理給它加上：

我們成功地通過代理模式給對象方法添加了異常處理!

但是現在這樣還是有問題的，比如我把 coding 方法改為 async 的就不行了：

那怎么辦呢?能不能統一對異步和同步方法做代理呢?

確實沒辦法，因為沒法區分方法是同步還是異步，而且這兩種方法的調用方式也不同，但我們可以單獨提供一個 runner 方法來運行這些異步邏輯：

class ExceptionsZone { static exceptionHandler = new ExceptionHandler(); static async asyncRun(callback) { try { await callback(); } catch (e) { this.exceptionHandler.handle(e); } } }

然后這樣運行：

(async function() { await ExceptionsZone.asyncRun(proxy.coding2); })();

這樣就能處理異步邏輯中的異常了：

我們通過代理的方式給對象的所有同步方法添加了異常處理，然后又提供了運行異步方法的 runner 函數，對運行時的異常做了處理，結合這兩種方式，優雅地給目標對象的所有方法加上了異常處理。

可能你會說，代理就代理，你定義這么多 class 干啥?

因為這段邏輯是我從 Nest.js 源碼里摘出來的，它源碼里就是這樣來給對象添加異常處理的：

異步邏輯也是單獨提供了個方法來運行：

我覺得這個透明給對象添加異常處理的方式很優雅，就把它從 Nest.js 源碼里抽了出來。

總結

為了保證健壯性，我們要對所有可能報錯的代碼添加異常處理，但是每個方法都添加 try catch 又太麻煩，所以我們利用 Proxy 實現了代理，透明的給對象的所有方法都添加上了異常處理。

但是，代理添加的只是同步的異常處理，并沒有捕獲異步邏輯的異常，我們可以單獨一個一個函數來運行異步方法。

結合代理 + 提供運行異步方法的 runner 這兩種方式，就能給一個沒有做任何異常處理的對象加上異常處理。是不是很優雅？

原文地址:https://mp.weixin.qq.com/s/hehUH9HL6unaLWq3LzQxNg