Javascript 什么'；这个indexOf实现有什么问题吗？

我知道当找不到值时，我会忽略-1选项，但为什么当值在数组中时它不起作用呢？它应该返回1，但返回未定义

function each(collection, callback) {
  if (Array.isArray(collection)) {
    for (var i = 0; i < collection.length; i++) {
      callback(collection[i], i, collection);
    }
  }
  else {
    for (var prop in collection) {
      callback(collection[prop], prop, collection);
    }
  }
}

function indexOf(array, value) {
  each(array, function(e, index) {
    if (e === value) {
      return index; 
    }
  })
}


console.log(indexOf([1, 2, 3, 4, 5], 2)); ---->>> undefined;

每个函数（集合、回调）{
if（数组.isArray（集合））{
对于（变量i=0；i>未定义；

您在回调中返回index的值，而不是在

indexOf（）函数本身中

尝试以下实现：

function indexOf(array, value) {
   var returnVal = -1;
   each(array, function(e, index) {
        if (e === value) {
            returnVal = index; 
            return false;
        }
    });
    return returnVal;
}

编辑：正如Barmar指出的，这将返回元素最后一次出现的索引，要返回第一次出现的索引，您还必须更新
each（）
，以便：

function each(collection, callback) {
    if (Array.isArray(collection)) {
        for (var i = 0; i < collection.length; i++) {
            if (callback(collection[i], i, collection) === false) break;
        }
    }
    else {
        for (var prop in collection) {
            if (callback(collection[prop], prop, collection) === false) break;
        }
    }
}

每个函数（集合、回调）{
if（数组.isArray（集合））{
对于（变量i=0；i
您在回调中返回index的值，而不是在
indexOf（）函数本身中

尝试以下实现：

function indexOf(array, value) {
   var returnVal = -1;
   each(array, function(e, index) {
        if (e === value) {
            returnVal = index; 
            return false;
        }
    });
    return returnVal;
}

编辑：正如Barmar指出的，这将返回元素最后一次出现的索引，要返回第一次出现的索引，您还必须更新
each（）
，以便：

function each(collection, callback) {
    if (Array.isArray(collection)) {
        for (var i = 0; i < collection.length; i++) {
            if (callback(collection[i], i, collection) === false) break;
        }
    }
    else {
        for (var prop in collection) {
            if (callback(collection[prop], prop, collection) === false) break;
        }
    }
}

每个函数（集合、回调）{
if（数组.isArray（集合））{
对于（变量i=0；i

这里的返回是从传递给
每个
的函数返回，而不是从
indexOf
函数返回。您需要以某种方式使该值超出该函数范围才能返回。使用当前的每个实现，您将无法打破循环，因此必须执行以下操作：

function indexOf(array, value) {
  var result = -1;

  each(array, function(e, index) {
    if (e === value) {
      result = index; 
    }
  })

  return result;
}


这里的返回是从传递给
每个
的函数返回，而不是从
indexOf
函数返回。您需要以某种方式使该值超出该函数范围才能返回。使用当前的每个实现，您将无法打破循环，因此必须执行以下操作：

function indexOf(array, value) {
  var result = -1;

  each(array, function(e, index) {
    if (e === value) {
      result = index; 
    }
  })

  return result;
}

您的
indexOf（）
函数没有返回任何内容。如果找到索引，回调将返回该索引，但您没有使用该值执行任何操作。您可以这样做：

for (var i = 0; i < collection.length; i++) {
  var result= callback(collection[i], i, collection);
  if (result) return result;
}

for（var i=0；i
您的
indexOf（）
函数没有返回任何内容。如果找到索引，回调将返回该索引，但您没有使用该值执行任何操作。您可以这样做：

for (var i = 0; i < collection.length; i++) {
  var result= callback(collection[i], i, collection);
  if (result) return result;
}

for（var i=0；i
如果找到索引，您需要返回索引。此外，一旦找到值，您需要退出循环，否则您将执行
lastIndexOf
，而不是
indexOf

function each(collection, callback) {
    if (Array.isArray(collection)) {
        for (var i = 0; i < collection.length; i++) {
            if (callback(collection[i], i, collection) === true) {
                return;
            }
        }
    }
    else {
        for (var prop in collection) {
            if (callback(collection[prop], prop, collection) === true) {
                return;
            }
        }
    }
}

function indexOf(array, value) {
    var foundIndex = -1;

    each(array, function(e, index) {
        if (e === value) {
            foundIndex = index;
            return true;
        }
    });

    return foundIndex;
}

每个函数（集合、回调）{
if（数组.isArray（集合））{
对于（变量i=0；i
如果找到索引，您需要返回索引。此外，一旦找到值，您需要退出循环，否则您将执行
lastIndexOf
，而不是
indexOf

function each(collection, callback) {
    if (Array.isArray(collection)) {
        for (var i = 0; i < collection.length; i++) {
            if (callback(collection[i], i, collection) === true) {
                return;
            }
        }
    }
    else {
        for (var prop in collection) {
            if (callback(collection[prop], prop, collection) === true) {
                return;
            }
        }
    }
}

function indexOf(array, value) {
    var foundIndex = -1;

    each(array, function(e, index) {
        if (e === value) {
            foundIndex = index;
            return true;
        }
    });

    return foundIndex;
}

每个函数（集合、回调）{
if（数组.isArray（集合））{
对于（变量i=0；i
indexOf函数总是返回未定义的，因为您只返回回调函数的值，而不是indexOf函数

试试这个：

function indexOf(array, value) {
    var i;

    each(array, function(e, index) {
        if (e === value) {
            i = index; 
        }
    })

   return i;
}

indexOf函数总是返回undefined，因为您只从回调函数返回值，而不是indexOf函数

试试这个：

function indexOf(array, value) {
    var i;

    each(array, function(e, index) {
        if (e === value) {
            i = index; 
        }
    })

   return i;
}

你为什么要重新发明轮子？由最新的BrowsersRactice with javascript Fundamentals支持。为了公平起见，如果修复了，这将不会与本机indexOf做相同的事情：此版本还允许您发现对象上具有指定值的第一个属性（“索引”）。当然，您可能会遇到非保证属性迭代顺序的问题。为什么要重新投资