从javascript对象访问父项的父项

就像是

var life= { users : { guys : function(){ this.SOMETHING.mameAndDestroy(this.girls); }, girls : function(){ this.SOMETHING.kiss(this.boys); }, }, mameAndDestroy : function(group){ }, kiss : function(group){ } }; 

这是。我想象的格式是,但它可能不是。 什么会退回到对象的父项?

JavaScript本身不提供此function。 我怀疑你甚至可以创build这种types的function。 例如:

 var Bobby = {name: "Bobby"}; var Dad = {name: "Dad", children: [ Bobby ]}; var Mom = {name: "Mom", children: [ Bobby ]}; 

鲍比是谁的?

我只是添加在第一个function

 parentThis = this; 

并在子function中使用parentThis。 为什么? 因为在JavaScript中,对象很软。 一个新的成员可以通过简单的赋值被添加到一个软对象中(而不是像古典对象那样的Java)。向硬对象添加新成员的唯一方法是创build一个新类。 ://www.crockford.com/javascript/inheritance.html

而且最后你不必杀死或者摧毁这个物体。 为什么我在这里find: http : //bytes.com/topic/javascript/answers/152552-javascript-destroy-object

希望这可以帮助

在这种情况下,你可以使用life来引用父对象。 或者你可以在用户对象中存储对life的引用。 在语言中不能有一个固定的parent对象,因为用户只是一个对象的引用,并且可能有其他引用。

 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! 

你可能会发现使用这样的东西很有帮助:

 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 

如果我正确地阅读你的问题,一般来说对象不知道它们被包含在哪里。 他们不知道他们的父母是谁。 要find这些信息,你必须parsing父数据结构。 当您在文档中讨论元素对象时,DOM有办法为我们做这件事,但是看起来您正在谈论香草对象。

关于通话:

你可以通过使用.call()来解决这个问题,其中:

  • 必须在函数addName.call()上调用
  • 你传递一个你想成为“this”的对象addName.call({"name" : 'angela'});
  • 你可以传递额外的参数,它可以在addName.call({"name": "angela"}, true);上被调用的函数中使用addName.call({"name": "angela"}, true); addName可能接受boolean append的参数。

使用呼叫:

对于这个特定的问题,我们可以通过call来传递“父对象”对象来覆盖通常存在于子对象中的对象。

先看看我们的问题

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

现在,这是一个解决scheme使用调用

和JSFIDDLE看到它的工作。

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

结论是

你可以使用.call()只要你在主对象的属性上使用方法: app.options.someFunction(arg)应该总是用app.options.someFunction.call(this, arg);app.options.someFunction.call(this, arg);来调用app.options.someFunction.call(this, arg); – 这样你可以确保你总是可以访问对象的每个部分。 它可以让你访问另一个属性的方法,如app.helpers.anotherFunction()

一个好主意是在somefunction ,将其存储在一个variables_parentThis所以这是显而易见的反映。

干得好:

 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(); 

另外,确保在“女孩”定义之后没有逗号。 这将导致脚本崩溃在IE中(任何时候你有一个逗号后的数组中的最后一个项目在它死了)。

看到它运行

我使用了类似于单例模式的东西:

 function myclass() = { var instance = this; this.Days = function() { var days = ["Piątek", "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; } } 

我做了这样的事情,它就像一个魅力。

简单。

PS有更多的对象,但我只是张贴相关的部分。

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

用下面的代码你可以访问对象的父对象:

 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"] 

我会build议你阅读JavaScript 对象了解如何使用对象,它帮助了我很多。 我甚至发现了我甚至不知道它们存在的function。

如果您希望获取字面对象( {} )中节点的所有父键,则可以这样做:

 (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); 

该algorithm使用FIFO概念来使用BFS方法迭代图。 此代码扩展了Object并添加了静态方法parentKeys ,该方法需要parentKeysliteral Object (哈希表 – 关联数组…)作为参数。

我希望我能帮上忙