CODEWITHSUNDEEP
javascriptnode.jsecmascript-6javascript-objects
Vladimir Venegas
Vladimir Venegas

Reputation: 4183

How create static functions/objects in javascript/nodejs (ES6)

I want to create a static class using Javascript/Node JS. I used google but i can't find any usefull example.

I want to create in Javascript ES6 something like this (C#):

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

For now, I have this class, but I think that this code will creates a new instance every time that it be called from "require".

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

Upvotes: 26

Views: 48035

Answers (5)

John Libes
John Libes

Reputation: 383

An IICE (Immediately Invoked Class Expression) :

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.

Or even better, a nameless class:

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

Upvotes: 0

ooouuiii
ooouuiii

Reputation: 319

I am late to the party, but it seems one aspect is missing.

NodeJs doesn't execute your module code every time you use require. It is more like a kind of stateful container, that initializes your module once and passes this instance each time you use require.

I am nodejs noobie, so don't use following without discussion with someone more mature, but I adhere for software principles, that considers using static methods evil (e.g. it is better to construct interface contracts against interfaces, not against concrete interface implementation; you just don't simply make it with static methods).

In other languages, it is usual corner stone to have some IoC container, that has all of your modules registered and solves passing of dependencies for you. Then you write everything as "Service" classes. Service class is instantiated most often only once per application life-time and every another piece of code, that requires it gets the same instance from the IoC container.

So I use something similar, without the comfort of IoC :( : Note in this example - A's constructor is called only once, althought required 3 times.

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

Result:

node test.js

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

So as You can see - no static methods. Works with instances (althought not with interfaces in this simplified example). A's constructor called only once.

Upvotes: 0

choz
choz

Reputation: 17858

Note that JS is prototype-based programming, instead of class-based.

Instead of creating the class multiple times to access its method, you can just create a method in an object, like

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

MyStaticClass.someMethod(); // Doing someMethod

Since in JS, everything is an object (except primitive types + undefined + null). Like when you create someMethod function above, you actually created a new function object that can be accessed with someMethod inside MyStaticClass object. (That's why you can access the properties of someMethod object like MyStaticClass.someMethod.prototype or MyStaticClass.someMethod.name)

However, if you find it more convenient to use class. ES6 now works with static methods.

E.g.

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

Upvotes: 54

guest271314
guest271314

Reputation: 1

You can use the static keyword to define a method for a class

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

console.log(MyStatisticsClass.someMethod());

Upvotes: 4

Mati
Mati

Reputation: 1148

I would use an object literal:

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

module.exports = myObject;

Upvotes: 4

Related Questions