web-dev-qa-db-fra.com

Comment créer des fonctions / objets statiques en javascript / nodejs (ES6)

Je veux créer une classe statique en utilisant Javascript/Node JS. J'ai utilisé Google, mais je ne trouve aucun exemple utile.

Je veux créer en Javascript ES6 quelque chose comme ça (C #):

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

Pour l'instant, j'ai cette classe, mais je pense que ce code créera une nouvelle instance à chaque fois qu'il sera appelé depuis "require".

function MyStaticClass() {
   let someMethod = () => {
      //do some stuff
   }
}
var myInstance = new MyStaticClass();
module.exports = factory;
javascriptnode.jsecmascript-6javascript-objects
20
Vladimir Venegas

Notez que JS est programmation basée sur un prototype , au lieu de basé sur une classe .

Au lieu de créer la classe plusieurs fois pour accéder à sa méthode, vous pouvez simplement créer une méthode dans un objet, comme

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

MyStaticClass.someMethod(); // Doing someMethod

Depuis JS, tout est un objet (sauf types primitifs + undefined + null). Comme lorsque vous créez la fonction someMethod ci-dessus, vous avez en fait créé un nouvel objet fonction accessible avec someMethod dans l'objet MyStaticClass. (C'est pourquoi vous pouvez accéder aux propriétés de l'objet someMethod comme MyStaticClass.someMethod.prototype ou MyStaticClass.someMethod.name)

Cependant, si vous trouvez plus pratique d'utiliser la classe. ES6 fonctionne désormais avec méthodes statiques .

Par exemple

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
39
vadi taslim

J'utiliserais un objet littéral:

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

module.exports = myObject;
4
mattias

Vous pouvez utiliser le mot clé static pour définir une méthode pour une classe

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

console.log(MyStatisticsClass.someMethod());
3
guest271314

Je suis en retard à la fête, mais il semble qu'un aspect manque.

NodeJs n'exécute pas le code de votre module chaque fois que vous l'utilisez. Cela ressemble plus à une sorte de conteneur avec état, qui initialise votre module une fois et transmet cette instance chaque fois que vous l'utilisez.

Je suis nodejs noobie, alors n'utilisez pas le suivi sans discussion avec quelqu'un de plus mature, mais j'adhère aux principes logiciels, qui envisagent d'utiliser des méthodes statiques maléfiques (par exemple, il est préférable de construire des contrats d'interface contre des interfaces, pas contre une implémentation d'interface concrète; vous ne le faites pas simplement avec des méthodes statiques).

Dans d'autres langues, c'est la pierre angulaire habituelle d'avoir un conteneur IoC, qui a tous vos modules enregistrés et résout le passage des dépendances pour vous. Ensuite, vous écrivez tout en tant que classes "Service". La classe de service n'est instanciée le plus souvent qu'une seule fois par durée de vie de l'application et tous les autres morceaux de code qui nécessitent qu'elle obtienne la même instance du conteneur IoC.

J'utilise donc quelque chose de similaire, sans le confort de l'IoC :(: Remarque dans cet exemple - le constructeur de A n'est appelé qu'une seule fois, bien que requis 3 fois.

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

Résultat:

node test.js

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

Donc, comme vous pouvez le voir - pas de méthodes statiques. Fonctionne avec les instances (mais pas avec les interfaces dans cet exemple simplifié). Le constructeur de A n'a appelé qu'une seule fois.

0
ooouuiii