迭代要领
1.every()
对数组中每一项举行给定函数，假如每一项都返回true，则返回true。
every(callback(element,index,array), thisArg)- callback:必须，对数组每一项所要实行的函数。
- thisArg:可选，划定callback回调函数this所指向的对象。
var numbers = [1,2,3,4,5,4,3,2,1];
var everyResult = numbers.every(function(item,index,array){
return item>2;
});
console.log(everyResult); //falsevar numbers = [1,2,3,4,5,4,3,2,1];
var obj = {num:2}
var everyResult = numbers.every(function(item,index,array){
return item>this.num;
},obj);
console.log(everyResult); //false迥殊申明：第一个参数是回调函数，第二个参数是一个对象，它可以重置回调函数中this的指向。那末，上述代码中回调函数的this就指向obj，因而this.num值即是2。
2.some()
对数组中每一项举行给定函数，假如恣意一项都返回true，则返回true
some(callback(element,index,array), thisArg)- callback:必须，对数组每一项所要实行的函数。
- thisArg:可选，划定callback回调函数this所指向的对象。
var numbers = [1,2,3,4,5,4,3,2,1];
var someResult = numbers.some(function(item,index,array){
return item>2;
});
console.log(someResult); //true
var numbers = [1,2,3,4,5,4,3,2,1];
var obj = {num:2}
var someResult = numbers.some(function(item,index,array){
return item>this.num;
},obj);
console.log(someResult); //true3.filter()
对数组中每一项举行给定函数,返回该函数会返回true的项组成新的数组。
filter(callback(element,index,array), thisArg)- callback:必须，对数组每一项所要实行的函数。
- thisArg:可选，划定callback回调函数this所指向的对象。
var numbers = [1,2,3,4,5,4,3,2,1];
var filterResult = numbers.filter(function(item,index,array){
return item>2;
});
console.log(filterResult); // [3,4,5,4,3]var numbers = [1,2,3,4,5,4,3,2,1];
var obj = {num:2}
var filterResult = numbers.filter(function(item,index,array){
return item>this.num;
},obj);
console.log(filterResult); // [3,4,5,4,3]4.map()
对数组中每一项举行给定函数,返回每次函数挪用的效果组成的新数组。
map(callback(element,index,array), thisArg)- callback:必须，对数组每一项所要实行的函数。
- thisArg:可选，划定callback回调函数this所指向的对象。
var numbers = [1,2,3,4,5,4,3,2,1];
var mapResult = numbers.map(function(item,index,array){
return item*2;
});
alert(mapResult); // [2, 4, 6, 8, 10, 8, 6, 4, 2]var numbers = [1,2,3,4,5,4,3,2,1];
var obj = {num:2}
var mapResult = numbers.map(function(item,index,array){
return item*this.num;
},obj);
alert(mapResult); // [2, 4, 6, 8, 10, 8, 6, 4, 2]5.forEach()
对数组中每一项举行给定函数,没有返回值，和for轮回相似。
forEach(callback(element,index,array), thisArg)- callback:必须，对数组每一项所要实行的函数。
- thisArg:可选，划定callback回调函数this所指向的对象。
var numbers = [1,2,3,4,5,4,3,2,1];
numbers.forEach(function(item,index,array){
console.log(item*2)
});
//2, 4, 6, 8, 10, 8, 6, 4, 2
console.log(numbers) //1,2,3,4,5,4,3,2,1var numbers = [1,2,3,4,5,4,3,2,1];
var obj = {num:2}
numbers.forEach(function(item,index,array){
console.log(item*this.num)
},obj);
//2, 4, 6, 8, 10, 8, 6, 4, 2合并要领
ES5新增了两个合并数组的要领：reduce(callback(prev,cur,index,array))和reduceRight(callback(prev,cur,index,array))。这两个要领迭代数组一切项，然后构建一个终究返回的值。reduce从左到右，reduceRight从右到左。
- prev:前一个值
- cur:当前值
- index:下标
- array:数组对象
var numbers = [1,2,3,4,5];
var sum = numbers.reduce(function(prev,cur,index,array){
return prev + cur;
});
console.log(sum); //15这个函数返回的任何值都邑作为第一个参数自动传给下一项。第一次迭代发生在第二项上，因而第一个参数是数组的第一项，第二个参数是数组的第二项。
检测数组
1.instanceof
ES3的要领
var numbers = [1,2,3];
if(numbers instanceof Array){
//对数组举行某些操纵
}2.Array.isArray
ES5的要领
var numbers = [1,2,3];
if(Array.isArray(numbers)){
//对数组举行某些操纵
}数组转化成字符串
1.toLocaleString() toString()
var numbers = [1,2,3];
console.log(numbers.toLocaleString()) //1,2,3
console.log(numbers.toString())//1,2,32.join()
将数组转换为字符串，且用分开符支解
var numbers = [1,2,3];
alert(numbers.join("|")); // 1|2|3栈要领
栈要领是指Last-In-First-Out后进先出
push() 从数组末端增加
pop() 从数组末端移除行列要领
行列要领是First-In-First-Out先进先出
shift() 从数组前端移除
unshift() 从数组前端增加重排序要领
1.reverse()
反转数组
var numbers = [1,2,3];
console.log(numbers.reverse()) //3,2,12.sort()
var numbers = [0,1,5,10,15];
numbers.sort(function(a,b){
return b-a;
});
console.log(numbers); //[15, 10, 5, 1, 0]操纵要领
1.concat()
用于复制或许从尾部增加，建立新数组。
concat(n1,n2,...,nN)- n1,n2,…,nN:都可选，既可以是数组，也可以是单个字符。
var numbers = [1,2,3];
var n1 = values.concat(); //复制
var n2 = values.concat(4); //尾部增加
var n3 = n1.concat(n2,10,11); //尾部增加
console.log(numbers); //[1,2,3]
console.log(n1); //[1,2,3]
console.log(n2); //[1,2,3,4]
console.log(n3); //[1, 2, 3, 1, 2, 3, 4,10,11]2.slice()
用于复制或截取数组，建立新数组。
slice(start,end)- strat:可选，数组实在位置，截取的时刻包含实在位置
- end:可选，完毕位置，截取的时刻不包含完毕位置
var numbers = [1,2,3];
var n1 = numbers.slice(); //复制
var n2 = numbers.slice(1); //截取
var n3 = numbers.slice(1,3); //截取
console.log(numbers); //[1,2,3]
console.log(n1); //[1,2,3]
console.log(n2); //[2,3]
console.log(n3); //[2,3]3.splice()
用于删除、插进去、替代，号称最壮大的数组要领
- 删除：可以删除恣意数目标项，须要两个参数，要删除的第一项的位置和要删除的项数
splice(start,num)
var values = [1,2,3,4,5,6];
var v = values.splice(0,2);
console.log(values); //[3,4,5,6]
console.log(v); //[1,2]- 插进去和替代：最少三个参数，第一个是肇端位置，第二个是要删除的项数，第三个及今后是要插进去或替代的值。
splice(start,num,n1,n2,...,nN)
//插进去demo
var values = [1,2,3,4,5,6];
var v1 = values.splice(1,0,1,1,1);
console.log(values); //[1,1,1,1,2,3,4,5,6]
console.log(v1); //[]
//替代demo
var values = [1,2,3,4,5,6];
var v1 = values.splice(1,2,1,1,1);
console.log(values); //[1,1,1,1,4,5,6]
console.log(v1); //[2,3]位置要领
indexOf(value,start)
lastIndexOf(value,start)都接收两个参数：查找的值、查找肇端位置。不存在，返回 -1 ；存在，返回位置。
indexOf 是夙昔今后查找， lastIndexOf 是从后往前查找。
var numbers = [1,2,3,4,5,6,7,8,9,5,3];
console.log(numbers.indexOf(5)) //4
console.log(numbers.lastIndexOf(5)) //9ES6新增新操纵数组的要领
1.find()
传入一个回调函数，找到数组中相符当前搜刮划定规矩的第一个元素，返回它，而且停止搜刮。
find(callback(element,index,array), thisArg)- callback：必须，回调函数，它制订了对数组元素的检索划定规矩。
- thisArg：可选，用来划定回调函数中this所指向的对象。
let arr = [2,3,4,5,6,7,8,9,10];
let elem=arr.find(function (ele) {
if (ele > 4) {
return true
}
})
console.log(elem); //5let arr = [2,3,4,5,6,7,8,9,10];
let obj = {num: 4};
let elem=arr.find(function (ele) {
if (ele > this.num) {
return true
}
},obj)
console.log(elem); //52.findIndex()
传入一个回调函数，找到数组中相符当前搜刮划定规矩的第一个元素，返回它的下标，停止搜刮。
findIndex(callback(element,index,array), thisArg)- callback：必须，回调函数，它制订了对数组元素的检索划定规矩。
- thisArg：可选，用来划定回调函数中this所指向的对象。
let arr = [2,3,4,5,6,7,8,9,10];
let elem=arr.findIndex(function (ele) {
if (ele > 4) {
return true
}
})
console.log(elem); //3let arr = [2,3,4,5,6,7,8,9,10];
let obj = {num: 4};
let elem=arr.findIndex(function (ele) {
if (ele > this.num) {
return true
}
},obj)
console.log(elem); //33.fill()
用新元素替代掉数组内的元素，可以指定替代下标局限。
fill(value,start,end)- value：必须，用来举行添补的值。
- start：可选，划定添补最先位置，默许从索引0处最先。
- end：可选，划定添补完毕位置，默许添补到数组末端。
const arr = ['a', 'b', 'c', 'd']
console.log(arr.fill('ss', 1, 3)) // ["a", "ss", "ss", "d"]
const arr2 = ['a', 'b', 'c', 'd']
console.log(arr.fill('ss')) // ["ss", "ss", "ss", "ss"]4.includes()
推断数组中是不是存在该元素，可以替代 ES5 时期的 indexOf 推断体式格局。
includes(value,start)- value：必须，要检测的元素。
- start：可选，划定添补最先位置，默许从索引0处最先。
let arr = ['a', 'b','c', 'd', NaN]
arr.includes('a') //true
arr.includes(NaN) //true
arr.indexOf(NaN) //-15.Array.from()
要领可以将指定的参数转换为真正的数组。固然并非恣意参数都是可以被转换为数组，可以转换的参数以下：类数组对象、具有遍历器接口的对象。
Array.from(arrayLike, mapFn, thisArg)- arrayLike：必须，将要被转换为真正数组的类数组或许具有遍历器接口的对象。
- mapFn：可选，对参数arrayLike中的数据举行处置惩罚并返回，作为新数组的元素。
- thisArg：可选，划定mapFn的挪用对象，那末mapFn中的this将会指向此挪用对象。
let obj = {
"0": "蚂蚁部落",
"1": "www.softwhy.com",
"2": 6,
"3":"ES2015",
length:4
};
console.log(Array.from(obj)); // ["蚂蚁部落", "www.softwhy.com", 6, "ES2015"]
obj = {
"a": "蚂蚁部落",
"b": "www.softwhy.com",
"c": 6,
"d":"ES2015",
length:4
};
console.log(Array.from(obj)); //[undefined, undefined, undefined, undefined]
obj = {
length:3
};
console.log(Array.from(obj)); //[undefined, undefined, undefined]上述代码将类数组对象转换为真正的数组，什么是类数组对象：许多材料上对类数组的形貌比较严苛，实在很简单，只需一个对象具有length属性就是类数组。固然一个类数组对象，假如属性正好相似于数组递增式索引，那就更好了，比方上面代码中的对象。上面对象只要一个length属性，他也是一个类数组对象，只不过天生的数组元素都是undefined。
let str = "蚂蚁部落";
console.log(Array.from(str)); // ["蚂", "蚁", "部", "落"]由于字符串具有遍历器接口，那末字符串也可以天生数组，数组的每个元素，就是组成字符串的字符。
let obj = {
"0": 1,
"1": 2,
"2": 3,
"3": 4,
length:4
};
let thisObj = {
num:2
}
console.log(Array.from(obj, function (elem, index) {
return elem * this.num
}, thisObj)); //[2, 4, 6, 8]扩大:睁开运算符天生数组
let str="蚂蚁部落";
console.log([...str]); //["蚂", "蚁", "部", "落"]6.Array.of()
Array.of(element0,element1,...,elementN)此要领可以接收恣意范例的参数，参数之间用逗号分开，而且可以将参数转换为数组。
console.log(Array.of(2)); //[2]
console.log(Array.of(2,3,4)); //[2,3,4]扩大：Array()与Array.of()要领区分
console.log(Array(2)) // [undefined, undefined]
console.log(Array.of(2)) // [2]
console.log(Array(2,3,4)) // [2,3,4]
console.log(Array.of(2,3,4)) // [2,3,4]这个要领的重要目标，是填补数组组织函数 Array() 的不足。
7.entries()
返回迭代器：返回一个遍历器对象【键值对】
//数组
const arr = ['a', 'b', 'c'];
for(let v of arr.entries()) {
console.log(v)
}
// [0, 'a'] [1, 'b'] [2, 'c']
for(let [key, value] of arr.entries()) {
console.log(key+'--'+value)
}
//0--a 1--b 2--c
//Set
const arr = new Set(['a', 'b', 'c']);
for(let v of arr.entries()) {
console.log(v)
}
// ['a', 'a'] ['b', 'b'] ['c', 'c']
//Map
const arr = new Map();
arr.set('a', 'a');
arr.set('b', 'b');
for(let v of arr.entries()) {
console.log(v)
}
// ['a', 'a'] ['b', 'b']8.keys()
返回迭代器：返回键值对的key
//数组
const arr = ['a', 'b', 'c'];
for(let v of arr.keys()) {
console.log(v)
}
// 0 1 2
//Set
const arr = new Set(['a', 'b', 'c']);
for(let v of arr.keys()) {
console.log(v)
}
// 'a' 'b' 'c'
//Map
const arr = new Map();
arr.set('a', 'a');
arr.set('b', 'b');
for(let v of arr.keys()) {
console.log(v)
}
// 'a' 'b'9.values()
返回迭代器：返回键值对的value
//数组
const arr = ['a', 'b', 'c'];
for(let v of arr.values()) {
console.log(v)
}
//'a' 'b' 'c'
//Set
const arr = new Set(['a', 'b', 'c']);
for(let v of arr.values()) {
console.log(v)
}
// 'a' 'b' 'c'
//Map
const arr = new Map();
arr.set('a', 'a');
arr.set('b', 'b');
for(let v of arr.values()) {
console.log(v)
}
