Question

Here有点背景。

所以我有我的父母班。构造函数接收两个对象：第一个是 class ，其中创建了父对象的实例（使用继承父类的其他类）。 第二个对象只是一些参数

parent.js

class ParentClass {
    constructor(nativeObject, params) {
        this.nativeObject = nativeObject;
        this.param1 = params.param1;
        this.param2 = params.param2;
    }
    // some logic here
}
module.exports = { ParentClass };

child.js

class ChildClass extends ParentClass {
    // some logic here
}
module.exports = { ChildClass };

我正在其他类方法中使用子类来创建它。我可以有多个如下文件：

usingclasses.js

let { ChildClass } = require('path/to/my/child/class');

let opts = {
    param1: 'idkSomeString';
    param2: 42;
}


class MyCoolClass {
    createChild() {
        return new ChildClass(this, opts);
    }
}
module.exports = { MyCoolClass };

anotherclasses.js

let { ChildClass } = require('path/to/my/child/class');

let opts = {
    param1: 'thatAstringToo';
    param2: 123;
}

class AnotherCoolClass{
    alsoCreatesChild() {
        return new ChildClass(this, opts);
    }
}
module.exports = { AnotherCoolClass};

我可以在一个类中以不同的方法创建ChildClass的多个实例：

thirdexample.js

let { ChildClass } = require('path/to/my/child/class');

let opts1 = {
    param1: 'aStringAgain';
    param2: 27;
}

let opts2 = {
    param1: 'ABC';
    param2: 33;
}

class ClassAgain{
    firstMethod() {
        return new ChildClass(this, opts1);
    }

    secondMethod() {
        return new ChildClass(this, opts2);
    }
}
module.exports = { ClassAgain };

我之所以通过.this是因为我正在ParentClass中使用它

例如用于记录console.log(`I know this was created in ${this.nativeObject .constructor.name}`);

我正在寻找的是摆脱每次创建.this的新实例时都传递ChildClass的方法

这背后的原因是，在一个文件（类）中，我最多可以创建10个以上的ChildClass实例。

在上一个问题中，我已经得到一个答案，可以帮助我使代码更加结构化和易于维护：

代替：

createChild() {
        return new ChildClass(this, param1, param2, param3, paramN);
    }

我在做

createChild() {
        return new ChildClass(this, paramObj);
}

因此，现在我可以将带有参数的所有对象存储在文件顶部（甚至是单独文件的顶部），并在需要时轻松查找和更改它。
...

现在，我正试图找到一种方法来消除每次创建.this时的ChildClass

ParentClass还能通过其他方式知道此ChildClass实例在哪里“住”吗？

我正在尝试使用.apply或.call做些什么，但似乎这不是我要寻找的机器人

更新：既然我在此方面的进展为零，甚至有评论说这很有可能是不可能的，现在让我们假设我需要一个仅创建LogClass的Class实例的类的名称。

在创建ChildClass时，如何在每次都不传递类的情况下检索该类的名称？

let opts = {
    className: 'MyCoolClass'
    param1: 'idkSomeString';
    param2: 42;
}


class MyCoolClass {
    createChild() {
        return new ChildClass(opts);
    }
}
module.exports = { MyCoolClass };

问题是我必须一次又一次地在className: 'MyCoolClass'的每个版本中设置opts……只需重复10-15次

Answer 1

您可以使用Reflect.construct实例化您的类。

class ParentClass {
  constructor (nat, x) {
    this.nat = nat
    this.x = x
  }
  log () {
    console.log('from ', this.nat.constructor.name, this.x)
  }
}
class ChildClass extends ParentClass{}

class ClassAgain{
  firstMethod () {
    return this.makeInstance({ a: 1 })
  }

  secondMethod () {
    return this.makeInstance({ b: 2 })
  }

  makeInstance (params) {
    return Reflect.construct(ChildClass, [this, params])
  }
}
const ca = new ClassAgain()
ca.firstMethod().log()
ca.secondMethod().log()

一种检索上下文而无需将`.this`作为参数的方法

1 个答案: