摘要：如果被引用的對象發生改變，則改變將反應到新的和原來的數組中對于字符串和數字來說不是和對象，會拷貝字符串和數字到新的數組里。在一個數組里修改這些字符串或數字，不會影響另一個數組。

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

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

(2) arr.indexOf(searchElement[, fromIndex = 0]) => 返回給定元素在數組中的第一個索引值，否則返回-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]) => 返回指定元素在數組中最后出現位置的索引值,從 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) => 在數組的末尾添加一個或多個元素，并返回數組新的 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) => 在數組的開頭添加一個或者多個元素，并返回數組新的 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() => 刪除數組中的最后的一個元素，并且返回這個元素

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

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

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

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) => 將傳入的數組或值與原數組合并,組成一個新的數組并返回

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

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

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

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

// start 從數組對哪一位開始修改內容
// deleteCount 整數，表示要移除的數組元素的個數
// itemN 要添加進數組的元素
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]]) => 把數組中的一部分淺拷貝，存入到一個新的數組中，并返回這個新數組

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

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

// slice 方法可以用來將一個類數組（Array-like）對象/集合轉換成一個數組
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 = ","]) => 將數組中的所有元素連接成一個字符串

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

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

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

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

//對數字進行升序排序
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]) => 讓數組的每一項都執行一次 callback 函數；thisArg 是可選參數，用來當作callback 函數內this值的對象。注：沒有辦法中止或者跳出forEach循環，除了拋出一個異常

//callback 函數傳三個參數：數組當前項的值、數組當前項的索引、數組對象本身
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]) => 返回一個由原數組中的每個元素調用一個指定方法后的返回值組成的新數組

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]) => 接收一個callback函數作為累加器（accumulator），數組中的每個值（從左到右）開始合并，最終為一個值

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

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

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

//eg.數組扁平化
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]) => 測試數組的所有元素是否都通過了指定函數的測試

// callback 被調用時傳入三個參數：元素的值，元素的索引，被遍歷的數組
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]) => 測試數組中的某些元素是否通過了指定函數的測試

// callback 被調用時傳入三個參數：元素的值，元素的索引，被遍歷的數組
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]) => 使用指定的函數測試所有元素，并創建一個包含所有通過測試的元素的新數組

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