Question

我有一些图书馆代码在我身上不停地骑自行车。

我不清楚如何在javascript中最好地执行循环检测和避免。也就是说，没有编程方式来检查一个物体是否来自“这个”参考，是吗？

这是代码。谢谢！

setAttrs: function(config) {
    var go = Kinetic.GlobalObject;
    var that = this;

    // set properties from config
    if(config !== undefined) {
        function setAttrs(obj, c) {
            for(var key in c) {
                var val = c[key];

                /*
                 * if property is an object, then add an empty object
                 * to the node and then traverse
                 */
                if(go._isObject(val) && !go._isArray(val) && !go._isElement(val)) {
                    if(obj[key] === undefined) {
                        obj[key] = {};
                    }
                    setAttrs(obj[key], val);  // <--- offending code; 
                                              // one of my "val"s is a "this" reference
                                              // to an enclosing object
                }

Answer 1

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

先生。 Crockford在cycle.js中使用这种方法，他使用Array来收集。摘录：

// 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中不可能使用原始的“Hash”方法，因为它缺少Identity-Map。虽然数组集合范围是O(n^2)，但并没有听起来那么糟糕：

这是因为，如果“访问”集合只是一个保护，那么n的值只是堆栈的深度：只有周期很重要，而多次复制同一个对象则不重要。也就是说，“访问”集合中的对象可以在堆栈展开时进行修剪。

在cycle.js代码中，“visited”集合无法被修剪，因为它必须确保始终使用给定对象的相同符号名称，这允许序列化在恢复时“维护引用”。但是，即使在这种情况下，n 仅遍历的唯一非原始值的数量。

我能想到的唯一其他方法是需要将“访问属性”直接添加到被遍历的对象，我认为这通常是不受欢迎的特性。（但是，请参阅Bergi关于这个工件的评论[相对]很容易清理。）

快乐的编码。

Answer 2

好的，我对@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 / getters，unwritable和nonenumerable属性

超值服务：

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

缺点：

不适用于__getDeepCircularCopy__方法与其声明的方法不同的对象。虽然在这个轻量级版本中不支持方法（具有函数值的属性）。

此解决方案适用于具有循环引用的对象，复制圆形结构而不会以无限循环结束。注意，“循环”在这里表示属性引用“树”中的一个“父”：

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

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

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

Answer 3

除非你想跟踪所有复制的属性，否则不会。

但是，如果您确定每个属性都是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.
}

这只是一个想法，我不知道表演。我担心大型物体可能会很慢。

Answer 4

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

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

computed

示例用法...

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;
};

Answer 5

我必须要做一次采访，这就是我得到的：

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。

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

5 个答案: