用try/catch javascript包装所有类？

如何用如下方法实现一个类

class ExistingClass {
     function func1() {} // might throw error
     function func2() {} // might throw error
     get try() {
        // Some magic here
        return this; // we need to return this to chain the calls, right? 
     }
}

可以称之为

obj.func1() //might throw an error
obj.try.func1() // execute func1 in a try/catch

基本上，我想要mochajs所拥有的东西：

expect（..）.to.not.equal（）

更新： 接受的答案应该有效，以下是它的更新版本，支持

async

功能

get try() {
    return new Proxy(this, {

        // Intercept method getter
        get: function(target, name) {
            if (typeof target[name] === 'function') {
                if (target[name][Symbol.toStringTag] === 'AsyncFunction') {
                    return async function() {
                        try {
                           await target[name].apply(target, arguments);
                        }
                        catch (e) {}
                    }
                } else {
                    return function() {
                        try {
                            return target[name].apply(target, arguments)
                        }
                        catch (e) {}
                    }
                }
            }
            return target[name];
        }
    });
}

---

您可以使用最新浏览器中的代理执行此操作：

class A {
  method() {
    throw 'Error';
  }

  get try() {
    return new Proxy(this, {
      // Intercept method getter
      get(target, name) {
        if (typeof target[name] === 'function') {
          return new Proxy(target[name], {
            // Intercept method call
            apply(target, self, args) {
              try {
                return target.apply(self, args);
              } catch(e) {
                // swallow error
              }
            }
          })
        }
        return target[name];
      }
    });
  }
}

const a = new A;

a.try.method(); // no error

a.method(); // throws error

---

您可以使用最新浏览器中的代理执行此操作：

class A {
  method() {
    throw 'Error';
  }

  get try() {
    return new Proxy(this, {
      // Intercept method getter
      get(target, name) {
        if (typeof target[name] === 'function') {
          return new Proxy(target[name], {
            // Intercept method call
            apply(target, self, args) {
              try {
                return target.apply(self, args);
              } catch(e) {
                // swallow error
              }
            }
          })
        }
        return target[name];
      }
    });
  }
}

const a = new A;

a.try.method(); // no error

a.method(); // throws error

简化版

简化版

---

对于不支持代理的

ES6之前的
浏览器
，如果我需要这样的功能，我会这样做：


/*一个构造函数以老式的方式创建*/
函数ExistingClass（）{
/*将分配给此的对象。请重试*/
var shadowObj={}；
/*抛出错误（调用非法构造函数）的函数*/
this.func1=函数（）{
返回新元素（）；
};
/*迭代上下文的每个属性*/
for（本文件中的var func）{
/*检查属性是否为函数*/
if（this[func]&&this[func].constructor==函数）{
/*创建上下文方法的阴影函数*/
shadowObj[func]=函数（）{
尝试{返回此[func]（）}
捕获（e）{console.log（“捕获错误：+e.message）}
}.约束（本）；
}
}
/*将阴影对象指定给此对象。请重试*/
this.try=shadowObj；
}
/*例如*/
var cls=新的现有类别；
cls.try.func1（）；
cls.func1（）对于不支持代理的
ES6之前的
浏览器，如果我需要这样的功能，我会这样做：


/*一个构造函数以老式的方式创建*/
函数ExistingClass（）{
/*将分配给此的对象。请重试*/
var shadowObj={}；
/*抛出错误（调用非法构造函数）的函数*/
this.func1=函数（）{
返回新元素（）；
};
/*迭代上下文的每个属性*/
for（本文件中的var func）{
/*检查属性是否为函数*/
if（this[func]&&this[func].constructor==函数）{
/*创建上下文方法的阴影函数*/
shadowObj[func]=函数（）{
尝试{返回此[func]（）}
捕获（e）{console.log（“捕获错误：+e.message）}
}.约束（本）；
}
}
/*将阴影对象指定给此对象。请重试*/
this.try=shadowObj；
}
/*例如*/
var cls=新的现有类别；
cls.try.func1（）；
cls.func1（）
是否需要能够调用类似这样的函数
obj.try.func1（）
？你能用这样的东西吗：
obj.try（“func1”）
？
get try{
…真的吗？这样行吗？我的两分钱：如果我看到代码或注释是“吞咽错误”，我会用另一种方式运行。只要说。你应该纠正错误，而不是吞咽错误。我看到mochajs有类似的东西。
expect（val）。not.equal（）
。我会这样做。这会让代码更易于阅读。当然，我们不应该接受错误，我们只是想“尝试”而
错误
也没什么大不了的。不管怎样，我只是想知道是否有可能做这样的事情。不过我从来没有说这是一个好代码。你需要能够调用像这样的函数吗
obj.try.func1（）
？你能用这样的东西吗：
obj.try（“func1”）
？
get try{
…真的吗？这很有效吗？我的两分钱：如果我看到代码或注释都是“吞咽错误”，我会用另一种方式运行。只要说“in”。你应该纠正错误，而不是吞咽错误。我看到mochajs有类似的东西。
expect（val）。not.equal（）
。我会这样做。这会让代码更易于阅读。当然，我们不应该接受错误，我们只是想“尝试”而
错误
也没什么大不了的。不管怎样，我只是想知道是否有可能这样做。不过我从来没有说过这是一个好代码。不需要双重代理。代理的getter可以返回一个函数，在try catch中调用原始函数。@BryanChen我真的想看看你的解决方案吗？@BryanChen，当然，这也是一个可能的解决方案，而且代理可能对性能更差。@Skinnypote提供的解决方案中有一个问题是，如果我们在方法中引用
这个
，那么
尝试后它将是
未定义的
。@elclanrs的答案实际上保留了
这个
引用intact@jAc科德：啊，是的，我不应该使用
apply（）
int首先。不需要双重代理。代理的getter可以返回一个调用try catch中原始函数的函数。@BryanChen我真的想看看你的解决方案吗？@BryanChen，当然，这也是一个可能的解决方案，而且代理可能对性能更差。提供的解决方案中有一个catch通过@SkinnyPete，如果我们在方法中引用
此
，则在
尝试
后，它将是
未定义的
。@elclanrs的答案实际上保留了
此
引用intact@jAckOdE：啊，是的，我不应该使用
apply（）
int首先。这里有兴趣看到另一种方法。这里有兴趣看到另一种方法。这是目前为止最好的解决方案。谢谢。这是目前为止最好的解决方案。谢谢。