**9改变8不变12遍历**
## 改变原数组的方法(9个):
```
let a = [1,2,3];
```
### ES5:
a.pop()/ a.shift()/ a.push()/ a.unshift()/ a.reverse()/ a.splice()/ a.sort()
## ES6:
a.copyWithin() / a.fill
## 不改变原数组的方法(8个):
### ES5：
join、toLocateString、toStrigin、slice、cancat、indexOf、lastIndexOf、
### ES7：
includes
## 遍历方法(12个):
### ES5：
forEach、every 、some、 fliter、map、reduce、reduceRight、
###
ES6：
find、findIndex、keys、values、entries
# 各方法详解
## 改变原数组的方法(9个):
let a = [1,2,3];
ES5:
a.pop()/ a.shift()/ a.push()/ a.unshift()/ a.reverse()/ a.splice()/ a.sort()
ES6:
a.copyWithin() / a.fill
对于这些能够改变原数组的方法，要注意避免在循环遍历中改变原数组的选项，比如: 改变数组的长度，导致遍历的长度出现问题。
pop() 删除一个数组中的最后的一个元素
定义: pop() 方法删除一个数组中的最后的一个元素，并且返回这个元素。
参数: 无。
```
let a = [1,2,3];
let item = a.pop(); // 3
console.log(a); // [1,2]
```
shift() 删除数组的第一个元素
定义: shift()方法删除数组的第一个元素，并返回这个元素。
参数: 无。
```
let a = [1,2,3];
let item = a.shift(); // 1
console.log(a); // [2,3]
```
push() 向数组的末尾添加元素
定义：push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。
参数: item1, item2, …, itemX ,要添加到数组末尾的元素
```
let a = [1,2,3];
let item = a.push('末尾'); // 4
console.log(a); // [1,2,3,'末尾']
```
unshift()
定义：unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
参数: item1, item2, …, itemX ,要添加到数组开头的元素
```
let a = [1,2,3];
let item = a.unshift('开头'); // 4
console.log(a); // ['开头',1,2,3]
```
reverse() 颠倒数组中元素的顺序
定义: reverse() 方法用于颠倒数组中元素的顺序。
参数: 无
let a = [1,2,3];
a.reverse();
console.log(a); // [3,2,1]
splice() 添加/删除数组元素
定义： splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目
语法： array.splice(index,howmany,item1,.....,itemX)
参数:
index：必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
howmany：必需。要删除的项目数量。如果设置为 0，则不会删除项目。
item1, …, itemX： 可选。向数组添加的新项目。
返回值: 如果有元素被删除,返回包含被删除项目的新数组。
```
let a = [1, 2, 3, 4, 5, 6, 7];
let item = a.splice(0, 3); // [1,2,3]
console.log(a); // [4,5,6,7]
// 从数组下标0开始，删除3个元素
let item = a.splice(-1, 3); // [7]
```
// 从最后一个元素开始删除3个元素，因为最后一个元素，所以只删除了7
eg2: 删除并添加
```
let a = [1, 2, 3, 4, 5, 6, 7];
let item = a.splice(0,3,'添加'); // [1,2,3]
console.log(a); // ['添加',4,5,6,7]
// 从数组下标0开始，删除3个元素，并添加元素'添加'
let b = [1, 2, 3, 4, 5, 6, 7];
let item = b.splice(-2,3,'添加1','添加2'); // [6,7]
console.log(b); // [1,2,3,4,5,'添加1','添加2']
```
// 从数组最后第二个元素开始，删除3个元素，并添加两个元素'添加1'、'添加2'
eg3: 不删除只添加:
```
let a = [1, 2, 3, 4, 5, 6, 7];
let item = a.splice(0,0,'添加1','添加2'); // [] 没有删除元素，返回空数组
console.log(a); // ['添加1','添加2',1,2,3,4,5,6,7]
let b = [1, 2, 3, 4, 5, 6, 7];
let item = b.splice(-1,0,'添加1','添加2'); // [] 没有删除元素，返回空数组
console.log(b); // [1,2,3,4,5,6,'添加1','添加2',7] 在最后一个元素的前面添加两个元素
```
从上述三个栗子可以得出:
数组如果元素不够，会删除到最后一个元素为止
操作的元素，包括开始的那个元素
可以添加很多个元素
添加是在开始的元素前面添加的
sort() 数组排序
定义: sort()方法对数组元素进行排序，并返回这个数组。
参数可选: 规定排序顺序的比较函数。
默认情况下sort()方法没有传比较函数的话，默认按字母升序，如果不是元素不是字符串的话，会调用toString()方法将元素转化为字符串的Unicode(万国码)位点，然后再比较字符。
// 字符串排列 看起来很正常
```
var a = ["Banana", "Orange", "Apple", "Mango"];
a.sort(); // ["Apple","Banana","Mango","Orange"]
```
// 数字排序的时候 因为转换成Unicode字符串之后，有些数字会比较大会排在后面 这显然不是我们想要的
```
var a = [10, 1, 3, 20,25,8];
console.log(a.sort()) // [1,10,20,25,3,8];
```
比较函数的两个参数：
sort的比较函数有两个默认参数，要在函数中接收这两个参数，这两个参数是数组中两个要比较的元素，通常我们用 a 和 b 接收两个将要比较的元素：
若比较函数返回值<0，那么a将排到b的前面;
若比较函数返回值=0，那么a 和 b 相对位置不变；
若比较函数返回值>0，那么b 排在a 将的前面；
对于sort()方法更深层级的内部实现以及处理机制可以看一下这篇文章深入了解javascript的sort方法
sort排序常见用法：
1、数组元素为数字的升序、降序:
```
var array = [10, 1, 3, 4,20,4,25,8];
// 升序 a-b < 0 a将排到b的前面，按照a的大小来排序的
// 比如被减数a是10，减数是20 10-20 < 0 被减数a(10)在减数b(20)前面
array.sort(function(a,b){
return a-b;
});
console.log(array); // [1,3,4,4,8,10,20,25];
// 降序 被减数和减数调换了 20-10>0 被减数b(20)在减数a(10)的前面
array.sort(function(a,b){
return b-a;
});
console.log(array); // [25,20,10,8,4,4,3,1];
```
2、数组多条件排序
```
var array = [{id:10,age:2},{id:5,age:4},{id:6,age:10},{id:9,age:6},{id:2,age:8},{id:10,age:9}];
array.sort(function(a,b){
if(a.id === b.id){// 如果id的值相等，按照age的值降序
return b.age - a.age
}else{ // 如果id的值不相等，按照id的值升序
return a.id - b.id
}
})
// [{"id":2,"age":8},{"id":5,"age":4},{"id":6,"age":10},{"id":9,"age":6},{"id":10,"age":9},{"id":10,"age":2}]
```
3、自定义比较函数，天空才是你的极限
类似的：运用好返回值，我们可以写出任意符合自己需求的比较函数
```
var array = [{name:'Koro1'},{name:'Koro1'},{name:'OB'},{name:'Koro1'},{name:'OB'},{name:'OB'}];
array.sort(function(a,b){
if(a.name === 'Koro1'){// 如果name是'Koro1' 返回-1 ，-1<0 a排在b的前面
return -1
}else{ // 如果不是的话，a排在b的后面
return 1
}
})
// [{"name":"Koro1"},{"name":"Koro1"},{"name":"Koro1"},{"name":"OB"},{"name":"OB"},{"name":"OB"}]
```
ES6: copyWithin() 指定位置的成员复制到其他位置
定义: 在当前数组内部，将指定位置的成员复制到其他位置,并返回这个数组。
语法:
```
array.copyWithin(target, start = 0, end = this.length)
```
参数:
三个参数都是数值，如果不是，会自动转为数值.
target（必需）：从该位置开始替换数据。如果为负值，表示倒数。
start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示倒数。
end（可选）：到该位置前停止读取数据，默认等于数组长度。使用负数可从数组结尾处规定位置。
浏览器兼容(MDN): chrome 45,Edge 12,Firefox32,Opera 32,Safari 9, IE 不支持
```
// -2相当于3号位，-1相当于4号位
[1, 2, 3, 4, 5].copyWithin(0, -2, -1)
// [4, 2, 3, 4, 5]
var a=['OB1','Koro1','OB2','Koro2','OB3','Koro3','OB4','Koro4','OB5','Koro5']
// 2位置开始被替换,3位置开始读取要替换的 5位置前面停止替换
a.copyWithin(2,3,5)
// ["OB1","Koro1","Koro2","OB3","OB3","Koro3","OB4","Koro4","OB5","Koro5"]
```
从上述栗子:
第一个参数是开始被替换的元素位置
要替换数据的位置范围:从第二个参数是开始读取的元素，在第三个参数前面一个元素停止读取
数组的长度不会改变
读了几个元素就从开始被替换的地方替换几个元素
ES6: fill() 填充数组
定义: 使用给定值，填充一个数组。
参数:
第一个元素(必须): 要填充数组的值
第二个元素(可选): 填充的开始位置,默认值为0
第三个元素(可选)：填充的结束位置，默认是为this.length
```
['a', 'b', 'c'].fill(7)
// [7, 7, 7]
['a', 'b', 'c'].fill(7, 1, 2)
// ['a', 7, 'c']
```
# 不改变原数组的方法(8个):
ES5：
join、toLocateString、toStrigin、slice、cancat、indexOf、lastIndexOf、
ES7：
includes
join() 数组转字符串
定义: join() 方法用于把数组中的所有元素通过指定的分隔符进行分隔放入一个字符串，返回生成的字符串。
语法:
```
array.join(str)
```
参数:
str(可选): 指定要使用的分隔符，默认使用逗号作为分隔符。
```
let a= ['hello','world'];
let str=a.join(); // 'hello,world'
let str2=a.join('+'); // 'hello+world'
```
使用join方法或者下文说到的toString方法时，当数组中的元素也是数组或者是对象时会出现什么情况？
```
let a= [['OBKoro1','23'],'test'];
let str1=a.join(); // OBKoro1,23,test
let b= [{name:'OBKoro1',age:'23'},'test'];
let str2 = b.join(); // [object Object],test
// 对象转字符串推荐JSON.stringify(obj);
```
所以，join()/toString()方法在数组元素是数组的时候，会将里面的数组也调用join()/toString(),如果是对象的话，对象会被转为[object Object]字符串。
toLocaleString() 数组转字符串
定义: 返回一个表示数组元素的字符串。该字符串由数组中的每个元素的 toLocaleString() 返回值经调用 join() 方法连接（由逗号隔开）组成。
语法:
array.toLocaleString()
参数：无。
```
let a=[{name:'OBKoro1'},23,'abcd',new Date()];
let str=a.toLocaleString(); // [object Object],23,abcd,2018/5/28 下午1:52:20
```
如上述栗子：调用数组的toLocaleString方法，数组中的每个元素都会调用自身的toLocaleString方法，对象调用对象的toLocaleString,Date调用Date的toLocaleString。
toString() 数组转字符串 不推荐
定义: toString() 方法可把数组转换为由逗号链接起来的字符串。
语法:
array.toString()
参数: 无。
该方法的效果和join方法一样，都是用于数组转字符串的，但是与join方法相比没有优势，也不能自定义字符串的分隔符，因此不推荐使用。
值得注意的是：当数组和字符串操作的时候，js 会调用这个方法将数组自动转换成字符串
```
let b= [ 'toString','演示'].toString(); // toString,演示
let a= ['调用toString','连接在我后面']+'啦啦啦'; // 调用toString,连接在我后面啦啦啦
```
slice() 浅拷贝数组的元素
定义： 方法返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象，且原数组不会被修改。
注意：字符串也有一个slice() 方法是用来提取字符串的，不要弄混了。
语法:
```
array.slice(begin, end);
```
参数:
begin(可选): 索引数值,接受负值，从该索引处开始提取原数组中的元素,默认值为0。
end(可选):索引数值(不包括),接受负值，在该索引处前结束提取原数组元素，默认值为数组末尾(包括最后一个元素)。
```
let a= ['hello','world'];
let b=a.slice(0,1); // ['hello']
a[0]='改变原数组';
console.log(a,b); // ['改变原数组','world'] ['hello']
b[0]='改变拷贝的数组';
console.log(a,b); // ['改变原数组','world'] ['改变拷贝的数组']
```
如上：新数组是浅拷贝的，元素是简单数据类型，改变之后不会互相干扰。
如果是复杂数据类型(对象,数组)的话，改变其中一个，另外一个也会改变。
```
let a= [{name:'OBKoro1'}];
let b=a.slice();
console.log(b,a); // [{"name":"OBKoro1"}] [{"name":"OBKoro1"}]
// a[0].name='改变原数组';
// console.log(b,a); // [{"name":"改变原数组"}] [{"name":"改变原数组"}]
// b[0].name='改变拷贝数组',b[0].koro='改变拷贝数组';
// [{"name":"改变拷贝数组","koro":"改变拷贝数组"}] [{"name":"改变拷贝数组","koro":"改变拷贝数组"}]
```
原因在定义上面说过了的：slice()是浅拷贝，对于复杂的数据类型浅拷贝，拷贝的只是指向原数组的指针，所以无论改变原数组，还是浅拷贝的数组，都是改变原数组的数据。
cancat
定义： 方法用于合并两个或多个数组，返回一个新数组。
语法：
```
var newArr =oldArray.concat(arrayX,arrayX,......,arrayX)
```
参数：
arrayX（必须）：该参数可以是具体的值，也可以是数组对象。可以是任意多个。
```
let a = [1, 2, 3];
let b = [4, 5, 6];
//连接两个数组
let newVal=a.concat(b); // [1,2,3,4,5,6]
// 连接三个数组
let c = [7, 8, 9]
let newVal2 = a.concat(b, c); // [1,2,3,4,5,6,7,8,9]
```
// 添加元素
let newVal3 = a.concat('添加元素',b, c,'再加一个');
// [1,2,3,"添加元素",4,5,6,7,8,9,"再加一个"]
// 合并嵌套数组 会浅拷贝嵌套数组
```
let d = [1,2 ];
let f = [3,[4]];
let newVal4 = d.concat(f); // [1,2,3,[4]]
```
ES6扩展运算符...合并数组：
因为ES6的语法更简洁易懂，所以现在合并数组我大部分采用...来处理，...运算符可以实现cancat的每个栗子，且更简洁和具有高度自定义数组元素位置的效果。
```
let a = [2, 3, 4, 5]
let b = [ 4,...a, 4, 4]
console.log(a,b); // [2, 3, 4, 5] [4,2,3,4,5,4,4]
```
indexOf() 查找数组是否存在某个元素，返回下标
定义: 返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
语法:
```
array.indexOf(searchElement,fromIndex)
```
参数:
searchElement(必须):被查找的元素
fromIndex(可选):开始查找的位置(不能大于等于数组的长度，返回-1)，接受负值，默认值为0。
严格相等的搜索:
数组的indexOf搜索跟字符串的indexOf不一样,数组的indexOf使用严格相等===搜索元素，即数组元素要完全匹配才能搜索成功。
注意：indexOf()不能识别NaN
```
let a=['啦啦',2,4,24,NaN]
console.log(a.indexOf('啦')); // -1
console.log(a.indexOf('NaN')); // -1
console.log(a.indexOf('啦啦')); // 0
```
使用场景：
数组去重
根据获取的数组下标执行操作，改变数组中的值等。
判断是否存在，执行操作。
lastIndexOf() 查找指定元素在数组中的最后一个位置
定义: 方法返回指定元素,在数组中的最后一个的索引，如果不存在则返回 -1。（从数组后面往前查找）
语法:
```
arr.lastIndexOf(searchElement,fromIndex)
```
参数:
searchElement(必须): 被查找的元素
fromIndex(可选): 逆向查找开始位置，默认值数组的长度-1，即查找整个数组。
关于fromIndex有三个规则:
正值。如果该值大于或等于数组的长度，则整个数组会被查找。
负值。将其视为从数组末尾向前的偏移。(比如-2，从数组最后第二个元素开始往前查找)
负值。其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。
```
let a=['OB',4,'Koro1',1,2,'Koro1',3,4,5,'Koro1']; // 数组长度为10
// let b=a.lastIndexOf('Koro1',4); // 从下标4开始往前找 返回下标2
// let b=a.lastIndexOf('Koro1',100); // 大于或数组的长度 查找整个数组 返回9
// let b=a.lastIndexOf('Koro1',-11); // -1 数组不会被查找
let b=a.lastIndexOf('Koro1',-9); // 从第二个元素4往前查找，没有找到 返回-1
```
ES7 includes() 查找数组是否包含某个元素 返回布尔
定义： 返回一个布尔值，表示某个数组是否包含给定的值
语法：
```
array.includes(searchElement,fromIndex=0)
```
参数：
searchElement(必须):被查找的元素
fromIndex(可选):默认值为0，参数表示搜索的起始位置，接受负值。正值超过数组长度，数组不会被搜索，返回false。负值绝对值超过长数组度，重置从0开始搜索。
includes方法是为了弥补indexOf方法的缺陷而出现的:
indexOf方法不能识别NaN
indexOf方法检查是否包含某个值不够语义化，需要判断是否不等于-1，表达不够直观
eg:
```
let a=['OB','Koro1',1,NaN];
// let b=a.includes(NaN); // true 识别NaN
// let b=a.includes('Koro1',100); // false 超过数组长度 不搜索
// let b=a.includes('Koro1',-3); // true 从倒数第三个元素开始搜索
// let b=a.includes('Koro1',-100); // true 负值绝对值超过数组长度，搜索整个数组
```
兼容性(MDN): chrome47, Firefox 43,Edge 14,Opera 34, Safari 9,IE 未实现。
# 遍历方法(12个):
js中遍历数组并不会改变原始数组的方法总共有12个:
ES5：
forEach、every 、some、 fliter、map、reduce、reduceRight、
ES6：
find、findIndex、keys、values、entries
关于遍历：
尽量不要在遍历的时候，修改后面要遍历的值
尽量不要在遍历的时候修改数组的长度（删除/添加）
forEach
定义: 按升序为数组中含有效值的每一项执行一次回调函数。
语法：
```
array.forEach(function(currentValue, index, arr), thisValue)
```
参数:
function(必须): 数组中每个元素需要调用的函数。
// 回调函数的参数
1. currentValue(必须),数组当前元素的值
2. index(可选), 当前元素的索引值
3. arr(可选),数组对象本身
hisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined
关于forEach()你要知道：
无法中途退出循环，只能用return退出本次回调，进行下一次回调。
它总是返回 undefined值,即使你return了一个值。
下面类似语法同样适用这些规则
1. 对于空数组是不会执行回调函数的
2. 对于已在迭代过程中删除的元素，或者空元素会跳过回调函数
3. 遍历次数再第一次循环前就会确定，再添加到数组中的元素不会被遍历。
4. 如果已经存在的值被改变，则传递给 callback 的值是遍历到他们那一刻的值。
```
let a = [1, 2, ,3]; // 最后第二个元素是空的，不会遍历(undefined、null会遍历)
let obj = { name: 'OBKoro1' };
let result = a.forEach(function (value, index, array) {
a[3] = '改变元素';
a.push('添加到尾端，不会被遍历')
console.log(value, 'forEach传递的第一个参数'); // 分别打印 1 ,2 ,改变元素
console.log(this.name); // OBKoro1 打印三次 this绑定在obj对象上
// break; // break会报错
return value; // return只能结束本次回调 会执行下次回调
console.log('不会执行，因为return 会执行下一次循环回调')
}, obj);
console.log(result); // 即使return了一个值,也还是返回undefined
```
// 回调函数也接受接头函数写法
every 检测数组所有元素是否都符合判断条件
定义: 方法用于检测数组所有元素是否都符合函数定义的条件
语法：
```
array.every(function(currentValue, index, arr), thisValue)
```
参数:(这几个方法的参数，语法都类似)
function(必须): 数组中每个元素需要调用的函数。
// 回调函数的参数
1. currentValue(必须),数组当前元素的值
2. index(可选), 当前元素的索引值
3. arr(可选),数组对象本身
thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined
方法返回值规则:
如果数组中检测到有一个元素不满足，则整个表达式返回 false，且剩余的元素不会再进行检测。
如果所有元素都满足条件，则返回 true。=
eg:
```
function isBigEnough(element, index, array) {
return element >= 10; // 判断数组中的所有元素是否都大于10
}
let result = [12, 5, 8, 130, 44].every(isBigEnough); // false
let result = [12, 54, 18, 130, 44].every(isBigEnough); // true
// 接受箭头函数写法
[12, 5, 8, 130, 44].every(x => x >= 10); // false
[12, 54, 18, 130, 44].every(x => x >= 10); // true
```
some 数组中的是否有满足判断条件的元素
定义：数组中的是否有满足判断条件的元素
语法：
```
array.some(function(currentValue, index, arr), thisValue)
```
参数:(这几个方法的参数，语法都类似)
function(必须): 数组中每个元素需要调用的函数。
// 回调函数的参数
1. currentValue(必须),数组当前元素的值
2. index(可选), 当前元素的索引值
3. arr(可选),数组对象本身
thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined
方法返回值规则：
如果有一个元素满足条件，则表达式返回true, 剩余的元素不会再执行检测。
如果没有满足条件的元素，则返回false。
```
function isBigEnough(element, index, array) {
return (element >= 10); //数组中是否有一个元素大于 10
}
let result = [2, 5, 8, 1, 4].some(isBigEnough); // false
let result = [12, 5, 8, 1, 4].some(isBigEnough); // true
```
filter 过滤原始数组，返回新数组
定义: 返回一个新数组, 其包含通过所提供函数实现的测试的所有元素。
语法：
let new_array = arr.filter(function(currentValue, index, arr), thisArg)
参数:(这几个方法的参数，语法都类似)
function(必须): 数组中每个元素需要调用的函数。
// 回调函数的参数
1. currentValue(必须),数组当前元素的值
2. index(可选), 当前元素的索引值
3. arr(可选),数组对象本身
thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined
```
let a = [32, 33, 16, 40];
let result = a.filter(function (value, index, array) {
return value >= 18; // 返回a数组中所有大于18的元素
});
console.log(result,a);// [32,33,40] [32,33,16,40]
```
map 对数组中的每个元素进行处理，返回新的数组
定义：创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
语法：
```
let new_array = arr.map(function(currentValue, index, arr), thisArg)
```
参数:(这几个方法的参数，语法都类似)
function(必须): 数组中每个元素需要调用的函数。
// 回调函数的参数
1. currentValue(必须),数组当前元素的值
2. index(可选), 当前元素的索引值
3. arr(可选),数组对象本身
thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined
```
let a = ['1','2','3','4'];
let result = a.map(function (value, index, array) {
return value + '新数组的新元素'
});
console.log(result, a);
```
// ["1新数组的新元素","2新数组的新元素","3新数组的新元素","4新数组的新元素"] ["1","2","3","4"]
reduce 为数组提供累加器，合并为一个值
定义：reduce() 方法对累加器和数组中的每个元素（从左到右）应用一个函数，最终合并为一个值。
语法：
```
array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
```
参数：
function(必须): 数组中每个元素需要调用的函数。
// 回调函数的参数
1. total(必须)，初始值, 或者上一次调用回调返回的值
2. currentValue(必须),数组当前元素的值
3. index(可选), 当前元素的索引值
4. arr(可选),数组对象本身
initialValue(可选): 指定第一次回调 的第一个参数。
回调第一次执行时:
如果 initialValue 在调用 reduce 时被提供，那么第一个 total 将等于 initialValue，此时 currentValue 等于数组中的第一个值；
如果 initialValue 未被提供，那么 total 等于数组中的第一个值，currentValue 等于数组中的第二个值。此时如果数组为空，那么将抛出 TypeError。
如果数组仅有一个元素，并且没有提供 initialValue，或提供了 initialValue 但数组为空，那么回调不会被执行，数组的唯一值将被返回。
eg:
// 数组求和
```
let sum = [0, 1, 2, 3].reduce(function (a, b) {
return a + b;
}, 0);
// 6
// 将二维数组转化为一维 将数组元素展开
let flattened = [[0, 1], [2, 3], [4, 5]].reduce(
(a, b) => a.concat(b),
[]
);
// [0, 1, 2, 3, 4, 5]
```
reduceRight 从右至左累加
这个方法除了与reduce执行方向相反外，其他完全与其一致，请参考上述 reduce 方法介绍。
ES6：find()& findIndex() 根据条件找到数组成员
find()定义：用于找出第一个符合条件的数组成员，并返回该成员，如果没有符合条件的成员，则返回undefined。
findIndex()定义：返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。
这两个方法
语法：
```
let new_array = arr.find(function(currentValue, index, arr), thisArg)
let new_array = arr.findIndex(function(currentValue, index, arr), thisArg)
```
参数:(这几个方法的参数，语法都类似)
function(必须): 数组中每个元素需要调用的函数。
// 回调函数的参数
1. currentValue(必须),数组当前元素的值
2. index(可选), 当前元素的索引值
3. arr(可选),数组对象本身
thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined
这两个方法都可以识别NaN,弥补了indexOf的不足.
```
// find
let a = [1, 4, -5, 10].find((n) => n < 0); // 返回元素-5
let b = [1, 4, -5, 10,NaN].find((n) => Object.is(NaN, n)); // 返回元素NaN
// findIndex
let a = [1, 4, -5, 10].findIndex((n) => n < 0); // 返回索引2
let b = [1, 4, -5, 10,NaN].findIndex((n) => Object.is(NaN, n)); // 返回索引4
```
浏览器兼容(MDN):Chrome 45,Firefox 25,Opera 32, Safari 8, Edge yes,
ES6 keys()&values()&entries() 遍历键名、遍历键值、遍历键名+键值
定义：三个方法都返回一个新的 Array Iterator 对象，对象根据方法不同包含不同的值。
语法：
array.keys()
array.values()
array.entries()
参数：无。
```
for (let index of ['a', 'b'].keys()) {
console.log(index);
}
for (let elem of ['a', 'b'].values()) {
console.log(elem);
}
// 'a'
// 'b'
for (let [index, elem] of ['a', 'b'].entries()) {
console.log(index, elem);
}
// 0 "a"
// 1 "b"
```
在for..of中如果遍历中途要退出，可以使用break退出循环。
如果不使用for...of循环，可以手动调用遍历器对象的next方法，进行遍历:
```
let letter = ['a', 'b', 'c'];
let entries = letter.entries();
console.log(entries.next().value); // [0, 'a']
console.log(entries.next().value); // [1, 'b']
console.log(entries.next().value); // [2, 'c']
```
entries()浏览器兼容性(MDN):Chrome 38, Firefox 28,Opera 25,Safari 7.1
keys()浏览器兼容性(MDN):Chrome 38, Firefox 28,Opera 25,Safari 8,
注意:目前只有Safari 9支持,，其他浏览器未实现，babel转码器也还未实现
- 前端综合问题
- 【01】工作中你是如何检测浏览器兼容问题的？
- 【02】手机端怎么适配？
- 【03】你对手机平台安装包后缀的理解
- 【04】你所了解的Web攻击技术
- 【05】如何防止XSS攻击？
- 【06】项目开发过程中都用过什么框架？
- 【07】一般情况下，端口号的取值范围是多少？
- 【08】简述http常见的状态码及含义
- 【09】CommonJS，AMD，CMD区别
- 【10】Svn与Git的区别
- 【11】http请求方式有几种？分别是什么？
- 【12】请你谈谈cookie的弊端？
- 【13】window对象常用的属性和方法有那些
- 【14】你有哪些性能优化的方法？
- 【15】web页面重构怎么操作？
- 【16】线程与进程的区别是什么?
- 【17】什么是WEB标准？什么是W3C标准？
- 【18】行内元素有哪些? 块级元素有哪些? CSS的盒模型?
- 【19】你如何优化自己的代码？
- 【20】如何实现浏览器内多个标签页之间的通信?
- 【21】请谈一下你对网页标准和标准制定机构重要性的理解
- 【22】浏览器是如何渲染页面的
- 【23】从输入url到显示页面，都经历了什么
- 【24】谈谈垃圾回收机制方式及内存管理
- 【25】请解释JSONP的工作原理，以及它为什么不是真正的AJAX
- 【26】http 和 https 有何区别？如何灵活使用？
- 【27】浏览器缓存有哪些，通常缓存有哪几种
- 【28】xml和json的区别
- 手写代码及阅读题
- 【01】计算1-10000中出现的0 的次数
- 【02】写一个兼容的function，清除字符串前后的空格
- 【03】请对一个数组的数组从小到大进行排序
- 【04】以下代码输出什么[空函数返回值]
- 【05】下面代码输出什么？[各种类型拼接]
- 【06】常用的两种函数声明有什么区别？
- 【07】请计算一个对象的长度
- 【08】看下面代码，给出输出结果[计时器]
- 【10】看下列代码,输出什么? [null相关]
- 【11】写一个正则，字母开头，后面可以是数字，下划线，字母，长度6-30
- 【12】以下代码的alert的值分别是多少？
- 【13】如何获取三个数中的最大值和最小值？
- 【14】数组去重几种方法是什么？
- 【15】求数组中的最大值
- 【16】求数组中的最小值
- 【17】获得每个月1号是星期几？
- 【18】将字符串转化为驼峰表示法
- 逻辑题目
- 【01】1元1瓶汽水，2个空瓶再换1瓶汽水，30元最多能喝几瓶？
- 【02】有8个球体，外观一样，但有1个球比其他7个球重，给你一个天平，几次能找出那个较重的球？
- CSS3
- 【01】把一个div变成圆左边蓝色 右边绿色
- 【02】css盒模型有哪些及区别
- 【03】什么是css盒模型
- 【04】如何让英文小写转换为大写
- 【05】 去掉inline-block元素间隙的几种方法
- 【06】less和sass的特点和区别
- 【07】什么叫优雅降级和渐进增强？
- 【08】rgba和opacity的透明何不同？
- 【09】css选择器有那些？CSS3新增了哪些
- 【10】CSS3有哪些新特性？
- 【11】display属性有哪些？
- 【12】box-sizing的属性和作用
- 【13】CSS样式覆盖规则
- HTML5
- 【01】请列举5个html5输入类型？并简要描述其用途？
- 【02】em和rem的区别？
- 【03】精灵图和base64 如何选择，或者字体图标什么时候使用？
- 【04】position定位有几种？有什么区别？哪几个是脱离文档流的？
- 【05】垂直水平居中的方法有几种？
- 【06】清除浮动的方法有哪些？
- 【07】link和import的区别
- 【08】opacity/visibility/display 隐藏对比
- 【09】XHTML和HTML有什么区别
- 【10】什么是语义化的HTML？
- 【11】常见的浏览器内核有哪些？
- 【12】HTML5有哪些新特性，移除了哪些元素？
- 【13】如何处理HTML5新标签的浏览器兼容问题？
- 【14】HTML5为什么只需要写！DOCTYPE HTML？
- 【15】介绍以下你对浏览器内核的理解？
- 【16】行内元素有哪些？块级元素有哪些？
- 【17】标签上title与alt属性的区别是什么？
- 【18】前端页面有哪三层构成是什么？作用是什么？
- 【19】H5特点有哪些？
- 【20】HTML5里的video标签支持哪些视频格式？
- 【21】margin-top父元素塌陷及解决办法
- 【22】透明度opacity的兼容写法
- 【23】让一行文字在固定宽度div里显示省略号的方法
- 【24】如何解决input和select的宽高不一致问题
- 【25】如何解决div与内部img间隙问题
- 【26】这个要改一下
- 【27】input设置为readonly和disable有什么区别？
- 【28】谈谈对BFC的理解
- 【29】简述src与href的区别
- 【30】什么是外边距重叠？以及防止方法
- 【31】HTML5 Input 表单新增输入类型
- 【32】HTML5语义化标签有哪些
- 【33】html常见兼容性问题
- 【34】Doctype的作用？严格模式与混杂模式的区别？
- 【35】HTML与XHTML的区别？
- 【36】input有那些类型？
- 【37】 img的alt与title有何异同？strong与em的异同？
- 【38】px和em的区别是什么？你还了解那些单位？
- 【39】把 Script 标签 放在页面的最底部的body封闭之前 和封闭之后有什么区别？浏览器会如何解析它们？
- 【40】什么是雪碧图？它作用是什么？
- Javascript
- 【01】简述ajax请求过程，以及注意事项。
- 【02】post和get的区别？
- 【03】简述jsonp跨域原理，以及你知道的其他跨域方法
- 【04】JSONP与JSON的区别
- 【05】谈谈对http和https的理解
- 【06】var let const 的区别是什么？
- 【07】简述“==”与“===”的区别？
- 【08】javascript各类型在转换为boolean式的规则？
- 【09】Object.creat()和new对象有什么区别？
- 【10】for in和Object.keys来遍历对象有什么区别？
- 【11】Object.assign()函数的作用及用法
- 【12】数组的常用方法有那些？
- 【13】js中内置 对象有哪些有哪些？
- 【14】控制台undefined和is not defined异常区别？
- 【15】JS中面向对象和面向过程的区别
- 【16】什么是脚本？
- 【17】cookies、sessionStorage和localStorage区别？
- 【18】谈一下你对面向对象的理解？
- 【19】什么是函数？
- 【20】正则验证，match()与test()函数的区别？
- 【21】什么是闭包？简述的优缺点
- 【22】Es6新特性有哪些？
- 【23】怎么判断一个object是否是数组(array)？
- 【24】函数声明和函数表达式的区别？
- 【25】this一般的指向，以及如何改变指向
- 【26】javascript的typeof返回哪些数据类型（和37重复了）
- 【27】列举IE和标准下有哪些兼容性的写法
- 【28】new操作符具体干了什么呢?
- 【29】什么是Json？
- 【30】js中的3种弹出式命令什么
- 【31】节点的种类有几种，分别是什么？
- 【32】Void（0）的作用是什么？
- 【33】箭头函数和普通函数的区别
- 【34】怎么获取对象的key值
- 【35】谈谈你对原型链的理解
- 【36】Javascript如何实现继承？
- 【37】typeof返回哪些数据类型
- 【38】创建函数的几种方式？
- 【39】js中同步和异步的区别
- 【40】事件绑定和普通事件有什么区别？
- 【41】documen.write和 innerHTML的区别?
- 【42】JS实现继承的6种方式
- 【43】什么是事件委派以及优缺点
- 【44】JS创建对象的几种方式？
- 【45】解释js垃圾回收机制和引起内存泄漏？
- 【46】DOM怎样添加、移除、移动、复制、创建和查找节点
- 【47】null和undefined的区别？
- 【48】正则常用符号代表什么？
- 【49】callee和caller的作用？
- 【50】如何阻止事件冒泡和默认事件?
- 【51】例举3种强制类型转换和2种隐式类型转换?
- 【52】JavaScript是一门什么样的语言，它有哪些特点？
- 【53】js延迟加载的方式有哪些？
- 【54】js作用域有那些
- 【55】同步和异步的区别?
- 【56】已知ID的Input输入框，希望获取这个输入框的输入值
- 【57】ajax请求的时候get 和post方式的区别
- 【58】eval()的作用
- 【59】如何用原生js给一个按钮绑定两个onclick事件？
- 【60】Javascript中的定时器有哪些？他们的区别及用法是什么？
- Node
- 【01】对nodejs的理解？
- 【02】import和require的区别
- 【03】Node.js的优点和缺点
- 框架及JS库
- 【01】jQuery如何实现事件委托？
- 【02】$(document).ready和window.onload的区别？
- 【03】v-if与v-show区别
- 【04】mvc和mvvm模式区别
- 【05】React早期创建组件的方式
- 【06】export与export default 的区别
- 【07】简述一下 Handlebars 的基本用法？
- React
- 【01】对React生命周期的理解
- 【02】React创建组件的三种方式及其区别是什么？
- 【03】react和vue有哪些不同，说说你对这两个框架的看法