摘要：如果被引用的對象發(fā)生改變，則改變將反應(yīng)到新的和原來的數(shù)組中對于字符串和數(shù)字來說不是和對象，會(huì)拷貝字符串和數(shù)字到新的數(shù)組里。在一個(gè)數(shù)組里修改這些字符串或數(shù)字，不會(huì)影響另一個(gè)數(shù)組。

(1) arr.length => 返回一個(gè)數(shù)組中的元素個(gè)數(shù)（數(shù)組屬性）

var numbers = [1,2,3,4,5];
numbers.length; // 5

(2) arr.indexOf(searchElement[, fromIndex = 0]) => 返回給定元素在數(shù)組中的第一個(gè)索引值，否則返回-1

var array = [2, 5, 9];
array.indexOf(5);     // 1
array.indexOf(9, 2);  // 2
array.indexOf(2, -3); // 0

(3) arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1]) => 返回指定元素在數(shù)組中最后出現(xiàn)位置的索引值,從 fromIndex 位置向前開始查找，如果不存在，則返回 -1

var arr = [2, 5, 9, 2];
arr.lastIndexOf(2);     // 3
arr.lastIndexOf(7);     // -1
arr.lastIndexOf(2, 3);  // 3
arr.lastIndexOf(2, 2);  // 0
arr.lastIndexOf(2, -2); //0

(4) arr.push(element1, ..., elementN) => 在數(shù)組的末尾添加一個(gè)或多個(gè)元素，并返回?cái)?shù)組新的 length 值

var sports = ["soccer", "baseball"];
var total = sports.push("football", "swimming");

console.log(sports); // ["soccer", "baseball", "football", "swimming"]
console.log(total);  // 4

(5) arr. unshift(element1, ..., elementN) => 在數(shù)組的開頭添加一個(gè)或者多個(gè)元素，并返回?cái)?shù)組新的 length 值

var sports = ["soccer", "baseball"];
var total = sports.unshift("football", "swimming");

console.log(sports); // ["football", "swimming", "soccer", "baseball"]
console.log(total);  // 4

(6) arr.pop() => 刪除數(shù)組中的最后的一個(gè)元素，并且返回這個(gè)元素

var myFish = ["angel", "clown", "mandarin", "surgeon"];
var popped = myFish.pop();

console.log(myFish); // ["angel", "clown", "mandarin"]
console.log(popped); // "surgeon"

(7) arr.shift() => 刪除數(shù)組中的第一個(gè)元素，并且返回這個(gè)元素

var myFish = ["angel", "clown", "mandarin", "surgeon"];
var shifted = myFish.shift();

console.log(myFish); // ["clown", "mandarin", "surgeon"]
console.log(shifted); // "angel"

(8) arr.concat(value1, value2, ..., valueN) => 將傳入的數(shù)組或值與原數(shù)組合并,組成一個(gè)新的數(shù)組并返回

var alpha = ["a", "b", "c"];
var numeric = [1, 2, 3];
var alphaNumeric = alpha.concat(numeric);        // 組成新數(shù)組 ["a", "b", "c", 1, 2, 3]; 原數(shù)組 alpha 和 numeric 未被修改
var alphaNumeric2 = alpha.concat(1,[2,3,[4,5]]); // 組成新數(shù)組 ["a", "b", "c", 1, 2, 3, [4,5]]

(9) arr.reverse() => 顛倒數(shù)組中元素的位置，并返回該數(shù)組的引用

var myArray = ["one", "two", "three"];
myArray.reverse(); 
console.log(myArray); // ["three", "two", "one"]

(10) array.splice(start, deleteCount[, item1[, item2[, ...]]]) => 用新元素替換舊元素，修改數(shù)組的內(nèi)容；返回由被刪除的元素組成的數(shù)組

// start 從數(shù)組對哪一位開始修改內(nèi)容
// deleteCount 整數(shù)，表示要移除的數(shù)組元素的個(gè)數(shù)
// itemN 要添加進(jìn)數(shù)組的元素
var myFish = ["angel", "clown", "mandarin", "surgeon"];
myFish.splice(2, 0, "drum"); // []  "增"
console.log(myFish); // ["angel", "clown", "drum", "mandarin", "surgeon"]

myFish.splice(1,2); // ["clown", "drum"]   "刪"
console.log(myFish); // ["angel", "mandarin", "surgeon"]

myFish.splice(0, 2, "parrot", "anemone", "blue"); // ["angel", "mandarin"]   "改"
console.log(myFish); // ["parrot", "anemone", "blue", "surgeon"]

(11) arr.slice([begin[, end]]) => 把數(shù)組中的一部分淺拷貝，存入到一個(gè)新的數(shù)組中，并返回這個(gè)新數(shù)組

// 原數(shù)組的元素按照下述規(guī)則拷貝：
// 1.如果該元素是個(gè)對象引用（不是實(shí)際的對象），slice會(huì)拷貝這個(gè)對象引用到新的數(shù)組
//   里。兩個(gè)對象都引用了同一個(gè)對象。如果被引用的對象發(fā)生改變，則改變將反應(yīng)到新的和
//   原來的數(shù)組中；
// 2.對于字符串和數(shù)字來說（不是String和Number對象），slice會(huì)拷貝字符串和數(shù)字到
//   新的數(shù)組里。在一個(gè)數(shù)組里修改這些字符串或數(shù)字，不會(huì)影響另一個(gè)數(shù)組。
// 如果向兩個(gè)數(shù)組任一中添加了新元素，則另一個(gè)不會(huì)受到影響

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
fruits.slice(1,3); // ["Orange", "Lemon"]
console.log(fruits); // ["Banana", "Orange", "Lemon", "Apple", "Mango"]

