从javascript对象访问父级的父级

Question

就像是

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

这个.SOMETHING是我想象的格式,但它可能不是.什么会退回到对象的父级？

Answer 1

我只是添加了第一个函数

parentThis = this;

并在子功能中使用parentThis.为什么？因为在JavaScript中,对象很软.可以通过简单的赋值将新成员添加到软对象中(不像是经典对象很难的Java.将新成员添加到硬对象的唯一方法是创建一个新类)更多相关内容:http ://www.crockford.com/javascript/inheritance.html

而且最后你不必杀死或破坏对象.为什么我在这里找到:http://bytes.com/topic/javascript/answers/152552-javascript-destroy-object

希望这可以帮助

Answer 2

JavaScript本身不提供此功能.我怀疑你甚至可以创建这种类型的功能.例如:

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

鲍比属于谁？

Answer 3

在这种情况下,您可以使用life引用父对象.或者您可以life在users对象中存储引用.在语言中没有固定的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

Answer 4

关于电话：

您可以通过使用.call()which来解决这个问题：

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

使用调用：

对于这个特殊问题，我们可以通过“父”对象call来覆盖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';
    }
};

现在，这是一个解决方案 use call

和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)应始终使用.call-调用app.options.someFunction.call(this, arg);- 这样您就可以确保您始终可以访问对象的每个部分。它可以让您访问另一个属性的方法，例如app.helpers.anotherFunction().

一个好主意是在somefunction, 存储this在一个变量中，_parentThis因此很明显this反映了什么。