数组的方法

参考：https://blog.csdn.net/MessageBox_/article/details/81225071

添加元素：push、unshift、concat、splice。

1. 改变元有数组

push、pop、shift、unshift、reverse、sort、splice、

2. 不改变原有数组

join、forEach、concat、slice、
map、some、every、filter、reduce
indexOf、find、findIndex、

3. ES6数组的扩展

扩展运算符、
Array.from()、Array.of()、
arr.copyWithin()、arr.fill()、arr.includes()、arr.flat()、

---

1.方法会改变原有数组

相应的方法有：unshift、shift、push、pop、reverse、sort、splice

push后面添加，pop后面删除
shift和unshift是一对，那么都是前面的；unshift字多，那么是添加，shift是删除。

unshift：向数组开头添加元素，并返回新的长度

var arr = [1,2,3,4];
var res = arr.unshift(0);
console.log("arr:",arr); // arr: (5) [0, 1, 2, 3, 4]
console.log("res:",res); // res: 5

shift：将第一个元素删除，并返回删除元素，空即为undefined

var arr = [1,2,3,4];
var res = arr.shift();
console.log("arr:",arr); // arr: (3) [2, 3, 4]
console.log("res:",res); // res: 1

var arr2=[];
var res2=arr2.shift();
console.log(arr2); // []
console.log(res2); // undefined

pop：删除最后一个，并返回删除的元素

var arr = [1,2,3,4];
var res = arr.pop();
console.log("arr:",arr); // arr: (3) [1, 2, 3]
console.log("res:",res); // res: 4

var arr2=[];
var res2=arr2.pop();
console.log(arr2); // []
console.log(res2); // undefined

push：向数组末尾添加元素，并返回新的长度

var arr = [1,2,3,4];
var res = arr.push(5);
console.log("arr:",arr); // arr: (5) [1, 2, 3, 4, 5]
console.log("res:",res); // 5

reverse：颠倒数组顺序

var arr = [1, 2, 3, 4];
var res = arr.reverse();
console.log("arr:", arr); // arr: (4) [4, 3, 2, 1]
console.log("res:", res); // res: (4) [4, 3, 2, 1]

sort：数组排序

默认是按照字符编码的顺序对数组中的元素进行排序；如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值。

• 默认按照字符编码排序（默认是按照最左边的数字进行排序）

var arr = [10,3,20,41];
var res = arr.sort();
console.log("arr:",arr); // arr: (4) [10, 20, 3, 41]
console.log("res:",res); // res: (4) [10, 20, 3, 41]

• 给予排序函数，从大到小排序

a-b，默认是升序的（a到b是升序，b到a是降序）。

var arr = [10,3,20,41];
var res = arr.sort((a,b)=>(a-b));
console.log("arr:",arr); // arr: (4) [3, 10, 20, 41]
console.log("res:",res); //res: (4) [3, 10, 20, 41]

• 给予排序函数，从大到小排序

var arr = [10,3,20,41];
var res = arr.sort((a,b)=>(b-a));
console.log("arr:",arr); // arr: (4) [41, 20, 10, 3]
console.log("res:",res); // res: (4) [41, 20, 10, 3]

splice(start,length,item)删，增，替换数组元素，返回被删除数组

应用：可以实现删除、插入和替换。

1.此方法有三个参数，后两个可以省略
2.item可以为多个，splice(start,length,iem1,item2,item3…)

• 一个参数：从start开始删除元素，返回删除的元素数组

var arr = [1,2,8,4,5];
var res = arr.splice(2);
console.log("arr:",arr); //arr: (2) [1, 2]
console.log("res:",res); // res: (3) [8, 4, 5]

如果从index=0开始（会改变原数组），eg：

var arr = [1,2,8,4,5];
var res = arr.splice(0);
console.log("arr:",arr); //arr: (2) []
console.log("res:",res); // res: (3) [1, 2, 8, 4, 5]

