当我们需要查找某个值位于数组中的那个项的时候我们就可以使用indexOf、lastIndexOf方法。

indexOf 方法

返回某个值在数组中的第一个匹配项的索引。

语法

array1.indexOf(searchElement[,fromIndex])

参数

array1，必须、且为一个数组对象。
searchElement，必须，为array1中定位的值。
fromIndex,可选。用于开始搜索的数组索引。如果省略则从0处开始搜索。

返回值

indexOf返回找到第一个匹配项的索引，如果找不到指定的值则为-1。

var ar=['ab','cd','ef','ab','cd'];
console.log(ar.indexOf('cd'));//Output:1
console.log(ar.indexOf('cd',2));//output 4
console.log(ar.indexOf('cd',-2));//output 4

当fromIndex为负值的时候，用数组的长度抵消负值后的数组为fromIndex，当抵消后的值仍为负值的时候从0处开始搜索。

lastIndexOf 方法

返回指定值在数组中最后一个匹配项的索引。

语法

array1.lastIndexOf(searchElement[,fromIndex])

参数

array1，必须、且为一个数组对象
searchElement,必须，为array1中定位的值。
fromIndex,可选。用于开始搜索的数组的索引。如果省略，则搜索将从数组中的最后一个索引处开始。

返回值

数组中的searchElement的最后一个匹配项的索引。如果为找到则返回-1；

var ar=['ab','cd','ab','ef','cd'];
console.log(ar.lastIndexOf('ab'));//Output:2
console.log(ar.lastIndexOf('ab',2));//output -1
console.log(ar.lastIndexOf('ab',-1));//output -1

fromIndex参数存在的时候，是从后向前检索匹配，找到第一个匹配的值。即整个数组中最后一个匹配的项。
搜索按降序索引顺序进行。首先搜索最后一个成员。indexOf则采用升序检索。
如果fromIndex大于或等于数组长度，则搜索整个数组。如果fromIndex为负，则搜索从数组长度加上fromIndex的位置处开始，如果计算所得的索引小于0，则返回-1；

兼容性

indexOf和lastIndexOf方法在ie9+浏览器支持。如果希望能在低版本浏览器支持indexOf，可以添加下面部分代码:摘自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;
  };
}

lastIndexof
Polyfill

if (!Array.prototype.lastIndexOf) {
  Array.prototype.lastIndexOf = function(searchElement /*, fromIndex*/) {
    'use strict';

    if (this === void 0 || this === null) {
      throw new TypeError();
    }

    var n, k,
        t = Object(this),
        len = t.length >>> 0;
    if (len === 0) {
      return -1;
    }

    n = len - 1;
    if (arguments.length > 1) {
      n = Number(arguments[1]);
      if (n != n) {
        n = 0;
      }
      else if (n != 0 && n != (1 / 0) && n != -(1 / 0)) {
        n = (n > 0 || -1) * Math.floor(Math.abs(n));
      }
    }

    for (k = n >= 0
          ? Math.min(n, len - 1)
          : len - Math.abs(n); k >= 0; k--) {
      if (k in t && t[k] === searchElement) {
        return k;
      }
    }
    return -1;
  };
}

总结：indexOf()和lastIndexOf()两个方法都是用来查找数组项在一个数组中的索引值，其中indexOf()是从前向后寻找，而lastIndexOf()是从后向前寻找。
indexOf返回某值在数组中项的索引，未找到返回-1，第二个参数为检索的起始项，当检索起始项为负值时候，用数组length加上负值得到的值为项的起始索引，若仍旧小于0则从第一项开始检索。
lastIndexOf返回匹配值的最后一项的索引。当有第二个参数时候，是从数组的最后项数向前的个数开始检索。若为负数则用数组的长度匹配后为检索开始位置，仍为0的时候返回-1；