摘要：位置方法為數組實例添加了兩個位置方法和。參數要查找的項和可選的表示查找起點位置的索引。函數接受個參數之前值當前值索引值以及數組本身。

這一章節主要記錄的是ES5的方法，在低版本瀏覽器上存在一定的兼容，但是主流手機上使用大可放心。

ECMAScript 5 為數組實例添加了兩個位置方法:indexOf()和 lastIndexOf()。

1.參數: 要查找的項和(可選的)表示查找起點位置的索引。
2.indexOf()方法從數組的開頭(位置0)開始向后查找，lastIndexOf()方法則從數組的末尾開始向前查找
3.兩個方法都返回要查找的項在數組中的位置，或者在沒找到的情況下返回-1。
4.在比較第一個參數與數組中的每一項時，會使用全等操作符

var numbers = [1,2,3,4,5,4,3,2,1];
alert(numbers.indexOf(4));        //3

alert(numbers.lastIndexOf(4)); //5
alert(numbers.indexOf(4, 4));     //5
alert(numbers.lastIndexOf(4, 4)); //3

var person = { name: "Nicholas" };
var people = [{ name: "Nicholas" }];
var morePeople = [person];
alert(people.indexOf(person));     //-1
alert(morePeople.indexOf(person)); //0

聲明：以下方法參數都是function類型，默認有傳參，方法中的function回調支持3個參數，第1個是遍歷的數組內容；第2個是對應的數組索引，第3個是數組本身

1.forEach()方法
【遍歷】遍歷數組，沒有返回值！沒有返回值！沒有返回值！重要的事情說三遍
forEach()方法幾乎可以代替for的用法，如果對數組的返回或跳出沒有要求

用法：

[1, 2 ,3, 4].forEach(function(value, index, arr){
    console.log(value); // 當前值
    console.log(index); // 當前索引
    console.log(arr); // 指向當前數組
});

// 等同于
var array = [1, 2, 3, 4];
for (var k = 0, length = array.length; k < length; k++) {
    //...
}

用法雖然簡單，但在低版本的瀏覽器上存在兼容，下面提供一個兼容性的寫法：

// 對于古董瀏覽器，如IE6-IE8

if (typeof Array.prototype.forEach != "function") {
  Array.prototype.forEach = function (fn, context) {
    for (var k = 0, length = this.length; k < length; k++) {
      if (typeof fn === "function" && Object.prototype.hasOwnProperty.call(this, k)) {
        fn.call(context, this[k], k, this);
      }
    }
  };
}

2.map()方法

【映射】對數組中的每一項運行給定函數，返回每次函數調用的結果組成的數組，返回的數組長度一定與原數組長度相同，常用來改造某一數組，例如對某段數組進行篩選或插入新的元素

基本用法：

// 含有return
[1, 2, 3, 4].map(function (item) {
  return item * item; // [1, 4, 9, 16]
});

// 不含return
[1, 2, 3, 4].map(function (item) {
  item * item; // [undefined, undefined, undefined, undefined]
});

用于篩選某一段數組，返回符合要求對元素組成的新數組：

var users = [
  {name: "佟麗婭", "email": "zhang@email.com"},
  {name: "趙麗穎",   "email": "jiang@email.com"},
  {name: "肉巴",  "email": "li@email.com"}
];

var emails = users.map(function (user) { return user.email; });
// ["zhang@email.com", "jiang@email.com", "li@email.com"]

用于插入新的元素：

var users = [
  {name: "佟麗婭", "email": "tongliya@email.com"},
  {name: "趙麗穎",   "email": "zhaoliying@email.com"},
  {name: "肉巴",  "email": "dilireba@email.com"}
];
users.map(function(v){
    v.enName = v.email.slice(0, v.email.indexOf("@"));
    return v
})

兼容性寫法：

if (typeof Array.prototype.map != "function") {
  Array.prototype.map = function (fn, context) {
    var arr = [];
    if (typeof fn === "function") {
      for (var k = 0, length = this.length; k < length; k++) {      
         arr.push(fn.call(context, this[k], k, this));
      }
    }
    return arr;
  };
}

3.filter()方法

【篩選】對數組中的每一項運行給定函數，返回該函數會返回 true 的項組成的數組
與map()方法的用法較為相似，但是僅返回滿足要求的項，返回的新的數組一定是原數組中的元素，且數組長度小于等于原數組長度

基本用法

[0, 1, 2, 3].filter(function(item) {
    return item; // [1, 2, 3]
});

