Question

行。所以到现在为止，我已经“离开了”使用这样的东西：

function foo(arg) {
    // Default values:
    var opt = { a: 1, b: 2, c: 3 }, 
        key;
    for (key in opt)
        if (opt.hasOwnProperty(key) && arg.hasOwnProperty(key))
           opt[key] = arg[key];
}

现在，我越来越倾向于使用hasOwnProperty，因为它可能已被某些自定义属性覆盖。

如果我们要使用 keys() ， forEach() 等，那么正确处理上述事情的方法是什么？像这样的东西？

function bar(arg) {
    // Default values:
    var opt = { a: 1, b: 2, c: 3 }, 
        keys = Object.keys(arg);
    Object.keys(opt).forEach(function(key) {
        if (keys.indexOf(key) !== -1)
            opt[key] = arg[key];
    });
}

Answer 1

如果您关注hasOwnProperty被覆盖，那么您可以这样做：

Object.prototype.hasOwnProperty.call(arg, key)

所以你的原始代码可能是：

function foo(arg) {
    var opt = { a: 1, b: 2, c: 3 },
        check = Object.prototype.hasOwnProperty,
        key;
    for (key in opt) {
        if (check.call(opt, key) && check.call(arg, key)) {
            opt[key] = arg[key];
        }
    }
    return opt;
}

Answer 2

您的原始代码没有任何问题 - 除了{和}令人震惊的缺乏！ ; - ）

如果您因某种原因需要使用Object.keys和forEach，则无需获取arg的密钥，只需opt。这将相当于您的第一个代码块，使用Object.keys和forEach。

function bar(arg) {
    // Default values:
    var opt = { a: 1, b: 2, c: 3 };
    Object.keys(opt).forEach(function(key) {
        if (arg.hasOwnProperty(key))
            opt[key] = arg[key];
    });
}

但同样，没有理由改变它，你的原始代码很好。

现在，我越来越多地使用hasOwnProperty，因为它可能已被某些自定义属性覆盖。

如果某人覆盖hasOwnProperty，那么理论上他们就有充分理由这样做。除了在某些特殊情况下，我不担心。但如果你想避免这种担忧，你可以这样做：

var hop = Object.prototype.hasOwnProperty;
function foo(arg) {
    // Default values:
    var opt = { a: 1, b: 2, c: 3 }, 
        key;
    for (key in opt)
        if (hop.call(opt, key) && hop.call(arg, key))
           opt[key] = arg[key];
}

然后你唯一担心的是有人取代Object.prototype.hasOwnProperty;如果他们这样做，并且他们的替换不能正常工作，你的循环可能是他们最不关心的问题。

适当的对象属性循环

2 个答案: