_.indexOf(array, value, [fromIndex=0])

19

_.indexOf(array, value, [fromIndex=0])

_.indexOf方法返回在数组中可以找到一个给定元素的第一个索引，使用SameValueZero来比较两个值是否相等

参数

array (Array): 需要查找的数组
value (*): 查找的元素
[fromIndex=0] (number): 查找的起始位置

返回值

(number):返回找到的第一个元素的索引，否则返回-1

例子

_.indexOf([1, 2, 1, 2], 2);
// => 1
 
// Search from the `fromIndex`.
_.indexOf([1, 2, 1, 2], 2, 2);
// => 3

源代码：

import baseIndexOf from './.internal/baseIndexOf.js'

/**
 * Gets the index at which the first occurrence of `value` is found in `array`
 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * for equality comparisons. If `fromIndex` is negative, it's used as the
 * offset from the end of `array`.
 *
 * @since 0.1.0
 * @category Array
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} [fromIndex=0] The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 * @example
 *
 * indexOf([1, 2, 1, 2], 2)
 * // => 1
 *
 * // Search from the `fromIndex`.
 * indexOf([1, 2, 1, 2], 2, 2)
 * // => 3
 */
//indexOf方法返回在数组中可以找到一个给定元素的第一个索引，使用SameValueZero来比较两个值是否相等
function indexOf(array, value, fromIndex) {
  const length = array == null ? 0 : array.length//数组长度
  if (!length) {//数组长度为0，返回-1
    return -1
  }
  let index = fromIndex == null ? 0 : +fromIndex//查找的起始位置，如果没有fromIndex，就从0开始，如果有，就转成number类型
  if (index < 0) {//处理起始位置是负数情况
    index = Math.max(length + index, 0)
  }
  return baseIndexOf(array, value, index)//调用baseIndexOf
}

export default indexOf

下面是baseIndexOf：

import baseFindIndex from './baseFindIndex.js'
import baseIsNaN from './baseIsNaN.js'//判断一个值是不是NaN
import strictIndexOf from './strictIndexOf.js'

/**
 * The base implementation of `indexOf` without `fromIndex` bounds checks.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
//寻找数组中指定值的位置，找不到返回-1，fromIndex是查找起始位置
function baseIndexOf(array, value, fromIndex) {
  return value === value
    ? strictIndexOf(array, value, fromIndex)
    : baseFindIndex(array, baseIsNaN, fromIndex)
    //如果value是NaN就调用baseFindIndex查找，传入的回调函数是自己实现的isNaN
    //如果value不是NaN就调用strictIndexOf查找
}

export default baseIndexOf

下面是baseFindIndex：

/**
 * The base implementation of `findIndex` and `findLastIndex`.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {Function} predicate The function invoked per iteration.
 * @param {number} fromIndex The index to search from.
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
//_.findIndex和_.findLastIndex的基础实现
//array查找的数组，predicate每次循环调用的函数，fromIndex遍历的起始位置，fromRight是否反向查找
function baseFindIndex(array, predicate, fromIndex, fromRight) {
  const { length } = array//数组长度
  let index = fromIndex + (fromRight ? 1 : -1)//循环索引，如果反向循环就加1，如果正向就减1

  while ((fromRight ? index-- : ++index < length)) {//正向就++，反向--
    if (predicate(array[index], index, array)) {//调用predicate，根据其返回的真假值，如果返回true说明找到了
      return index
    }
  }
  return -1//找不到返回-1
}

export default baseFindIndex

下面是baseIsNaN：

/**
 * The base implementation of `isNaN` without support for number objects.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
 */
//判断一个之是不是NaN
function baseIsNaN(value) {
  return value !== value
}

export default baseIsNaN

下面是strictIndexOf：

/**
 * A specialized version of `indexOf` which performs strict equality
 * comparisons of values, i.e. `===`.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
//indexOf实现，使用严格等于来判断值是否相等
function strictIndexOf(array, value, fromIndex) {
  let index = fromIndex - 1//循环索引
  const { length } = array//数组长度

  while (++index < length) {
    if (array[index] === value) {//如果当前值严格等于value，就返回index索引
      return index
    }
  }
  return -1//找不到返回-1
}

export default strictIndexOf