isArray()//判斷數(shù)組
concat()//合并數(shù)組、把對象合并為數(shù)組蝙叛、對象淺拷貝
slice()//提取原數(shù)組
join()//分割數(shù)組為字符串
reverse()//顛倒順序，改變原數(shù)組
--------------------------
push、pop堆棧方法
shift际起、unshift隊列方法：
splice各種改
//原數(shù)組改變
--------------------------
sort()排序
filter()過濾唇撬，返回新數(shù)組，不改變原數(shù)組
--------------------------
map返回新數(shù)組, 不改變原數(shù)組
forEach ,用于操作數(shù)據(jù),不返回新數(shù)組烧给，不改變原數(shù)組
//遍歷
-------------------------
some() 類似或
every() 類似與
//群體判斷
-------------------------
reduce(), reduceRight()
//累計方法
-------------------------
indexOf(), lastIndexOf()
//value搜尋酝惧，一前一后

判斷數(shù)組 Array.isArray()

Array.isArray方法用來判斷一個值是否為數(shù)組返回布爾值，比typeof好用

var arr = [1,2,3]
typeof arr //object
Array.isArray(arr) // true

Array的實例方法

valueOf(), toString()

valueOf方法返回數(shù)組本身

var arr = [1,2,3]
arr.valueOf() // [1,2,3]

`toString方法把數(shù)組轉(zhuǎn)化為字符串

var a = [1, 2, 3];
a.toString() // "1,2,3"
var a = [1, 2, 3, [4, 5, 6]];
a.toString() // "1,2,3,4,5,6"

push()

改變原數(shù)組
push方法用于在數(shù)組的末端添加一個或多個元素悍及，并返回添加新元素后的數(shù)組

var arr = [];
arr .push(1); // 1
arr .push('a'); // 2
arr .push(true, {}) // 4
arr // [1, 'a', true, Object]

如何合并兩個數(shù)組

var a = [1, 2, 3];
var b = [4, 5, 6];
Array.prototype.push.apply(a,b);
// 或者
[].push.apply(a,b)
// 上面兩種寫法等同于
a.push(4, 5, 6)
a // [1, 2, 3, 4, 5, 6]

這兩個都具有push，從這里我們也可以看出一點(diǎn)原型的知識

Array.prototype.push
[].push

注意：直接使用使用push或call而不用apply也出現(xiàn)如圖中的錯誤届谈。
fun.apply(thisArg[, argsArray])
fun.call(thisArg[, arg1[, arg2[, ...]]])

pop()

改變原數(shù)組
pop方法用于刪除數(shù)組的最后一個元素曙搬，并返回該元素。

var arr = [1,2,3]
arr.pop() //3
arr // [1,2]

對空數(shù)組使用pop方法橡娄，不會報錯，而是返回undefined匠童。

[].pop() // undefined

join()

join方法以參數(shù)作為分隔符，將所有數(shù)組成員組成一個字符串返回。如果不提供參數(shù)勒奇，默認(rèn)用逗號分隔。

var a = [1, 2, 3, 4];
a.join(' ') // '1 2 3 4'
a.join(' | ') // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"

如果數(shù)組成員是undefined或null或空位，會被轉(zhuǎn)成空字符串痘括。

[undefined, null].join('#')
// '#'
['a',, 'b'].join('-')
// 'a--b'

通過call方法疮绷，這個方法也可以用于字符串椅贱。

Array.prototype.join.call('hello', '-')
// "h-e-l-l-o"
[].join.call('world','+')
// "w+o+r+l+d"

join方法也可以用于類似數(shù)組的對象喜德。

var obj = { 0: 'a', 1: 'b', length: 2 };
Array.prototype.join.call(obj, '-')
// 'a-b'

必須加上length屬性

var obj = { 0: 'a', 1: 'b'};
Array.prototype.join.call(obj, '-')
""

concat()

concat方法用于多個數(shù)組的合并。它將新數(shù)組的成員丧诺，添加到原數(shù)組的尾部，然后返回一個新數(shù)組呵晚，原數(shù)組不變。

['hello'].concat(['world'])
// ["hello", "world"]
['hello'].concat(['world'], ['!'])
// ["hello", "world", "!"]

除了接受數(shù)組作為參數(shù)，concat也可以接受其他類型的值作為參數(shù)。它們會作為新的元素饼酿，添加數(shù)組尾部紊婉。

[1, 2, 3].concat(4, 5, '6')
// [1, 2, 3, 4, 5, "6"]
[1, 2, 3].concat({a:1})
[1, 2, 3, {a:1}]

如果不提供參數(shù)，concat方法返回當(dāng)前數(shù)組的一個淺拷貝筐乳。所謂“淺拷貝”路召，指的是如果數(shù)組成員包括復(fù)合類型的值（比如對象）廷区，則新數(shù)組拷貝的是該值的引用。

var obj = { a:1 };
var oldArray = [obj];
var newArray = oldArray.concat();
obj.a = 2;
newArray[0].a // 2 淺拷貝并沒有生成新的對象

concat()方法也可以用于將對象合并為數(shù)組，但是必須借助call方法。

[].concat.call({a: 1}, {b: 2})
// [{ a: 1 }, { b: 2 }]
[].concat.call({a: 1}, [2])
// [{a: 1}, 2]
[2].concat({a: 1})
// [2, {a: 1}]

shift()

改變原數(shù)組
shift()方法用于刪除數(shù)組的第一個元素秤标，并返回該元素。

var a = ['a', 'b', 'c'];
a.shift() // 'a'
a // ['b', 'c'

unshift()

改變原數(shù)組
unshift()方法用于在數(shù)組的第一個位置添加元素布近，并返回添加新元素后的數(shù)組長度。

var a = ['a', 'b', 'c'];
a.unshift('x'); // 4
a // ['x', 'a', 'b', 'c']

unshift()方法可以在數(shù)組頭部添加多個元素。push()也可以添加多個

var arr = [ 'c', 'd' ];
arr.unshift('a', 'b') // 4
arr // [ 'a', 'b', 'c', 'd' ]

reverse()

改變原數(shù)組
reverse()方法用于顛倒數(shù)組中元素的順序，返回改變后的數(shù)組父叙。注意甜癞，該方法將改變原數(shù)組烤惊。

var a = ['a', 'b', 'c'];
a.reverse() // ["c", "b", "a"]
a // ["c", "b", "a"]

slice()

slice()方法用于提取原數(shù)組的一部分，返回一個新數(shù)組柒室，原數(shù)組不變渡贾。
它的第一個參數(shù)為起始位置（從0開始），第二個參數(shù)為終止位置（但該位置的元素本身不包括在內(nèi)）雄右。如果省略第二個參數(shù)空骚，則一直返回到原數(shù)組的最后一個成員肋坚。

// 格式
arr.slice(start_index, upto_index);
// 用法
var a = ['a', 'b', 'c'];
a.slice(0) // ["a", "b", "c"]
a.slice(1) // ["b", "c"]
a.slice(1, 2) // ["b"]
a.slice(2, 6) // ["c"]
a.slice() // ["a", "b", "c"]

上面代碼中，最后一個例子slice沒有參數(shù)辫愉，實際上等于返回一個原數(shù)組的拷貝膀值。

如果slice方法的參數(shù)是負(fù)數(shù)，則表示倒數(shù)計算的位置未舟。

var a = ['a', 'b', 'c'];
a.slice(-2) // ["b", "c"]
a.slice(-2, -1) // ["b"]

splice()

改變原數(shù)組
splice()方法用于刪除原數(shù)組的一部分成員野揪，并可以在被刪除的位置添加入新的數(shù)組成員，返回值是被刪除的元素。
第一個參數(shù)是刪除的起始位置透乾，第二個參數(shù)是被刪除的元素個數(shù)搜变。如果后面還有更多的參數(shù)茉唉，則表示這些就是要被插入數(shù)組的新元素缚忧。

// 格式
arr.splice(index, count_to_remove, addElement1, addElement2, ...);
// 用法
var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(4, 2) // ["e", "f"]
a // ["a", "b", "c", "d"]

上面代碼從原數(shù)組4號位置始腾，刪除了兩個數(shù)組成員。

var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(4, 2, 1, 2) // ["e", "f"]
a // ["a", "b", "c", "d", 1, 2]

上面代碼除了刪除成員冕屯，還插入了兩個新成員财边。

起始位置如果是負(fù)數(shù)鸣皂，就表示從倒數(shù)位置開始刪除

var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(-4, 2) // ["c", "d"]

上面代碼表示，從倒數(shù)第四個位置c開始刪除兩個成員。

如果只是單純地插入元素，splice方法的第二個參數(shù)可以設(shè)為0祭陷。

var a = [1, 1, 1];
a.splice(1, 0, 2) // []
a // [1, 2, 1, 1]

sort()

sort()方法對數(shù)組成員進(jìn)行排序按价，默認(rèn)是按照字典順序排序惭适。排序后，原數(shù)組將被改變楼镐。

['d', 'c', 'b', 'a'].sort()
// ['a', 'b', 'c', 'd']
[4, 3, 2, 1].sort()
// [1, 2, 3, 4]
[11, 101].sort()
// [101, 11]
[10111, 1101, 111].sort()
// [10111, 1101, 111]

上面代碼的最后兩個例子癞志，需要特殊注意。sort方法不是按照大小排序框产，而是按照對應(yīng)字符串的字典順序排序凄杯。也就是說，數(shù)值會被先轉(zhuǎn)成字符串秉宿，再按照字典順序進(jìn)行比較戒突，所以101排在11的前面。

如果想讓sort方法按照自定義方式排序描睦，可以傳入一個函數(shù)作為參數(shù)膊存，表示按照自定義方法進(jìn)行排序。該函數(shù)本身又接受兩個參數(shù)忱叭，表示進(jìn)行比較的兩個元素隔崎。如果返回值大于0，表示第一個元素排在第二個元素后面窑多；其他情況下仍稀，都是第一個元素排在第二個元素前面。

[10111, 1101, 111].sort(function (a, b) {
 return a - b;
})
// [111, 1101, 10111]
[
 { name: "張三", age: 30 },
 { name: "李四", age: 24 },
 { name: "王五", age: 28 }
].sort(function (o1, o2) {
 return o1.age - o2.age;
})
// [
// { name: "李四", age: 24 },
// { name: "王五", age: 28 },
// { name: "張三", age: 30 }
// ]

map()

map()方法對數(shù)組的所有成員依次調(diào)用一個函數(shù)埂息，根據(jù)函數(shù)結(jié)果返回一個新數(shù)組。

var numbers = [1, 2, 3];
var arr = numbers.map(function (n) {
 return n + 1;
});
numbers
// [1, 2, 3] 原數(shù)組并沒有改變
arr
//[2, 3, 4]

map方法接受一個函數(shù)作為參數(shù)遥巴。該函數(shù)調(diào)用時千康，map方法會將其傳入三個參數(shù)，分別是當(dāng)前成員铲掐、當(dāng)前位置和數(shù)組本身拾弃。

[1, 2, 3].map(function(elem, index, arr) {
 return elem * index;
});
// [0, 2, 6]

上面代碼中，map方法的回調(diào)函數(shù)的三個參數(shù)之中摆霉，elem為當(dāng)前成員的值豪椿，index為當(dāng)前成員的位置奔坟，arr為原數(shù)組（[1, 2, 3]）
map方法不僅可以用于數(shù)組，還可以用于字符串搭盾，用來遍歷字符串的每個字符咳秉。但是，不能直接使用鸯隅，而要通過函數(shù)的call方法間接使用澜建，或者先將字符串轉(zhuǎn)為數(shù)組，然后使用蝌以。

[].map.call('abc', n => n.toUpperCase())
//["A", "B", "C"]
'abc'.split('').map(n => n.toUpperCase())
//["A", "B", "C"]

map方法還可以接受第二個參數(shù)炕舵，表示回調(diào)函數(shù)執(zhí)行時this所指向的對象。

var arr = ['a', 'b', 'c'];
[1, 2].map(function(e){
 return this[e];
}, arr)
// ['b', 'c']

參數(shù)e為傳入的索引跟畅，this為arr

上面代碼通過map方法的第二個參數(shù)咽筋，將回調(diào)函數(shù)內(nèi)部的this對象，指向arr數(shù)組徊件。

forEach()

forEach方法與map方法很相似晤硕，也是遍歷數(shù)組的所有成員，執(zhí)行某種操作庇忌，但是forEach方法一般不返回值舞箍，只用來操作數(shù)據(jù)。如果需要有返回值皆疹，一般使用map方法疏橄。

forEach方法的參數(shù)與map方法一致，也是一個函數(shù)略就，數(shù)組的所有成員會依次執(zhí)行該函數(shù)捎迫。它接受三個參數(shù)，分別是當(dāng)前位置的值表牢、當(dāng)前位置的編號和整個數(shù)組窄绒。

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

forEach方法也可以接受第二個參數(shù)，用來綁定回調(diào)函數(shù)的this關(guān)鍵字崔兴。

var out = [];
[1, 2, 3].forEach(function(elem) {
 this.push(elem * elem);
}, out);
out // [1, 4, 9] this指向了out

上面代碼中彰导，空數(shù)組out是forEach方法的第二個參數(shù)，結(jié)果敲茄，回調(diào)函數(shù)內(nèi)部的this關(guān)鍵字就指向out位谋。這個參數(shù)對于多層this非常有用，因為多層this通常指向是不一致的堰燎。

var obj = {
 name: '張三',
 times: [1, 2, 3],
 print: function () {
 this.times.forEach(function (n) {
 console.log(this.name);
 });
 }
};
obj.print()
// 沒有任何輸出

上面代碼中掏父，obj.print方法有兩層this，它們的指向是不一致的秆剪。外層的this.times指向obj對象赊淑，內(nèi)層的this.name指向頂層對象window爵政。這顯然是違背原意的，解決方法就是使用forEach方法的第二個參數(shù)固定this陶缺。

var obj = {
 name: '張三',
 times: [1, 2, 3],
 print: function () {
 this.times.forEach(function (n) {
 console.log(this.name);
 }, this);
 }
};
obj.print()
// 張三
// 張三
// 張三

forEach方法會跳過數(shù)組的空位钾挟。

var log = function (n) {
 console.log(n + 1);
};
[1, undefined, 2].forEach(log)
// 2
// NaN
// 3
[1, null, 2].forEach(log)
// 2
// 1
// 3
[1, , 2].forEach(log)
// 2
// 3

上面代碼中，forEach方法不會跳過undefined和null组哩，但會跳過空位等龙。
forEach方法也可以用于類似數(shù)組的對象和字符串。

var obj = {
 0: 1,
 a: 'hello',
 length: 1
}
Array.prototype.forEach.call(obj, function (elem, i) {
 console.log( i + ':' + elem);
});
// 0:1
var str = 'hello';
Array.prototype.forEach.call(str, function (elem, i) {
 console.log( i + ':' + elem);
});
// 0:h
// 1:e
// 2:l
// 3:l
// 4:o

filter()

filter方法的參數(shù)是一個函數(shù)伶贰，所有數(shù)組成員依次執(zhí)行該函數(shù)蛛砰，返回結(jié)果為true的成員組成一個新數(shù)組返回。該方法不會改變原數(shù)組黍衙。

[1, 2, 3, 4, 5].filter(function (elem) {
 return (elem > 3);
})
// [4, 5]

上面代碼將大于3的原數(shù)組成員泥畅，作為一個新數(shù)組返回。

再看一個例子琅翻。

var arr = [0, 1, 'a', false];
arr.filter(Boolean)
// [1, "a"]

上面例子中位仁，通過filter方法，返回數(shù)組arr里面所有布爾值為true的成員方椎。

filter方法的參數(shù)函數(shù)可以接受三個參數(shù)聂抢，第一個參數(shù)是當(dāng)前數(shù)組成員的值，這是必需的棠众，后兩個參數(shù)是可選的琳疏，分別是當(dāng)前數(shù)組成員的位置和整個數(shù)組。

[1, 2, 3, 4, 5].filter(function (elem, index, arr) {
 return index % 2 === 0;
});
// [1, 3, 5]

filter方法還可以接受第二個參數(shù)闸拿，指定測試函數(shù)所在的上下文對象（即this對象）空盼。

var Obj = function () {
 this.MAX = 3;
};
var arr = [2, 8, 3, 4, 1, 3, 2, 9];
arr.filter(function (item) {
 if (item > this.MAX) {
 return true;
 }
}, new Obj())
//[8, 4, 9]

var Obj = function () {
 this.MAX = 3;
};
var myFilter = function (item) {
 if (item > this.MAX) {
 return true;
 }
};
var arr = [2, 8, 3, 4, 1, 3, 2, 9];
arr.filter(myFilter, new Obj())
// [8, 4, 9]

上面代碼中，測試函數(shù)myFilter內(nèi)部有this對象新荤，它可以被filter方法的第二個參數(shù)綁定揽趾。上例中，myFilter的this綁定了Obj對象的實例苛骨，返回大于3的成員篱瞎。

some(), every()

這兩個方法類似“斷言”（assert），用來判斷數(shù)組成員是否符合某種條件智袭。

它們接受一個函數(shù)作為參數(shù)奔缠，所有數(shù)組成員依次執(zhí)行該函數(shù)，返回一個布爾值吼野。該函數(shù)接受三個參數(shù)，依次是當(dāng)前位置的成員两波、當(dāng)前位置的序號和整個數(shù)組瞳步。

some方法是只要有一個數(shù)組成員的返回值是true闷哆，則整個some方法的返回值就是true，否則false单起。

var arr = [1, 2, 3, 4, 5];
arr.some(function (elem, index, arr) {
 return elem >= 3;
});
// true

上面代碼表示抱怔，如果存在大于等于3的數(shù)組成員，就返回true嘀倒。
every方法則是所有數(shù)組成員的返回值都是true屈留，才返回true，否則false测蘑。

var arr = [1, 2, 3, 4, 5];
arr.every(function (elem, index, arr) {
 return elem >= 3;
});
// false

上面代碼表示灌危，只有所有數(shù)組成員大于等于3，才返回true碳胳。

注意勇蝙，對于空數(shù)組，some方法返回false挨约，every方法返回true味混，回調(diào)函數(shù)都不會執(zhí)行。

function isEven(x) { return x % 2 === 0 }
[].some(isEven) // false
[].every(isEven) // true

some和every方法還可以接受第二個參數(shù)诫惭，用來綁定函數(shù)中的this關(guān)鍵字翁锡。

reduce(), reduceRight()

reduce方法和reduceRight方法依次處理數(shù)組的每個成員，最終累計為一個值夕土。

它們的差別是馆衔，reduce是從左到右處理（從第一個成員到最后一個成員），reduceRight則是從右到左（從最后一個成員到第一個成員）隘弊，其他完全一樣哈踱。

這兩個方法的第一個參數(shù)都是一個函數(shù)。該函數(shù)接受以下四個參數(shù)梨熙。

累積變量开镣，默認(rèn)為數(shù)組的第一個成員
當(dāng)前變量，默認(rèn)為數(shù)組的第二個成員
當(dāng)前位置（從0開始）
原數(shù)組
這四個參數(shù)之中咽扇，只有前兩個是必須的邪财，后兩個則是可選的。

[1, 2, 3, 4, 5].reduce(function(x, y){
 console.log(x, y)
 return x + y;
});
// 1 2
// 3 3
// 6 4
// 10 5
//最后結(jié)果：15

上面代碼中质欲，第一輪執(zhí)行树埠，x是數(shù)組的第一個成員，y是數(shù)組的第二個成員嘶伟。從第二輪開始怎憋，x為上一輪的返回值，y為當(dāng)前數(shù)組成員，直到遍歷完所有成員绊袋，返回最后一輪計算后的x毕匀。

如果要對累積變量指定初值，可以把它放在reduce方法和reduceRight方法的第二個參數(shù)癌别。

[1, 2, 3, 4, 5].reduce(function(x, y){
 return x + y;
}, 10);
// 25

上面代碼指定參數(shù)x的初值為10皂岔，所以數(shù)組從10開始累加，最終結(jié)果為25展姐。注意躁垛，這時y是從數(shù)組的第一個成員開始遍歷。

function substract(prev, cur) {
 return prev - cur;
}
[3, 2, 1].reduce(substract) // 0
[3, 2, 1].reduceRight(substract) // -4

上面代碼中圾笨，reduce方法相當(dāng)于3減去2再減去1教馆，reduceRight方法相當(dāng)于1減去2再減去3

indexOf(), lastIndexOf()

indexOf方法返回給定元素在數(shù)組中第一次出現(xiàn)的位置，如果沒有出現(xiàn)則返回-1墅拭。

var a = ['a', 'b', 'c'];
a.indexOf('b') // 1
a.indexOf('y') // -1

indexOf方法還可以接受第二個參數(shù)活玲，表示搜索的開始位置。

['a', 'b', 'c'].indexOf('a', 1) // -1

lastIndexOf方法返回給定元素在數(shù)組中最后一次出現(xiàn)的位置谍婉，如果沒有出現(xiàn)則返回-1舒憾。

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

注意，如果數(shù)組中包含NaN穗熬，這兩個方法不適用镀迂，即無法確定數(shù)組成員是否包含NaN。

[NaN].indexOf(NaN) // -1
[NaN].lastIndexOf(NaN) // -1

這是因為這兩個方法內(nèi)部唤蔗，使用嚴(yán)格相等運(yùn)算符（===）進(jìn)行比較探遵，而NaN是唯一一個不等于自身的值。
參考數(shù)組Array標(biāo)準(zhǔn)