1. {
  2.   for (var i = 1; i <= 3; i++) {
  3.     console.log(i); // 1 2 3
  4.     // setTimeout(function () {
  5.     //   console.log(i); // 4 4 4
  6.     // }, 0);
  7.   }
  8. }
  10. {
  11.   var a = null;
  12.   console.log(typeof a); // object
  13. }
  15. {
  16.   var a = 100;
  18.   function test() {
  19.     console.log(a); // 100
  20.     a = 10;
  21.     console.log(a); // 10
  22.   }
  23.   test();
  24.   console.log(a); // 10
  25. }
  27. {
  28.   var uname = "jack";
  29.   function change() {
  30.     console.log(uname); // undefined
  31.     var uname = "wcd";
  32.     console.log(uname); // wcd
  33.   }
  34.   change();
  35. }
  37. {
  38.   function createBase(baseNumber) {
  39.     return function (N) {
  40.       return baseNumber + N;
  41.     };
  42.   }
  43.   let addSix = createBase(6);
  44.   console.log(addSix(10)); // 16
  45.   console.log(addSix(21)); // 27
  46. }
  48. {
  49.   var name = "global";
  50.   var obj = {
  51.     name: "obj",
  52.     sex: function () {
  53.       this.name = "wcd";
  54.       return function () {
  55.         return this.name;
  56.       };
  57.     }
  58.   };
  59.   console.log(obj.sex().call(this)); // undefined
  60.   console.log(obj.sex().call(obj)); // wcd
  61. }
  63. {
  64.   /**
  65.    * 需求：假设需要对字符串进行字符长度限制
  66.    * str为字符串，len为长度
  67.    */
  68.   function setString(str, len) {
  69.     var strlen = 0;
  70.     var s = "";
  71.     for (var i = 0; i < str.length; i++) {
  72.       if (str.charCodeAt(i) > 128) {
  73.         strlen += 2;
  74.       } else {
  75.         strlen++;
  76.       }
  77.       s += str.charAt(i);
  78.       if (strlen >= len) {
  79.         return s + "...";
  80.       }
  81.     }
  82.     return s;
  83.   }
  84. }
  86. {
  87.   const isType = (obj, type) => {
  88.     if (typeof obj !== 'object') return false;
  89.     const typeString = Object.prototype.toString.call(obj);
  90.     let flag;
  91.     switch (type) {
  92.       case 'Array':
  93.         flag = typeString === '[object Array]';
  94.         break;
  95.       case 'Date':
  96.         flag = typeString === '[object Date]';
  97.         break;
  98.       case 'RegExp':
  99.         flag = typeString === '[object RegExp]';
  100.         break;
  101.       default:
  102.         flag = false;
  103.     }
  104.     return flag;
  105.   }
  106.   const getRegExp = re => {
  107.     var flags = '';
  108.     if (re.global) flags += 'g';
  109.     if (re.ignoreCase) flags += 'i';
  110.     if (re.multiline) flags += 'm';
  111.     return flags;
  112.   }
  113. }

1~100的完全平方数

  1. {
  2.   // 1~100的完全平方数
  3.   function isSqrt(n) {    
  4.     for (var i = 1; n > 0; i += 2) {
  5.       n -= i;
  6.     }
  7.     return 0 == n;
  8.   }
  9.   for (var j = 1; j <= 100; j++) {
  10.     if (isSqrt(j)) {
  11.       console.log(j); // 1 4 9 16 25 36 49 64 81 100
  12.     }
  13.   }
  14. }

统计数组中相同项的个数

  1. {
  2.   // 统计数组中相同项的个数
  3.   var cars = ["xiaoming", "xiaohong", "xiaohong", "xiaohong", "xiaolv", "xiaolan", "xiaohei"];
  4.   var carsObj = cars.reduce(function (obj, name) {
  5.     obj[name] = obj[name] ? ++obj[name] : 1;
  6.     return obj;
  7.   }, {});
  8.   console.log(carsObj); // { xiaoming: 1, xiaohong: 3, xiaolv: 1, xiaolan: 1, xiaohei: 1 }
  9. }

判断数组或者一个字符串中出现次数最多的元素及其出现的次数

  1. {
  2.   // 判断数组或者一个字符串中出现次数最多的元素及其出现的次数
  3.   function maxCountElement(arr) {
  4.     var obj = {};
  5.     for (var i = 0; i < arr.length; i++) {
  6.       var key = arr[i];
  7.       if (obj[key]) {
  8.         obj[key]++;
  9.       } else {
  10.         obj[key] = 1;
  11.       }
  12.     }
  13.     var maxCount = 0;
  14.     var maxElement = arr[0];
  15.     var eq = [];
  16.     for (var key in obj) {
  17.       if (maxCount < obj[key]) {
  18.         maxCount = obj[key];
  19.         maxElement = key;
  20.         eq.length = 0;
  21.       } else if (maxCount === obj[key]) {
  22.         eq.push(key);
  23.       }
  24.     }
  25.     if (eq.length > 0) {
  26.       for (var j = 0; j < eq.length; j++) {
  27.         maxElement += "，" + eq[j];
  28.       }
  29.     }
  30.     return `该数组中出现次数最多的元素:${maxElement},出现了:${maxCount}次`;
  31.   }
  32.   var arr = [1, 2, 2, 2, 3, 3, 3, 4, 5, 6];
  33.   var res = maxCountElement(arr);
  34.   console.log(res); // 该数组中出现次数最多的元素:2，3,出现了:3次
  35. }

判断回文字符串

  1. {
  2.   // 实现一个函数，判断输入是不是回文字符串(在我的理解，如果将一个字符串翻转过来，能和原字符串完全相等，那么就可以称之为“回文”)
  4.   // one
  5.   function Palindrome1(input) {
  6.     if (typeof input !== "string") return false;
  7.     return (input.split("").reverse().join("") === input);
  8.   }
  10.   // two
  11.   function Palindrome2(line) {
  12.     line += "";
  13.     for (var i = 0, j = line.length - 1; i < j; i++, j--) {
  14.       if (line.charAt(i) !== line.charAt(j)) {
  15.         return false;
  16.       }
  17.     }
  18.     return true;
  19.   }
  20. }

trim

  1. {
  2.   String.prototype.trim = function () {
  3.     return this.replace(/^\s+/, "").replace(/\s+$/, "");
  4.   };
  5. }
  7. {
  8.   // 正则实现trim()功能
  9.   function myTrim(str) {
  10.     let reg = /^\s+|\s+$/g;
  11.     return str.replace(reg, "");
  12.   }
  13.   let str = "    wcd    ";
  14.   console.log(myTrim(str)); // wcd
  15. }

检测平台（设备）类型

  1. {
  2.   // 检测平台（设备）类型
  3.   let isWechat = /micromessenger/i.test(navigator.userAgent),
  4.     isWeibo = /weibo/i.test(navigator.userAgent),
  5.     isQQ = /qq\//i.test(navigator.userAgent),
  6.     isIOS = /(iphone|ipod|ipad|ios)/i.test(navigator.userAgent),
  7.     isAndroid = /android/i.test(navigator.userAgent);
  8. }

