js數組經常使用的一些方法

(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]