从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可能接受booleanappend的参数。
使用呼叫：
对于这个特定的问题，我们可以通过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 ，该方法需要parentKeys的literal Object （哈希表 – 关联数组…）作为参数。
我希望我能帮上忙