获取 URL 的中参数

  1. {
  2.   // 获取 URL 的中参数 (推荐 https://github.com/derek-watson/jsUri)
  3.   // 正则
  4.   function getQueryString(name) {
  5.     var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)", "i");
  6.     var r = window.location.search.substr(1).match(reg); //获取url中"?"符后的字符串并正则匹配
  7.     var context = "";
  8.     if (r != null) context = r[2];
  9.     reg = null;
  10.     r = null;
  11.     return context == null || context == "" || context == "undefined" ? "" : context;
  12.   }
  13.   // such as：
  14.   // alert(GetQueryString("参数名1"));
  15.   // alert(GetQueryString("参数名2"));
  16.   // alert(GetQueryString("参数名3"));
  18.   // split拆分法
  19.   function GetRequest() {
  20.     var url = location.search; //获取url中"?"符后的字串
  21.     var theRequest = new Object();
  22.     if (url.indexOf("?") != -1) {
  23.       var str = url.substr(1);
  24.       strs = str.split("&");
  25.       for (var i = 0; i < strs.length; i++) {
  26.         theRequest[strs[i].split("=")[0]] = unescape(strs[i].split("=")[1]);
  27.       }
  28.     }
  29.     return theRequest;
  30.   }
  31.   var Request = new Object();
  32.   Request = GetRequest();
  33.   // var 参数1,参数2,参数3,参数N;
  34.   // 参数1 = Request['参数1'];
  35.   // 参数2 = Request['参数2'];
  36.   // 参数3 = Request['参数3'];
  37.   // 参数N = Request['参数N'];
  39.   // 修改 URL 的中某个参数值
  40.   //替换指定传入参数的值,paramName为参数,replaceWith为新值
  41.   function replaceParamVal(paramName, replaceWith) {
  42.     var oUrl = this.location.href.toString();
  43.     var re = eval("/(" + paramName + "=)([^&]*)/gi");
  44.     var nUrl = oUrl.replace(re, paramName + "=" + replaceWith);
  45.     this.location = nUrl;
  46.     window.location.href = nUrl;
  47.   }
  49.   /**
  50.    * 指定参数名称，返回该参数的值 或者 空字符串
  51.    * 不指定参数名称，返回全部的参数对象 或者 {}
  52.    * 如果存在多个同名参数，则返回数组
  53.    */
  54.   function getUrlParam(url, key) {
  55.     var arr = {};
  56.     url.replace(/\??(\w+)=(\w+)&?/g, function (match, matchKey, matchValue) {
  57.       if (!arr[matchKey]) {
  58.         arr[matchKey] = matchValue;
  59.       } else {
  60.         var temp = arr[matchKey];
  61.         arr[matchKey] = [].concat(temp, matchValue);
  62.       }
  63.     });
  64.     if (!key) {
  65.       return arr;
  66.     } else {
  67.       for (ele in arr) {
  68.         if ((ele = key)) {
  69.           return arr[ele];
  70.         }
  71.       }
  72.       return "";
  73.     }
  74.   }
  75. }

H5(ios)-在点击输入框，出现键盘后，弹出层被顶上去，而光标还停留在原处，即出现错位情况

  1. {
  2.   // 单个input(textarea)
  3.   $("input.van-field__control, textarea.van-field__control").blur(function () {
  4.     setTimeout(function () {
  5.       var currentPosition = document.documentElement.scrollTop || document.body.scrollTop;
  6.       window.scrollTo(0, currentPosition); //页面向上滚动
  7.     }, 200);
  8.   });
  10.   // 多个input(textarea)
  11.   $(function () {
  12.     var setTimerTop = 0;
  13.     $(document).on('blur', 'input.van-field__control, textarea.van-field__control', function () {
  14.       event.preventDefault()
  15.       setTimerTop = setTimeout(function () {
  16.         window.scrollBy(0, 5); // 页面向上滚动
  17.         window.scrollBy(0, -5);
  18.       }, 500)
  19.     }).on('focus', 'input.van-field__control, textarea.van-field__control', function () {
  20.       clearTimeout(setTimerTop)
  21.     })
  22.   })
  24.   // 多个input(textarea)-iframe情况
  25.   $(function() {
  26.     var setTimerTop = 0;
  27.     $(document).on('blur', 'input.van-field__control, textarea.van-field__control', function() {
  28.       event.preventDefault()
  29.       setTimerTop = setTimeout(function() {
  30.         parent.scrollBy(0, 5); // 页面向上滚动
  31.         parent.scrollBy(0, -5);
  32.         $('#hide-area-cb').focus();
  33.       }, 500)
  34.     }).on('focus', 'input.van-field__control, textarea.van-field__control', function() {
  35.       clearTimeout(setTimerTop);
  36.     }).on('focus', 'input.van-field__control[disabled]', function() {
  37.       setTimerTop = setTimeout(function() {
  38.         parent.scrollBy(0, 5); // 页面向上滚动
  39.         parent.scrollBy(0, -5);
  40.       }, 500)
  41.     })
  42.   })
  43. }

