如何在 javascript/nodejs (ES6) 中创建静态函数/对象

Question

我想使用 Javascript/Node JS 创建一个静态类。我用谷歌，但我找不到任何有用的例子。

我想在 Javascript ES6 中创建类似这样的东西（C#）：

public static MyStaticClass {
   public static void someMethod() {
      //do stuff here
   }
}

目前，我有这个类，但我认为每次从“require”调用这段代码时，它都会创建一个新实例。

function MyStaticClass() {
   let someMethod = () => {
      //do some stuff
   }
}
var myInstance = new MyStaticClass();
module.exports = factory;

Answer 1

注意，JS 是prototype-based programming，而不是class-based。

您可以在对象中创建一个方法，而不是多次创建类来访问其方法，例如

var MyStaticClass = {
    someMethod: function () {
        console.log('Doing someMethod');
    }
}

MyStaticClass.someMethod(); // Doing someMethod

由于在 JS 中，一切都是对象（primitive types + undefined + null 除外）。就像你在上面创建someMethod 函数时一样，你实际上创建了一个新的函数对象，可以在MyStaticClass 对象中使用someMethod 访问它。 （这就是为什么您可以访问someMethod 对象的属性，例如MyStaticClass.someMethod.prototype 或MyStaticClass.someMethod.name）

但是，如果您发现使用 class. ES6 现在可以使用 static methods。

例如

MyStaticClass.js

class MyStaticClass {
    static someMethod () {
        console.log('Doing someMethod');
    }

    static anotherMethod () {
        console.log('Doing anotherMethod');
    }
}

module.exports = MyStaticClass;

Main.js

var MyStaticClass = require("./MyStaticClass");

MyStaticClass.someMethod(); // Doing someMethod
MyStaticClass.anotherMethod(); // Doing anotherMethod

Answer 2

我会使用对象字面量：

const myObject = {
  someMethod() {
    // do stuff here
  }
}

module.exports = myObject;

Answer 3

您可以使用static 关键字为类定义方法

class MyStatisticsClass {
  static someMethod() {
    return "MyStatisticsClass static method"
  }
}

console.log(MyStatisticsClass.someMethod());

Answer 4

我迟到了，但似乎缺少了一个方面。

NodeJs 不会在您每次使用 require 时执行您的模块代码。它更像是一种有状态的容器，初始化你的模块一次，每次使用 require 时都会传递这个实例。

我是nodejs noobie，所以不要在没有与更成熟的人讨论的情况下使用following，但我坚持软件原则，认为使用静态方法是邪恶的（例如，最好针对接口构造接口契约，而不是针对具体接口实现；您不能简单地使用静态方法来实现）。

在其他语言中，拥有一些 IoC 容器通常是基石，它会注册您的所有模块并为您解决依赖关系的传递。然后你把所有东西都写成“服务”类。服务类最常在每个应用程序生命周期和每隔一段代码实例化一次，这要求它从 IoC 容器中获取相同的实例。

所以我使用类似的东西，没有 IoC 的舒适性 :( : 注意在这个例子中 - A 的构造函数只被调用了一次，虽然需要 3 次。

Test.ts：

import {a} from './A';
import {b} from './B';
import {c} from './C';

console.log(c, b);

A.ts：

export class A
{
    constructor(){
        console.log('"A" constructor called');
    }

    foo() {
        console.log('foo');
    }
}

export const a = new A();

B.ts：

import {a, A} from './A';

export class B
{
    constructor(a: A)
    {
        console.log('"B" constructor called, got a:', a);
        a.foo();
    }
}

export const b = new B(a);

C.ts：

//The same as B.ts

结果：

node test.js

"A" constructor called
"B" constructor called, got a: A {}
foo
"C" constructor called, got a: A {}
foo
C {} B {}

如您所见 - 没有静态方法。适用于实例（尽管在此简化示例中不适用于接口）。 A 的构造函数只调用了一次。

Answer 5

IICE（立即调用的类表达式）：

const A = new (class a{Print(){console.log('I Am static function')}});();
A.Print();

// console.log(a);
// **Uncaught ReferenceError: a is not defined at <anonymous>:`enter code here`1:1**
// 'A' Variable is the only reference to the class a, and the only instance of it.

或者更好的是，一个无名的类：

const A = new class {Print(){console.log('I Am static function')}};