Node.js 如何在另一个类中使用类函数？ 我如何将C++类中的指针类类实例应用到类实例函数？< /P>

例如：

class A {
    constructor()
    { 
       this.block = [];
    }

    method()
    {
       return this.blocks.length;
    }
}

另一类：

class B {
    constructor(instance)
    { 
       this.instance = instance;
    }

    method()
    {
        this.instance.method(); // here i'm getting cannot get length of undefined
    }
}

---

如果我想这样做，那么我在调用它时遇到了问题

您可以在JS中通过调用如下静态方法轻松做到这一点：

class A {
  static write(){  //static method
    console.log("Called write from A");
  }
}

class B {
   doIt(){
     A.write();
   }
}


let b = new B();
b.doIt();

选项2，在另一个类的构造函数中实例化该类，如下所示：

class A {
  write(){
    console.log("Non-static write() called from class A");
  }
}

class B {
   constructor() {
       this.a = new A();
   }

   doIt(){
     this.a.write();
   }
}

let b = new B();
b.doIt();

---

在JS中，您可以通过调用如下静态方法轻松做到这一点：

class A {
  static write(){  //static method
    console.log("Called write from A");
  }
}

class B {
   doIt(){
     A.write();
   }
}


let b = new B();
b.doIt();

选项2，在另一个类的构造函数中实例化该类，如下所示：

class A {
  write(){
    console.log("Non-static write() called from class A");
  }
}

class B {
   constructor() {
       this.a = new A();
   }

   doIt(){
     this.a.write();
   }
}

let b = new B();
b.doIt();

---

你可以试试这个。在这里，当创建B类的实例时，我给它一个A类的实例作为参数。然后在B中，我们可以调用实例的方法，并访问其属性

此外，正如@ViaTech发布的，您可以使用静态方法访问它们，而无需初始化类的对象。这就是静态方法。提及

B类{
构造函数（实例）
{
this.instance=instance；
}
方法（）
{
this.instance.method（）；
}
}
甲级{
构造函数（）
{
}
方法（）
{
console.log（“A的方法”）；
}
}
var a=新的a（）；
var b=新的b（a）；
b、 方法（）；//A的方法

您可以试试这个。在这里，当创建B类的实例时，我给它一个A类的实例作为参数。然后在B中，我们可以调用实例的方法，并访问其属性

此外，正如@ViaTech发布的，您可以使用静态方法访问它们，而无需初始化类的对象。这就是静态方法。提及

B类{
构造函数（实例）
{
this.instance=instance；
}
方法（）
{
this.instance.method（）；
}
}
甲级{
构造函数（）
{
}
方法（）
{
console.log（“A的方法”）；
}
}
var a=新的a（）；
var b=新的b（a）；
b、 方法（）；//A的方法

有几种方法：
我无意中在PHP和Javascript之间切换，但两者的原则是相同的）

使用静态函数： 通常，您在类中有一个

this

。假设您有以下代码：

class Car {
    let color;
    public function setColor(newColor){ this.color = newColor;}
}
let car = new Car(); 
car->setColor('green')`

setColor

功能的

此

指的是

汽车

。您可以设置

让另一辆车=新车（）

，然后当您设置

另一辆车->设置颜色（'red'）

时，您只更改那辆车，而不是第一辆车。简单化：您可以创建多个实例

如果您不需要该类，但只需要一次该类，则可以将其设置为静态。一个简单的解释方法是“你有一个单独的函数集合，只是放在一个包装类中（实际上做的不多）”。例如，您可能有一些sanatizing方法：

class Sanitize {
    static function makeHtmlSave(input){
        return doYourMagicHere(input);
    }
    static function removeXssCode(input){
        return doMoreMagicHere(input);
    }
}

这样，您可以多次重复使用它。如果您想使用它，请在需要它的地方执行

Sanitize:：makeHtmlSave（someCode）

。没有一个

Sanitize

的东西，它只是一个包装器，用于访问其中的fruncions

---

使用扩展： 您可以扩展一个类。假设您有一个通用类

车辆

，它具有一些属性（例如电机、数字鳗鱼、颜色），您可以使用更具体的类来扩展它：

class Vehicle {
    let color;
    public function setColor(newColor){ this.color = newColor}
}
class Car extends Vehicle {
    let hasAirco = false;
    public function hasAirco(newValue){ this.hasAirco = newValue};
}

如果执行

let car=new car（）

，则会得到一个car对象，该对象扩展/放大/补充了车辆类，因此可以同时使用其（公共）功能。在内部，汽车也可以使用汽车的功能

---

把它递给我

---

您现在可以这样做

let a=new One（）；设b=新的两个（a）。您可以不使用一乘二的函数，但仍然可以使用
a->doSomething（）
。这种解决方案感觉是最简单的，但几乎从来都不是。类/对象是棘手的东西，但我很少使用这种解决方案。有一些用例，但通常是一种异味指示器。
有几种方法：

我无意中在PHP和Javascript之间切换，但两者的原则是相同的）

使用静态函数：
通常，您在类中有一个
this
。假设您有以下代码：

class Car {
    let color;
    public function setColor(newColor){ this.color = newColor;}
}
let car = new Car(); 
car->setColor('green')`

setColor
功能的
此
指的是
汽车
。您可以设置
让另一辆车=新车（）
，然后当您设置
另一辆车->设置颜色（'red'）
时，您只更改那辆车，而不是第一辆车。简单化：您可以创建多个实例

如果您不需要该类，但只需要一次该类，则可以将其设置为静态。一个简单的解释方法是“你有一个单独的函数集合，只是放在一个包装类中（实际上做的不多）”。例如，您可能有一些sanatizing方法：

class Sanitize {
    static function makeHtmlSave(input){
        return doYourMagicHere(input);
    }
    static function removeXssCode(input){
        return doMoreMagicHere(input);
    }
}

这样，您可以多次重复使用它。如果您想使用它，请在需要它的地方执行
Sanitize:：makeHtmlSave（someCode）
。没有一个
Sanitize
的东西，它只是一个包装器，用于访问其中的fruncions


使用扩展：
您可以扩展一个类。假设您有一个通用类
车辆
，它具有一些属性（例如电机、数字鳗鱼、颜色），您可以使用更具体的类来扩展它：

class Vehicle {
    let color;
    public function setColor(newColor){ this.color = newColor}
}
class Car extends Vehicle {
    let hasAirco = false;
    public function hasAirco(newValue){ this.hasAirco = newValue};
}

如果执行
let car=new car（）
，则会得到一个car对象，该对象扩展/放大/补充了车辆类，因此可以同时使用其（公共）功能。在内部，汽车也可以使用汽车的功能


把它递给我
您现在可以这样做
let a=new One（）；设b=新的两个（a）。您可以不使用一乘二的函数，但仍然可以使用
a->doSomething（）
。这种解决方案感觉是最简单的，但几乎从来都不是。类/对象是棘手的东西，但我很少使用这种解决方案。有一些用例，但通常它是一个异味指示器。
它看起来像
B
希望您传入
a
的实例。如果您这样做，它将起作用。看起来
B
希望您传入
A
的实例。如果你这样做，它会起作用的。哦，糟糕，我在编辑之前已经给第一班打了电话