数组去重

//数组去重

let arr = [1,2,3,5,1,2,2,2,1,1,5,6,4,3,1,2];

//创建一个新数组，利用includes判断是否重复
let newArr = [];
for(let i = 0; i < arr.length; i++){
    if(!newArr.includes(arr[i])){
        newArr.push(arr[i]);
    }
}
console.log(newArr);


//利用splice删除j这一个
for(let i = 0; i < arr.length -1; i++){
    for(let j = i + 1; j < arr.length; j++){
        if(arr[j] === arr[i]){
            arr.splice(j , 1);
            j--;//数组塌陷
        }
    }
}
console.log(arr);
let arr1 = [1,2,3,5,1,2,2,2,1,1,5,6,4,3,1,2];
//基于对象去重
let obj = {};

for(let i = 0; i < arr1.length; i++){
    let item = arr1[i];
    if(obj[item]){
        arr1[i] = arr1[arr1.length - 1];//重复就和数组最后一个交换
        arr1.length--;//长度-1
        i--;//依然检查当前的元素是否重复
    }else{
        obj[item] = item;
    }
}
console.log(arr1);


//SET去重
let arr2 = [1,2,3,5,1,2,2,2,1,1,5,6,4,3,1,2];
console.log([...new Set(arr2)]);


//map 返回一个新数组 element元素  index 是下标  arr3是元数组 
let arr3 = ['apple','banana','panada'];
arr3 = arr3.map((element, index, arr3)=>{
    return element + ' that';
})
console.log(arr3);

//fliter是筛选数组，然后返回新数组 参数同上  返回true的元素
let arr4 = [1,2,3,4,5,6,7,8,9];

arr4 = arr4.filter((element) => {
    return element%2 === 0;
})

console.log(arr4);

//reduce对数组所有值转化成一个值
let arr5 = [1,2,3,4,5,6];
let sum = arr5.reduce((acc,element,index,arr5)=>{
    return acc + element;
},0);
console.log(sum);

数组拍平

var result = []
function unfold(arr){
     for(var i=0;i< arr.length;i++){
      if(typeof arr[i]=="object" && arr[i].length>1) {
       unfold(arr[i]);
     } else {        
       result.push(arr[i]);
     }
  }
}
var arr = [1,3,4,5,[6,[0,1,5],9],[2,5,[1,5]],[5]];
unfold(arr)


var c=[1,3,4,5,[6,[0,1,5],9],[2,5,[1,5]],[5]];
var b = c.toString().split(',')


var arr=[1,3,4,5,[6,[0,1,5],9],[2,5,[1,5]],[5]];

const flatten = arr => arr.reduce((a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []);

var result = flatten(arr)

数组求深度

let arr1 = [1,2,[0],[3,4,[5,[6,[7,8]]]]]

function dfs(arr){
    let eleDepths = [];

    arr.forEach((item)=>{
        let depth = 0;
        if(Array.isArray(item)){
           depth = dfs(item);//递归求每一个数组的深度
        }
        eleDepths.push(depth);
    })

    return 1 + Math.max.apply(null,eleDepths);//返回最大的深度
}

console.log(dfs(arr1));

reduce的用法

//数组求和
let arr1 = [1,2,3,4,5,6,7,8,9];
let sum = arr1.reduce((pre,cur,index)=>{
    return pre + cur;
},0);
console.log(sum);

//数组摊平
let arr2 = [2,4,1,[2,4,5,7,8,[8,5,4,[8]]]];

let newArr = (arr) =>{
    return arr.reduce((pre,cur,index)=>{
        if(Array.isArray(cur)){
            return pre.concat(newArr(cur));
        }else{
            return pre.concat(cur);
        }
    },[])
}

console.log(newArr(arr2));

//数组去重

let arr3 = [1,3,4,5,6,1,3,5,6,7,7,1,2,2,3];

let newArr2 = arr3.reduce((pre,cur,index)=>{
    if(!pre.includes(cur)){
        return pre.concat(cur);
    }else{
        return pre;
    }
},[]);
console.log(newArr2);

for..in 和 for..of 的区别

• 推荐在循环对象属性的时候，使用for...in,在遍历数组的时候的时候使用for...of。
• for…in…遍历对象会遍历出对象的所有可枚举的属性
• for...in循环出的是key，for...of循环出的是value
• 注意，for...of是ES6新引入的特性。修复了ES5引入的for...in的不足 for...of不能循环普通的对象，需要通过和Object.keys()搭配使用