在 Javascript 中，在执行深度复制时，由于属性为“this”，我如何避免循环

这种情况的"可靠和干净"的方法是使用"访问"对象的集合，然后根据当前对象是否已被"访问"做出反应 - 终止，插入符号引用等。

Crockford 先生在循环中使用这种方法.js并且他使用数组作为集合。摘录：

// If the value is an object or array, look to see if we have already
// encountered it. If so, return a $ref/path object. This is a hard way,
// linear search that will get slower as the number of unique objects grows.
for (i = 0; i < objects.length; i += 1) {
    if (objects[i] === value) {
        return {$ref: paths[i]};
    }
}

JavaScript中不可能使用原始的"哈希"方法，因为它缺少身份映射。虽然数组集合边界O(n^2)但这并不像听起来那么糟糕：

这是因为，如果"访问"集合只是一个守卫，那么n的值只是堆栈的深度：只有循环是重要的，而多次复制同一个对象则不重要。也就是说，"访问"集合中的对象可以在堆栈展开时修剪。

在循环中.js无法修剪"访问"集合的代码，因为它必须确保始终为给定对象使用相同的符号名称，这允许序列化在还原时"维护引用"。但是，即使在这种情况下，n也只是遍历的唯一非基元值的数量。

我能想到的唯一其他方法是将"访问的属性"直接添加到正在遍历的对象中，我认为这是一个通常不希望的功能。（但是，请参阅Bergi关于此工件[相对]容易清理的评论。

快乐编码。

好的，我对@pst提到的"访问"属性的外观感兴趣，所以我编写了这个代码：

Object.copyCircular = function deepCircularCopy(o) {
    const gdcc = "__getDeepCircularCopy__";
    if (o !== Object(o))
        return o; // primitive value
    var set = gdcc in o,
        cache = o[gdcc],
        result;
    if (set && typeof cache == "function")
        return cache();
    // else
    o[gdcc] = function() { return result; }; // overwrite
    if (o instanceof Array) {
        result = [];
        for (var i=0; i<o.length; i++) {
            result[i] = deepCircularCopy(o[i]);
    } else {
        result = {};
        for (var prop in o)
            if (prop != gdcc)
                result[prop] = deepCircularCopy(o[prop]);
            else if (set)
                result[prop] = deepCircularCopy(cache);
    }
    if (set)
        o[gdcc] = cache; // reset
    else
        delete o[gdcc]; // unset again
    return result;
};

请注意，这只是一个示例。它不支持：

• 非普通对象。所有带有原型的东西（数组除外）都不会被克隆，而是复制到new Object！这包括功能！
• 跨全局范围对象：它使用 instanceof Array 。
• 属性描述符，如 setter/getter、不可写和不可枚举的属性

糖果：

• 它不使用每次遇到对象时都需要搜索的大数组。

缺点：

• 不适用于具有不声明的__getDeepCircularCopy__方法的对象。尽管在此轻量级版本中无论如何都不支持方法（以函数作为值的属性）。

此解决方案将适用于具有循环引用的对象，复制循环结构，而不会以无限循环结束。请注意，"循环"在这里意味着属性引用了"树"中的"父项"之一：

   [Object]_            [Object]_
     /    |'              /    |'
   prop     |           prop    |
     '_____/             |      |
                        '|/     |
                      [Object]  |
                          '     |
                         prop   |
                            '___/

共享一片叶子的树的结构不会被复制，它们将成为两片独立的叶子：

            [Object]                     [Object]
             /    '                       /    '
            /      '                     /      '
          |/_      _'|                 |/_      _'|  
      [Object]    [Object]   ===>  [Object]    [Object]
           '        /                 |           |
            '      /                  |           |
            _'|  |/_                 '|/         '|/
            [Object]               [Object]    [Object]

除非您想跟踪复制的每个属性，否则不会。

但是，如果您确定每个属性都是 null 、字符串、数字、数组或简单对象，则可以捕获JSON.stringify异常以查看是否存在反向引用，如下所示：

try {
    JSON.stringify(obj);
    // It's ok to make a deep copy of obj
} catch (e) {
    // obj has back references and a deep copy would generate an infinite loop
    // Or finite, i.e. until the stack space is full.
}

这只是一个想法，我对表演一无所知。我担心在大型物体上可能会很慢。

这是一个简单的递归克隆方法。与许多其他解决方案一样，大多数非基本属性将与原始对象（如函数）共享引用。

它通过保留引用对象的映射来处理无限循环，以便后续引用可以共享相同的克隆。

const georgeCloney = (originalObject, __references__ = new Map()) => {
  if(typeof originalObject !== "object" || originalObject === null) {
    return originalObject;
  }
  // If an object has already been cloned then return a
  // reference to that clone to avoid an infinite loop
  if(__references__.has(originalObject) === true) {
    return __references__.get(originalObject);
  }
  let clonedObject = originalObject instanceof Array ? [] : {};
  __references__.set(originalObject, clonedObject);
  for(let key in originalObject) {
    if(originalObject.hasOwnProperty(key) === false) {
      continue;
    }
    clonedObject[key] = georgeCloney(originalObject[key], __references__);
  }
  return clonedObject;
};

示例用法...

let foo = {};
foo.foo = foo;
let bar = georgeCloney(foo);
bar.bar = "Jello World!";
// foo output
// {
//   foo: {
//     foo: {...}
//   }
// }
// 
// bar output
// { 
//   foo: { 
//     foo: {...},
//     bar: "Jello World!"
//   }, 
//   bar: "Jello World!"
// }

我不得不这样做进行面试，这就是我得到的：

Object.defineProperty(Object.prototype, 'deepclone', { enumerable :false, configurable :true, value :function(){
  let map /*for replacement*/ =new Map(), rep ={} ;map.set(this, rep)
  let output = (function medclone(_, map){  let output ={..._}
    for(let k in _){  let v =_[k]
      let v2 ;if(!(v instanceof Object)) v2 =v ;else {
        if(map.has(v)) v2 =map.get(v) ;else {
          let rep ={}
          map.set(v, rep), v2 =medclone(v, map)
          Replace(rep, v2), map.set(v, v2)
        }
      }
      output[k] =v2
    }    return output
  })(this, map)
  Replace(rep, output)
  return output
  /*[*/ function Replace(rep/*resentative*/, proper, branch =proper, seens =new Set()){
    for(let k in branch){  let v =branch[k]
      if(v ===rep) branch[k] =proper
      else if(v instanceof Object &&!seens.has(v)) seens.add(v), Replace(rep, proper, v, seens)
    }
  }/*]*/
} })
                                                                                                                                  // Code is freely available for use for academia/scrutiny. As for development, contact author. 

该方法是"砍杀"而不是"编码前有充足的时间计划"，所以结果不可能那么好，但它有效。 可以迭代它以删除递归入口点中的 WET，例如。