Question

我需要在JavaScript中扩展一个singleton类。

我面临的问题是，我得到了要从中扩展的类实例，而不仅仅是获得了类的方法。

我尝试删除super来获取实例，但随后出现错误

在访问“ this”或从派生构造函数返回之前，必须在派生类中调用超级构造函数

代码示例：

let instanceA = null;
let instanceB = null;

class A {
  constructor(options) {
    if (instanceA === null) {
      this.options = options;
      instanceA = this;
    }
    return instanceA;
  }
}

class B extends A {
  constructor(options) {
    if (instanceB === null) {
      super()
      console.log('real class is ' + this.constructor.name)
      this.options = options
      instanceB = this;
    }
    return instanceB;
  }
}

const a = new A({
  i_am_a: "aaaaaa"
});

const b = new B({
  i_am_b: "bbbbbb"
}) // this change a 

console.log(b.options)

console.log(a.options)

Answer 1

所以，首先这里有一个误解：

我尝试删除super而不获取实例，但随后出现错误

super()在创建的子类实例（即this所引用的实例）上调用父类的构造函数。它不返回父类实例。 See here了解更多信息。

因此，调用super()完全不会违反父类的singleton属性。如果正确实施，它可能只会被构造一次。

考虑到这一点，您应该对代码进行一些改进。

一个明智的改变是从构造函数中删除实例管理。一种解决方案是使用静态构造器，如果不存在实例，则创建单例，或者返回创建的实例。

另一种方法是将参数放在单例类构造函数中。将参数传递给应该实例化一次的类实际上没有任何意义（您永远不会再对构造函数参数进行任何操作）。您可以立即使单例的arguments属性。这是SO answer支持Java单例的这一点。

具有静态构造函数且不带参数的完整示例如下：

let instanceA = null;
let instanceB = null;

let counters = { A: 0, B: 0 }; // count class instantiations

class A {
  static getInstance() {
    if (instanceA === null) {
      instanceA = new A();
    }
    return instanceA;
  }
  whoami() {
    const name = this.constructor.name;
    return `${name} #${counters[name]}`;
  }
  constructor() {
    counters[this.constructor.name] += 1;
  }
}

class B extends A {
  static getInstance() {
    if (instanceB === null) {
      instanceB = new B();
    }
    return instanceB;
  }
  constructor() {
    super();
  }
}

const a1 = A.getInstance();
const a2 = A.getInstance();
const a3 = A.getInstance();
const b1 = B.getInstance();
const b2 = B.getInstance();
const b3 = B.getInstance();
console.log(a1.whoami());
console.log(a2.whoami());
console.log(a3.whoami());
console.log(b1.whoami());
console.log(b2.whoami());
console.log(b3.whoami());

请注意，B从whoami继承了A，构造函数调用计数器从不超过1。

显然，使用这种方法不能保证每个类的单例属性都适用，除非仅使用静态构造函数生成实例（因为仍然可以访问构造函数）。我认为这是一个很好的妥协。

Answer 2

在JavaScript中，单例只是对象文字。

const a = {
    options: {
        i_am_a: "aaaaaa"
    }
};
const b = {
    options: {
        i_am_b: "bbbbbb"
    }
};

如果确实需要构造函数，则可以编写一个返回对象的函数。

function makeSingleton(options) {

    return {
        options
    }

}

const a = makeSingleton({i_am_a: "aaaaaa"});
const b = makeSingleton({i_am_b: "bbbbbb"});

这里没有继承链，只有两个对象文字。如果您绝对需要一个类，则可以只创建一个类，但这是不必要的资源和打字浪费。

class Singleton {

    constructor(options) {
        this.options = options;
    }

}

const a = new Singleton({i_am_a: "aaaaaa"});
const b = new Singleton({i_am_b: "bbbbbb"});

在继承方面，如果确实需要继承，则可以根据需要使用Object.create()或Object.assign()。请注意，两者都是浅层的-它们仅在单层深处工作，因此修改子级的options属性也会修改父级的options属性。

const a = {
    options: {
        i_am_a: "aaaaaa"
    },
    getOptions() {
        return this.options;
    }
};
const b = Object.create(a);
b.options.i_am_b: "bbbbbb";
a.options.i_am_b; // -> "bbbbbb"
b.getOptions(); // -> { i_am_a: "aaaaaa", i_am_b: "bbbbbb" }

当然，您也可以在Object.create()上使用Object.assign()或options。

说实话，我认为您要么需要几个相同类的实例，要么需要一个没有任何继承的简单对象文字。

Answer 3

好吧，我不知道这是否是最好的解决方案，但是我所做的是检查构造函数名称是否与类名称不同。如果是这样，那么我让它创建一个新实例，因为那意味着我尝试扩展该类

这是我测试的一个有效示例

Valid.framework

Answer 4

const instances = {}

class Singleton {
    constructor() {
        const instance = instances[this.constructor];

        if (instance == null) {
            return instances[this.constructor] = this;
        }

        return instance;
    }
}

class Foo extends Singleton {
    constructor() {
        super();

        this.foo = "foo";
    }
}

class Bar extends Singleton {
    constructor() {
        super();

        this.foo = "bar";
    }
}

const foo1 = new Foo();
const foo2 = new Foo();
const bar1 = new Bar();
const bar2 = new Bar();

console.log(foo1 === foo2, bar1 === bar2, foo1 === bar1, foo1.foo = 123, foo2, bar1);

在es6中扩展单例类

4 个答案: