探讨一个问题，try catch影响多少效率

Question

如题，在执行大规模程序的时候会拖慢几个百分点，自己试了一下貌似并不大
希望能分析的透彻点

Answer 1

var now=new Date().getTime()
for(var i=0;i<10000;++i){
    try{
      [1,2,3,4].concat([5,6,7,8])
}catch(err){}
}
console.log(new Date().getTime()-now)有时候加了try{}catch(err){} 比没加还更快了

Answer 2

前端不用太考虑效率问题,复杂的计算请不要放在前端进行,就我现在接触到的,写网站时都不会考虑js代码的执行效率,更没人会去想一个try catch的对效率的影响,你想太多了

Answer 3

try catch只在特殊情况下做兼容调试用。又不是随便用担心什么效率？
就如担心感冒药什么副作用做什么？只有感冒时你才吃一点而已，也是不得已。

Answer 4

可以控件的，尽量控制一下。比如 if ( obj!=undefined && obj !=null ) { ... }一些实在不可控制的代码， 就不用这么麻烦了， 还是老老实实 try catch吧。这个原则， 适用于所有的语言。你的想法， 还是尽量不要 try catch 对吧？打个比方，一个很简单的取用户信息的方法：
public User GetUserById(string uid)
即使你的语句写的再好， 也会有一些意想不到的错误的。比如：
DB服务器突然断开了连接；
你在开发环境有某个字段，但生产环境发布时忘记加上这个字段了；
……但是，从另外一个角度来讲， 上面的这些错误是极少发生的， 所以根本不需要这么在意这些小概率事件——如果你刻意在代码中把这些意外因素考虑进来， 一是正常情况时代码的执行效率反而下降（如上面，你得判断连接是否存在，DB中是否存在User表，User表是否存在你要取的所有字段……绝对让你头大）。二是意外情况你根本想不完，绝对会有你意料之外的情况出现，但出现的机会很少，根本都不会影响软件的正常使用效率。所以总可能发生一些意外情况的地方， 直接 try catch 就好。

Answer 5

我现在写的东西有些需要非常考虑效率，稍不留意能把ie卡死，怎么办，纯js功能的页面

Answer 6

我想做一个事件处理的程序架构，给某个事件添加多个处理之后，前面的报错但不能影响后面的执行，貌似只能try一下

Answer 7

非自己代码直接控制的调用 并且没有错误机制会抛出异常的 不希望代码因为异常脱离自己控制的 应该用try/catch
你说的事件处理要加

Answer 8

你不用Ext4不就没事了，用Ext3 写web应用程序，ie下根本没有卡死的现象，而且就功能来说，ext3也已经足够；还有什么纯js界面，那不是卡死的理由，你写那点js比起ext本身来说微不足道

Answer 9

所有地方我都是尽量原生代码的，纯粹是dom操作太多，运算量也很大，ie那破引擎跟不上

Answer 10

其实卡死和你的代码行数没什么关系，就是一些ext4组件，有卡死可能，比如tree组件，节点太多ie就会报脚本慢，我以前用ext3写的，每个页面都加一个自己写的组件库，2700多行，加一些常用函数，再加上页面本身的js代码，部分页面也有4000多行js代码吧，没有出现过卡死现象。
还有既然使用了组件库，纯面向对象的方式生成界面，那就尽量用组件提供的方法，不要去获取dom来操作，不然你用组件做什么？你自己的方法还未必有组件内部使用的效率高呢（组件内部代码是最注重效率的，组件库更是各个组件一层层继承，扩展，代码的使用效率远远高于你自己写的，你不适用组件提供的方法，代表你必须自己写更多代码去实现功能，而且组件自身的代码你又不可能不加载，你还觉得效率更高？）
如果你觉得是因为代码太多造成了页面缓慢，不常用的js代码可以动态加载，用完就移除，但我认为完全不是这个原因

Answer 11

支持wzs_xyz说的。
extjs并不是版本越高越快，虽然extjs4.0+使用了MVC模式，但是从推出以来最争议的就是速度奇慢，IE6绝对惨不忍睹。
try catch可以使用，但是不能滥用，只有在能预见到可能出错的地方才使用，满版代码都有try catch就说明你的代码质量不高。

