js 數組循環和迭代

（以前一直沒怎麼注意數組循環，今天作一道題時，用到forEach循環發現它並無按照我想象的樣子執行，總結一下數組循環）

一.第一種方法就是for()循環

　　  for( var index = 0; index < array.length; i ++){} 

　　這種方法很常見，各個語言都有，這裏就再也不贅述

二.es5新增長的迭代方法（every,filter,forEach,map,some）

　　這些方法都接收兩個參數，1）在每一項上可運行的函數（傳入的函數接受三個參數：a. 數組項的值；b. 該項在數組中的位置； c. 數組自己）；2）（可選）運行該函數的做用域——影響this的值。

　　語法：以forEach爲例，其餘相似

array.forEach(callback [, thisArg])
/**
*callback爲要執行的回調函數，thisArg爲綁定的this若未傳參，
 的  值在非嚴格模式下將是全局對象，嚴格模式下爲 *callbackthisundefined
*/

var  nums = [3, 2, 3, 4]
nums.forEach(function(value, index, array){
   //執行某些操做
})
/**
*其中匿名函數爲每一項要執行的函數；thisArg省略
* 匿名函數中 value爲每一項的值，如3,2,3,4
* index爲每一項的位置即索引，如0，1，2，3
*array爲數組自己，如nums
*
*thisArg省略
*/

1） every（）方法:

　　測試數組中全部元素是否都經過指定函數的測試，如有一項返回false即返回false；

　　every方法爲元素的每一個元素執行一次callback函數（不包括經過某些方法刪除或者未定義的項，值定義爲undefined的項除外），直到找到一個使callback返回false（可轉化爲false的值），跳出迭代並返回false。不然（全部元素均返回true）返回true。

　　every方法遍歷到的元素爲第一次調用callback那一個的值，以後添加的值不會被訪問到。

function isBigEnough(elemen) {
  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

 

2）filter（）方法：

　　使用指定的函數測試全部的元素，建立並返回一個包含全部經過測試的元素的新數組

　　filter爲數組中的每一個元素調用一次callback（不包括經過某些方法刪除或者未定義的項，值定義爲undefined的項除外），並利用全部callback返回true或等價於true的元素建立一個新數組，未經過callback測試的元素會被跳過，不會包含在新數組裏。

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

 

3)forEach()方法：

　　forEach按升序爲數組中含有相知的每一項執行一次callback函數（不包括經過某些方法刪除或者未定義的項，值定義爲undefined的項除外）

　　forEach遍歷的範圍在第一次調用 callback 前就會肯定。調用forEach後添加到數組中的項不會被 callback 訪問到。若是已經存在的值被改變，則傳遞給 callback  的值是 forEach遍歷到他們那一刻的值。已刪除的項不會被遍歷到。若是已訪問的元素在迭代時被刪除了(例如使用 shift()) ，以後的元素將被跳過 。老是返回undefined，不能鏈式調用。

　　沒有辦法停止或者跳出 forEach 循環，除了拋出一個異常。若是你須要這樣，使用forEach()方法是錯誤的，你能夠用一個簡單的循環做爲替代

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

// 注意索引2被跳過了，由於在數組的這個位置沒有項
[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

 

　　

　　若是數組在迭代時被修改了，則其餘元素會被跳過。

下面的例子輸出"one", "two", "four"。當到達包含值"two"的項時，整個數組的第一個項被移除了，這致使全部剩下的項上移一個位置。由於元素 "four"如今在數組更前的位置，"three"會被跳過。 forEach()不會在迭代以前建立數組的副本。

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

 

4) map()方法：

　　爲數組每一項（不包括經過某些方法刪除或者未定義的項，值定義爲undefined的項除外）執行一個指定函數，返回一個新數組，每一個元素都是回調函數的結果

　　使用 map 方法處理數組時，數組元素的範圍是在 callback 方法第一次調用以前就已經肯定了。在 map 方法執行的過程當中：原數組中新增長的元素將不會被 callback 訪問到；若已經存在的元素被改變或刪除了，則它們的傳遞到 callback 的值是 map 方法遍歷到它們的那一時刻的值；而被刪除的元素將不會被訪問到。

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

 

5）some（）方法：

　　測試數組中某些元素是否經過指定函數的測試，如有一項返回true即返回true

　　some爲數組中的每個元素執行一次 callback函數，直到找到一個使得 callback 返回一個「真值」（便可轉換爲布爾值 true 的值），中止迭代並返回true；不然（全部元素均爲false），返回false。

var a = [1, 2, 3, 7,4].some (function(value){
   return value > 8       
})
console.log(a)//false
a = [1, 2, 3, 9,4].some (function(value){
   return value > 8       
})
console.log(a)//true