判断类型

  1.   // 判断类型
  2.   function toType(obj) {
  3.     return {}.toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase();
  4.   }

对象判空

注：永远不要使用构造函数创建对象

  1. {
  2.   function isEmptyObject(value) {
  3.     return (
  4.       value && Object.keys(value).length === 0 && value.constructor === Object
  5.     );
  6.   }
  7. }
  9. {
  10.   function isEmptyObject(value) {
  11.     return (
  12.       Object.prototype.toString.call(value) === "[object Object]" &&
  13.       JSON.stringify(value) === "{}"
  14.     );
  15.   }
  16. }
  18. // Lodash
  19. _.isEmpty({});
  21. // jQuery
  22. jQuery.isEmptyObject({});

函数防抖

  1. {
  2.   // 简单 函数防抖
  3.   function debounce(method, wait) {
  4.     let timeout;
  5.     // args为返回函数调用时传入的参数，传给method
  6.     return function (...args) {
  7.       let context = this;
  8.       if (timeout) {
  9.         clearTimeout(timeout);
  10.       }
  11.       timeout = setTimeout(() => {
  12.         // args是一个数组，所以使用fn.apply
  13.         // 也可写作method.call(context, ...args)
  14.         method.apply(context, args);
  15.       }, wait);
  16.     };
  17.   }
  19.   // 完整 函数防抖
  20.   function debounce(method, wait, immediate) {
  21.     let timeout;
  22.     // debounced函数为返回值
  23.     // 使用Async/Await处理异步，如果函数异步执行，等待setTimeout执行完，拿到原函数返回值后将其返回
  24.     // args为返回函数调用时传入的参数，传给method
  25.     let debounced = function (...args) {
  26.       return new Promise(resolve => {
  27.         // 用于记录原函数执行结果
  28.         let result;
  29.         // 将method执行时this的指向设为debounce返回的函数被调用时的this指向
  30.         let context = this;
  31.         // 如果存在定时器则将其清除
  32.         if (timeout) {
  33.           clearTimeout(timeout);
  34.         }
  35.         // 立即执行需要两个条件，一是immediate为true，二是timeout未被赋值或被置为null
  36.         if (immediate) {
  37.           // 如果定时器不存在，则立即执行，并设置一个定时器，wait毫秒后将定时器置为null
  38.           // 这样确保立即执行后wait毫秒内不会被再次触发
  39.           let callNow = !timeout;
  40.           timeout = setTimeout(() => {
  41.             timeout = null;
  42.           }, wait);
  43.           // 如果满足上述两个条件，则立即执行并记录其执行结果
  44.           if (callNow) {
  45.             result = method.apply(context, args);
  46.             resolve(result);
  47.           }
  48.         } else {
  49.           // 如果immediate为false，则等待函数执行并记录其执行结果
  50.           // 并将Promise状态置为fullfilled，以使函数继续执行
  51.           timeout = setTimeout(() => {
  52.             // args是一个数组，所以使用fn.apply
  53.             // 也可写作method.call(context, ...args)
  54.             result = method.apply(context, args);
  55.             resolve(result);
  56.           }, wait);
  57.         }
  58.       });
  59.     };
  61.     // 在返回的debounced函数上添加取消方法
  62.     debounced.cancel = function () {
  63.       clearTimeout(timeout);
  64.       timeout = null;
  65.     };
  67.     return debounced;
  68.   }
  69. }

