1.arr.valueOf() // 返回值为该对象的原始值
var arr=[1,2,3,4,56,6];
2.arr.toString() // 返回数组内容的字符串表示形式
const arr = [1, 2, 3, 4, 56, 6];
console.log(arr.toString()); //1,2,3,4,56,6
3.String(arr) // 将数组中每个元素转为字符串，并用逗号连接。
const arr = [1, 2, 3, 4, 56, 6];
console.log(String(arr)); //1,2,3,4,56,6
4.arr.join(“连接符”) // 将数组中每个元素转为字符串，用自定义的"连接符"连接每个元素,需要用变量借助
const arr = [1, 2, 3, 4, 56, 6];
console.log(arr.join("")); //1234566
console.log(arr.join(" ")); //1 2 3 4 56 6
console.log(arr.join(",")); //1,2,3,4,56,6
5.arr.reverse() // 将数组中元素的位置颠倒,并返回该数组,注意：原数组会改变
const arr = [1, 2, 3, 4, 56, 6];
console.log(arr.reverse()); // [6, 56, 4, 3, 2, 1]
6.arr.sort() // 数组排序，按字符串大小排序,会改变原数组
const arr = [1, 2, 3, 4, 56, 6];
console.log(arr.sort((a, b) => a - b)); // [1, 2, 3, 4, 6, 56]
console.log(arr.sort((a, b) => b - a)); //[56, 6, 4, 3, 2, 1]
7.arr.concat(otherArr) // 合并新元素，返回一个新数组需要用变量接住，不会改变原数组
const arr = [1, 2, 3, 4, 56, 6];
arr.concat([0, 12, 12]);
console.log(arr.concat([0, 12, 12])); //[1, 2, 3, 4, 56, 6, 0, 12, 12]
console.log(arr.concat(2)); //[1, 2, 3, 4, 56, 6, 2]
8.arr.slice(start,end) // 剪切数组，含头不含尾 ,返回新的数组，不会改变原数组
const arr = [1, 2, 3, 4, 56, 6];
//两个参数
console.log(arr.slice(1, 3)); //[2, 3]
//一个参数
console.log(arr.slice(1)); //[2, 3, 4, 56, 6]
console.log(arr.slice(2)); //[ 3, 4, 56, 6]
注意：拼接和截取: 都无法直接修改原数组而是返回新数组，用变量接住
arr.split([ 起始位置 | 要删除元素的个数 | 要插入元素的值，可以写入多个值 ] )剪切数组/替 换/新增
9.arr.indexOf(item) // 返回第一个匹配到的元素在数组中所在的位置 ，如果没有找到就是返回 -1
const arr = [1, 2, 3, 4, 56, 6];
console.log(arr.indexOf(6)); //5
console.log(arr.indexOf(66)); //-1表示没有找到
10.arr.push() // 尾部添加元素，返回被新数组的长度,原数组会改变
const arr = [1, 2, 3, 4, 56, 6];
console.log(arr.push(1)); //返回数组元素的个数
console.log(arr); //[1, 2, 3, 4, 56, 6, 1]
11.arr.pop() // 尾部删除元素，返回被删除的元素,原数组会改变
const arr = [1, 2, 3, 4, 56, 6];
console.log(arr.pop()); //返回被删除的元素，原数组被修改
console.log(arr); //[1, 2, 3, 4, 56]
12.arr.unshift(item) // 头部添加元素，返回新数组的长度,原数组会改变
const arr = [1, 2, 3, 4, 56, 6];
console.log(arr.unshift(1)); //在数组卡起头添加元素，返回数组元素的个数，会修改原数组的
console.log(arr); //[1, 1, 2, 3, 4, 56, 6]
13.arr.shift(item) // 头部删除元素，返回被删除的元素,原数组会改变
const arr = [1, 2, 3, 4, 56, 6];
console.log(arr.shift()); //返回被删除的元素，会修改原数组的
console.log(arr); //[ 2, 3, 4, 56, 6
14.arr.every(function(item,index,array){}) // 该函数对每一项都返回true，则返回true,否则返回false
array.every(function(item,index,array）{
//item:当前元素的值；
//index:当前元素的索引；
// array:当前元素的数组对象；
})
every()方法使用指定函数检测数组中的所有元素:
如果数组中检测到有一个元素不满足，则整个表达式返回false，且剩余的元素不会再进行检测。如果所有元素都满足条件，则返回true；
注意：every()不会对空数组进行检测；
every()不会改变原来的数组
15.arr.some(function(item,index,array){}) // 该函数对其中一项返回true，则返回true
array.some(function(item,index,array){
//item:当前元素的值；
//index:当前元素的索引；
// array:当前元素的数组对象；
}
some()方法会依次执行数组的每个元素:
如果有一个元素满足条件，则表达式返回true，剩余的元素不会再执行检测。如果没有满足条件的元素，则返回false
注意：some()不会对空数组进行检测；
some()不会改变原始数组；
16.arr.filter(callback) // 数组过滤，返回满足条件的元素组成的一个新数组
17.arr.map(callback) // 对数组每一项进行计算等处理，返回处理结果组成的数组,返回的是一个新数组
var numbers = [1, 4, 9];
var doubles = numbers.map(function (num) {
return num * 2;
});
console.log(numbers);
console.log(doubles);
注意:通常情况下，map 方法中的 callback 函数只需要接受一个参数，就是正在被遍历的数组元素本身。但这并不意味着 map 只给 callback 传了一个参数
eg;
["1", "2", "3"].map(parseInt);// [1, NaN, NaN]
18.arr.reduce(fn) // 前一个元素 | 当前元素，从1开始 | 后一个元素的序列，从1开始计数 | 表示该数组
var arr = [1,2,3,4,5];
var reduceArr = arr.reduce(function(pre,cur,index,array){
return prev + cur;
}) //15
19， …[arr] 数组扩展运算符
20.Math.min(…[arr]) 等同于Math.min.apply(null,arr) 替换数组的apply方法
var arr=[1,2,3,4,5,6,7];
console.log(Math.min(...arr));//1
21.arr1.push(…arr2) 等同于Array.prototype.push.apply(arr1,arr2) 一个数组添加到另一个数组的尾部
var arr=[1,2,3,4,5,6,7];
var arr1=[8,9,10];
arr.push(...arr1);
console.log(arr);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
22.[…arr1,…arr2,…arr3] 等同于arr1.concat(arr2,arr3) 合并数组
var arr=[1,2,3,4,5,6,7];
var arr1=[8,9,10];
var arr2=[20,23,34,35,26];
console.log([...arr,...arr1,...arr2]);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 23, 34, 35, 26]
23.let[first,…const]=[1,2,3,4]，结果first=1，const=[2,3,4] 结合解构一起使用
let [a,...b]=[1,2,3,4,5];
console.log(a);//1
console.log(b);//[2, 3, 4, 5]
24.Array.from() 将类数组对象和可遍历的对象转换为真正的数组（包括ES6新增的数据结构Set和Map）
Array.from(“hello”) [“h”,”e”,”l”,”l”,”o”]
let person={
0:'张三',
1:'李四',
2:'王五',
length:3 //必须要设置对象长度
};
let arr=Array.from(person); //等同于let arr=[].slice.call(person);
Array.of(1,2,3) //将一组值转换为数组 [1, 2, 3]
25.Array.find(function(val,index,arr){
…
})
找到第一个符合条件的数组成员Array.find(function(val,index,arr)) 找到第一个符合条件的数组位置
这两个方法都可以发现NaN，弥补了数组的IndexOf方法的不足。
//find方法
[1, 2, 3, 4].find((value, index, arr) => {
console.log(value,index,arr);
// 1 0 (4) [1, 2, 3, 4]
// 2 1 (4) [1, 2, 3, 4]
// 3 2 (4) [1, 2, 3, 4]
// 4 3 (4) [1, 2, 3, 4]
value：每一次迭代查找的数组元素。
index：每一次迭代查找的数组元素索引。
arr：被查找的数组。
//-------------------------------------------------
const arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
var ret1 = arr1.find((value, index, arr) => {
return value > 4
})
var ret2 = arr1.find((value, index, arr) => {
return value > 14
})
console.log(ret1);//5
console.log(ret2);//undefined
26.arr.includes()方法
let site = ['runoob', 'google', 'taobao'];
site.includes('runoob');
// true
site.includes('baidu');
// false
//------------------------------------
//arr.includes(searchElement, fromIndex)
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true
//searchElement 必须。需要查找的元素值。
//fromIndex 可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。