常用js函数

1.时间格式化

function formatDate (oldDate, fmt) {  
  let date = new Date()  
  if (typeof oldDate === 'string' || typeof oldDate === 'number') {    
    date = new Date(+oldDate)  
  } else {    
    date = oldDate  
  }  
if (/(y+)/.test(fmt)) {    
  fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length))  }  
  let o = {    
  'M+': date.getMonth() + 1,    
  'd+': date.getDate(),    
  'h+': date.getHours(),    
  'm+': date.getMinutes(),    
  's+': date.getSeconds()  }  
  function padLeftZero (str) {    
    return ('00' + str).substr(str.length)  
  }  
  for (let k in o) {    
    if (new RegExp(`(${k})`).test(fmt)) {      
      let str = o[k] + ''      
      fmt = fmt.replace(RegExp.$1, (RegExp.$1.length === 1) ? str : padLeftZero(str))    
    }  
  }  
  return fmt
}

2.以“天”为单位获取响应的时间戳

function setData(num) {

return Date.now() + num * 24 * 60 * 60 * 1000

}

时间为正可以获得未来的时间，时间为负可以获得过去的时间。 

3.数组降维

  二维数组

let arr = [ [1], [2], [3] ]
arr = Array.prototype.concat.apply([], arr); 
console.log(arr)   // [1,2,3]

多维数组

let arr = [1, 2, [3], [[4]]]
arr = arr.flat(3)
console.log(arr)  // [1,2,3,4]

4.深拷贝和浅拷贝

①.浅拷贝

     创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝的就是内存地址 ，所以如果其中一个对象改变了这个地址，就会影响到另一个对象。

 ②.深拷贝

      将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象,且修改新对象不会影响原对象

   方法：JSON转换

var targetObj = JSON.parse(JSON.stringify(copyObj))
let arr4 = JSON.parse(JSON.stringify(arr))

             普通递归函数

function clone(rtn) {
    if (typeof rtn=== 'object') {
        let cloneRtn = Array.isArray(rtn) ? [] : {};  //数组兼容
        for (const key in rtn) {
            cloneRtn[key] = clone(rtn[key]);
        }
        return cloneRtn;
    } else {
        return rtn;
    }
};

              防栈溢出函数

function clone(x) {
    const root = {};

    // 栈
    const loopList = [
        {
            parent: root,
            key: undefined,
            data: x,
        }
    ];

    while(loopList.length) {
        // 深度优先
        const node = loopList.pop();
        const parent = node.parent;
        const key = node.key;
        const data = node.data;

        // 初始化赋值目标，key为undefined则拷贝到父元素，否则拷贝到子元素
        let res = parent;
        if (typeof key !== 'undefined') {
            res = parent[key] = {};
        }

        for(let k in data) {
            if (data.hasOwnProperty(k)) {
                if (typeof data[k] === 'object') {
                    // 下一次循环
                    loopList.push({
                        parent: res,
                        key: k,
                        data: data[k],
                    });
                } else {
                    res[k] = data[k];
                }
            }
        }
    }

    return root;
}