注：clone一个新数组，原数组 就为空了。

• 两个参数：从start开始删除length个元素，返回删除的元素数组

var arr = [1,2,8,4,5];
var res = arr.splice(2,2);
console.log("arr:",arr); // arr: (3) [1, 2, 5]
console.log("res:",res); // res: (2) [8, 4]

注：用法：在前端处理数组的增删改查。eg：

// 删除：
deleteFunc(item) {
  let arr=[]; // 某个数组
  arr.forEach((v,k)=>{
    if(v.id==item.id){
      arr.splice(k,1);
    }
  })
}

• 三个以上参数：从start开始删除length个元素，并将item及item后的参数从start处插入到数组中

var arr = [1,2,8,4,5];
var res = arr.splice(2,2,9,9,3);
console.log("arr:",arr); // arr: (6) [1, 2, 9, 9, 3, 5]
console.log("res:",res); // res: (2) [8, 4]

应用：在数组中间的某一项前面加一个值，eg：在arr[2]前面加值：
与push、pop、shift、unshift功能类似的！

var arr = [1,2,8,4,5];
var res = arr.splice(2,0,9);
console.log("arr:",arr); // arr: (6) [1, 2, 9, 8, 4, 5]
console.log("res:",res); // res: []

注：lodash中：在某个位置加元素；在某个位置删除元素；

2.方法不会改变原数组

相应的方法有：
join、forEach、concat、slice、
map、every、some、filter、reduce、
indexOf、find、findeIndex、

arr.join(separator) 将数组以separator为分隔符进行连接，并返回字符串

separator：可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。

var arr = [1,2,'aa',4];

var res = arr.join('|');
var res2 = arr.join();

console.log("arr:",arr); // arr: (4) [1, 2, "aa", 4]
console.log("res:",res); // res: 1|2|aa|4
console.log(res2); // 1,2,aa,4

arr.forEach((v,k)=>{})循环调用回调函数会处理每一项，且无法正常退出循环，除非抛出异常。没有返回值(undefined)。

使用break，return false都不行的，可以使用try-catch来抛出异常，停止循环。

var arr = [1,2,3];
var res = arr.forEach((v,k)=>{
    console.log(k,v);
    return  2 * v;
});

console.log("arr:",arr); // arr: (3) [1, 2, 3]
console.log("res:",res); // res: undefined

arr.concat(arr1,arr2,arr3...)将数组进行拼接，不会进行去重处理，可以同时连接很多个数组，返回一个连接后的新数组

注：参数可以为单个元素、多个元素、单个数组或者多个数组。

var arr = [1,2,3];
var res = arr.concat([1,2],[3,4]);

console.log("arr:",arr); // arr: (3) [1, 2, 3]
console.log("res:",res); // res: (7) [1, 2, 3, 1, 2, 3, 4]

注：如果是值，直接放进去；如果是数组，只会去除最外一层；eg：

[1].concat(2, [3,[5]], [[4]]); // [1,2,3,[5],[4]]
[1].concat(2, [3,5], [[4]]); // [1,2,3,5,[4]]

arr.slice(start,end)数组中截取从start开始，end结束的数组。返回一个新数组。

注：与splice的区分。splice字多，参数多。参数含义也不一样的。
包括start但不包括end。[start,end)

var  arr = [1,2,3,4,5];
var  res = arr.slice(1,4);

console.log("arr:",arr); // arr: (5) [1, 2, 3, 4, 5]
console.log("res:",res); // res: (3) [2, 3, 4]

var  arr = [1,2,3,4,5];
var  res = arr.slice(0,arr.length);

console.log("arr:",arr); // arr: (5) [1, 2, 3, 4, 5]
console.log("res:",res); // res: (5) [1, 2, 3, 4, 5]
console.log(arr == res); // false
console.log(arr === res); // false

如果数组内部是引用类型的时候：

