我有一些图书馆代码在我身上无休止地骑自行车。
我不清楚如何在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
}
我所知道的处理这种情况的“可靠和干净”的方法是使用“访问过的”对象的集合，然后根据当前对象是否已被“访问”进行反应 - 终止，插入符号引用等“ 或不。
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关于这个工件的评论[相对]容易清理。）
快乐的编码。
好的，我对@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。超值服务：
缺点：
__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!"
// }