15

我有一些库代码在我身上无休止地循环。

我不清楚如何最好地在 javascript 中执行循环检测和避免。即没有检查对象是否来自“this”引用的编程方式，有吗？

这是代码。谢谢！

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

5 回答 5

10

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

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 中为此使用原始的“哈希”方法，因为它缺少 Identity-Map。虽然 Array-collection 的界限O(n^2)并不像听起来那么糟糕：

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

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

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

快乐编码。

于 2012-05-23T22:03:02.527 回答
4

好的，我对@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]
于 2012-05-23T23:24:50.827 回答
2

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

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

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

于 2012-05-23T22:03:29.517 回答
1

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

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

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!"
// }
于 2019-03-27T11:53:41.537 回答
0

我必须这样做才能接受采访，这就是我得到的：

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.

该方法是“hack and slash”而不是“在编码之前有充足的时间计划”，所以结果不可能那么好，但它确实有效。可以对其进行迭代以删除递归入口点中的 WET，例如。

于 2020-11-14T05:58:42.930 回答