除了下面这些，还要结合这里一起看看 juejin.cn/post/698239…
<script>
// 一 数组扁平化
// 方法一： reduce + concat 无视数据类型
function flatten(arr) {
return arr.reduce((result, item) => {
return result.concat(Array.isArray(item) ? flatten(item) : item)
}, [])
}
let arr = [...flatten([1, 2, 3, [5, 5, 6, [7, 8]]])]
// arr = Array.from(new Set(arr))
// const arr1 = [1, 2, 3, ["5", 5, 6, [7, 8]]]
console.log(arr);
// 方法二：只有数据类型的才可以 toString + slpit + map + parseInt
// console.log([2,[3,[4,[5,[6]]]]].toString().split(',').map(item => parseInt(item)));
// console.log(["1", 2, 3, ["5", 5, 6, [7, 8]]].toString().split(',').map(item => parseInt(item)));
// 方法三： join + split + map + parseInt
// console.log(["1", 2, 3, ["5", 5, 6, [7, 8]]].join(',').split(',').map(item => parseInt(item)));
// 方法四：arr.flat(Infinity)
// console.log(arr1.flat(Infinity));
// 二 数组去重
// 方法一（es6常用）
// const arr2 = [1, 1, 1, 2, 2, 3, 3, 5, 1, 6]
// console.log(Array.from(new Set(arr2)));
// 方法二（es5 for嵌套for + splice）
// function unique(arr2) {
// for (var i = 0; i < arr2.length; i++) {
// for (j = i + 1; j < arr2.length; j++) {
// if (arr2[i] == arr2[j]) {
// arr2.splice(j, 1)
// j--
// }
// }
// }
// return arr2
// }
// console.log(unique(arr2));
// 方法三（filter + indexOf） 筛选条件：当前元素位置===数组该元素的第一个位置
let arr = [8, 2, 2, 4, 3, 5]
let r = arr.filter(function (currentValue, index, arr) {
return arr.indexOf(currentValue) === index
})
console.log(r); // [8, 2, 4, 3, 5]
// 三 数组排序
// 方法一 arr.sort
// const arr3 = [1, 1, 1, 2, 2, 3, 3, 5, 1, 6]
// console.log(arr3.sort((a, b) => {
// return b - a
// }))
// 方法二 冒泡排序 for + for
// for (var i = 0; i < arr3.length; i++) {
// for (var j = i + 1; j < arr3.length; j++) {
// if (arr3[i] > arr3[j]) {
// var temp = []
// temp = arr3[i]
// arr3[i] = arr3[j]
// arr3[j] = temp
// }
// }
// }
// console.log(arr3);
// 四 数组最大值
// 方法一
// let arr4 = [1, 1, 1, 2, 2, 3, 3, 5, 1, 6]
// // console.log(Math.max(...arr4));
// arr4 = arr4.sort()
// console.log(arr4[arr4.length-1]);
// 五 数组求和
// 方法一 arr.reduce
// let arr5 = [1, 1, 1, 2, 2, 3, 3, 5, 1, 6, 5]
// function total(arr5) {
// return arr5.reduce(function (result, num) {
// return result + num
// })
// }
// console.log(total(arr5));
// 方法二
// let total = 0
// for (var i = 0; i < arr5.length; i++) {
// total += arr5[i]
// }
// console.log(total);
// 六 数组合并
// 方法一 concat
// var arr6 = [1, 2, 3]
// var arr66 = [4, 5, 6]
// var arr666 = arr6.concat(arr66)
// console.log(arr666);
// // 方法二 ...
// console.log([...arr6, ...arr66]);
// 七 判断数组中是否有值
// 方法一 ：indexOf 有值返回对应下标 没有返回 -1
var arr7 = [1, 2, 1, 3]
console.log(arr7.indexOf(1));
// 方法二：findIndex 直接返回下标位置 找不到 返回 -1
console.log(arr7.findIndex(item => item == 1));
// 方法三 ：includes 有返回 true 无返回 false
console.log(arr7.includes(1));
// 方法四： some 找到返回 true 找不到 返回false
console.log(arr7.some(item => item == 33));
// 方法五：find 直接返回查到到对应的内容 找不到 返回undefined
console.log(arr7.find(item => item == 3));
// 区别：
// indexOf ：查找值作为第一个参数，采用 === 比较，更多的是用于查找基本类型，如果是对象类型，则是判断是否是同一个对象的引用
// findIndex ：比较函数作为第一个参数，多用于非基本类型(例如对象)的数组索引查找，或查找条件很复杂
// some() 方法用于检测数组中的元素是否满足指定条件，不会改变原始数组，不会对空数组进行检测。
// 返回布尔值 如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测,否则则返回false。
// includes() 方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false
// 九 每项设置值 array.fill(value, start, end)
console.log([2, 3, 5].fill(true, false, true)); // [true,3,5]
console.log([2, 3, 5].map(() => 0)); // [0,0,0]
console.log([false, false, false].map(() => 0)); // [0,0,0]
// 十 每一项是否满足/某一项是否满足
console.log([2, 3, 5].every(item => item > 2));
console.log([2, 3, 5].some(item => item > 2));
// 十一：对象和数组转化
console.log(Object.keys({ name: '张三', age: 14 })); // ["name", "age"]
console.log(Object.values({ name: '张三', age: 14 })); // ["张三", 14]
console.log(Object.entries({ name: '张三', age: 14 })); // // [Array(2), Array(2)] 0: (2)["name", "张三"]1: (2)["age", 14]
</script>
