当我们需要查找某个值位于数组中的那个项的时候我们就可以使用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；
