Question

我实际上正在开发一个项目，在这个项目中，我需要一堆对象（如果您愿意，可以使用类，而不是实例）来实现相同的行为。基本上，每个“类”都需要提供一种操作包含每个实例的数组的方法。

编码这样的事情困扰着我：

function A() { ... }
A.instances = [];
A.someStaticMethod = function () {
    for (var i = 0 ; i < A.instances ; i++) {
        A.instances[i].doSomething();
    }
}
A.prototype.doSomething = function () { ... }

function B() { ... }
B.instances = [];
B.someStaticMethod = function () {
    for (var i = 0 ; i < B.instances ; i++) {
        B.instances[i].doSomething();
    }
}
B.prototype.doSomething = function () { ... }

我只是不喜欢某种复制/粘贴式代码。来自类语言，我自然认为我所要做的就是创建一个实现这些静态成员/方法的第三个类，让我的其他类继承它。我不知道，你不能继承静态成员。

我愿意学习javascript是如何工作的，所以我想知道是否有任何方法可以获得想要的行为，而不必每次都重复代码。

Answer 1

您可以尝试使用一种函数来使用某种 mixin 函数来增强对象。

function enhanceStatic(type) {
    type.instances = [];
    type.someStaticMethod = function () {
        for (var i = 0; i < type.instances.length; i++) {
            type.instances[i].doSomething();
        }
    };
}

function A(msg) {
    this.msg = msg;
}
enhanceStatic(A);
A.prototype.doSomething = function () {
    console.log("A: " + +this.msg);
}

function B(msg) {
    this.msg = msg;
}
enhanceStatic(B);
B.prototype.doSomething = function () {
    console.log("B: " + +this.msg);
}

A.instances = [new A(1), new A(2)];
B.instances = [new B(1), new B(2), new B(3)];
A.someStaticMethod();
B.someStaticMethod();

输出：

A: 1
A: 2
B: 1
B: 2
B: 3

Answer 2

有多种方法可以在javascript中实现类行为。提到的框架是ExtJs（以及原型），它具有清晰简单的语法并支持静态方法。由于巨大的代码库和许可证（GPL，商业）使我无法使用相同的代码编写小型预算项目而烦恼，我编写了一个类管理器，它位于MIT许可证下，名为Esf-Core，用于核心类加载器功能（{{ 3}}）类似于ExtJS编码风格。以下是如何使用它的示例：

Esf.define('A', {
    a: null,

    constructor: function (a) {
        // Save var
        this.a = a;

        // Heyho
        console.log('A');
    },
    foo: function (b) {
        console.log('foo - ' + b);
    }
});

Esf.define('B', {
    b: null,

    constructor: function (a, b) {
        // Call super constructor
        this.callParent(a);

        // Save var
        this.b = b;

        // Heyho
        console.log('B');
    },
    foo: function () {
        this.callParent('bar');
    }
}, {
    extend: 'A'
});

// Use
var b = new B(1, 2);

// or
var b = Esf.create('B', 1, 2);

/*
 * Output:
 * A
 * B
 * foo - bar
 */
b.foo();

静态方法尚未实现，但在不久的将来（如果您愿意，您可以单独执行，它只能执行一段代码）以及用于动态加载依赖项的类加载器。仍在进行中的主要框架也将基于骨干网带来依赖注入和模型存储等。

如果您在此处看到，还有其他多种方法以更轻量级的方式执行此操作：https://npmjs.org/package/esf-core（线程结束）

以下是静态方法的ExtJS方法：

Ext.define('Computer', {
     statics: {
         factory: function() {
             // This refers to the class not the object in static context
             return this.factory;
         }
     },

     factory: 'Unknown',
});

Ext.define('PC', {
     extends: 'Computer',

     factory: 'Dell',
});

// Dell
console.log(PC.factory());

代码应该可以工作，但我没有尝试： - ）

静态成员继承的解决方法

2 个答案: