JS数组的各种方法汇总

最新推荐文章于 2023-03-29 18:37:46 发布

Ezms

最新推荐文章于 2023-03-29 18:37:46 发布

阅读量632

点赞数 4

文章标签： javascript js

本文链接：https://blog.csdn.net/qq_41260655/article/details/108953033

版权

JS数组各种方法汇总

1、数组的创建

1、[ ]包裹添加元素，赋值给变量
2、构造器Array对象创建一个数组；
                           无参构造：空数组
                           有参构造：①单个参数为数组长度length
                                             ②多个参数为每一项元素
3、Es6中Array.of( )方法；（解决了构造器参数不同导致的问题）
                           无参构造：空数组
                           有参构造：①无论几个参数，都是数组的每一项

//1、[ ]包裹添加元素，赋值给变量
 let arr=[1,3,2]//[1,3,2]

/*
* 2、构造方法，数组实际是一个对象Array创建一个对象，new Array（有参/无参）
* 实际上加不加new没有不影响，new Array===Array
*
* 无参构造：空数组
* 有参构造：①单个参数，为数组长度，数组内容都为undefined,占位②多个参数，则为数组的每一项元素
*
*  */
 let arr1 = Array();//[]空数组
 let arr2 = Array(4);//单个参数时候为length,[undefined,undefined,undefined,undefined]
 let arr3= Array(4,2,3);//多个参数，则为数组的每一项元素[4,2,3]
 
/*
*
* 3、Es6中Array.of();
* 无参数：空数组
* 有参数：返回所有参数组成的数组
* 解决了构造器因为参数不同导致的问题
* */
 let arr4 =Array.of(3)//[3]

2、Es6中Array中from方法（我们现在用Object.values(对象)多一些,不过不是数组的方法，而是对象的内置方法）

// Es6中Array.from()将两种类型对象转为真正数组
 //   ①对象拥有length
 //   ②部署了Iterator接口,比如str Set NodeList对象
 // 定义：将两类对象转成真正的数组（不改变原对象，返回新数组）
 //参数：
 //     第一个参数(必须):要转换成对象的
 //     第二个参数(可选):对每个元素进行处理类似于map操作
 //     第三个参数(可选): 用来绑定this。

        let obj = {w:"w",1:"3",2:"ew",length:4}
        let arr = Array.from(obj)//[undefined, "3", "ew", undefined]

        let arr2 = Array.from("hello")//['h','e','l','l','o']
        //用Object.values("htllo"),也能实现

3、改变原数组的方法（9个）

 let arr=[2,12,3]
    //Es5中
    arr.pop()//删除一个数组中的最后的一个元素
    arr.shift()// 删除数组的第一个元素
    arr.push()//向数组的末尾添加元素
    arr.unshift()//unshift()向数组的开始添加元素
    arr.reverse()//reverse() 颠倒数组中元素的顺序
    arr.splice()// 添加/删除数组元素
    arr.sort()//数组排序
    //Es6
    arr.copyWithin()//指定位置的成员复制到其他位置
    arr.fill()//填充数组

3.1、pop删除一个数组中的呃最后一个元素

   //定义:pop()方法删除一个数组中的最后一个元素,并且返回这个元素
    //参数:无参数
    let arr=[2,12,3]
    let item=arr.pop()//item===3
    console.log(arr)//[2,12]

3.2、shift() 删除数组的第一个元素

// 定义: shift()方法删除数组的第一个元素，并返回这个元素。
// 参数: 无。
let arr = [2,12,3]
let item = arr.shift()    // 2
console.log(arr)    // [12,3]

3.3、push() 向数组的末尾添加元素

// 定义：push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。
// 参数: item1, item2, …, itemX ,要添加到数组末尾的元素
//返回值：数组长度length
let a = [2,12,3]
let item = a.push('4')    // 4(a.length)
console.log(a)    // [2,12,3,4]

3.4、unshift()向数组的开始添加元素

// 定义：unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
// 参数: item1, item2, …, itemX ,要添加到数组开头的元素
//返回值：数组长度length
let a = [1,2,3]
let item = a.unshift(4)    // 4(a.length)
console.log(a)    // [4,1,2,3]

3.5、reverse() 颠倒数组中元素的顺序

// 定义: reverse() 方法用于颠倒数组中元素的顺序。
// 参数: 无
let a = [1,2,3]
a.reverse()
console.log(a)    // [3,2,1]

