常用的方法

1. 多维数组转一维数组

   var arr = [1,2, [1,2,3],4,5,[5,6,[1,2]],7,8]
   // 转字符串后转回数组，此时数组值为字符串，然后用map转number
   let arr1 = arr.join(',').split(',')
   let res = arr1.map(item =>  Number (item))
   
  // 方法二递归
    var arr = [1,2, [10,20,30],4,5,[15,16,[21,31]],7,8]
   
    function fun (data){
        var res = []
        for(let item of data) {
            if(item instanceof Array){
                fun(item)
            } else {
                 res.push(item)
            }
        }
        return res
    }
    console.log(fun(arr))
   

2.排序

// 1.冒泡排序
  let arr = [1,3,6,2,10]
  
  function fun (arr){
     for (var i=0;i<arr.length-1;i++){
        //控制每比较的次数
        for (var j=0;j<arr.length-1-i;j++){
            if (arr[j]<arr[j+1]){
                // 或es6的数组解构语法
                [arr[j], arr[j+1]] = [arr[j+1], arr[j]]
            }
        }
    }
    return arr
  }

 //   2.快速排序
    // //快排
  var arr = [2,5,1,4,9,10]
    
  function fun (arr) {
    var arr1 = []
    var cindex = Math.floor(arr.length / 2)
    var c = arr.splice(cindex, 1);
    for (var i = 0; arr.length > i; i++){
        if (arr[i] > c){
            arr1.push(arr[i])
        } else {
            arr1.unshift(arr[i])
        }
    }
    arr1.splice(cindex-1, 0, ...c)
    return arr1
  }

3.字符串中重复最多的字符

    var str = 'aaabbbbccd' 或 var str = [1,1,1,1,2,2,3,4]
    
    var obj = {} //转成对象格式
    for(let i = 0; str.length > i; i++){
     if(!obj[str[i]]){ //对象key值不存在时，新加入value默认1
        obj[str[i]] = 1
     }else {
        obj[str[i]]++ // 存在自加
     }
    }
   console.log(obj) // {a:3;b:4;c:2;d:1}

    var max = 0 // 最多次数即对象value最大值
    var n = '' // 最大值的key
    for(var j in obj) {
        if(obj[j] > max){
           max = obj[j]
           n = j
        }
    }

4.json对象去重函数

function uniqueArray(arr,key){
    // new_arr数组是存放key值的对象，用于排除重复的对象
    var new_arr=[];
    // result用于存放new_arr排除后没有重复对象的值
    var result=[];
    for(var i=0; i<arr.length; i++){
        //  new_arr中不包含key值才能进入
        if(!new_arr.includes(arr[i][key])){     
            //如果没有找到就把这个key放到arr里面，以便下次循环时用
            new_arr.push(arr[i][key]);           
            //result中不存在的项push进去
            result.push(arr[i]);                 
        }
    }
    return result;
}

5.浅拷贝与深拷贝

1）深复制在计算机中开辟了一块内存地址用于存放复制的对象，
2）而浅复制仅仅是指向被复制的内存地址，如果原地址中对象被改变了，那么浅复制出来的对象也会相应改变。

//1.浅拷贝
    ES6：Object.assign() 
    数组： 
        let arr = [1, 2, 3]
        let copy_arr = []
        
        1.copy_arr = Array.from(arr)
        2.copy_arr = [...arr]
        3.for(var i=0; i<arr.length; i++){
          copy_arr[i]=arr[i];
        }
    对象：
        let obj = {name: 'zhangsan',sex: '男'}
        let copy_obj = {}
        for(var i in obj){
            copy_obj[i] = obj[i]
        }
        
//2.深拷贝--递归复制

function deepCopy(obj){
    let result = Array.isArray(obj)?[]:{};  
    if(obj && typeof obj === 'object'){ 
        for(let key in obj){
            if(obj.hasOwnProperty(key)){
                // 如果key还是对象或数组继续调用该方法
                if(obj[key]&&typeof obj[key]==='object'){
                    result[key]=deepCopy(obj[key]);
                }else{
                    result[key]=obj[key];
                }
            }
        }
    }
    return result;
}

6.倒计时

// 倒计时10秒
//1.延时器实现
var time = 10
var timer = setInterval(() => {
if(time>1){
    time -- 
} else {
    time = 0
    clearInterval(timer)
}
console.log(time)
},1000)

//2.定时器实现
    var time = 10
    function fun(){
        var timer = setTimeout(fun,1000) 
        if(time>1){
            time -- 
        } else {
            time = 0
            clearTimeout(timer)
        }
        
        console.log(time)
    }
    fun()

Json 对象，判断两个value值相等

function uniqueArray(arr,key,val){
    // new_arr数组是存放key值的对象，用于排除重复的对象
    var new_arr=[];
    // result用于存放new_arr排除后没有重复对象的值
    var result=[];
    for(var i=0; i<arr.length; i++){
        arr[i][key] = arr[i][key] - 0
        arr[i][val] = arr[i][val] - 0
        //  new_arr中不包含key,val值才能进入
        if(new_arr.includes(arr[i][key]) && new_arr.includes(arr[i][val])){
            arr[i][val] += (Math.random() * 0.0001)
            result.push(arr[i]);
        } else {
            new_arr.push(arr[i][key]);
            new_arr.push(arr[i][val]);
            result.push(arr[i]);
        }
    }
    return result;
}

6.多层嵌套json对象添加属性

// 方法一 递归函数
// data: json对象数据
// beforeActive：添加的属性
dataFormat(data) {
  if (!data.hasOwnProperty('beforeActive')) {
    // data['tag'] = 'beforeActive';
    data.beforeActive = true
  }
  // 要返回其枚举自身属性的对象
  const propArr = Object.keys(data);
  propArr.forEach(item => {
    if (typeof data[item] === 'object') {
      this.dataFormat(data[item]);
    }
  });
  return data;
};
// 方法二
// obj为json对象，addkey：添加的属性。addvalue: 添加的属性值
mapObj(obj, addkey, addvalue){
  for(let key in obj){
    if (key === 'children'
        && obj.hasOwnProperty("children")
        && obj[key] instanceof Object
        && !obj instanceOf Array) {
      obj[key][addkey] = addvalue
      mapObj(obj[key],addkey,addvalue)
    }
  }
}