// slice 方法可以用來將一個(gè)類數(shù)組（Array-like）對象/集合轉(zhuǎn)換成一個(gè)數(shù)組
function list() {
  return Array.prototype.slice.call(arguments);
  // 或者 return [].prototype.slice.call(arguments);
}
var list1 = list(1, 2, 3); // [1, 2, 3]

(12) arr.join([separator = ","]) => 將數(shù)組中的所有元素連接成一個(gè)字符串

var a = ["Wind", "Rain", "Fire"];
var myVar1 = a.join();      // myVar1的值變?yōu)?Wind,Rain,Fire"
var myVar2 = a.join(", ");  // myVar2的值變?yōu)?Wind, Rain, Fire"
var myVar3 = a.join(" + "); // myVar3的值變?yōu)?Wind + Rain + Fire"
var myVar4 = a.join("");    // myVar4的值變?yōu)?WindRainFire"

(13) arr.sort([compareFunction]) => 對數(shù)組的元素排序，并返回這個(gè)數(shù)組；默認(rèn)按照字符串的Unicode碼位點(diǎn)（code point）排序

var fruit = ["cherries", "apples", "bananas"];
fruit.sort(); // ["apples", "bananas", "cherries"]

var scores = [1, 10, 2, 21]; 
scores.sort(); // [1, 10, 2, 21]

//對數(shù)字進(jìn)行升序排序
function compareNumbers(a, b) {
  return a - b;
}
var numbers = [4, 20, 5, 12, 3];
numbers.sort(compareNumbers); // [3, 4, 5, 12, 20]

(14) array.forEach(callback[, thisArg]) => 讓數(shù)組的每一項(xiàng)都執(zhí)行一次 callback 函數(shù)；thisArg 是可選參數(shù)，用來當(dāng)作callback 函數(shù)內(nèi)this值的對象。注：沒有辦法中止或者跳出forEach循環(huán)，除了拋出一個(gè)異常

//callback 函數(shù)傳三個(gè)參數(shù)：數(shù)組當(dāng)前項(xiàng)的值、數(shù)組當(dāng)前項(xiàng)的索引、數(shù)組對象本身
function logArrayElements(item, index, array) {
    console.log("a[" + index + "] = " + item);
}
[2, 5, 9].forEach(logArrayElements);
// a[0] = 2
// a[1] = 5
// a[2] = 9

(15) array.map(callback[, thisArg]) => 返回一個(gè)由原數(shù)組中的每個(gè)元素調(diào)用一個(gè)指定方法后的返回值組成的新數(shù)組

var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
console.log(numbers); // [1, 4, 9]
console.log(roots); // [1, 2, 3]

(16) arr.reduce(callback,[initialValue]) => 接收一個(gè)callback函數(shù)作為累加器（accumulator），數(shù)組中的每個(gè)值（從左到右）開始合并，最終為一個(gè)值

// callback 函數(shù)傳四個(gè)參數(shù)：
//   @param previousValue 上一次調(diào)用回調(diào)返回的值，或者是提供的初始值（initialValue）
//   @param currentValue 數(shù)組中當(dāng)前被處理的元素
//   @param index 當(dāng)前元素在數(shù)組中的索引
//   @param array 調(diào)用 reduce 的數(shù)組

function accAdd(previousValue, currentValue, index, array){
  return previousValue + currentValue;
};
[0,1,2,3,4].reduce(accAdd); // 10 第一次調(diào)用時(shí)，previousValue = 0，currentValue = 1
[0,1,2,3,4].reduce(accAdd,10); // 20 第一次調(diào)用時(shí)，previousValue = 10，currentValue = 0

//eg.將數(shù)組所有項(xiàng)相加
var total = [0, 1, 2, 3].reduce(function(a, b) {
    return a + b;
});
console.log(total); // 6

//eg.數(shù)組扁平化
var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
    return a.concat(b);
});
console.log(flattened); // [0, 1, 2, 3, 4, 5]

(17) arr.every(callback[, thisArg]) => 測試數(shù)組的所有元素是否都通過了指定函數(shù)的測試

// callback 被調(diào)用時(shí)傳入三個(gè)參數(shù)：元素的值，元素的索引，被遍歷的數(shù)組
function isBigEnough(element, index, array) {
  return (element >= 10);
}
[12, 5, 8, 130, 44].every(isBigEnough);   // false
[12, 54, 18, 130, 44].every(isBigEnough); // true

(18) arr.some(callback[, thisArg]) => 測試數(shù)組中的某些元素是否通過了指定函數(shù)的測試

// callback 被調(diào)用時(shí)傳入三個(gè)參數(shù)：元素的值，元素的索引，被遍歷的數(shù)組
function isBigEnough(element, index, array) {
  return (element >= 10);
}
[2, 5, 8, 5, 4].some(isBigEnough);   // false
[2, 3, 4, 5, 11].some(isBigEnough); // true

(19) arr.filter(callback[, thisArg]) => 使用指定的函數(shù)測試所有元素，并創(chuàng)建一個(gè)包含所有通過測試的元素的新數(shù)組

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