Something like
var life= {
users : {
guys : function(){ this.SOMETHING.mameAndDestroy(this.girls); },
girls : function(){ this.SOMETHING.kiss(this.boys); },
},
mameAndDestroy : function(group){ },
kiss : function(group){ }
};
this.SOMETHING is what I imagine the format is, but it might not be. What will step back up to the parent of an object?
This question is related to
javascript
oop
You can sort of solve this issue by using .call() which:
addName.call()addName.call({"name" : 'angela'});addName.call({"name": "angela"}, true); where perhaps addName accepts an argument of boolean append.For this particular problem, we can pass the "parent" object through call to override the this normally present in the child object.
var app = {
init: function() {
var _this = this; // so we can access the app object in other functions
$('#thingy').click(function(){
alert(_this.options.thingy());
});
$('#another').click(function(){
alert(_this.options.getAnother());
});
},
options: {
thingy: function() {
// PROBLEM: the this here refers to options
return this.getThingy();
},
getAnother: function() {
// PROBLEM 2: we want the this here to refer to options,
// but thingy will need the parent object
return 'another ' + this.thingy();
},
},
getThingy: function() {
return 'thingy';
}
};
And JSFIDDLE to see it work.
var app = {
init: function() {
var _this = this; // so we can access the app object in other functions
$('#thingy').click(function(){
// SOLUTION: use call to pass _this as the 'this' used by thingy
alert(_this.options.thingy.call(_this));
});
$('#another').click(function(){
// SOLUTION 2: Use call to pass parent all the way through
alert(_this.options.getAnother.call(_this));
});
},
options: {
thingy: function() {
// SOLUTION in action, the this is the app object, not options.
return this.getThingy();
},
getAnother: function() {
// SOLUTION 2 in action, we can still access the options
// AND pass through the app object to the thingy method.
return 'another ' + this.options.thingy.call(this);
},
},
getThingy: function() {
return 'thingy';
}
};
You can use .call() whenever you use a method on a property of your main object: app.options.someFunction(arg) should always be called with .call - app.options.someFunction.call(this, arg); - that way you can ensure that you'll always have access to every part of the object. It could give you access to another property's methods like app.helpers.anotherFunction().
A good idea is in the somefunction, store this in a variable _parentThis so it's obvious what the this reflects.
If I'm reading your question correctly, objects in general are agnostic about where they are contained. They don't know who their parents are. To find that information, you have to parse the parent data structure. The DOM has ways of doing this for us when you're talking about element objects in a document, but it looks like you're talking about vanilla objects.
In this case, you could use life to reference the parent object. Or you could store a reference to life in the users object. There can't be a fixed parent available to you in the language, because users is just a reference to an object, and there could be other references...
var death = { residents : life.users };
life.users.smallFurryCreaturesFromAlphaCentauri = { exist : function() {} };
// death.residents.smallFurryCreaturesFromAlphaCentauri now exists
// - because life.users references the same object as death.residents!
You might find it helpful to use something like this:
function addChild(ob, childName, childOb)
{
ob[childName] = childOb;
childOb.parent = ob;
}
var life= {
mameAndDestroy : function(group){ },
kiss : function(group){ }
};
addChild(life, 'users', {
guys : function(){ this.parent.mameAndDestroy(this.girls); },
girls : function(){ this.parent.kiss(this.boys); },
});
// life.users.parent now exists and points to life
I used something that resembles singleton pattern:
function myclass() = {
var instance = this;
this.Days = function() {
var days = ["Piatek", "Sobota", "Niedziela"];
return days;
}
this.EventTime = function(day, hours, minutes) {
this.Day = instance.Days()[day];
this.Hours = hours;
this.minutes = minutes;
this.TotalMinutes = day*24*60 + 60*hours + minutes;
}
}
In this case, you could use life to reference the parent object. Or you could store a reference to life in the users object. There can't be a fixed parent available to you in the language, because users is just a reference to an object, and there could be other references...
var death = { residents : life.users };
life.users.smallFurryCreaturesFromAlphaCentauri = { exist : function() {} };
// death.residents.smallFurryCreaturesFromAlphaCentauri now exists
// - because life.users references the same object as death.residents!
You might find it helpful to use something like this:
function addChild(ob, childName, childOb)
{
ob[childName] = childOb;
childOb.parent = ob;
}
var life= {
mameAndDestroy : function(group){ },
kiss : function(group){ }
};
addChild(life, 'users', {
guys : function(){ this.parent.mameAndDestroy(this.girls); },
girls : function(){ this.parent.kiss(this.boys); },
});
// life.users.parent now exists and points to life
If you want get all parents key of a node in a literal object ({}), you can to do that:
(function ($) {
"use strict";
$.defineProperties($, {
parentKeys: {
value: function (object) {
var
traces = [],
queue = [{trace: [], node: object}],
block = function () {
var
node,
nodeKeys,
trace;
// clean the queue
queue = [];
return function (map) {
node = map.node;
nodeKeys = Object.keys(node);
nodeKeys.forEach(function (nodeKey) {
if (typeof node[nodeKey] == "object") {
trace = map.trace.concat(nodeKey);
// put on queue
queue.push({trace: trace, node: node[nodeKey]});
// traces.unshift(trace);
traces.push(trace);
}
});
};
};
while(true) {
if (queue.length) {
queue.forEach(block());
} else {
break;
}
}
return traces;
},
writable: true
}
});
})(Object);
This algorithm uses the FIFO concept for iterate the graphs using the BFS method. This code extend the class Object adding the static method parentKeys that expects a literal Object (hash table - associative array...) of the Javacript, as parameter.
I hope I have helped.
I simply added in first function
parentThis = this;
and use parentThis in subfunction. Why? Because in JavaScript, objects are soft. A new member can be added to a soft object by simple assignment (not like ie. Java where classical objects are hard. The only way to add a new member to a hard object is to create a new class) More on this here: http://www.crockford.com/javascript/inheritance.html
And also at the end you don't have to kill or destroy the object. Why I found here: http://bytes.com/topic/javascript/answers/152552-javascript-destroy-object
Hope this helps
If I'm reading your question correctly, objects in general are agnostic about where they are contained. They don't know who their parents are. To find that information, you have to parse the parent data structure. The DOM has ways of doing this for us when you're talking about element objects in a document, but it looks like you're talking about vanilla objects.
I have done something like this and it works like a charm.
Simple.
P.S. There is more the the object but I just posted the relevant part.
var exScript = (function (undefined) {
function exScript() {
this.logInfo = [];
var that = this;
this.logInfo.push = function(e) {
that.logInfo[that.logInfo.length] = e;
console.log(e);
};
}
})();
As others have said, it is not possible to directly lookup a parent from a nested child. All of the proposed solutions advise various different ways of referring back to the parent object or parent scope through an explicit variable name.
However, directly traversing up to the the parent object is possible if you employ recursive ES6 Proxies on the parent object.
I've written a library called ObservableSlim that, among other things, allows you to traverse up from a child object to the parent.
Here's a simple example (jsFiddle demo):
var test = {"hello":{"foo":{"bar":"world"}}};
var proxy = ObservableSlim.create(test, true, function() { return false });
function traverseUp(childObj) {
console.log(JSON.stringify(childObj.__getParent())); // returns test.hello: {"foo":{"bar":"world"}}
console.log(childObj.__getParent(2)); // attempts to traverse up two levels, returns undefined because test.hello does not have a parent object
};
traverseUp(proxy.hello.foo);
In this case, you could use life to reference the parent object. Or you could store a reference to life in the users object. There can't be a fixed parent available to you in the language, because users is just a reference to an object, and there could be other references...
var death = { residents : life.users };
life.users.smallFurryCreaturesFromAlphaCentauri = { exist : function() {} };
// death.residents.smallFurryCreaturesFromAlphaCentauri now exists
// - because life.users references the same object as death.residents!
You might find it helpful to use something like this:
function addChild(ob, childName, childOb)
{
ob[childName] = childOb;
childOb.parent = ob;
}
var life= {
mameAndDestroy : function(group){ },
kiss : function(group){ }
};
addChild(life, 'users', {
guys : function(){ this.parent.mameAndDestroy(this.girls); },
girls : function(){ this.parent.kiss(this.boys); },
});
// life.users.parent now exists and points to life
I simply added in first function
parentThis = this;
and use parentThis in subfunction. Why? Because in JavaScript, objects are soft. A new member can be added to a soft object by simple assignment (not like ie. Java where classical objects are hard. The only way to add a new member to a hard object is to create a new class) More on this here: http://www.crockford.com/javascript/inheritance.html
And also at the end you don't have to kill or destroy the object. Why I found here: http://bytes.com/topic/javascript/answers/152552-javascript-destroy-object
Hope this helps
I used something that resembles singleton pattern:
function myclass() = {
var instance = this;
this.Days = function() {
var days = ["Piatek", "Sobota", "Niedziela"];
return days;
}
this.EventTime = function(day, hours, minutes) {
this.Day = instance.Days()[day];
this.Hours = hours;
this.minutes = minutes;
this.TotalMinutes = day*24*60 + 60*hours + minutes;
}
}
You can sort of solve this issue by using .call() which:
addName.call()addName.call({"name" : 'angela'});addName.call({"name": "angela"}, true); where perhaps addName accepts an argument of boolean append.For this particular problem, we can pass the "parent" object through call to override the this normally present in the child object.
var app = {
init: function() {
var _this = this; // so we can access the app object in other functions
$('#thingy').click(function(){
alert(_this.options.thingy());
});
$('#another').click(function(){
alert(_this.options.getAnother());
});
},
options: {
thingy: function() {
// PROBLEM: the this here refers to options
return this.getThingy();
},
getAnother: function() {
// PROBLEM 2: we want the this here to refer to options,
// but thingy will need the parent object
return 'another ' + this.thingy();
},
},
getThingy: function() {
return 'thingy';
}
};
And JSFIDDLE to see it work.
var app = {
init: function() {
var _this = this; // so we can access the app object in other functions
$('#thingy').click(function(){
// SOLUTION: use call to pass _this as the 'this' used by thingy
alert(_this.options.thingy.call(_this));
});
$('#another').click(function(){
// SOLUTION 2: Use call to pass parent all the way through
alert(_this.options.getAnother.call(_this));
});
},
options: {
thingy: function() {
// SOLUTION in action, the this is the app object, not options.
return this.getThingy();
},
getAnother: function() {
// SOLUTION 2 in action, we can still access the options
// AND pass through the app object to the thingy method.
return 'another ' + this.options.thingy.call(this);
},
},
getThingy: function() {
return 'thingy';
}
};
You can use .call() whenever you use a method on a property of your main object: app.options.someFunction(arg) should always be called with .call - app.options.someFunction.call(this, arg); - that way you can ensure that you'll always have access to every part of the object. It could give you access to another property's methods like app.helpers.anotherFunction().
A good idea is in the somefunction, store this in a variable _parentThis so it's obvious what the this reflects.
If I'm reading your question correctly, objects in general are agnostic about where they are contained. They don't know who their parents are. To find that information, you have to parse the parent data structure. The DOM has ways of doing this for us when you're talking about element objects in a document, but it looks like you're talking about vanilla objects.
With the following code you can access the parent of the object:
var Users = function(parent) {
this.parent = parent;
};
Users.prototype.guys = function(){
this.parent.nameAndDestroy(['test-name-and-destroy']);
};
Users.prototype.girls = function(){
this.parent.kiss(['test-kiss']);
};
var list = {
users : function() {
return new Users(this);
},
nameAndDestroy : function(group){ console.log(group); },
kiss : function(group){ console.log(group); }
};
list.users().guys(); // should output ["test-name-and-destroy"]
list.users().girls(); // should output ["test-kiss"]
I would recommend you read about javascript Objects to get to know how you can work with Objects, it helped me a lot. I even found out about functions that I didn't even knew they existed.
As others have said, it is not possible to directly lookup a parent from a nested child. All of the proposed solutions advise various different ways of referring back to the parent object or parent scope through an explicit variable name.
However, directly traversing up to the the parent object is possible if you employ recursive ES6 Proxies on the parent object.
I've written a library called ObservableSlim that, among other things, allows you to traverse up from a child object to the parent.
Here's a simple example (jsFiddle demo):
var test = {"hello":{"foo":{"bar":"world"}}};
var proxy = ObservableSlim.create(test, true, function() { return false });
function traverseUp(childObj) {
console.log(JSON.stringify(childObj.__getParent())); // returns test.hello: {"foo":{"bar":"world"}}
console.log(childObj.__getParent(2)); // attempts to traverse up two levels, returns undefined because test.hello does not have a parent object
};
traverseUp(proxy.hello.foo);
With the following code you can access the parent of the object:
var Users = function(parent) {
this.parent = parent;
};
Users.prototype.guys = function(){
this.parent.nameAndDestroy(['test-name-and-destroy']);
};
Users.prototype.girls = function(){
this.parent.kiss(['test-kiss']);
};
var list = {
users : function() {
return new Users(this);
},
nameAndDestroy : function(group){ console.log(group); },
kiss : function(group){ console.log(group); }
};
list.users().guys(); // should output ["test-name-and-destroy"]
list.users().girls(); // should output ["test-kiss"]
I would recommend you read about javascript Objects to get to know how you can work with Objects, it helped me a lot. I even found out about functions that I didn't even knew they existed.
I have done something like this and it works like a charm.
Simple.
P.S. There is more the the object but I just posted the relevant part.
var exScript = (function (undefined) {
function exScript() {
this.logInfo = [];
var that = this;
this.logInfo.push = function(e) {
that.logInfo[that.logInfo.length] = e;
console.log(e);
};
}
})();
If I'm reading your question correctly, objects in general are agnostic about where they are contained. They don't know who their parents are. To find that information, you have to parse the parent data structure. The DOM has ways of doing this for us when you're talking about element objects in a document, but it looks like you're talking about vanilla objects.
In this case, you could use life to reference the parent object. Or you could store a reference to life in the users object. There can't be a fixed parent available to you in the language, because users is just a reference to an object, and there could be other references...
var death = { residents : life.users };
life.users.smallFurryCreaturesFromAlphaCentauri = { exist : function() {} };
// death.residents.smallFurryCreaturesFromAlphaCentauri now exists
// - because life.users references the same object as death.residents!
You might find it helpful to use something like this:
function addChild(ob, childName, childOb)
{
ob[childName] = childOb;
childOb.parent = ob;
}
var life= {
mameAndDestroy : function(group){ },
kiss : function(group){ }
};
addChild(life, 'users', {
guys : function(){ this.parent.mameAndDestroy(this.girls); },
girls : function(){ this.parent.kiss(this.boys); },
});
// life.users.parent now exists and points to life
Here you go:
var life={
users:{
guys:function(){ life.mameAndDestroy(life.users.girls); },
girls:function(){ life.kiss(life.users.guys); }
},
mameAndDestroy : function(group){
alert("mameAndDestroy");
group();
},
kiss : function(group){
alert("kiss");
//could call group() here, but would result in infinite loop
}
};
life.users.guys();
life.users.girls();
Also, make sure you don't have a comma after the "girls" definition. This will cause the script to crash in IE (any time you have a comma after the last item in an array in IE it dies).
Source: Stackoverflow.com