數組的操做

數組的建立

var arrayObj = []; //普通數組建立
var arrayObj = new Array();　//建立一個數組
var arrayObj = new Array([size]);　//建立一個數組並指定長度，注意不是上限，是長度
var arrayObj = new Array([element0[, element1[, ...[, elementN]]]]);　//建立一個數組並賦值

數組的添加

• push()方法將一個或多個新元素添加到數組結尾，並返回數組新長度,數組不變

var arr = [1]
console.log(arr.push(2)) //2
console.log(arr) //[1, 2]

• unshift()方法將一個或多個新元素添加到數組頭部，並返回數組新長度,數組不變

var arr = [1]
console.log(arr.unshift(2)) //2
console.log(arr) //[2, 1]

• splice()將一個或多個新元素插入到數組的指定位置，插入位置的元素自動後移，返回""。

var arr = [1,2,3,4,5]
arr.splice(2,0,'insert') //表示在第二個位置插入，刪除0個元素,返回[]
console.log(arr) //[1, 2, "insert", 3, 4, 5]

var newArr = [1,2,3,4,5]
newArr.splice(2,1,'insert') //表示刪除第二個位置後的1個元素並插入
console.log(newArr) //[1, 2, "insert", 4, 5]

數組的刪除

• pop()移除最後一個元素並返回該元素值
• shift()移除最前一個元素並返回該元素值，數組中元素自動前移
• splice(deletePos,deleteCount)刪除從指定位置deletePos開始的指定數量deleteCount的元素，數組形式返回所移除的元素

數組的截取和合並

• concat()將多個數組（也能夠是字符串，或者是數組和字符串的混合）鏈接爲一個數組，返回鏈接好的新的數組

var a = [1]
var b = [2]
a.concat(b) //[1,2] 既不是a也不是b

• slice(start, [end])以數組的形式返回數組的一部分，注意不包括 end 對應的元素，若是省略 end 將複製 start 以後的全部元素

數組的拷貝

arrayObj.slice(0); //返回數組的拷貝數組，注意是一個新的數組，不是指向
arrayObj.concat(); //返回數組的拷貝數組，注意是一個新的數組，不是指向

數組元素的排序

arrayObj.reverse(); //反轉元素（最前的排到最後、最後的排到最前），返回數組地址
arrayObj.sort(); //對數組元素排序，返回數組地址

數組元素的字符串化

join()方法是一個很是實用的方法，它把當前Array的每一個元素都用指定的字符串鏈接起來，而後返回鏈接後的字符串：

arrayObj.join(separator); //返回字符串，這個字符串將數組的每個元素值鏈接在一塊兒，中間用 separator 隔開。
var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // 'A-B-C-1-2-3'

數組的查找

• indexOf()
• lastIndexOf()
• find()方法，用於找出第一個符合條件的數組成員

  find方法的回調函數能夠接受三個參數，依次爲當前的值、當前的位置和原數組。

[1, 5, 10, 15].find(function(value, index, arr) {
return value > 9;
}) // 10

• findIndex()返回第一個符合條件的數組成員的位置，若是全部成員都不符合條件，則返回-1。

[1, 5, 10, 15].findIndex(function(value, index, arr) {
return value > 9;
}) // 2

判斷是否爲數組

• typeof 操做符

var arr=new Array("1","2","3","4","5");
alert(typeof(arr));  // Object

• instanceof()運算符會返回一個 Boolean 值，指出對象是不是特定類的一個實例。

var arrayStr=new Array("1","2","3","4","5");
alert(arrayStr instanceof Array);  //true

• Array.isArray()用來判斷某個值是否爲數組。若是是，則返回 true，不然返回 false。

// 下面的函數調用都返回 true
Array.isArray([]);
Array.isArray([1]);
Array.isArray(new Array());
// 不爲人知的事實：其實 Array.prototype 也是一個數組。
Array.isArray(Array.prototype);

數組迭代

• filter()使用指定的函數測試全部元素，並建立一個包含全部經過測試的元素的新數組。

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

• forEach()讓數組的每一項都執行一次給定的函數。

function logArrayElements(element, index, array) {
  console.log("a[" + index + "] = " + element);
}
[2, 5, 9].forEach(logArrayElements);
// logs:
// a[0] = 2
// a[1] = 5
// a[2] = 9

• every()測試數組的全部元素是否都經過了指定函數的測試。

//檢測數組中的全部元素是否都大於 10
function isBigEnough(element, index, array) {
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

• map()返回一個由原數組中的每一個元素調用一個指定方法後的返回值組成的新數組。

const arr = [1,2,3]
arr.map((item,index) => {
console.log(item)
})

• some()測試數組中的某些元素是否經過了指定函數的測試。

//檢測在數組中是否有元素大於 10。
function isBigEnough(element, index, array) {
return (element >= 10);
}
var passed = [2, 5, 8, 1, 4].some(isBigEnough);
// passed is false
passed = [12, 5, 8, 1, 4].some(isBigEnough);
// passed is true

• reduce()接收一個函數做爲累加器（accumulator），數組中的每一個值（從左到右）開始縮減，最終爲一個值。

  語法: arr.reduce(callback,[initialValue]) callback:執行數組中每一個值的函數，包含四個參數

  • previousValue 上一次調用回調返回的值，或者是提供的初始值（initialValue）
  • currentValue 數組中當前被處理的元素
  • index 當前元素在數組中的索引
  • array 調用 reduce 的數組 initialValue: 做爲第一次調用 callback 的第一個參數。

var total = [0, 1, 2, 3].reduce(function(a, b) {
return a + b;
});
// total == 6

• Array.from()用於將兩類對象轉爲真正的數組：相似數組的對象（array-like object）和可遍歷（iterable）的對象（包括ES6新增的數據結構Set和Map）。

let arrayLike = {
'0': 'a',
'1': 'b',
'2': 'c',
length: 3
};

// ES6的寫法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

• Array.of()方法用於將一組值，轉換爲數組。

Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1

• fill()方法使用給定值，填充一個數組。

['a', 'b', 'c'].fill(7)
// [7, 7, 7]
new Array(3).fill(7)
// [7, 7, 7]

fill方法還能夠接受第二個和第三個參數，用於指定填充的起始位置和結束位置。

['a', 'b', 'c'].fill(7, 1, 2)
// ['a', 7, 'c']

遍歷數組

• ·keys()`是對鍵名的遍歷

for (let index of ['a', 'b'].keys()) {
console.log(index);
}
// 0
// 1

• values()是對鍵值的遍歷

for (let elem of ['a', 'b'].values()) {
  console.log(elem);
}
// 'a'
// 'b'

• entries()是對鍵值對的遍歷。

for (let [index, elem] of ['a', 'b'].entries()) {
  console.log(index, elem);
}
// 0 "a"
// 1 "b"

• includes()