生成 -0

  1.   // one
  3.   // 首先创建一个8位的ArrayBuffer
  4.   const buffer = new ArrayBuffer(8);
  5.   // 创建DataView对象操作buffer
  6.   const dataView = new DataView(buffer);
  7.   // 将第1个字节设置为0x80，即最高位为1
  8.   dataView.setUint8(0, 0x80);
  9.   // 将buffer内容当做Float64类型返回
  10.   console.log(dataView.getFloat64(0)); // -0
  12.   // two
  13.   console.log(0 * -1); // -0

reduce

  1. {
  2.   // 对后端返回的列表数据进行相同数据整合处理
  3.   let oldList = [
  4.     { id: 111, date: "05-25", list: [1, 2, 3] },
  5.     { id: 222, date: "05-26", list: [4, 5] },
  6.     { id: 111, date: "05-25", list: [4, 5] }
  7.   ];
  8.   function formatList() {
  9.     return Array.from(
  10.       oldList.reduce((dict, item) => {
  11.         if (dict.has(item.id)) {
  12.           dict.get(item.id).list.push(...item.list);
  13.         } else {
  14.           dict.set(item.id, {
  15.             id: item.id,
  16.             date: item.date,
  17.             list: [...item.list]
  18.           });
  19.         }
  20.         return dict;
  21.       }, new Map())
  22.     ).map(item => ({
  23.       date: item[1].date,
  24.       id: item[1].id,
  25.       list: item[1].list
  26.     }));
  27.   }
  28.   console.log(formatList());
  29.   // [
  30.   //     { id: 111, date: "05-25", list: [1, 2, 3, 4, 5] },
  31.   //     { id: 222, date: "05-26", list: [4, 5] }
  32.   // ];
  34.   // 数组list去重
  35.   const data = [
  36.     { name: "Kris", age: "24" },
  37.     { name: "Andy", age: "25" },
  38.     { name: "Kitty", age: "25" },
  39.     { name: "Andy", age: "25" },
  40.     { name: "Kitty", age: "25" },
  41.     { name: "Andy", age: "25" },
  42.     { name: "Kitty", age: "25" }
  43.   ];
  45.   let newData = Object.values(
  46.     data.reduce((prev, cur, idx) => {
  47.       let obj = {};
  48.       const { name } = cur;
  49.       obj[name] = cur;
  50.       return {
  51.         ...prev,
  52.         ...obj
  53.       };
  54.     }, {})
  55.   );
  56.   console.log(newData)
  57. }
  59. {
  60.   /**
  61.    * reduce方法同时实现map和filter
  62.    * 需求：假设现在有一个数列，你希望更新它的每一项（map的功能）然后筛选出一部分（filter的功能）。如果是先使用map然后filter的话，你需要遍历这个数组两次。 在下面的代码中，我们将数列中的值翻倍，然后挑选出那些大于50的数
  63.    */
  64.   const numbers = [10, 20, 30, 40];
  65.   const doubledOver50 = numbers.reduce((finalList, num) => {
  66.     num = num * 2;
  67.     if (num > 50) {
  68.       finalList.push(num);
  69.     }
  70.     return finalList;
  71.   }, []);
  72.   console.log(doubledOver50); // [ 60, 80 ]
  73. }

