0

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

编码这样的事情让我很困扰：

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是如何工作的，所以我想知道是否有任何方法可以获得想要的行为而不必每次都复制代码。

4

2 回答 2

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
于 2013-04-17T20:12:34.370 回答
0

有多种方法可以在 javascript 中实现类行为。值得一提的框架是 ExtJs（也是原型），它具有清晰简单的语法并支持静态方法。巨大的代码库和许可证（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());

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

于 2013-04-17T19:18:31.623 回答