类似于某事
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是我所想象的格式，但不一定正确。如何回到对象的父级？
我只是在第一个函数中添加了
parentThis = this;
JavaScript本身并没有提供这种功能。而且我怀疑你甚至无法创建这种类型的功能。例如：
var Bobby = {name: "Bobby"};
var Dad = {name: "Dad", children: [ Bobby ]};
var Mom = {name: "Mom", children: [ Bobby ]};
Bobby属于谁？
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
您可以使用.call()来解决这个问题，它：
addName.call()addName.call({"name" : 'angela'});addName.call({"name": "angela"}, true);，其中可能addName接受一个布尔值append作为参数。对于这个特定的问题，我们可以通过call将“parent”对象传递来覆盖子对象中通常存在的this。
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';
}
};
并且可以在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';
}
};
无论何时你要在主对象的属性上使用方法：app.options.someFunction(arg) 都应该使用.call - app.options.someFunction.call(this, arg); - 这样可以保证您始终可以访问对象的每个部分。这可能会使您访问到另一个属性的方法，例如app.helpers.anotherFunction()。
一个好的想法是在somefunction中，将this存储在变量_parentThis中，这样就清楚了this反映了什么。
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);
给您：
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();
同时，请确保在“girls”定义后没有逗号。这会导致脚本在IE中崩溃（在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;
}
}
如果因為一些原因（通常是因為從庫中獲得的）你無法修改對象的結構，你可以遞歸地遍歷對象以找到其父對象。
/**
* Recursively traverse the rootObject to find the parent of childObject.
* @param rootObject - root object to inspect
* @param childObject - child object to match
* @returns - parent object of child if exists, undefined otherwise
*/
function findParent(rootObject, childObject) {
if (!(rootObject && typeof rootObject === 'object')) {
return undefined;
}
if (Array.isArray(rootObject)) {
for (let i = 0; i < rootObject.length; i++) {
if (rootObject[i] === childObject) {
return rootObject;
}
const child = this.findParent(rootObject[i], childObject);
if (child) {
return child;
}
}
} else {
const keys = Object.keys(rootObject);
for (let i = 0; i < keys.length; i += 1) {
const key = keys[i];
if (rootObject[key] === childObject) {
return rootObject;
}
const child = this.findParent(rootObject[key], childObject);
if (child) {
return child;
}
}
}
return undefined;
}
// tests
const obj = {
l1: { l11: { l111: ['a', 'b', 'c'] } },
l2: { l21: ['a', 1, {}], l22: 123 },
l3: [ { l33: {} } ],
};
assert.equal(findParent(obj, obj.l1), obj);
assert.equal(findParent(obj, obj.l1.l11), obj.l1);
assert.equal(findParent(obj, obj.l2), obj);
assert.equal(findParent(obj, obj.l2.l21), obj.l2);
assert.equal(findParent(obj, obj.l2.l22), obj.l2);
assert.equal(findParent(obj, obj.l3[0]), obj.l3);
assert.equal(findParent(obj, obj.l3[0].l33), obj.l3[0]);
我已经做了类似的事情，它非常有效。
简单明了。
附言：对象还有更多内容，但我只发布了相关部分。
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);
};
}
})();
Window对象。 - Andre Figueiredo