摘要：數(shù)組循環(huán)對(duì)象循環(huán)迭代在中新增了幾種迭代方法。方法為數(shù)組中的每個(gè)元素執(zhí)行一次函數(shù)，直到它找到一個(gè)使返回表示可轉(zhuǎn)換為布爾值的值的元素。數(shù)組為數(shù)組未被修改測(cè)試數(shù)組中某些元素是否通過指定函數(shù)的測(cè)試，若有一項(xiàng)終止循環(huán)返回。

在Javascript中數(shù)組循環(huán)使用for循環(huán)，跟其他的語(yǔ)言非常類似。

//數(shù)組循環(huán)
var array = [1,2,3,4,5];
for(var i = 0; i < array.length; i++){
    console.log(array[i]);
}

//對(duì)象循環(huán)
var obj = {a:1,b:2,c:3};
for(var i in obj){
    console.log(i+":"+obj[i]);
}

在ES5中新增了幾種迭代方法（forEach, every, filter, map, some）。根據(jù)文檔顯示，這些方法都含有兩個(gè)參數(shù)：

callback

? ? 為數(shù)組中每個(gè)元素執(zhí)行的函數(shù)，該函數(shù)接收三個(gè)參數(shù)：

? ? currentValue(當(dāng)前值)

? ? ? ? 數(shù)組中正在處理的當(dāng)前元素。

? ? index(索引)

? ? ? ? 數(shù)組中正在處理的當(dāng)前元素的索引。

? ? array

? ? ? ? 方法正在操作的數(shù)組。

thisArg可選

? ? 可選參數(shù)。當(dāng)執(zhí)行回調(diào)?函數(shù)時(shí)用作this的值(參考對(duì)象)。

循環(huán)遍歷數(shù)組。forEach?方法按升序?yàn)閿?shù)組中含有效值的每一項(xiàng)執(zhí)行一次callback?函數(shù)，那些已刪除（使用delete方法等情況）或者未初始化的項(xiàng)將被跳過（但不包括那些值為?undefined 的項(xiàng)）。

forEach?遍歷的范圍在第一次調(diào)用?callback?前就會(huì)確定。調(diào)用forEach?后添加到數(shù)組中的項(xiàng)不會(huì)被?callback?訪問到。如果已經(jīng)存在的值被改變，則傳遞給?callback?的值是?forEach?遍歷到他們那一刻的值。已刪除的項(xiàng)不會(huì)被遍歷到。如果已訪問的元素在迭代時(shí)被刪除了(例如使用 shift()) ，之后的元素將被跳過 。

forEach()?為每個(gè)數(shù)組元素執(zhí)行callback函數(shù)；不像?map()?或者?reduce()?，它總是返回?undefined?值，并且不可鏈?zhǔn)秸{(diào)用。典型用例是在一個(gè)鏈的最后執(zhí)行副作用。

沒有辦法中止或者跳出 forEach 循環(huán)，除了拋出一個(gè)異常。如果你需要這樣，使用forEach()方法是錯(cuò)誤的，你可以用一個(gè)簡(jiǎn)單的循環(huán)作為替代。

下面的代碼會(huì)為每一個(gè)數(shù)組元素輸出一行記錄：

function logArrayElements(element, index, array) {
    console.log("a[" + index + "] = " + element);
}

// 注意索引2被跳過了，因?yàn)樵跀?shù)組的這個(gè)位置沒有項(xiàng)
[2, 5, ,9].forEach(logArrayElements);

// a[0] = 2
// a[1] = 5
// a[3] = 9

[2, 5,"" ,9].forEach(logArrayElements);
// a[0] = 2
// a[1] = 5
// a[2] = 
// a[3] = 9

[2, 5, undefined ,9].forEach(logArrayElements);
// a[0] = 2
// a[1] = 5
// a[2] = undefined
// a[3] = 9


let xxx;
// undefined

[2, 5, xxx ,9].forEach(logArrayElements);
// a[0] = 2
// a[1] = 5
// a[2] = undefined
// a[3] = 9

從每個(gè)數(shù)組中的元素值中更新一個(gè)對(duì)象的屬性：

function Counter() {
    this.sum = 0;
    this.count = 0;
}

Counter.prototype.add = function(array) {
    array.forEach(function(entry) {
        this.sum += entry;
        ++this.count;
    }, this);
    //console.log(this);
};

var obj = new Counter();
obj.add([1, 3, 5, 7]);

obj.count; 
// 4 === (1+1+1+1)
obj.sum;
// 16 === (1+3+5+7)

下面的例子輸出"one", "two", "four"。當(dāng)?shù)竭_(dá)包含值"two"的項(xiàng)時(shí)，整個(gè)數(shù)組的第一個(gè)項(xiàng)被移除了，這導(dǎo)致所有剩下的項(xiàng)上移一個(gè)位置。因?yàn)樵?"four"現(xiàn)在在數(shù)組更前的位置，"three"會(huì)被跳過。?forEach()不會(huì)在迭代之前創(chuàng)建數(shù)組的副本。

var words = ["one", "two", "three", "four"];
words.forEach(function(word) {
  console.log(word);
  if (word === "two") {
    words.shift();
  }
});
// one
// two
// four

測(cè)試數(shù)組中所有元素是否都通過指定函數(shù)的測(cè)試，若有一項(xiàng)終止并返回false。

every?方法為數(shù)組中的每個(gè)元素執(zhí)行一次?callback?函數(shù)，直到它找到一個(gè)使?callback?返回?false（表示可轉(zhuǎn)換為布爾值 false 的值）的元素。如果發(fā)現(xiàn)了一個(gè)這樣的元素，every?方法將會(huì)立即返回?false。否則，callback?為每一個(gè)元素返回?true，every?就會(huì)返回?true。callback?只會(huì)為那些已經(jīng)被賦值的索引調(diào)用。不會(huì)為那些被刪除或從來沒被賦值的索引調(diào)用。

every?不會(huì)改變?cè)瓟?shù)組。

every?遍歷的元素范圍在第一次調(diào)用?callback?之前就已確定了。在調(diào)用?every?之后添加到數(shù)組中的元素不會(huì)被?callback?訪問到。如果數(shù)組中存在的元素被更改，則他們傳入?callback?的值是?every?訪問到他們那一刻的值。那些被刪除的元素或從來未被賦值的元素將不會(huì)被訪問到。

every?和數(shù)學(xué)中的"所有"類似，當(dāng)所有的元素都符合條件才返回true。另外，空數(shù)組也是返回true。(空數(shù)組中所有元素都符合給定的條件，注：因?yàn)榭諗?shù)組沒有元素)。

檢測(cè)數(shù)組中的所有元素是否都大于 10。

function isBigEnough(element, index, array) {
  return (element >= 10);
}
var passed = [12, 5, 8, 130, 44].every(isBigEnough);
// passed is false
passed = [12, 54, 18, 130, 44].every(isBigEnough);
// passed is true

var a = [1, 2, 3,, 4].every (function(value){
console.log(value)
   return value       
})//1，2，3，4
console.log(a)//true
a = [1, 2, 3, undefined,4].every (function(value){
console.log(value)
   return value       
})//1，2，3，undefind
console.log(a)//false

使用指定的函數(shù)測(cè)試所有的元素，創(chuàng)建并返回一個(gè)包含所有通過測(cè)試的元素的新數(shù)組。如果沒有通過測(cè)試則返回空數(shù)組。

filter?為數(shù)組中的每個(gè)元素調(diào)用一次?callback?函數(shù)，并利用所有使得?callback?返回 true 或等價(jià)于 true 的值的元素創(chuàng)建一個(gè)新數(shù)組。callback?只會(huì)在已經(jīng)賦值的索引上被調(diào)用，對(duì)于那些已經(jīng)被刪除或者從未被賦值的索引不會(huì)被調(diào)用。那些沒有通過?callback?測(cè)試的元素會(huì)被跳過，不會(huì)被包含在新數(shù)組中。

filter?不會(huì)改變?cè)瓟?shù)組，它返回過濾后的新數(shù)組。

filter?遍歷的元素范圍在第一次調(diào)用?callback?之前就已經(jīng)確定了。在調(diào)用?filter?之后被添加到數(shù)組中的元素不會(huì)被?filter?遍歷到。如果已經(jīng)存在的元素被改變了，則他們傳入?callback?的值是?filter?遍歷到它們那一刻的值。被刪除或從來未被賦值的元素不會(huì)被遍歷到。

使用?filter?創(chuàng)建了一個(gè)新數(shù)組，該數(shù)組的元素由原數(shù)組中值大于 10 的元素組成。

var a = [1, 2, 3, 7,4].filter(function(value){
   return value > 4      
})
console.log(a)//[7]

function isBigEnough(element) {
  return element >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44]