3.6、splice() 添加/删除数组元素

// 定义： splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目
// 语法： array.splice(index,howmany,item1,.....,itemX)
// 参数:
// index：必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
// howmany：必需。要删除的项目数量。如果设置为 0，则不会删除项目。
// item1, …, itemX： 可选。向数组添加的新项目。
// 返回值: 如果有元素被删除,返回包含被删除项目的新数组。

// eg1: 删除元素
let a = [1,2,3,4,5,6,7]
// 从数组下标为1的元素开始删除3个元素
let item = a.splice(1,3)    // [2,3,4]
console.log(a)    // [1,5,6,7]
// 从最后一个元素开始删除3个元素，因为是最后一个元素，所以只删除了7
let item = a.splice(-1,3)    // [7]
console.log(a)    // [1,5,6]

// eg2: 删除并添加
let a = [1, 2, 3, 4, 5, 6, 7];
// 从数组下标0开始，删除3个元素，并添加元素'添加'
let item = a.splice(0,3,'添加'); // [1,2,3]
console.log(a); // ['添加',4,5,6,7]
// 从数组最后第二个元素开始，删除3个元素，并添加两个元素'添加1'、'添加2'
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']

// 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] 在最后一个元素的前面添加两个元素

3.7、sort() 数组排序
语法：array.sort(fun)；参数function可选。规定排序顺序。必须是函数。
注：如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。

如果想按照其他规则进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b，其返回值如下：
若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
若 a 等于b，则返回 0。
若 a 大于 b，则返回一个大于 0 的值。
简单点就是：比较函数两个参数a和b，返回a-b 升序，返回b-a 降序

// 定义: sort()方法对数组元素进行排序，并返回这个数组。
// 参数可选: 规定排序顺序的比较函数。
// 默认情况下sort()方法没有传比较函数的话，默认按字母升序，如果不是元素不是字符串的话，会调用toString()方法将元素转化为字符串的Unicode(万国码)位点，然后再比较字符，这时候比较第一个位的字符串，相同比较第二位，对于数字的话违背了规则12>3,但是toString后比较12<3。
// 字符串排列 看起来很正常
//注：原数组发生改变




let a = ["a", "b", "s", "c"];
a.sort(); // ["a","b","c","a"]
// 数字排序的时候 因为转换成Unicode字符串之后，有些数字会比较大会排在后面 这显然不是我们想要的
var a = [10, 1, 3, 20,25,8];
console.log(a.sort()) // [1,10,20,25,3,8];

sort排序常见用法：
3.7.1、数组元素为数字的升序、降序:

let 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];

3.7.2、数组多条件排序

let 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.7.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"}]

3.8、ES6: copyWithin() 指定位置的成员复制到其他位置（左闭右开，end的位置停止不包含）

// 定义: 在当前数组内部，将指定位置的成员复制到其他位置,并返回这个数组。
// 语法: 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"]

3.9、ES6: fill() 填充数组

// 定义: 使用给定值，填充一个数组。
// 参数:
// 第一个元素(必须): 要填充数组的值
// 第二个元素(可选): 填充的开始位置,默认值为0
// 第三个元素(可选)：填充的结束位置，默认是为this.length
['a', 'b', 'c'].fill(7)    // [7, 7, 7]
['a', 'b', 'c'].fill(7, 1, 2)    // ['a', 7, 'c']

4.不改变原数组的方法(8个)

ES5：
join()
toLocateString()
toStrigin()
slice()
cancat()
indexOf()
lastIndexOf()
ES7：
includes()

4.1.join() 数组转字符串（数组[ ]去掉利用分隔符（无参默认逗号，有参数为分隔符）连接到一起）

// 定义: join() 方法用于把数组中的所有元素通过指定的分隔符进行分隔放入一个字符串，返回生成的字符串。
// 语法:array.join(str)
// 参数:str(可选): 指定要使用的分隔符，默认使用逗号作为分隔符。
let a= ['hello','world'];
let str=a.join(); // 'hello,world'
let str2=a.join('+'); // 'hello+world'

4.2、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。

4.3、toString() 数组转字符串不推荐（无参数只能逗号分隔符链接成字符串和join无参一样，但是join更优秀的是有参时候，所以完全替代）

