JavaScript 數組總結

JavaScript沒有明確的數組數據類型，可是外面能夠經過使用內置Array對象和它的方法對數組進行操做，Array對象有不少操做數組的方法，好比 合併，反轉 ，排序，數組對象有一個決定數組長度和使用正則表達式操做其餘屬性的屬性，你能夠分配length屬性，寫一個小於數組元素變量的值會縮短數組自己，寫0會完全清空數組

var cats = ['Dusty', 'Misty', 'Twiggy'];
console.log(cats.length); // 3

cats.length = 2;
console.log(cats); // logs "Dusty,Misty" - Twiggy has been removed

cats.length = 0;
console.log(cats); // logs nothing; the cats array is empty

cats.length = 3;
console.log(cats); // [undefined, undefined, undefined]

 

遍歷數組

var colors = ['red', 'green', 'blue'];
for (var i = 0; i < colors.length; i++) {
  console.log(colors[i]);
}

若是你肯定數組中沒有一個元素的求值是false —— 若是你的數組只包含DOM節點，以下,你能夠選擇一個更高效的土法子:

var divs = document.getElementsByTagName('div');
for (var i = 0, div; div = divs[i]; i++) {
  /* Process div in some way */
}

這樣避免了檢測數組長度的開銷，額外的好處是確保了div變量當前在每次循環中都被從新賦值爲當前項。 

forEach()方法提供了遍歷數組元素的其它方法
var colors=['red', 'green', 'blue'];
colors.forEach(function(color){
console.log(color); //color要寫或其餘的名字也行，但不能爲空
});

被傳遞給forEach的函數會在數組的每一個元素像上執行一次，元素做爲參數傳遞給該函數。未賦值的值不會在forEach循環迭代。

注意，在數組定義時省略的元素不會在forEach遍歷時被列出，可是手動賦值爲undefined的元素是會被列出的：

數組的方法 concat()鏈接兩個數組並返回一個新的數組

var myArray=new Array("1","2","3");
myArray=myArray.concat("a", "b", "c");
myArray is now["1","2","3","a", "b", "c"] 
若是
var myArray=new Array("1","2","3");
myArray1=myArray.concat("a", "b", "c");  // myArray ["1","2","3"]   myArray1 ["1","2","3","a", "b", "c"]  

join()將數組的全部元素鏈接成一個字符串 

var myArray=new Array("Wind", "Rain", "Fire");
var list=myArray.join("-")  // list is "Wind-Rain-Fire"

push()在數組末尾添加一個或多個元素，並返回數組 操做後的長度

var myArray = new Array("1", "2");
myArray.push("3"); // myArray is now ["1", "2", "3"]

pop()從數組移出最後一個元素，並返回該元素

var myArray = new Array("1", "2", "3");
var last = myArray.pop(); 
// myArray is now ["1", "2"], last = "3"

shift()從數組移出第一個元素，並返回該元素

var myArray = new Array ("1", "2", "3");
var first = myArray.shift(); 
// myArray is now ["2", "3"], first is "1"

unshift()在數組開頭添加一個或者多個元素，並返回數組的新長度

var myArray = new Array ("1", "2", "3");
myArray.unshift("4", "5"); 
// myArray becomes ["4", "5", "1", "2", "3"]

slice()從數組提取一個片斷，並做爲一個新數組返回 

var myArray = new Array ("a", "b", "c", "d", "e");
myArray1 = myArray.slice(1, 4); // starts at index 1 and extracts all elements
                               // until index 3，不包含4, returning [ "b", "c", "d"]

splice(添加或刪除的位置，數量，增長的元素)從數組移出一些元素（可選）並替換他們

在數組的第2位置添加一個元素 - splice()
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,0,"Lemon","Kiwi");
Banana,Orange,Lemon,Kiwi,Apple,Mango

reverse()顛倒數組元素的順序，第一個變成最後一個，最後一個變成第一個

var myArray = new Array ("1", "2", "3");
myArray.reverse(); 
// transposes the array so that myArray = [ "3", "2", "1" ]

sort() 給數組元素排序。
var myArray = new Array("Wind", "Rain", "Fire");
myArray.sort(); //按字母順序升序
// sorts the array so that myArray = [ "Fire", "Rain", "Wind" ]

sort()也能夠帶一個回調函數來決定怎麼比較數組元素，這個回調函數比較2個值，並返回3個值中的一個
var points = [40,100,1,5,25,10];
points.sort(function(a,b){return a-b});//數字升序排列數組，
解釋：第一次比較第一個與第二個數（a(40)與b(100)）,a-b爲負數，則位置不變，若a-b爲正數則位置交換，而後比較第一個和第三個，依次比較到第一個與最後一個，第二輪，第二個與第三個開始比較，第二個與第四個比較，直到第二個與最後一個，而後第三輪。。。
這種排序方法叫作冒泡排序
var points = [40,100,1,5,25,10];
points.sort(function(a,b){return b-a});//數字降序排列數組

例如，下面的代碼經過字符串的最後一個字母進行排序：
var sortFn = function(a, b){
  if (a[a.length - 1] < b[b.length - 1]) return -1;
  if (a[a.length - 1] > b[b.length - 1]) return 1;
  if (a[a.length - 1] == b[b.length - 1]) return 0;
}
myArray.sort(sortFn); 
// sorts the array so that myArray = ["Wind","Fire","Rain"]
若是 a 小於 b ，返回 -1(或任何負數)
若是 a 大於 b ，返回 1 (或任何正數)
若是 a 和 b 相等，返回 0。

indexOf(選擇元素，開始位置)

var a = ['a', 'b', 'a', 'b', 'a'];
console.log(a.indexOf('b')); // logs 1
// Now try again, starting from after the last match
console.log(a.indexOf('b', 2)); // logs 3
console.log(a.indexOf('z')); // logs -1,

laseIndexOf(選擇元素，開始位置)和indexOf差很少，可是從結尾開始，而且是反向搜索

var a = ['a', 'b', 'c', 'd', 'a', 'b'];
console.log(a.lastIndexOf('b')); // logs 5
// Now try again, starting from before the last match
console.log(a.lastIndexOf('b', 4)); // logs 1

map(callback[, thisObject]) 也就是遍歷數組，並經過callback對數組元素進行操做，並將所要操做結果放入數組中並返回該數組

var a1=["a","b","c"];
var a2=a1.map(function(item){return item.toUpperCase();});
console.log(a2);// a2 ["A","B","C"]

filter(callback[, thisObject]) 返回一個全部在回調函數上返回true的元素的新數組

var a1 = ['a', 10, 'b', 20, 'c', 30];
var a2=a1.filter(function(item){return typeof itme=="number";}); // a2[10,20,30]

every(callback[, thisObject])  當數組中每一個元素在callback上被返回true時就返回true,功能相似filter,只不過
功能是判斷是否是數組中的全部元素都符號條件，而且返回的是bool值

function isNumber(value){
  return typeof value == 'number';
}
var a1 = [1, 2, 3];
console.log(a1.every(isNumber)); // logs true
var a2 = [1, '2', 3];
console.log(a2.every(isNumber)); // logs false

some(callback[, thisObject]) 只要數組中有一項在callback上被返回true，就返回true。

function isNumber(value){
  return typeof value == 'number';
}
var a1 = [1, 2, 3];
console.log(a1.some(isNumber)); // logs true
var a2 = [1, '2', 3];
console.log(a2.some(isNumber)); // logs true
var a3 = ['1', '2', '3'];
console.log(a3.some(isNumber)); // logs false

如下代碼建立了一個二維數組.

var a = []; for (i = 0; i < 4; i++) {   a[i] = [];   for (j = 0; j < 4; j++) {     a[i][j] = "[" + i + "," + j + "]";   } }