為數(shù)組每一項(xiàng)（不包括通過某些方法刪除或者未定義的項(xiàng)，值定義為undefined的項(xiàng)除外）執(zhí)行一個(gè)指定函數(shù)，返回一個(gè)新數(shù)組，每個(gè)元素都是回調(diào)函數(shù)的結(jié)果。

map?方法會(huì)給原數(shù)組中的每個(gè)元素都按順序調(diào)用一次 ?callback?函數(shù)。callback?每次執(zhí)行后的返回值（包括?undefined?）組合起來形成一個(gè)新數(shù)組。?callback?函數(shù)只會(huì)在有值的索引上被調(diào)用；那些從來沒被賦過值或者使用?delete?刪除的索引則不會(huì)被調(diào)用。

map?不修改調(diào)用它的原數(shù)組本身（當(dāng)然可以在?callback?執(zhí)行時(shí)改變?cè)瓟?shù)組）。

使用 map 方法處理數(shù)組時(shí)，數(shù)組元素的范圍是在 callback 方法第一次調(diào)用之前就已經(jīng)確定了。在 map 方法執(zhí)行的過程中：原數(shù)組中新增加的元素將不會(huì)被 callback 訪問到；若已經(jīng)存在的元素被改變或刪除了，則它們的傳遞到 callback 的值是 map 方法遍歷到它們的那一時(shí)刻的值；而被刪除的元素將不會(huì)被訪問到。

下面的代碼創(chuàng)建了一個(gè)新數(shù)組，值為原數(shù)組中對(duì)應(yīng)數(shù)字的平方根：

var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
// roots的值為[1, 2, 3], numbers的值仍為[1, 4, 9]

以下代碼將一個(gè)包含對(duì)象的數(shù)組用以創(chuàng)建一個(gè)包含新重新格式化對(duì)象的新數(shù)組。

var kvArray = [{key: 1, value: 10}, 
               {key: 2, value: 20}, 
               {key: 3, value: 30}];

var reformattedArray = kvArray.map(function(obj) { 
   var rObj = {};
   rObj[obj.key] = obj.value;
   return rObj;
});

// reformattedArray 數(shù)組為： [{1: 10}, {2: 20}, {3: 30}], 

// kvArray 數(shù)組未被修改: 
// [{key: 1, value: 10}, 
//  {key: 2, value: 20}, 
//  {key: 3, value: 30}]

測(cè)試數(shù)組中某些元素是否通過指定函數(shù)的測(cè)試，若有一項(xiàng)終止循環(huán)返回true。

some?為數(shù)組中的每一個(gè)元素執(zhí)行一次?callback?函數(shù)，直到找到一個(gè)使得 callback 返回一個(gè)“真值”（即可轉(zhuǎn)換為布爾值 true 的值）。如果找到了這樣一個(gè)值，some?將會(huì)立即返回?true。否則，some?返回?false。callback?只會(huì)在那些”有值“的索引上被調(diào)用，不會(huì)在那些被刪除或從來未被賦值的索引上調(diào)用。

some?被調(diào)用時(shí)不會(huì)改變數(shù)組。

some?遍歷的元素的范圍在第一次調(diào)用?callback. 時(shí)就已經(jīng)確定了。在調(diào)用?some?后被添加到數(shù)組中的值不會(huì)被?callback?訪問到。如果數(shù)組中存在且還未被訪問到的元素被?callback改變了，則其傳遞給?callback?的值是?some?訪問到它那一刻的值。

下面的例子檢測(cè)在數(shù)組中是否有元素大于 10。

function isBiggerThan10(element, index, array) {
  return element > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10);  // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true

[2, 5, 8, 1, 4].some(x => x > 10);  // false
[12, 5, 8, 1, 4].some(x => x > 10); // true

var fruits = ["apple", "banana", "mango", "guava"];

function checkAvailability(arr, val) {
  return arr.some(function(arrVal) {
    return val === arrVal;
  });
}

checkAvailability(fruits, "kela");   // false
checkAvailability(fruits, "banana"); // true

var TRUTHY_VALUES = [true, "true", 1];

function getBoolean(value) {
  "use strict";
   
  if (typeof value === "string") { 
    value = value.toLowerCase().trim();
  }

  return TRUTHY_VALUES.some(function(t) {
    return t === value;
  });
}

getBoolean(false);   // false
getBoolean("false"); // false
getBoolean(1);       // true
getBoolean("true");  // true