Answer 12

使用不当对性能是有影响。
当try块发生错误时，程序流程自动转入catch块，并将异常对象推入作用域前端的一个可变对象中。在catch块中，函数的所有局部就是被放在第二个作用链对象中。如try {
methodThatMightCauseAnError();
} catch (ex){
alert(ex.message); //scope chain is augmented here
}如果作用得当，try-catch表达式是非常有用的语句，所以不完全避免。
如果你计划使用一个try-catch语句，请确保你了解可能发生的错误。
一个try-catch语句不应该作为javascript错误的解决方法。如果你知道一个错误经常发生，那说明应当修正代码本身的问题。
你可以通过精缩代码的办法最小化catch子句对性能的影响。一个很好的模式是将错误交给一个专用函数处理。如：try {
methodThatMightCauseAnError();
} catch (ex){
handleError(ex); //delegate to handler method
}
handError函数是catch子句中进行的唯一代码。此函数以适应方法自由地处理错误，并接收错误产生的异常对象。由于只有一条语句，没局部变量访问，作用域临时改变不会影响代码的性能。

Answer 13

我可没说过卡是因为代码多引起的……
也没说过我用了ext，我用的是原生代码，没道理原生的比组件还慢，至少从innerHTML和appendChild上没道理
大量的循环和dom操作无法避免，大量浮点运算无法避免，这些都不是组件能解决的我只想知道try语句降低性能的详细指标
还有，js代码加载过之后移除没用，它不是css

Answer 14

到目前为止，我的代码里几乎没有try语句，确实用不着不过一旦做成底层框架的话，添加进来的监听函数根本无法保证全都正常执行，但某个函数执行失败引发后续全部崩溃是我想避免的事情，就好像浏览器的事件处理，第一个处理函数报错了但它不影响后面的程序
你分析的是catch语句里额外操作降低性能，这个会有一部分。但我猜try既然有这么牛B的特效那它应该有很独特的执行环境才对，这个执行环境的性能如何我想知道

Answer 15

我扒了一段新浪微博的事件代码，大家分析一下
STK.register("core.evt.custEvent",function (a)
{
    var b = "__custEventKey__",
        c = 1,
        d = {},e = function (a,c)
        {
            var e = typeof a == "number" ? a : a[b];
            return e && d[e] && {
                obj: typeof c == "string" ? d[e][c] : d[e],
                key: e
            }
        },f = {},g = function (a,b,c,d,f)
        {
            if(a && typeof b == "string" && c)
            {
                var g = e(a,b);
                if(!g || !g.obj) throw "custEvent (" + b + ") is undefined !";
                g.obj.push({
                    fn: c,
                    data: d,
                    once: f
                });
                return g.key
            }
        },h = function (b,c,d,f)
        {
            var g = !0,
                h = function ()
                {
                    g = !1
                };
            if(b && typeof c == "string")
            {
                var i = e(b,c),
                    j;
                if(i && (j = i.obj))
                {
                    d = typeof d != "undefined" && [].concat(d) || [];
                    for(var k = j.length - 1;k > -1 && j[k];k--)
                    {
                        var l = j[k].fn,
                            m = j[k].once;
                        if(l && l.apply) try
                        {
                            l.apply(b,[{
                                obj: b,
                                type: c,
                                data: j[k].data,
                                preventDefault: h
                            }].concat(d));
                            m && j.splice(k,1)
                        } catch(n)
                        {
                            a.log("[error][custEvent]" + n.message,n,n.stack)
                        }
                    }
                    g && a.core.func.getType(f) === "function" && f();
                    return i.key
                }
            }
        },i = {
            define: function (a,e)
            {
                if(a && e)
                {
                    var f = typeof a == "number" ? a : a[b] || (a[b] = c++),
                        g = d[f] || (d[f] = {});
                    e = [].concat(e);
                    for(var h = 0;h < e.length;h++) g[e[h]] || (g[e[h]] = []);
                    return f
                }
            },
            undefine: function (a,c)
            {
                if(a)
                {
                    var e = typeof a == "number" ? a : a[b];
                    if(e && d[e]) if(c)
                    {
                        c = [].concat(c);
                        for(var f = 0;f < c.length;f++) c[f] in d[e] && delete d[e][c[f]]
                    } else delete d[e]
                }
            },
            add: function (a,b,c,d)
            {
                return g(a,b,c,d,!1)
            },
            once: function (a,b,c,d)
            {
                return g(a,b,c,d,!0)
            },
            remove: function (b,c,d)
            {
                if(b)
                {
                    var f = e(b,c),
                        g,h;
                    if(f && (g = f.obj))
                    {
                        if(a.core.arr.isArray(g)) if(d)
                        {
                            var i = 0;
                            while(g[i])
                            {
                                if(g[i].fn === d) break;
                                i++
                            }
                            g.splice(i,1)
                        } else g.splice(0,g.length);
                        else for(var i in g) g[i] = [];
                        return f.key
                    }
                }
            },
            fire: function (a,b,c,d)
            {
                return h(a,b,c,d)
            },
            hook: function (a,e,g)
            {
                if(!(!a || !e || !g))
                {
                    var j = [],
                        k = a[b],
                        l = k && d[k],
                        m,n = e[b] || (e[b] = c++),
                        o;
                    if(l)
                    {
                        o = f[k + "_" + n] || (f[k + "_" + n] = {});
                        var p = function (a)
                        {
                            var b = !0;
                            h(e,o[a.type].type,Array.prototype.slice.apply(arguments,[1,arguments.length]),function ()
                            {
                                b = !1
                            });
                            b && a.preventDefault()
                        };
                        for(var q in g)
                        {
                            var r = g[q];
                            if(!o[q]) if(m = l[q])
                            {
                                m.push({
                                    fn: p,
                                    data: undefined
                                });
                                o[q] = {
                                    fn: p,
                                    type: r
                                };
                                j.push(r)
                            }
                        }
                        i.define(e,j)
                    }
                }
            },
            unhook: function (a,c,d)
            {
                if(!(!a || !c || !d))
                {
                    var e = a[b],
                        g = c[b],
                        h = f[e + "_" + g];
                    if(h) for(var j in d)
                    {
                        var k = d[j];
                        h[j] && i.remove(a,j,h[j].fn)
                    }
                }
            },
            destroy: function ()
            {
                d = {};
                c = 1;
                f = {}
            }
        };
    return i
});

Answer 16

没用ext，那你就只能从自己的算法上找原因了
自己好好调试分析自己写的函数的效率问题吧
try catch语句js中本就很少用，你觉得影响效率完全可以不用，没把握的dom选择，if判断一下就行了
不用Ext，面向对象的js库感觉也就ext最好啊，doju看了看api，似乎也还比较全面，其他就不知道了，你用的是什么？如果没有一个面向对象的组件库，写纯js界面，真的很难想象代码数量和质量，反正感觉那样的话5700行代码页未必就能有多大作为（大量的代码要用来增加class，属性，style什么的），反而增加出问题的可能

Answer 17

要是chrome都卡的话我就不说啥了，真为ie6着急啊
作为嘛，你来看吧http://i.finance.sina.com.cn/zixuan

Answer 18

才几千行不会卡吧 现在做的ipad项目，二万多行都还顺畅运行。512内存啊

Answer 19

try...catch 只要不滥用，对效率影响不大。

Answer 20

该用的地方必须用，try的存在我想与效率无关吧。

Answer 21

突然想起之前做的一个ajax实时聊天室之类的...
一开始那个判断是否断开了服务器的判断我还是用ty catch做的...
后来发现根本没有catch...断开了服务器只不过是那个xmlhttprequest的state改变而已...
想想自己还为此蛋疼了一天...

Answer 22

为什么要throw an error and try catch？？
如果是涉及网络请求、操作内存之外的数据，那么可以。如果仅仅是利用这个机制完成你的业务逻辑，可以用返回值或其他方式代替。