实现数字金额转大写金额

  1. function digitUppercase(n) {
  2.     let fraction = ["角", "分"];
  3.     let digit = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"];
  4.     let unit = [
  5.         ["元", "万", "亿"],
  6.         ["", "拾", "佰", "仟"]
  7.     ];
  8.     let head = n < 0 ? "欠" : "";
  9.     n = Math.abs(n);
  10.     let s = "";
  11.     for (let i = 0; i < fraction.length; i++) {
  12.         s += (digit[Math.floor(n * 10 * Math.pow(10, i)) % 10] + fraction[i]).replace(/零./, "");
  13.     }
  14.     s = s || "整";
  15.     n = Math.floor(n);
  16.     for (let k = 0; k < unit[0].length && n > 0; k++) {
  17.         let p = "";
  18.         for (let j = 0; j < unit[1].length && n > 0; j++) {
  19.             p = digit[n % 10] + unit[1][j] + p;
  20.             n = Math.floor(n / 10);
  21.         }
  22.         s = `${p.replace(/(零.)*零$/, "").replace(/^$/, "零")}${unit[0][k]}${s}`;
  23.     }
  24.     return `${head}${s.replace(/(零.)*零元/, "元").replace(/(零.)+/g, "零").replace(/^整$/, "零元整")}`;
  25. }
  27. console.log(digitUppercase(7682.01)); // 柒仟陆佰捌拾贰元壹分
  28. console.log(digitUppercase(7682)); // 柒仟陆佰捌拾贰元整
  29. console.log(digitUppercase(951434677682.0)); // 玖仟伍佰壹拾肆亿叁仟肆佰陆拾柒万柒仟陆佰捌拾贰元整
  32. function noToChinese(num) {
  33.     if (!/^\d*(\.\d*)?$/.test(num)) return;
  35.     var digit = new Array("零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖");
  36.     var unit = new Array("", "拾", "佰", "仟", "萬", "億", "点", "");
  37.     var a = ("" + num).replace(/(^0*)/g, "").split("."),
  38.         k = 0,
  39.         re = "";
  40.     for (var i = a[0].length - 1; i >= 0; i--) {
  41.         switch (k) {
  42.             case 0:
  43.                 re = unit[7] + re;
  44.                 break;
  45.             case 4:
  46.                 if (!new RegExp("0{4}\\d{" + (a[0].length - i - 1) + "}$").test(a[0]))
  47.                     re = unit[4] + re;
  48.                 break;
  49.             case 8:
  50.                 re = unit[5] + re;
  51.                 unit[7] = unit[5];
  52.                 k = 0;
  53.                 break;
  54.         }
  55.         if (k % 4 == 2 && a[0].charAt(i + 2) != 0 && a[0].charAt(i + 1) == 0)
  56.             re = digit[0] + re;
  57.         if (a[0].charAt(i) != 0) re = digit[a[0].charAt(i)] + unit[k % 4] + re;
  58.         k++;
  59.     }
  60.     // 处理小数部分
  61.     if (a.length > 1) {
  62.         re += unit[6];
  63.         for (var i = 0; i < a[1].length; i++) re += digit[a[1].charAt(i)];
  64.     }
  65.     return re;
  66. }

返回字符串的字节长度

  1.   function byteSize(str) {
  2.       return new Blob([str]).size;
  3.   }
  4.   console.log(byteSize("Hello World")); // 11

平均数

  1.   // 平均数
  2.   const average = (...nums) => nums.reduce((acc, val) => acc + val, 0) / nums.length;
  3.   console.log(average(...[1, 2, 3])); // 2
  4.   console.log(average(1, 2, 3)); // 2

日期

  1.   // 当前日期天数
  2.   const dayOfYear = date => Math.floor((date - new Date(date.getFullYear(), 0, 0)) / 1000 / 60 / 60 / 24);
  3.   console.log(dayOfYear(new Date())); // 302
  5.   // 返回日期间的天数
  6.   const getDaysDiffBetweenDates = (dateInitial, dateFinal) => (dateFinal - dateInitial) / (1000 * 3600 * 24);
  7.   console.log(getDaysDiffBetweenDates(new Date('2019-01-01'), new Date('2019-10-29'))); // 301

解析有效日期

iOS 解析 YYYY-MM-DD HH:mm:ss 这种日期格式会报错 Invalid Date，Android 无问题
查看开发手册发现可用：YYYY/MM/DD HH:mm:ss，那么需替换其中的 - 为 / 

  1. const date = "2021-02-05 10:39:00";
  2. new Date(date.replace(/\-/g, "/"));

