在仅供内部使用的代码中进行额外的检查是一个好习惯吗？

Question

是否有必要检查代码中的所有参数和其他条件，如果我知道，我永远不会传递错误的参数，它应该可以正常工作（假设我已经在该代码之外进行了一些检查）。

示例：

此代码：

/**
 * Applies function to all elements of array in specified
 * context.
 * If array is empty, returns null.
 */
MyNameSpace.foreach = function(arr, callback, context) {
   if (!(arr instanceof Array)) {
       throw new Error('first argument is not an array');
   }
   if (typeof callback !== 'function') {
       throw new Error('callback is not a function');
   }
   if (typeof arr.length === 'undefined') {
      throw new Error('Length undefined');
   }

   var con = typeof context === 'object' ? context : window;

   var i = arr.length;
   if ( i <= 0 ) {
       return null;
   }

   for ( j = 0; j < i; j++ ) {
        callback.call(con, j, arr[j]);
   }
}

可以是：

MyNameSpace.foreach = function(arr, callback, context) {
   var con = typeof context === 'object' ? context : window;

   var i = arr.length;
   if ( i <= 0 ) {
       return null;
   }

   for ( j = 0; j < i; j++ ) {
        callback.call(con, j, arr[j]);
   }
}

Answer 1

这绝对是一个很好的做法。它可以提高应用程序的稳定性并帮助调试。缺点是它会使代码变得混乱（使其难以阅读），并且会影响性​​能（尽管对于大多数 JavaScript 应用程序来说，性能并不重要）。

你必须针对每种情况采取看法。这实际上取决于（1）参数不正确的可能性有多大以及（2）如果参数不正确将会造成多大的损害。

Answer 2

虽然如果在生产中保持启用它可能会稍微减慢执行速度，但您可以在生产中或调试期间使用类型检查库：

function TypeEnforce (func, ctx, config) {
    if (!(this instanceof TypeEnforce)) {
        return new TypeEnforce(func, ctx);
    }
    if (typeof func === 'string' && ctx) {
        this.funcString = func;
        func = ctx[func];
    }
    this.ctx = ctx;
    this.autoset = config && config.autoset;
    this.oldFunc = func;
}
TypeEnforce.prototype.argTypes = function (args) {
    var that = this;
    this.reqArgTypesFunc = function () {
        for (var i=0, argl = args.length; i < argl; i++) {
            if (
                (args[i] === 'Array' && Object.prototype.toString.call(arguments[i]) !== '[object Array]') ||
                (args[i] !== 'Array' && typeof arguments[i] !== args[i])
            ) {
                throw 'Argument ' + i + ' [' + arguments[i] + '] should be of type ' + args[i];
            }
        }
        that.oldFunc.apply(that.ctx, arguments);
    };
    if (this.autoset) {
        this.ctx[this.funcString] = this.reqArgTypesFunc;
    }
    return this;
};
TypeEnforce.prototype.props = function (props) {
    var that = this;
    this.reqPropsFunc = function () { 
        for (var p in props) {
            if (typeof arguments[p][props[p]] === 'undefined') {
                throw 'The property "' + props[p] + '" of argument no. ' + p + 
                        ' [' + arguments[p] + '] should not be undefined';
            }
        }
        var method = that.reqArgTypesFunc || that.oldFunc;
        method.apply(that.ctx, arguments);
    };
    if (this.autoset) {
        this.ctx[this.funcString] = this.reqPropsFunc;
    }
    return this;
};
TypeEnforce.prototype.get = function (props) {
    return this.reqPropsFunc || this.reqArgTypesFunc || this.oldFunc;
};

...在您的情况下，您可以按如下方式使用：

if (!MyNameSpace) {
    var MyNameSpace = {};
}
MyNameSpace.foreach = function(arr, callback, context) {
   var con = typeof context === 'object' ? context : window;

   var i = arr.length;
   if ( i <= 0 ) {
       return null;
   }

   for ( j = 0; j < i; j++ ) {
        callback.call(con, j, arr[j]);
   }
};

TypeEnforce('foreach', MyNameSpace, {autoset:true}).
    argTypes(['Array', 'function']).
    props({0:'length'});

MyNameSpace.foreach(['a', 'b'], function (k, v) {
    alert(k+':'+v);
});

通过这种方法，您可以分离出丑陋的类型检查代码，如果您只在测试期间需要它，甚至可以禁用它。您可以进一步添加用于参数或属性值检查的方法。

Answer 3

软件中测试输入和输出的一般原则是：“输入灵活，输出严格”。您应该始终对您的输入进行额外的检查，以便您的代码在您的方法得到不期望的结果时不会中断。

Answer 4

这绝对是一个很好的做法，因为任何使用您的类或函数的代码都可能在不知不觉中向您传递值，这可能会导致您的代码崩溃。
例如：一位程序员曾经不小心向我的代码发送了一个 NULL 指针，该代码必须对指针指向的对象进行深层复制。
但由于我在复制构造函数的初始化列表中克隆指向的实例，所以没有人能弄清楚程序崩溃的原因。

程序员说我应该检查 NULL 指针，但最终我们决定在他这边保留检查，因为我们需要保持通过初始化列表进行复制的效率，这样更快。

因此，您可以根据以下情况决定是否进行支票：
1. 使用复制构造函数初始化列表的效率。
2. 您对函数/类的输入参数和限制的记录情况如何。
3. 您的代码是否会因恶意输入而崩溃/产生安全问题
4. 您的软件需要什么样的异常处理。