JavaScript：绑定对象的上下文'；将方法添加到父对象

此示例按预期工作：

class A {
  constructor(name) {
     this.name = name
  }
}

A.prototype.someMethod1 = function() { console.log("1: " + this.name) }
A.prototype.someMethod2 = function() { console.log("2: " + this.name) }

let a = new A("John")
a.someMethod1()
a.someMethod2()

有时我们需要将方法按其含义分组到子对象中，以便像这样调用它：a.some.method1（），a.some.method2（）。让我们试着写：

class A {
  constructor(name) {
     this.name = name
  }
}

A.prototype.some = {
  method1: function() { console.log("1: " + this.name) },
  method2: function() { console.log("2: " + this.name) }
}

现在我们可以调用a.some.method1（）和a.some.method2（），但其中的“this”指向“a.some”，而不是所需的“a”。因此，这些方法中的“this.name”现在将是“未定义的”

所以我可以将方法的上下文绑定到主对象吗

目前我只知道一种方法。在构造函数中类似这样的内容：

class A {
  constructor(name) {
    this._name = name

    // bind context to this
    Object.keys(this.name).forEach(n => {
      this.name[n] = this.name[n].bind(this)
    })
  }
}

但是还有更优雅的方法吗

---

注：应在申报时指定。方法调用的修改，比如A.Auth.Mult1（）。调用（a）是不可接受的。

< P>这可能根本不是你要找的，但是你可以考虑这样做：

class A {
    constructor(name) {
        this.name = name;
        this.some = new Some(this);        
    }
}

class Some {
    constructor(a) {
        this.a = a;
    }

    method1() { console.log("1: " + this.a.name) }
    method2() { console.log("2: " + this.a.name) }
}

var x = new A('x name');
x.some.method1();
x.some.method2();

---

这可能根本不是你想要的，但是你可以考虑这样做：

class A {
    constructor(name) {
        this.name = name;
        this.some = new Some(this);        
    }
}

class Some {
    constructor(a) {
        this.a = a;
    }

    method1() { console.log("1: " + this.a.name) }
    method2() { console.log("2: " + this.a.name) }
}

var x = new A('x name');
x.some.method1();
x.some.method2();

---

是的，您可以定义类的实例，然后通过将其绑定到

a

A类{
建造师（姓名）{
this.name=name
}
}
让a=新a（“你好”）
A.prototype.some={
方法1:function（）{console.log（“1:+this.name）}.bind（a），
方法2:function（）{console.log（“2:+this.name）}.bind（a）
}
a、 some.method1（）

是的，您可以定义类的实例，然后通过将其绑定到

a

A类{
建造师（姓名）{
this.name=name
}
}
让a=新a（“你好”）
A.prototype.some={
方法1:function（）{console.log（“1:+this.name）}.bind（a），
方法2:function（）{console.log（“2:+this.name）}.bind（a）
}
a、 some.method1（）

您可以使

some

成为一个函数，返回一个对象，您可以在其中指定要使用的方法，然后可以从该对象调用这些方法

A类{
建造师（姓名）{
this.name=name
}
}
A.prototype.someMethod1=函数（）{
console.log（“1:+this.name）
}
A.prototype.someMethod2=函数（）{
console.log（“2:+this.name）
}
A.prototype.some=函数（）{
返回{
somethod1：这个。somethod1.绑定（这个），
someMethod2:this.someMethod2.bind（this）
}
}
让a=新的a（“约翰”）
a、 someMethod1（）
a、 方法2（）
a、 some（）.someMethod1（）
a、 some（）.someMethod2（）

您可以使

some

成为一个函数，返回一个对象，您可以在其中指定要使用的方法，然后可以从该对象调用这些方法

A类{
建造师（姓名）{
this.name=name
}
}
A.prototype.someMethod1=函数（）{
console.log（“1:+this.name）
}
A.prototype.someMethod2=函数（）{
console.log（“2:+this.name）
}
A.prototype.some=函数（）{
返回{
someMethod1:this.someMethod1.bind（this），
someMethod2:this.someMethod2.bind（this）
}
}
让a=新的a（“约翰”）
a、 someMethod1（）
a、 方法2（）
a、 some（）.someMethod1（）
a、 some（）.someMethod2（）

“有时我们需要将方法按其含义分组到子对象中”-这背后的原因是什么？它们不都只是实例的方法吗？为什么需要这种分组？例如，如果我有一种插件扩展某个类，我不想让它们乱丢对象范围。我更喜欢一种方式，当每个插件将其方法分开的范围键命名的插件的名称。我认为这并不是唯一需要的情况。“有时我们需要根据它的意义将方法分组到子对象中”——这背后的原因是什么？它们不都只是实例的方法吗？为什么需要这种分组？例如，如果我有一种插件扩展某个类，我不想让它们乱丢对象范围。我更喜欢一种方式，当每个插件将其方法分开的范围键命名的插件的名称。我认为这不是唯一需要的情况。不，这是不可接受的。我写道，它必须在宣言中。客户代码不应了解变现细节。不，这是不可接受的。我写道，它必须在宣言中。客户端代码不应该知道实现细节。在这种情况下，我们不解决主要目标-保持主对象的范围干净。@WindBridges您可以为此专门创建另一个类，该类继承自第一个类。在这种情况下，我们不解决主要目标-保持主对象的范围干净。@WindBridges您可以为此专门创建另一个从第一个类继承的类是的，这不是我要找的。是的，这不是我要找的。