数组具有较多的方法，接下来总结一些常用的方法。
目录
一、方法总结
| 方法名 | 对应版本 | 功能 | 原数组是否改变 |
|---|---|---|---|
| push() | ES5 | 在最后一位新增一或多个数据，返回长度 | 是 |
| unshift() | ES5 | 在第一位新增一或多个数据，返回长度 | 是 |
| pop() | ES5 | 删除最后一位，并返回删除的数据 | 是 |
| shift() | ES5 | 删除第一位，并返回删除的数据 | 是 |
| reverse() | ES5 | 反转数组，返回结果。（ES6的替代toReversed()不会改变原数组，而是返回原数组操作后的拷贝） | 是 |
| sort() | ES5 | 排序（字符规则），返回结果。（ES6的替代toSorted()不会改变原数组，而是返回原数组操作后的拷贝） | 是 |
| indexOf() | ES5 | 查询并返回数据的索引 | 否 |
| lastIndexOf() | ES5 | 反向查询并返回数据的索引 | 否 |
| toString() | ES5 | 直接转为字符串，并返回 | 否 |
| join() | ES5 | 使用分隔符，将数组转为字符串并返回 | 否 |
| valueOf() | ES5 | 返回数组对象的原始值 | 否 |
| splice() | ES5 | 删除指定位置，并替换，返回删除的数据。（ES6的替代toSpliced()不会改变原数组，而是返回原数组操作后的拷贝） | 是 |
| slice() | ES5 | 截取指定位置的数组，并返回 | 否 |
| concat() | ES5 | 合并数组，并返回合并之后的数据 | 否 |
| forEach() | ES5 | 参数为回调函数，会遍历数组所有的项，回调函数接受三个参数，分别为value，index，self；forEach没有返回值 | 否 |
| map() | ES5 | 同forEach，同时回调函数返回数据，组成新数组由map返回 | 否 |
| filter() | ES5 | 同forEach，同时回调函数返回布尔值，为true的数据组成新数组由filter返回 | 否 |
| every() | ES5 | 同forEach，同时回调函数返回布尔值，全部为true，由every返回true | 否 |
| some() | ES5 | 同forEach，同时回调函数返回布尔值，只要由一个为true，由some返回true | 否 |
| reduce() | ES5 | 归并，同forEach，迭代数组的所有项，并构建一个最终值，由reduce返回 | 否 |
| reduceRight() | ES5 | 反向归并，同forEach，迭代数组的所有项，并构建一个最终值，由reduceRight返回 | 否 |
| find() | ES6 | 回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined | 否 |
| findIndex() | ES6 | 返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回-1。 | 否 |
| Array.from() | ES6 | 数组对象静态方法，将可遍历对象以及类似数组的对象转为真数组 | 否 |
| includes() | ES6 | 返回一个布尔值，表示某个数组是否包含给定的值 | 否 |
二、方法介绍
1、push()
作用：向数组的末尾添加一个或更多元素
参数：push(newData1, newData2, ......)返回值：新数组的长度
原数组为添加元素后的新数组
var arr = [1,2,3];
console.log(arr.push("hello")); //4
console.log(arr); //[1,2,3,"hello"]---原数组改变
2、 unshift()
作用：向数组的开头添加一个或更多元素
参数：unshift(newData1, newData2, ......)返回值：新数组的长度
原数组为添加元素后的新数组
var arr = [1,2,3];
console.log(arr.unshift("hello")); //4
console.log(arr); //["hello",1,2,3]---原数组改变
3、 pop()
作用：删除数组的最后一个元素
参数：无返回值：删除的元素
原数组为删除元素后的新数组
var arr = [1,2,3];
console.log(arr.pop()); //3
console.log(arr); //[1,2]---原数组改变4、 shift()
作用：删除数组的第一个元素
参数：无返回值：删除的元素
原数组为删除元素后的新数组
var arr = [1,2,3]
console.log(arr.shift()); //1
console.log(arr); //[2,3]---原数组改变5、 reverse()
作用：翻转数组
参数：无返回值：翻转后的数组
原数组为翻转后的数组
var arr = [1,2,3];
console.log(arr.reverse()); //[3,2,1]
console.log(arr); //[3,2,1]---原数组改变6、 sort()
作用：对数组中的元素进行排序，默认是升序。
返回值：排序后的数组
原数组为元素隐式转换后的新数组
var arr = [6,1,5,2,3];
console.log(arr.sort()); //[1, 2, 3, 5, 6]
console.log(arr); //[1, 2, 3, 5, 6]---原数组改变但是不按照数组元素数值的大小对数字进行排序，而是按照字符编码的顺序进行排序，即在排序前，会先调用数组的toString方法，将每个元素都隐式转成字符之后，再逐位比较，进行排序。
var arr = [6,1024,52,256,369];
console.log(arr.sort()); //[1024, 256, 369, 52, 6]
console.log(arr); //[1024, 256, 369, 52, 6]---原数组改变参数：sort(callback)
如果需要按照数值排序，需要传参。callback为回调函数，该函数应该具有两个参数，比较这两个参数，然后返回一个用于说明这两个值的相对顺序的数字（a-b）其返回值如下：a-b 升序 b-a 降序
var arr = [6,1024,52,256,369];
console.log(arr.sort(fn)); //[6, 52, 256, 369, 1024]
console.log(arr); //[6, 52, 256, 369, 1024]---原数组改变
function fn(a,b){
return a-b;
}
var data = [
{ realname: "张三", age: 19 },
{ realname: "小明", age: 19 },
{ realname: "李四", age: 20 },
{ realname: "王五", age: 28 },
{ realname: "小红", age: 28 },
{ realname: "赵六", age: 21 },
]
//数组中有引用类型，根据引用类型排序，a与b相当于数组元素，a.age取到对象的属性值
data.sort(function (a, b) {
return a.age - b.age;
})7、 indexOf()
作用：根据指定的数据，从头开始，查询在数组中出现的位置，如果不存在指定的数据，返回-1，找到了指定的数据返回该数据的索引
参数：indexOf(value, start);value为要查询的数据；start为可选，表示开始查询的位置，当start为负数时，从数组的尾部向前数；如果查询不到value的存在，则方法返回-1
返回值：元素的索引值，且只返回一个值
原数组不变
var arr = ["h","e","l","l","o"];
console.log(arr.indexOf("l")); //2
console.log(arr.indexOf("l",3)); //3
console.log(arr.indexOf("l",4)); //-1
console.log(arr.indexOf("l",-1)); //-1
console.log(arr.indexOf("l",-3)); //28、lastIndexOf()
作用：根据指定的数据，从尾部开始，查询在数组中出现的位置，如果不存在指定的数据，返回-1。该方法是查询方法，不会对数组产生改变。
参数：lastIndexOf(value, start);value为要查询的数据；start为可选，表示开始查询的位置，当start为负数时，从数组的尾部向前数；如果查询不到value的存在，则方法返回-1返回值：元素的索引值，且只返回一个值
原数组不变
var arr = ["h","e","l","l","o"];
console.log(arr.lastIndexOf("l")); //3
console.log(arr.lastIndexOf("l",3)); //3
console.log(arr.lastIndexOf("l",1)); //-1
console.log(arr.lastIndexOf("l",-3)); //2
console.log(arr.lastIndexOf("l",-4)); //-19、 toString()
作用：将数组转换成字符串，类似于没有参数的join()。该方法会在数据发生隐式类型转换时被自动调用，如果手动调用，就是直接转为字符串。
参数：无返回值：数组元素转换的字符串
原数组不变
var arr = [1,2,3];
console.log(arr.toString()); //1,2,3
console.log(arr); //[1,2,3]---原数组未改变10、join()
功能：根据指定分隔符将数组中的所有元素放入一个字符串，并返回这个字符串。
参数：join(str);参数可选，默认为","号，以传入的字符作为分隔符，其中‘’表示无分隔符返回值：数组元素转换的字符串，字符串元素之间用参数值连接
原数组不变
var arr = [1,2,3];
console.log(arr.join()); //1,2,3
console.log(arr.join("-")); //1-2-3
console.log(arr); //[1,2,3]---原数组未改变11、 valueOf()
作用：返回数组的原始值（一般情况下其实就是数组自身），一般由js在后台调用，并不显式的出现在代码中
参数：无返回值：数组自身
原数组不变
var arr = [1,2,3];
console.log(arr.valueOf()); //[1,2,3]
console.log(arr); //[1,2,3]
//为了证明返回的是数组自身
console.log(arr.valueOf() == arr); //true12、 splice()
作用：向数组中添加，或从数组删除，或替换数组中的元素。
参数：arrayObj.splice（start，deleteNum，insert); 第一个参数 从索引值start 开始；第二个参数 delNum 删除元素的个数； 第三个参数 insert 插入的新元素；参数皆可选
1、无参数传递，无操作；
2、只写一个参数 会从指定开始的位置开始删除直到数组的末尾 以数组的形式返回删除的元素；
3、写两个参数 会从指定的位置 删除指定个数的元素 并以数组的形式返回；
4、写三个参数 从指定位置开始 删除指定的元素，并将新元素从指定开始的位置添加 ；
5、写四个或更多元素 从指定位置开始 删除指定的元素，并将新元素从指定开始的位置添加 ，并将第三个参数及后面所有参数，插入到start的位置。
返回值：以数组的形式返回被删除/替换的元素
原数组为被添加、删除或替换元素后的新数组
var arr = ["Tom","Jack","Lucy","Lily","May"];
console.log(arr.splice(2,0,"a","b")); //[]
console.log(arr); //["Tom", "Jack", "a", "b", "Lucy", "Lily", "May"]---原数组改变13、slice()
作用：以数组的形式返回数组的一部分
参数： arrayObj.slice(start, [end]); strat表示从第几位开始；end为可选，表示到第几位结束(不包含end位)，省略表示到最后一位；start和end都可以为负数，负数时表示从最后一位开始算起，如-1表示最后一位。
返回值：包含原数组中选中元素的新数组，无参数时，返回原数组的副本
原数组不变
var arr = ["Tom","Jack","Lucy","Lily","May"];
console.log(arr.slice(1,3)); //["Jack","Lucy"]
console.log(arr.slice(1)); //["Jack","Lucy","Lily","May"]
console.log(arr.slice(-4,-1)); //["Jack","Lucy","Lily"]
console.log(arr.slice(-2)); //["Lily","May"]
console.log(arr.slice(1,-2)); //["Jack","Lucy"]
console.log(arr); //["Tom","Jack","Lucy","Lily","May"]---原数组未改变14、concat()
功能：用于连接两个或多个数组
参数：concat(data1,data2,...);所有参数可选，要合并的数据；data为数组时，将data合并到原数组；data为具体数据时直接添加到原数组尾部返回值：有参数传递，返回添加元素的数组；无参数时，返回原数组的副本
原数组不变
var arr1 = [1,2,3]
var arr2 = arr1.concat();
console.log(arr1); //[1,2,3]---原数组
console.log(arr1 === arr2); //false
console.log(arr2); //[1,2,3]---原数组的副本
console.log(arr1.concat("hello","world")); //[1,2,3,"hello","world"]
console.log(arr1.concat(["a","b"],[[3,4],{"name":"admin"}])); //[1,2,3,"a","b",[3,4],{"name":"admin"}]
console.log(arr1); //[1,2,3]---原数组未改变补充：slice()与concat() 在无参数传递时，返回的是原数组的副本，即对原数组进行拷贝。
需要注意的是：
1、这两种方法是浅拷贝。当原数组中包含对象、函数或数组元素时，不可拷贝这些元素的堆地址，如果修改这些元素的值，原数组也会被修改。
2、使用JSON.parse(JSON.stringify(array));可实现数组的深拷贝；
var arr = [1, 2, 3, 4, [10, 11]];
var arr1 = arr.slice();
var arr2 = arr.concat();
arr1[4][1] = 88;
arr2[4][0] = 100;
console.log(arr);//[1,2,3,4,[100,88]]
console.log(arr1);//[1,2,3,4,[100,88]]
console.log(arr2);//[1,2,3,4,[100,88]]15、 forEach()
作用：ES5新增的方法，用来遍历数组，没有返回值，因为return并不会起到终止代码运行并返回值的作用
参数：forEach(callback);callback默认有三个参数，分别为value(遍历到的数组的数据)，index(对应的索引)，self(数组自身)。
返回值：无
原数组不变
var arr = [2, 6, 77, 66, 5];
var flag = 0;
arr.forEach(function (value, index, self) {
if (value > 10) {
flag++;
}
});
console.log(flag);//216、 map()
作用：1.同forEach功能；
2.map的回调函数会将执行结果返回，最后map将所有回调函数的返回值组成新数组 返回。
参数：map(callback);callback默认有三个参数，分别为value(遍历到的数组的数据)，index(对应的索引)，self(数组自身)。
返回值：将所有回调函数的返回值组成新数组返回
原数组不变
var arr = ["Tom","Jack","Lucy","Lily","May"];
var a = arr.map(function(value,index,self){
return "hi:"+value;
})
console.log(a); //["hi:Tom", "hi:Jack", "hi:Lucy", "hi:Lily", "hi:May"]
console.log(arr); //["Tom", "Jack", "Lucy", "Lily", "May"]---原数组未改变17、filter()
作用：1.同forEach功能；
2.filter的回调函数需要返回布尔值，当为true时，将本次数组的数据返回给filter，最
后filter将所有回调函数的返回值组成新数组返回（此功能可理解为“过滤”）。
参数：filter(callback);callback默认有三个参数，分别为value，index，self。
返回值：当回调函数返回值为true时，将所有回调函数的返回值组成新数组返回
原数组不变
var arr = ["Tom","Jack","Lucy","Lily","May"];
var a = arr.filter(function(value,index,self){
return value.length > 3;
})
console.log(a); //["Jack", "Lucy", "Lily"]
console.log(arr); //["Tom", "Jack", "Lucy", "Lily", "May"]---原数组未改变补充：map()与filter()的区别：
1、map()方法是根据一定的条件对原数组内容进行处理返回一个新的数组，这个新数组不会改变原数组的长度，只改变原数组的内容。
自我理解：return后跟非判断句
2、filter()方法是根据一定的条件对原数组长度进行过滤返回一个新的数组，这个新数组改变了原数组的长度，不会改变原数组的内容。
自我理解：return后跟判断句，回调函数得到一个布尔值，true的时候才有返回值
//map()如果改变原数组的长度，返回的新数组长度不会有任何变化，效果如下：
let a = [1, 2, 3, 4, 5, 6]
let newA = a.map((x) => {
if (x > 4) {
return x
}
})
console.log(a); //(6) [1, 2, 3, 4, 5, 6]
console.log(newA); //(6) [undefined, undefined, undefined, undefined, 5, 6]
//filter()如果改变原数组的内容，返回的原数组和新数组内容不会有任何变化，效果如下：
let a = [1, 2, 3, 4, 5, 6]
let newA = a.filter((x) => {
return x + '个'
})
console.log(a); //(6) [1, 2, 3, 4, 5, 6]
console.log(newA); //(2)[5,6]
18、every()
作用：
1、当每个回调函数的返回值都为true时，every的返回值为true，只要有一个回调函数的返回值为false，every的返回值都为false （一错全错，全对才对）
2、当回调函数的返回值为true时，类似于forEach的功能，遍历所有；如果为false，那么停止执行，后面的数据不再遍历，停在第一个返回false的位置。（true时才遍历元素）
参数：every(callback);这个回调函数需要有返回值。callback默认有三个参数，分别为value，index，self。
返回值：当所有回调函数返回值为true时，返回true，此时相当于foreach()；当回调函数有一个返回值为false时，返回false，停止遍历；
原数组不变
自我理解：因为每个回调函数都需要返回一个布尔值，因此return后跟的是一个判断句或者一个布尔值
//作用1：
//当每个回调函数的返回值都为true时，every的返回值为true
var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
var a = arr.every(function(value,index,self){
return value.length > 3;
})
console.log(a); //false
//只要有一个回调函数的返回值为false，every的返回值都为false
var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
var a = arr.every(function(value,index,self){
return value.length > 2;
})
console.log(a); //true
//作用2：
//当回调函数的返回值为true时，类似于forEach的功能，遍历所有；
var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
var a = arr.every(function(value,index,self){
console.log(value + "--" + index + "--" + (arr == self))
return true;
})
//如果为false，那么停止执行，后面的数据不再遍历，停在第一个返回false的位置。
var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
var a = arr.every(function(value,index,self){
console.log(value + "--" + index + "--" + (arr == self))
return value.length < 4;
})19、 some()
作用：
1、只要有一个回调函数的返回值都为true，some的返回值为true，所有回调函数的返回值为false，some的返回值才为false（一对全对，全错才错）
2、当回调函数的返回值为false时，类似于forEach的功能，遍历所有；如果为true，那么停止执行，后面的数据不再遍历，停在第一个返回true的位置。（false时才遍历元素）
参数：some(callback);这个回调函数需要有返回值。callback默认有三个参数，分别为value，index，self。
返回值：当所有回调函数返回值为false时，返回false，此时相当于foreach()；当回调函数有一个返回值为true时，返回true，停止遍历；
原数组不变
自我理解：与every()实现的功能差不多，只是布尔值对方法的影响正好相反，多用于查找唯一元素的情况
//作用1：
//只要有一个回调函数的返回值都为true，some的返回值为true，
var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
var a = arr.some(function(value,index,self){
return value.length > 3;
})
console.log(a); //true
//所有回调函数的返回值为false，some的返回值才为false
var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
var a = arr.some(function(value,index,self){
return value.length > 4;
})
console.log(a); //false//作用2：
//当回调函数的返回值为false时，类似于forEach的功能，遍历所有；
var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
var a = arr.some(function(value,index,self){
console.log(value + "--" + index + "--" + (arr == self))
return false;
})
// 打印结果为：
// Tom--0--true
// abc--1--true
// Jack--2--true
// Lucy--3--true
// Lily--4--true
// May--5--true
//如果为true，那么停止执行，后面的数据不再遍历，停在第一个返回true的位置。
var arr = ["Tom","abc","Jack","Lucy","Lily","May"];
var a = arr.some(function(value,index,self){
console.log(value + "--" + index + "--" + (arr == self))
return true;
})
// 打印结果为：
// Tom--0--true20、reduce()
作用：从数组的第一项开始，逐个遍历到最后，迭代数组的所有项，然后构建一个最终返回的值。返回函数累计处理的结果，经常用于求和等
参数：
reduce(function(累计值，当前元素 [，索引号] [，源数组]){ }，起始值);
累计值参数：
1、如果有起始值，则以起始值为准开始累计，即累计值=起始值；
2、如果没有起始值，则累计值以数组的第一个数组元素作为起始值开始累计；
3、以后每次遍历就会用后面的数组元素，累计到累计值里（类似求和里面的sum）
返回值：return后的公式构建得到的值
原数组不变
//demo1:不省略initial参数，回调函数没有返回值
var arr = [10,20,30,40,50];
arr.reduce(function(prev,now,index,self){
console.log(prev + "--" + now + "--" + index + "--" + (arr == self))
}, 2019)
// 打印结果为：
// 2019--10--0--true
// undefined--20--1--true
// undefined--30--2--true
// undefined--40--3--true
// undefined--50--4--true
// 此时回调函数没有return，所以从第二次开始，prev拿到的是undefined
//demo2:省略initial参数，回调函数没有返回值
var arr = [10,20,30,40,50];
arr.reduce(function(prev,now,index,self){
console.log(prev + "--" + now + "--" + index + "--" + (arr == self))
})
// 打印结果为：第一次，回调函数的第一个参数是数组的第一项。第二个参数就是数组的第二项
// 10--20--1--true
// undefined--30--2--true
// undefined--40--3--true
// undefined--50--4--true
// 此时回调函数没有return，所以从第二次开始，prev拿到的是undefined
//demo3:不省略initial参数，回调函数有返回值
var arr = [10,20,30,40,50];
arr.reduce(function(prev,now,index,self){
console.log(prev + "--" + now + "--" + index + "--" + (arr == self));
return "hello";
}, 2019)
// 打印结果为：
// 2019--10--0--true
// hello--20--1--true
// hello--30--2--true
// hello--40--3--true
// hello--50--4--true
// 此时回调函数有return，所以从第二次开始，prev拿到的是回调函数return的值
//demo4:省略initial参数，回调函数有返回值
var arr = [10,20,30,40,50];
arr.reduce(function(prev,now,index,self){
console.log(prev + "--" + now + "--" + index + "--" + (arr == self));
return "hello";
})
// 打印结果为：第一次，回调函数的第一个参数是数组的第一项。第二个参数就是数组的第二项
// 10--20--1--true
// hello--30--2--true
// hello--40--3--true
// hello--50--4--true
// 此时回调函数有return，所以从第二次开始，prev拿到的是回调函数return的值
//demo5：使用reduce计算数组中所有数据的和
var arr = [10,20,30,40,50];
var sum = arr.reduce(function(prev,now,index,self){
return prev + now;
})
console.log(sum); //150
// 回调函数的最后一次return的结果被返回到reduce方法的身上
//demo6：使用reduce计算数组中所有数据的和
var arr = [10,20,30,40,50];
var sum = arr.reduce(function(prev,now,index,self){
return prev + now;
}, 8)
console.log(sum); //158
// 回调函数的最后一次return的结果被返回到reduce方法的身上
// 因为reduce有第二个参数initial，在第一次执行时被计算，所以最终结果被加上821、reduceRight()
与reduce的区别仅在于：从数组的最后一项开始，向前逐个遍历到第一位，反向归并。
22、find()
作用：返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。
参数：find(function(value,index,array){}，[，thisArg]);
返回值：数组中满足函数条件的第一个元素，没有找到满足条件的元素则返回undefined
原数组不变
const arr = [1, 2, 3, 4, 5];
let element = arr.find(value => value > 3);
console.log(element);//423、findIndex()
作用：返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回-1。
参数：findIndex(function(value,index,array){}，[，thisArg]);
返回值：数组中通过提供测试函数的第一个元素的索引。否则，返回-1
原数组不变
const arr = [1, 2, 3, 4, 5];
let index = arr.findIndex(value => value > 3);
console.log(index);//324、Array.from()
作用：将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象。
参数：第一个参数：需要转换的对象；第二个参数：类似map()，对每个元素进行处理（可省）
返回值：返回对象转换成的新数组
原对象不变
//所谓类似数组的对象，本质特征只有一点，即必须有length属性
let arrayLike = {
'0': 'a',
'1': 'b',
'2': 'c',
length: 3
};
// ES5 的写法
var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']
// ES6 的写法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']补充： 扩展运算符背后调用的是遍历器接口（
Symbol.iterator），如果一个对象没有部署这个接口，就无法转换。因此，任何有length属性的对象，都可以通过Array.from()方法转为数组，而此时扩展运算符就无法转换。
//只要是部署了 Iterator 接口的数据结构，Array.from()都能将其转为数组。
Array.from('hello')
// ['h', 'e', 'l', 'l', 'o']
let namesSet = new Set(['a', 'b'])
Array.from(namesSet) // ['a', 'b']Array.from() 第二个参数的使用 ：只要有一个原始的数据结构，你就可以先对它的值进行处理，然后转成规范的数组结构，进而就可以使用数量众多的数组方法。
Array.from(arrayLike, x => x * x);
// 等同于
Array.from(arrayLike).map(x => x * x);
Array.from([1, 2, 3], (x) => x * x)
// [1, 4, 9]25、includes
作用： 返回一个布尔值，表示某个数组是否包含给定的值。与字符串的
includes方法类似。参数：includes(值，搜索的起始位置)，第二个参数表示搜索的起始位置，默认为
0。如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度（比如第二个参数为-4，但数组长度为3），则会重置为从0开始返回值：一个布尔值
原数组不变
[1, 2, 3].includes(2) // true
[1, 2, 3].includes(4) // false
[1, 2, NaN].includes(NaN) // true
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true注意： 在ES6之前使用
indexOf方法，检查是否包含某个值，具有局限性；ES6后使用includes方法。
109
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
