静态成员继承的解决方法

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(也包括prototype)，它具有清晰简单的语法并支持静态方法。被庞大的代码库和许可证(GPL，商业)所困扰，这使得用相同的代码编写小预算项目变得不可能，我写了一个类管理器，它在MIT许可证下被称为Esf-Core，用于核心类加载器功能(https://npmjs.org/package/esf-core)，类似于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();

静态方法尚未实现，但将在不久的将来(你可以自己做，如果你喜欢，它只是一段代码)，也是一个类加载器动态加载依赖。仍在开发中的主框架还将带来依赖注入和基于主干的模型存储等。

还有很多其他的方法可以用更轻量级的方式做到这一点，如果你看到这里:javascript继承框架(线程结束)

以下是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());

代码应该工作，但我没有尝试:-)