var arr = [{a:1},{b:2},{c:3},{d:4},{e:5}];
var res = arr.slice(1, 4);

console.log("arr:", arr);// [{a:1},{b:2},{c:3},{d:4},{e:5}]
console.log("res:",res); // [{b:2},{c:3},{d:4}]

// 如果修改值：
res[1].c=111;
console.log("arr:", arr);// [{a:1},{b:2},{c:111},{d:4},{e:5}]
console.log("res:",res); // [{b:2},{c:111},{d:4}]

说明：是浅拷贝，还是会互相影响的！

有负数的情况：

let str= 'abcdefg';

console.log(str.slice(0, -1)); // abcdef
console.log(str.slice(0, -2)); // abcde
console.log(str.slice(-2, 111)); // fg
console.log(str.slice(-4, 111)); // defg
console.log(str.slice(-4, 5)); // de

注：
1.第一个参数为负数，那么是从倒数第几位开始，到end结束。（负数从-1开始，没有0）。
2.第二个参数为负数，那么是从start开始，到倒数第几个。

arr.map((v,k)=>{})返回一个新的数组，新数组的每一项都是回调函数处理的结果。

var arr = [1,2,3];
var res = arr.map((v,k)=>{
    console.log(k,v);
    return  2 * v;
});

console.log("arr:",arr); // arr: (3) [1, 2, 3]
console.log("res:",res); // res: (3) [2, 4, 6]

var arr= [{name:1,value:111},{name:2,value:222}];
arr.map(o=>o.value)

// 返回的数组： [111, 222]

var arr=[
    {key:'key1',value:1,name:'a'},
    {key:'key2',value:2,name:'b'},
    {key:'key3',value:3,name:'c'},
    {key:'key4',value:4,name:'d'},
];

var newArr=arr.map((v,k)=>{
    return v.value*2; // 只会返回value这一项。
});

console.log(arr); // 不变
console.log(newArr); // [2,4,6,8]

arr.every(callback)检测数组所有元素是否都符合callback中的指定条件，返回boolean值

如果数组中检测到有一个元素不满足，则表达式返回 false ，且不再检测剩余元素。
如果所有元素都满足条件，则返回 true。
callback 被调用时传入三个参数：元素值，元素的索引，原数组。
遇假就退出，返回false。

var arr = [1,2,3];
var res = arr.every((v,k,arr)=>{
    console.log(arr); // [1, 2, 3]
    console.log(k,v); // 只执行了一次：0 1，就直接跳出了，返回结果。
    return  v>3;
});

console.log("arr:",arr); // arr: (3) [1, 2, 3]
console.log("res:",res); // res: false

arr.some(callback)检测数组中是否有符合callback中条件的元素，如果有就返回true，否则返回false

1.如果有一个元素满足条件，则表达式返回true , 且不再检测剩余元素。
如果没有满足条件的元素，则返回false。
2.callback 被调用时传入三个参数：元素的值，元素的索引，被遍历的数组。
遇真就退出，且返回true。

var arr = [1, 2, 8, 4];
var res = arr.some((val) => (val > 3));
console.log("arr:", arr);
console.log("res:", res);
//输出
//arr: (4) [1, 2, 8, 4]
//res: true

arr.filter(callback)返回数值中符合callback中条件的所有元素组成的新数组

var arr = [1, 2, 8, 4];
var res = arr.filter((v, k) => {
    console.log(k, v);
    return v > 3;
})

console.log("arr:", arr); // arr: (4) [1, 2, 8, 4]
console.log("res:", res); // res: (2) [8, 4]

var arr = [{a:1},{b:2},{c:3},{d:4},{e:5}];
var res = arr.filter((v,k)=>{
    return k!=0;
})

console.log("arr:", arr);// [{a:1},{b:2},{c:3},{d:4},{e:5}]
console.log("res:",res); // [{b:2},{c:3},{d:4},{e:5}]

res[1].c=111;
console.log("arr:", arr);// [{a:1},{b:2},{c:111},{d:4},{e:5}]
console.log("res:",res); // [{b:2},{c:111},{d:4},{e:5}]

也是浅层次的拷贝，会互相影响的！

arr.reduce(callback)

参考：https://www.cnblogs.com/leejersey/p/5466091.html

callback：执行数组中每个值的函数，包含四个参数

// 语法：
arr.reduce((previousValue, currentValue, index, array) => {
    return previousValue + currentValue;
}, initialValue)

参数：
previousValue：上一次调用回调返回的值，或者是提供的初始值（initialValue）。
currentValue 数组中当前被处理的元素。
index当前元素在数组中的索引。
array调用 reduce 的数组。
initialValue作为第一次调用 callback 的第一个参数。

注：initialValue可以省略；
如果省略的话，那么previousValue取arr[0]，currentValue取arr[1]；执行arr.length-1次。
如果没有省略的话，那么previousValue取initialValue，currentValue取arr[0]；执行arr.length次。

 var arr = [1, 2, 3, 4, 5];
 var res = arr.reduce((prev, val, key, arr) => {
         console.log(arr); // (5) [1, 2, 3, 4, 5]
         console.log(prev, val, key); // 执行了4次，eg：
         // 1 2 1
         // 3 3 2
         // 6 4 3
         // 10 5 4
         return prev + val;
     }
 );
 console.log("arr:", arr); // arr: (5) [1, 2, 3, 4, 5]
 console.log("res:", res); //res: 15

arr.indexOf(value,index)寻找数组中值为value项的索引，如果没有符合条件的则返回 -1

var  arr = [1,2,3];
var  res = arr.indexOf(2);

console.log("arr:",arr); // arr: (3) [1, 2, 3]
console.log("res:",res); // res: 1

注：数组内为引用类型，那么是找不到的。eg：

var  arr = [
    {key:'key1',value:1,name:'a',},
    {key:'key2',value:2,name:'b',flag:true,},
    {key:'key3',value:3,name:'c',flag:false,},
];
var  res = arr.indexOf({key:'key2',value:2,name:'b',flag:true,}); // 直接复制粘贴查找第二项，找不到的；如果是arr[1]，那么可以找到。
var  res2 = arr.indexOf(arr[1]);

console.log("res:",res); // res: -1
console.log("res2:",res2); // res2: 1

arr.find(callback)返回callback中符合测试条件的第一个数组元素的值，如果没有符合条件的元素返回 undefined

var arr = [1,22,23,24];
var res = arr.find((val)=> val > 22 );

console.log("arr:",arr); // arr: (4) [1, 22, 23, 24]
console.log("res:",res); // res: 23

var arr = [
    {key:'key1',value:1,name:'a',},
    {key:'key2',value:2,name:'b',flag:true,},
    {key:'key3',value:3,name:'c',flag:true,},
];
var res = arr.find((val)=> {
    return val.flag;
} );

console.log("arr:",arr); // 不变
console.log("res:",res); // {key: "key2", value: 2, name: "b", flag: true} // 有符合的就跳出了，不继续执行。

arr.findIndex(callback)返回callback中符合测试条件的第一个数组元素索引，如果没有符合条件的则返回 -1

var arr = [1, 2, 8, 4];
var res = arr.findIndex((val) => (val > 3));

console.log("arr:", arr); // arr: (4) [1, 2, 8, 4]
console.log("res:", res); // res: 2

ES6数组的扩展

1.扩展运算符（...）
2.Array.from()
3.Array.of()
4.arr.copyWithin()
5.arr.find()和arr.findIndex()
6.arr.fill()
7.arr.includes()
8.arr.flat()
详见：myself：https://blog.csdn.net/weixin_42995876/article/details/87874242

判断一个数组是否为数组：
Array.isArray() 返回值为boolean值