var users = [
  {name: "佟麗婭", "email": "tongliya@email.com", age: 24},
  {name: "趙麗穎",   "email": "zhaoliying@email.com", age: 18},
  {name: "肉巴",  "email": "dilireba@email.com", age: 17}
];
users.map(function(v){
    return v.age > 18// {name: "佟麗婭", email: "tongliya@email.com", age: 24}
})

兼容性寫法：

if (typeof Array.prototype.filter != "function") {
  Array.prototype.filter = function (fn, context) {
    var arr = [];
    if (typeof fn === "function") {
       for (var k = 0, length = this.length; k < length; k++) {
          fn.call(context, this[k], k, this) && arr.push(this[k]);
       }
    }
    return arr;
  };
}

every()方法

【全滿足返回true】對數組中的每一項運行給定函數，如果該函數對每一項都返回 true，則返回 true

基本用法：

// 數組中所有項滿足要求時返回true，否則為false
[1,2,3,4,5,6,7].every(function(v){
    return v > 2; // false
})

兼容性寫法：

if (typeof Array.prototype.every != "function") {
  Array.prototype.every = function (fn, context) {
    var passed = true;
    if (typeof fn === "function") {
       for (var k = 0, length = this.length; k < length; k++) {
          if (passed === false) break;
          passed = !!fn.call(context, this[k], k, this);
      }
    }
    return passed;
  };
}

some()方法

【某項滿足返回true】對數組中的每一項運行給定函數，如果該函數對任一項返回 true，則返回 true

基本寫法

// 數組中某一項滿足要求時返回true，否則為false
[1,2,3,4,5,6,7].some(function(v){
    return v > 2; // true
})

兼容性寫法：

if (typeof Array.prototype.some != "function") {
  Array.prototype.some = function (fn, context) {
    var passed = false;
    if (typeof fn === "function") {
         for (var k = 0, length = this.length; k < length; k++) {
          if (passed === true) break;
          passed = !!fn.call(context, this[k], k, this);
      }
    }
    return passed;
  };
}

歸并方法包括reduce()和reduceRight()兩種，寫法同上面的方式相似。函數接受4個參數：之前值、當前值、索引值以及數組本身。initialValue參數可選，表示初始值。若指定，則當作最初使用的previous值；如果缺省，則使用數組的第一個元素作為previous初始值，同時current往后排一位，相比有initialValue值少一次迭代

1.reduce()方法

基本用法：

var sum = [1, 2, 3, 4].reduce(function (previous, current, index, array) {
  return previous + current;
});

console.log(sum); // 10

// 執行過程
// 初始設置
previous = initialValue = 1, current = 2
// 第一次迭代
previous = (1 + 2) =  3, current = 3
// 第二次迭代
previous = (3 + 3) =  6, current = 4
// 第三次迭代
previous = (6 + 4) =  10, current = undefined (退出)

var sum = [1, 2, 3, 4].reduce(function (previous, current, index, array) {
  return previous + current;
}, 10);

console.log(sum); // 20
// 執行過程
// 初始設置
initialValue = 10, previous = 1, current = 2
// 第一次迭代
previous = (10 + 1) =  11, current = 2
// 第二次迭代
previous = (11 + 2) =  13, current = 3
// 第三次迭代
previous = (13 + 3) =  16, current = 4
// 第四次迭代
previous = (16 + 4) =  20, current = undefined

數組扁平化

var matrix = [
  [1, 2],
  [3, 4],
  [5, 6]
];

// 二維數組扁平化
var flatten = matrix.reduce(function (previous, current) {
  return previous.concat(current);
});

console.log(flatten); // [1, 2, 3, 4, 5, 6]

兼容寫法：

if (typeof Array.prototype.reduce != "function") {
  Array.prototype.reduce = function (callback, initialValue ) {
     var previous = initialValue, k = 0, length = this.length;
     if (typeof initialValue === "undefined") {
        previous = this[0];
        k = 1;
     }
     
    if (typeof callback === "function") {
      for (k; k < length; k++) {
         this.hasOwnProperty(k) && (previous = callback(previous, this[k], k, this));
      }
    }
    return previous;
  };
}

2.reduceRight()方法

與reduce()方法相同，只是執行順序是從右往左

兼容性寫法：

if (typeof Array.prototype.reduceRight != "function") {
  Array.prototype.reduceRight = function (callback, initialValue ) {
    var length = this.length, k = length - 1, previous = initialValue;
    if (typeof initialValue === "undefined") {
        previous = this[length - 1];
        k--;
    }
    if (typeof callback === "function") {
       for (k; k > -1; k-=1) {          
          this.hasOwnProperty(k) && (previous = callback(previous, this[k], k, this));
       }
    }
    return previous;
  };
}

參考：ES5中新增的Array方法詳細說明