javascript获取父嵌套对象？

我有一个这样的对象，例如：

obj = {
    subobj1: {

    },
    subobj2: {
        func1: function(){

        },
        func2: function(){

        }
    },
    subobj3: {
        func3: function(){

        },
        func4: function(){

        }        
    },
}

---

如何从func4中调用func1，而不必调用obj.subobj2.func1（）？

您不能准确地说。你没有办法知道你的函数存在于什么对象中

请注意，它可能不止一个：您可以在现有代码之后编写：

var obj2 = {some:obj.subobj3};

因此，从属性值到包含它的对象之间不可能有唯一的链接（并且没有可访问的链接）

现在，假设您对对象创建时创建的链接感到满意，您可以使用工厂来构建对象：

obj = (function(){
    var parent = {
        subobj1: {

        },
        subobj2: {
            func1: function(){

            },
            func2: function(){

            }
        },
        subobj3: {
            func3: function(){

            },
            func4: function(){
                parent.subobj2.func1();
            }        
        }
    };
    return parent;
})();

然后你可以打电话

obj.subobj3.func4();

---

编辑

我看到你的问题被贴上了OOP标签。您应该知道，我给出的模式更常用于定义模块。javascript中的OOP通常使用

new

和

prototype

来实现，以便支持实例共享方法和继承。由于您可能希望使用模块而不是OOP，所以您看起来还不错

---

请参阅。

这是不可能的。对象属性由设置它们的对象获取。JavaScript不会隐式地将根对象设置为全局对象，因此您不能将

obj.subobj2.func1

别名为

func1

或以任何方式更短。如果您发现自己过度调用该函数，请尝试设置一个变量。

您不能直接这样做，因为无法像文件系统中的“.”那样“向上”对象层次结构

可以做的是让变量直接指向子对象或子函数，这样就不需要遍历层次结构来调用它们。以下是创建Javascript模块的常见模式：

obj = (function(){

    var obj1 = {...}
    var obj2 = {...}

    var func3 = function(){...};
    var func4 = function(){...};

    return {
        subobj1: obj1,
        subobj2: obj2,
        subobj3: {
            func3: func3,
            func4: func4
        }
    }
}());

---

在此示例中，内部函数可以直接从其变量访问

obj1

、

obj2

、

func3

和

func4

。self-calling函数使这些内部变量是私有的，对外隐藏，return语句允许您仅导出要公开的函数。

下面是一个类似asnwer的

ActionScript

，易于理解：

function MainObject() {
   this.x = 100;
   this.y = 50;
   this.second = new SecondObject(this);
}

function SecondObject(p) {
    this.parent = p;
}

var firstobject = new MainObject();

// Saving a reference to SecondObject.
var secondObject = firstobject.second;

// Because of parent variable, you can access second object parent without needing to have the parent object in a variable.
console.log(secondObject.parent.x);
console.log(secondObject.parent.y);

---

请记住，一个对象不能有多个父对象。

实现该对象是不可能的。取决于您的需要-以下实施可能很有用：

obj = function(){
  var obj = {
    subobj1: {

    },
    subobj2: {
        func1: function(){
          console.log('func1');
        },
        func2: function(){

        }
    },
    subobj3: {
        func3: function(){

        },
        func4: function(){
          this.parentObject.subobj2.func1();
        }        
    }
  }
  obj.subobj3.parentObject = obj;
/*  
  //You can also init parentObject reference of the rest of the nested objects if you need
  obj.subobj1.parentObject = obj;
  obj.subobj2.parentObject = obj;
*/  
  return obj;
}();

obj.subobj3.func4();

其思想是嵌套对象不知道谁是它们的父对象，但是父对象可以告诉它的子对象谁是他（但是需要init.code，正如您在我的实现中看到的那样）

---

您可以在此处进行测试：

以下是如何使用递归初始化向任何子对象添加

.parent

：

var obj = {
    init: function() {
        for (var i in this) {
            if (typeof this[i] == 'object') {
                    this[i].init = this.init;
                    this[i].init();
                    this[i].parent = this;
            }
        }
        return this;
    },
    subobj1: {
    },
    subobj2: {
        func1: function(){
            console.log('hey');
        },
        func2: function(){
        }
    },
    subobj3: {
        func3: function(){
        },
        func4: function(){
            this.parent.subobj2.func1();
        }        
    }
}.init();

obj.subobj3.func4();

使用此解决方案，您还可以根据嵌套要求多次使用

.parent

，例如，如果您有两个嵌套级别：

this.parent.parent.subobjX.funcY();

---

正如其他人所说，对于普通对象，无法从嵌套的子对象中查找父对象

但是，如果您使用递归作为帮助程序，这是可能的

我编写了一个名为的库，它允许您从子对象向上遍历到父对象

下面是一个简单的例子（）：

---

有这样的函数。parent.func1（）？不能只在对象声明中设置变量。这不起作用啊，这很有意义，要从工厂外调用subobj2.func1，我必须调用obj.that.suboj2.func1吗？否：您可以直接调用

obj.suboj2.func1（）。事实上，
parent
（“上次编辑之前的那个”）是私有的：如果它不是简单的obj，你不能在工厂外调用它。这看起来是最干净的工作解决方案，我使用它，并且非常喜欢它。另外，嵌套
.parent
非常有用。当一个属性被指定为null时，我收到一个错误。修复了将
if（此[i]=“对象”的类型）替换为
if（此[i]=“对象”的类型和此[i]！==null）
var test = {"hello":{"foo":{"bar":"world"}}};
var proxy = ObservableSlim.create(test, true, function(changes) {
    console.log(JSON.stringify(changes));
});

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