这是.indexOf的正确实现吗？ Javascript

Question

我测试了我的.indexOf的实现，它似乎可以在我的测试用例上工作，但我已经看到了其他解决方案，它们在if条件array[i] === elem && notFound === -1中添加了它们。第二种情况的目的是什么？这是我的版本：

var indexOf = function (array, elem) { 
    var notFound = -1; 
    for (var i = 0; i < array.length; i++) { 
    if (array[i] === elem) {return i;} 
    } 
    return notFound; 
} 

Answer 1

你的实现似乎没什么问题。

我怀疑额外的检查是在函数的一个版本中，当它找到一个匹配时不会跳出循环。当它发现匹配时，它会设置notFound = i;，并保持循环（不必要）;当循环完成时，它返回notFound。测试notFound === -1是否阻止它在发现第二个匹配时更新变量。

如果不是这样，那么如果您实际上发布了一个使用您显示的检查的实现示例，将会有所帮助。这可能只是一个错误 - 仅仅因为你在互联网上发现了代码，并不意味着它是正确的。

Answer 2

采取看看下面的填充工具（from mdn）：

// Production steps of ECMA-262, Edition 5, 15.4.4.14 
// Reference: http://es5.github.io/#x15.4.4.14 
if (!Array.prototype.indexOf) { 
    Array.prototype.indexOf = function(searchElement, fromIndex) { 

    var k; 

    // 1. Let o be the result of calling ToObject passing 
    // the this value as the argument. 
    if (this == null) { 
     throw new TypeError('"this" is null or not defined'); 
    } 

    var o = Object(this); 

    // 2. Let lenValue be the result of calling the Get 
    // internal method of o with the argument "length". 
    // 3. Let len be ToUint32(lenValue). 
    var len = o.length >>> 0; 

    // 4. If len is 0, return -1. 
    if (len === 0) { 
     return -1; 
    } 

    // 5. If argument fromIndex was passed let n be 
    // ToInteger(fromIndex); else let n be 0. 
    var n = +fromIndex || 0; 

    if (Math.abs(n) === Infinity) { 
     n = 0; 
    } 

    // 6. If n >= len, return -1. 
    if (n >= len) { 
     return -1; 
    } 

    // 7. If n >= 0, then Let k be n. 
    // 8. Else, n<0, Let k be len - abs(n). 
    // If k is less than 0, then let k be 0. 
    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0); 

    // 9. Repeat, while k < len 
    while (k < len) { 
     // a. Let Pk be ToString(k). 
     // This is implicit for LHS operands of the in operator 
     // b. Let kPresent be the result of calling the 
     // HasProperty internal method of o with argument Pk. 
     // This step can be combined with c 
     // c. If kPresent is true, then 
     // i. Let elementK be the result of calling the Get 
     //  internal method of o with the argument ToString(k). 
     // ii. Let same be the result of applying the 
     //  Strict Equality Comparison Algorithm to 
     //  searchElement and elementK. 
     // iii. If same is true, return k. 
     if (k in o && o[k] === searchElement) { 
     return k; 
     } 
     k++; 
    } 
    return -1; 
    }; 
}