学习链接

如何优雅地嗅探”对象“是否存在”环“？

阿里笔试题：链式调用、对象比较以及对象是否存在循环引用

cycle.js

判断循环引用

  1. function checkLoop(object) {
  2.     const objSet = new WeakSet();
  3.     let loop = false;
  5.     function check(value) {
  6.         // 确保 value 是非null普通对象或数组 且未发现循环
  7.         // 否则直接返回
  8.         if (!value || typeof value !== 'object' || loop) {
  9.             return;
  10.         }
  12.         // 判断是否已经用到过该对象
  13.         if (objSet.has(value)) {
  14.             loop = true; // 存在循环
  15.             return;
  16.         }
  18.         // 未用到过 则添加进记录中去
  19.         objSet.add(value);
  21.         // value 为普通对象 或 数组
  22.         Object.keys(value).forEach(key => check(value[key]));
  24.         // 同级判断完后删除 防止误判 例4
  25.         objSet.delete(value);
  27.         return;
  28.     }
  30.     check(object);
  32.     return loop;
  33. };
  1. // 1. 对象之间相互引用
  2. let obj1 = {};
  3. let obj2 = {};
  4. obj1.obj = obj2
  5. obj2.obj = obj1
  7. console.log(checkLoop(obj1)) // true
  8. console.log(checkLoop(obj2)) // true
  10. // 2. 对象的属性引用了对象本身
  11. let obj = { father: 'father' }
  12. obj.child = obj
  14. console.log(checkLoop(obj)) // true
  16. // 3. 对象的属性引用部分属性
  17. let obj3 = {
  18.     father: 'father',
  19.     child: {}
  20. }
  21. obj3.child.obj = obj3.child
  23. console.log(checkLoop(obj3)) // true
  25. // 4. 对象的属性指向同一引用
  26. let tempObj = {
  27.     name: '名字'
  28. }
  29. let obj4 = {
  30.     child1: tempObj,
  31.     child2: tempObj
  32. }
  34. console.log(checkLoop(obj4)) // false
  36. // 5. 其他数据类型
  38. console.log(checkLoop(1)) // false
  39. console.log(checkLoop('str')) // false
  40. console.log(checkLoop(false)) // false
  41. console.log(checkLoop(null)) // false
  42. console.log(checkLoop(undefined)) // false
  43. console.log(checkLoop([])) // false
  44. console.log(checkLoop(Symbol())) // false

补充

  1. // 处理
  2. // var a = [];
  3. // a[0] = a;
  4. // return JSON.stringify(JSON.decycle(a));
  5. // produces the string '[{"$ref":"$"}]'.
  7. if (typeof JSON.decycle !== "function") {
  8.     JSON.decycle = function decycle(object, replacer) {
  9.         const objMap = new WeakMap(); // 对象到路径的映射
  11.         return (function derez(value, path) {
  12.             // derez函数 通过递归 实现深拷贝
  14.             let oldPath; // 旧路径
  15.             let newValue; // 新对象或数组
  17.             // 调用自定义替换值函数 replacer
  19.             if (replacer !== undefined) {
  20.                 value = replacer(value);
  21.             }
  23.             // 确保 value 是普通对象或数组, 既非null 又非内置对象
  24.             // 否则直接返回
  25.             if (
  26.                 typeof value !== 'object'
  27.                 || value === null
  28.                 || value instanceof Boolean
  29.                 || value instanceof Number
  30.                 || value instanceof String
  31.                 || value instanceof RegExp
  32.                 || value instanceof Date
  33.             ) {
  34.                 return value;
  35.             }
  37.             // 此时 value 是一个普通对象或者数组
  39.             // 判断是否已经用到过该对象
  40.             // 如果用到了 返回 {"$ref": PATH}
  42.             oldPath = objMap.get(value);
  43.             if (oldPath !== undefined) {
  44.                 return { $ref: oldPath };
  45.             }
  46.             // if (objMap.has(value)) {
  47.             //   return { $ref: objMap.get(value) };
  48.             // }
  50.             // 未用到过 则添加进记录中去
  51.             objMap.set(value, path);
  53.             // value 为数组
  54.             if (Array.isArray(value)) {
  55.                 newValue = [];
  57.                 // 递归处理
  58.                 value.forEach((element, i) => {
  59.                     newValue[i] = derez(element, path + "[" + i + "]");
  60.                 });
  61.             } else {
  62.                 // value 为普通对象
  63.                 newValue = {};
  64.                 Object.keys(value).forEach(key => {
  65.                     newValue[key] = derez(
  66.                         value[key],
  67.                         path + "[" + JSON.stringify(key) + "]"
  68.                     );
  69.                 });
  70.             }
  72.             return newValue;
  74.         }(object, "$"));
  75.     };
  76. }
  78. // 还原
  79. // var s = '[{"$ref":"$"}]';
  80. // return JSON.retrocycle(JSON.parse(s));
  81. // produces an array containing a single element which is the array itself.
  83. if (typeof JSON.retrocycle !== "function") {
  84.     JSON.retrocycle = function retrocycle($) {
  85.         const px = /^\$(?:\[(?:\d+|"(?:[^\\"\u0000-\u001f]|\\(?:[\\"\/bfnrt]|u[0-9a-zA-Z]{4}))*")\])*$/;
  87.         function rez(value) {
  88.             if (!value || typeof value !== 'object') {
  89.                 return;
  90.             }
  92.             if (Array.isArray(value)) {
  93.                 value.forEach((element, i) => {
  94.                     if (typeof element !== 'object' || element === null) {
  95.                         return ;
  96.                     }
  98.                     const path = element.$ref;
  99.                     if (typeof path === 'string' && px.test(path)) {
  100.                         value[i] = eval(path);
  101.                         return;
  102.                     }
  103.                     rez(element);
  104.                 });
  105.                 return;
  106.             }
  108.             Object.keys(value).forEach(key => {
  109.                 const element = value[key];
  111.                 if (typeof element !== 'object' || element === null) {
  112.                     return;
  113.                 }
  115.                 const path = element.$ref;
  116.                 if (typeof path === 'string' && px.test(path)) {
  117.                     value[key] = eval(path);
  118.                     return;
  119.                 }
  120.                 rez(element);
  121.             });
  122.         }
  124.         rez($);
  126.         return $;
  127.     }
  128. }
  131. // 处理
  132. // const a = [];
  133. // a[0] = a;
  135. const sameObj = {
  136.     x: 1,
  137.     y: 2
  138. }
  140. const a = {
  141.     b: sameObj,
  142.     c: sameObj,
  143.     d: {
  144.         e: 5,
  145.         f: {
  147.         }
  148.     }
  149. };
  150. a.d.f.g = a.d;
  152. const s = JSON.stringify(JSON.decycle(a))
  153. console.log('JSON.stringify(JSON.decycle(a)): ', JSON.stringify(JSON.decycle(a)));
  155. // 还原
  156. console.log('JSON.parse(s): ', JSON.parse(s));
  157. console.log('JSON.retrocycle(JSON.parse(s)): ', JSON.retrocycle(JSON.parse(s)));