// 定义: toString() 方法可把数组转换为由逗号链接起来的字符串。
// 语法:array.toString()
// 参数: 无。
// 该方法的效果和join方法一样，都是用于数组转字符串的，但是与join方法相比没有优势，也不能自定义字符串的分隔符，因此不推荐使用。
// 值得注意的是：当数组和字符串操作的时候，js 会调用这个方法将数组自动转换成字符串
let b= [ 'toString','演示'].toString(); // toString,演示
let a= ['调用toString','连接在我后面']+'啦啦啦'; // 调用toString,连接在我后面啦啦啦

4.4.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'] ['改变拷贝的数组']

4.5、cancat拼接，（但是在Es6中的重构已经替代了）

// 定义： 方法用于合并两个或多个数组，返回一个新数组。
// 语法：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重构合并数组：

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]

既然提到重构了就简单啰嗦几句,扩展运算符（ spread ）是三个点（…）,既能展现拆分又能展现合并

//拆分数组

console.log(...[1, 2, 3])
// 1 2 3
console.log(1, ...[2, 3, 4], 5)
// 1 2 3 4 5
[...document.querySelectorAll('div')]
// [<div>, <div>, <div>]



//数组的合并

let j = [7, 1, 2];
let k = [5, 0, 8];
j = [...k, ...j];
console.log(j)
 
//打印出来的值[5, 0, 8, 7, 1, 2]

该运算符主要用于函数调用，在形参的时候…表示一个参数代表好多参数，不管传入多少参数都没有问题，在函数体中/或者说代码块中作用域中…是进行拆分的一个作用，把items代表的值都拆分打开

function push(array, ...items) {
array.push(...items);
}
function add(x, y) {
return x + y;
}
var numbers = [4, 38];
add(...numbers) // 42

4.6、indexOf() 查找数组是否存在某个元素，返回下标（不能识别NaN,查找NaN直接返回-1，找不到）

// 定义: 返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-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

它还有一个很大的用处，清除数组中重复出现的元素：

let arr=[1,3,3,4,4,4,'abc','abc'];
let arr1=[];
for(var i=0;i<arr.length;i++){
   if(arr1.indexof(arr[i])<0){  
    //  判断arr1中是否有arr中的元素，如果没有，返回-1，进而添加到arr1里面，如果有，则不添加
    arr1.push(arr[i]);
    }
}
console.log(arr1);   //  输出1，3，4，‘abc’

利用这种思想，我们也能查找出字符串中重复出现的字母有哪些利用split()将字符串转化成数组

4.7、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

4.8、ES7 includes() 查找数组是否包含某个元素返回布尔

// 定义： 返回一个布尔值，表示某个数组是否包含给定的值
// 语法：array.includes(searchElement,fromIndex=0)
// 参数：
// searchElement(必须): 被查找的元素
// fromIndex(可选): 默认值为0，参数表示搜索的起始位置，接受负值。正值超过数组长度，数组不会被搜索，返回false。负值绝对值超过长数组度，重置从0开始搜索。
// includes方法是为了弥补indexOf方法的缺陷而出现的:
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 负值绝对值超过数组长度，搜索整个数组

4.数组遍历方法(12个)

ES5：
forEach()遍历操作每个数组元素
every() 判断数组每一项是否都满足条件
some()判断是否存在满足条件的元素，只要一个满足返回true
fliter()过滤筛选，满足条件的直接保留，不满足剔除
map()对所有元素统一操作
reduce()实现迭代
reduceRight()和reduce反向迭代其他都一样
ES6：
find()根据条件找到数组成员
findIndex()根据条件找到数组成员
keys()遍历键名
values()遍历键值
entries()遍历键名+键值

5.1、forEach

遍历数组全部元素，利用回调函数对数组进行操作，自动遍历数组.length次数，且无法break中途跳出循环
因此不可控
不支持return操作输出，return只用于控制循环是否跳出当前循环