首(每个)字母大、小写

  1.   // 首字母大写
  2.   const capitalize = ([first, ...rest]) => first.toUpperCase() + rest.join('');
  3.   console.log(capitalize('fooBar')); // FooBar
  4.   console.log(capitalize('fooBar', true)); // FooBar
  6.   // 首字母小写
  7.   const decapitalize = ([first, ...rest]) => first.toLowerCase() + rest.join('');
  8.   console.log(decapitalize('FooBar')); // fooBar
  9.   console.log(decapitalize('FooBar')); // fooBar
  11.   // 每个单词首字母大写
  12.   const capitalizeEveryWord = str => str.replace(/\b[a-z]/g, char => char.toUpperCase());
  13.   console.log(capitalizeEveryWord('hello world!')); // 'Hello World!'

平滑滚动至顶部

  1.     const scrollToTop = () => {
  2.     const c = document.documentElement.scrollTop || document.body.scrollTop;
  3.     if (c > 0) {
  4.       window.requestAnimationFrame(scrollToTop);
  5.       window.scrollTo(0, c - c / 8);
  6.     }
  7.   };

滚动到指定元素区域

  1.   const smoothScroll = element =>
  2.     document.querySelector(element).scrollIntoView({
  3.       behavior: 'smooth'
  4.     });
  5.   smoothScroll('#fooBar');

深克隆

  2.   const clone = parent => {
  3.     // 维护两个储存循环引用的数组
  4.     const parents = [];
  5.     const children = [];
  7.     const _clone = parent => {
  8.       if (parent === null) return null;
  9.       if (typeof parent !== 'object') return parent;
  11.       let child, proto;
  13.       if (isType(parent, 'Array')) {
  14.         // 对数组做特殊处理
  15.         child = [];
  16.       } else if (isType(parent, 'RegExp')) {
  17.         // 对正则对象做特殊处理
  18.         child = new RegExp(parent.source, getRegExp(parent));
  19.         if (parent.lastIndex) child.lastIndex = parent.lastIndex;
  20.       } else if (isType(parent, 'Date')) {
  21.         // 对Date对象做特殊处理
  22.         child = new Date(parent.getTime());
  23.       } else {
  24.         // 处理对象原型
  25.         proto = Object.getPrototypeOf(parent);
  26.         // 利用Object.create切断原型链
  27.         child = Object.create(proto);
  28.       }
  30.       // 处理循环引用
  31.       const index = parents.indexOf(parent);
  33.       if (index != -1) {
  34.         // 如果父数组存在本对象,说明之前已经被引用过,直接返回此对象
  35.         return children[index];
  36.       }
  37.       parents.push(parent);
  38.       children.push(child);
  40.       for (let i in parent) {
  41.         // 递归
  42.         child[i] = _clone(parent[i]);
  43.       }
  45.       return child;
  46.     };
  47.     return _clone(parent);
  48.   };
  50. {
  51.   const isComplexDataType = (obj) => (typeof obj === "object" || typeof obj === "function") && obj !== null;
  53.   const deepClone = function (obj, hash = new WeakMap()) {
  54.     // 日期对象直接返回一个新的日期对象
  55.     if (obj.constructor === Date) {
  56.       return new Date(obj);
  57.     }
  59.     //正则对象直接返回一个新的正则对象
  60.     if (obj.constructor === RegExp) {
  61.       return new RegExp(obj);
  62.     }
  64.     //如果循环引用了就用 weakMap 来解决
  65.     if (hash.has(obj)) {
  66.       return hash.get(obj);
  67.     }
  69.     let allDesc = Object.getOwnPropertyDescriptors(obj);
  71.     //遍历传入参数所有键的特性
  72.     let cloneObj = Object.create(Object.getPrototypeOf(obj), allDesc);
  74.     //继承原型链
  75.     hash.set(obj, cloneObj);
  77.     for (let key of Reflect.ownKeys(obj)) {
  78.       cloneObj[key] =
  79.         isComplexDataType(obj[key]) && typeof obj[key] !== "function"
  80.           ? deepClone(obj[key], hash)
  81.           : obj[key];
  82.     }
  84.     return cloneObj;
  85.   };
  86. }