I was wondering if anyone has a good, working example of a circular reference in javascript? I know this is incredibly easy to do with closures, but have had a hard time wrapping my brain around this. An example that I can dissect in Firebug would be most appreciated.
Thanks
A simple way to create a circular reference is to have an object that refers to itself in a property:
function Foo() {
this.abc = "Hello";
this.circular = this;
}
var foo = new Foo();
alert(foo.circular.circular.circular.circular.circular.abc);
Here the foo object contains a reference to itself.
With closures this is usually more implicit, by just having the circular reference in scope, not as an explicit property of some object:
var circular;
circular = function(arg) {
if (arg) {
alert(arg);
}
else {
// refers to the |circular| variable, and by that to itself.
circular("No argument");
}
}
circular("hello");
circular();
Here the function saved in circular refers to the circular variable, and thereby to itself. It implicitly holds a reference to itself, creating a circular reference. Even if circular now goes out of scope, it is still referenced from the functions scope. Simple garbage collectors won't recognize this loop and won't collect the function.
circular is always accessible and can be updated? I ask because my API has a circular object that carries database transaction context, so it seems like it would be updated all the time with new context info, so avoiding garbage collection seems like a good plan. Am I close?console.log(JSON.stringify(circular)). I'm curious why I can't view it in this manner to see the current context.
Or even simpler, an array "containing" itself. See example:
var arr = [];
arr[0] = arr;
Probably the shortest way to define a cyclic object.
a = {}; a.a = a;
window.onload = function() {
hookup(document.getElementById('menu'));
function hookup(elem) {
elem.attachEvent( "onmouseover", mouse);
function mouse() {
}
}
}
As you can see, the handler is nested within the attacher, which means it is closed over the scope of the caller.
Or using ES6:
class Circular {
constructor() {
this.value = "Hello World";
this.self = this;
}
}
circular = new Circular();
You can do:
window.window...windowvar circle = {}; circle.circle = circle;var circle = []; circle[0] = circle; or circle.push(circle)function Circle(){this.self = this}; var circle = new Circle()
var b = [];
var a = [];
a[0] = b;
b[0] = a;
Printing a or b would return Circular.
function circular(arg){
var count = 0;
function next(arg){
count++;
if(count > 10) return;
if(arg){
console.log('hava arg: ' + arg);
next();
}else{
console.log('no arg');
next('add');
}
}
next();
}
circular();
Circular and with a closures.
A real-world example of circular reference
const person1 = {
name: "x",
age: 28,
};
const person2 = {
name: "y",
age: 26,
};
person1.spouse = person2;
person2.spouse = person1;
console.log(JSON.stringify(person1)); // will throw the error
