const/var/let 的区别
1.const定义的变量不可以修改，而且必须初始化。
2.var定义的变量可以修改，如果不初始化会输出undefined，不会报错。
3.let是块级作用域，函数内部使用let定义后，对函数外部无影响。
新建数组
数组内可以存放任意类型的数据
1. let arr = new Array(); //先创建数组对象再赋值
2. let arr = new Array(123, "string", true); //直接实例化创建
3. let arr = [123, "string", true]; //推荐
增删改查
栈方法 push & pop 增删数组元素(从尾部)
let push1 = arr.push(456, "hi"); //返回更新后的数组长度
let pop1 = arr.pop(); //弹出尾部元素，并返回弹出的元素
队列 shift & unshift 方法增删数组元素(从头部)
let unshift1 = arr.unshift(111, "abc"); //返回更新后的数组长度
let shift1 = arr.shift(); //返回弹出元素
splice 增删数组元素
splice(arg1, arg2, arg3, …)第一个参数定义了新添加元素的位置，第二个参数定义应删除多少元素，其余参数定义要添加的元素，并返回一个包含已删除项的数组
concat 合并数组
let concat1 = temp1.concat(temp2, temp3);
slice 裁剪数组
slice(arg1, arg2) 返回一个新数组，第一个参数为元素选取开始位置，第二个参数为元素选取结束位置
查找定位
查数组中的最大值和最小值
Math.max.apply(null, arr) 来获取数组中的最大值。
Math.min.apply(null, arr) 来获取数组中的最小值。
查找索引
indexOf(arg1, arg2)方法在数组中搜索元素值并返回其位置。arg1 为搜索元素，arg2 可选从哪里开始搜索。负值将从结尾开始的给定位置开始，并搜索到结尾。
lastIndexOf(arg1,arg2) 与 indexOf() 类似，但是从数组结尾开始搜索。arg2 可选从哪里开始搜索。负值将从结尾开始的给定位置开始，并搜索到开头。
findIndex() 方法返回通过测试函数的第一个数组元素的索引。
let temp = [1,2,3,4,5,4,3,2];
let pos1 = temp.indexOf(4); //第一次出现4的位置
console.log(pos1); //3
let pos2 = temp.lastIndexOf(4); //最后一次出现4的位置
console.log(pos2); //5
let temp = [1,35,67,8];
//返回第一个大于10的元素索引
let findIndex1 = temp.findIndex(function(value){
return value > 10;
});
console.log(findIndex1); //1
查找值
find(function(arg1,arg2,arg3)) 方法返回通过测试函数的第一个数组元素的值。arg1 为数组元素值， arg2 为数组元素索引，arg3 为数组本身。
let temp = [1,35,67,8];
// 返回第一个大于10的值
let find1 = temp.find(function(value){
return value > 10;
});
console.log(find1);//35
数组转换
toString 数组转字符串（toString()方法把每个元素转换为字符串，然后以逗号连接输出显示）
let toString1 = arr.toString();
join 数组转字符串 (可以指定分隔符，默认使用逗号作为分隔符)
let join = arr.join('*');
split 字符串转数组(split(arg1,arg2),第一个参数为分隔符，指定从哪儿进行分隔的标记；第二个参数指定要返回数组的长度)
let split =temp.split("-", 2);
对象转数组
let obj = {key1: "value1", key2: "value2"}
// 对象的键组成数组
let trans1 = Object.keys(temp); //["key1", "key2"]
// 对象的值组成数组
let trans2 = Object.values(temp); //["value1", "value2"]
// 键值对组成的数组
let trans3 = Object.entries(temp); //[["key1", "value1"], ["key2", "value2"]]
数组转对象
let temp = ["a","b"];
let trans1 = {...temp}; //{0: "a", 1: "b"}
let trans2 = Object.assign({}, temp); //{0: "a", 1: "b"}
数组排序
//字符串可以直接进行排序
arr.sort();
//数字排序
// sort比值函数修正：降序
let temp = [40, 100, 1, 5, 25, 10];
temp.sort(function(a, b){
return b-a
});
// sort比值函数修正：升序
let temp = [40, 100, 1, 5, 25, 10];
temp.sort(function(a, b){
return a-b;
});
reverse 数组反转
temp.reverse();
数组迭代
temp.forEach(function(value, index, array){});
temp.map(function(value, index, array){});
filter(function(arg1,arg2,arg3){})方法创建一个包含通过指定条件的数组元素的新数组, arg1 为数组元素值， arg2 为数组元素索引，arg3 为数组本身，不会更改源数组。
every(function(arg1,arg2,arg3){})方法测试数组的所有元素是否通过了置顶条件。arg1 为数组元素值， arg2 为数组元素索引，arg3 为数组本身。不会更改源数组。
some(function(arg1,arg2,arg3){})方法测试数组中是否有元素通过了指定条件的测试。不会更改源数组。
reduce(function(arg1,arg2,arg3,arg4){})接收一个函数作为累加器（accumulator），数组中的每个值（从左到右）开始缩减，最终为一个值。arg1 上一次调用回调返回的值，或者是提供的初始值（initialValue）,arg2 为数组元素值， arg3 为数组元素索引，arg4 为数组本身。不会更改源数组。
//普遍for循环
for(let i=0,len=temp.length;i<len;i++) {}
for(let i in temp){}
for(let i of temp){}
检测类型
1. temp1 instanceof Array
2. Array.isArray(temp1)
3 .Object.prototype.toString.call(temp1)
洗牌算法
let temp = [1,3,5,6,7,2,4];
temp.sort(() => {
return Math.random() - 0.5;
})
数组去重
// es6的set方法
let unique1 = Array.from(new Set(temp));
// 遍历数组
for(let i=0; i<temp.length;i++){
if(newArr.indexOf(temp[i]) === -1){
newArr.push(temp[i]);
}
}
数组扁平化
对于[1, [1,2], [1,2,3]]这样多层嵌套的数组，我们如何将其扁平化为[1, 1, 2, 1, 2, 3]这样的一维数组呢：
1.ES6的flat()
const arr = [1, [1,2], [1,2,3]]
arr.flat(Infinity) // [1, 1, 2, 1, 2, 3]
2.序列化后正则
const arr = [1, [1,2], [1,2,3]]
const string = `[${JSON.stringify(arr).replace(/\[|\]/g, '')}]`
JSON.parse(string)
3.递归
const arr = [1, [1,2], [1,2,3]]
function flat(arr){
let result = [];
for(const item of arr){
item instanceof Array ? result = result.concat(flat(item)) : result.push(item)
}
return result;
}
flat(arr);
4.reduce()递归
function flat(arr) {
return arr.reduce((prev, cur) => {
return prev.concat(cur instanceof Array ? flat(cur) : cur)
}, [])
}
flat(arr)
5.迭代+展开运算符
let arr = [1, [1,2], [1,2,3]]
while (arr.some(Array.isArray)) {
arr = [].concat(...arr);
}
console.log(arr) // [1, 1, 2, 1, 2, 3]