// 定义: 按升序为数组中含有效值的每一项执行一次回调函数。
// 语法：array.forEach(function(currentValue, index, arr), thisValue)
// 参数:一个回调函数，回调函数3个参数，和一个this绑定（可选）
// function(必须): 数组中每个元素需要调用的函数。
// （1）回调函数的参数
// 1. currentValue(必须),数组当前元素的值
// 2. index(可选), 当前元素的索引值
// 3. arr(可选),数组对象本身
// （2）thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined
let a = [1, 2, ,3]; // 最后第二个元素是空的，不会遍历(undefined、null会遍历)
let obj = { name: 'OBKoro1' };
let result = a.forEach(function (currentValue, 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
// 回调函数也接受接头函数写法

5.2、every检测数组所有元素是否都符合判断条件

// 定义: 方法用于检测数组所有元素是否都符合函数定义的条件
// 语法：array.every(function(currentValue, index, arr), thisValue)
// 参数:(这几个方法的参数，语法都类似)
// function(必须): 数组中每个元素需要调用的函数。
// 回调函数的参数
// 1. currentValue(必须),数组当前元素的值
// 2. index(可选), 当前元素的索引值
// 3. arr(可选),数组对象本身
// thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined
// 方法返回值规则:
// 如果数组中检测到有一个元素不满足，则整个表达式返回 false，且剩余的元素不会再进行检测。
// 如果所有元素都满足条件，则返回 true。
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

5.3、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

5.4、fliter过滤原始数组，返回新数组

// 定义: 返回一个新数组, 其包含通过所提供函数实现的测试的所有元素。
// 语法：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]

5.5、map对数组中的每个元素进行处理，返回新的数组（这里的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"]

5.6、reduce为数组迭代出一个值，返回整个迭代的值
参数：
        回调函数：
                        total：迭代体（初次默认为数组第一项）
                        item：每一项元素
                        index：下标
                        arr：数组
        迭代体的初始值：赋值给total初始值

	// 数组求和 
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]

之前见到过这样一道题目：
计算下列的所有人的成绩的和，以下展示一些错误的思路的想法，直接会想到用reduce方法

let students =[
        {
            name:"火焰",
            score:80
        },
        {
            name:"是否",
            score:75
        },
        {
            name:"雪碧",
            score:80
        },
        {
            name:"可乐",
            score:90
        }
  			  ]

❌错误思路一原因:item（数组里的每一项）是什么？是对象，对象＋对象＋对象＋对象；对象之间相加转换成[object Object]

  // 计算以上的成绩总和
    // 思路一：错误❌
    let s1=students.reduce(function (total,item){
        return total+item
    })
    console.log(s1);//[object Object][object Object][object Object][object Object]

❌错误思路二原因:虽然后边采用了item.scorce,调用了对象的属性值，但是我们第一次回调的时候默认是数组里的第一项，所以相当于对象＋80+75+80最后得到[object Object]807590

 // 计算以上的成绩总和
    // 思路二：错误❌
    let s2 = students.reduce(function (total,item){
        return total +item.score
    })
    console.log(s2);//[object Object]807590

❌错误思路三原因:第一次计算total.score（因为默认的是数组的第一项的第一个对象，所以可以调用score属性）第一次计算没有问题80+75=155,但是第二次回调的时候total变成了155，根本就没有scroe这个属性，所以会变成undefined，undefined+80=NAN，后边的NAN+90=NAN

// 计算以上的成绩总和
    // 思路三：错误❌
    let s3 = students.reduce(function (total,item){
        return total.score +item.score
    })
    console.log(s3)//NAN

正确解答
设置两个参数：回调函数和迭代体的初始值

 let s = students.reduce(function (total,item){
        return total+item.score
    },0)
    console.log(s);//0+80+75+80+90=325

5.7、reduceRight从右至左累加,与reduce执行方向相反，其他完全与其一致，请参考上述 reduce 方法介绍。
5.8、ES6：find()& findIndex() 根据条件找到数组成员

// find()定义：用于找出第一个符合条件的数组成员，并返回该成员，如果没有符合条件的成员，则返回undefined。
// findIndex()定义：返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。
// 语法：let new_array = arr.find/findIndex(function(currentValue, index, arr), thisArg)
// 参数：
// function(必须): 数组中每个元素需要调用的函数。
// 回调函数的参数
// 1. currentValue(必须),数组当前元素的值
// 2. index(可选), 当前元素的索引值
// 3. arr(可选),数组对象本身
// thisValue(可选): 当执行回调函数时this绑定对象的值，默认值为undefined
// 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

5.9、ES6 keys()&values()&entries() 遍历键名、遍历键值、遍历键名+键值注意:目前只有Safari 9支持,，其他浏览器未实现，babel转码器也还未实现

// 定义：三个方法都返回一个新的 Array Iterator 对象，对象根据方法不同包含不同的值。
// 语法：
// array.keys()
// array.values()
// array.entries()
// 参数：无。
for (let index of ['a', 'b'].keys()) {
 console.log(index);
}
// 0
// 1
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']