Node.js ES6 classes com requer

Então, até agora, criei classes e módulos node.jsda seguinte maneira:

    var fs = require('fs');

var animalModule = (function () {
    /**
     * Constructor initialize object
     * @constructor
     */
    var Animal = function (name) {
        this.name = name;
    };

    Animal.prototype.print = function () {
        console.log('Name is :'+ this.name);
    };

    return {
        Animal: Animal
    }
}());

module.exports = animalModule;

Agora, com o ES6, você é capaz de criar classes "reais" assim:

class Animal{

 constructor(name){
    this.name = name ;
 }

 print(){
    console.log('Name is :'+ this.name);
 }
}

Agora, em primeiro lugar, adoro isto :) mas levanta uma questão. Como você usa isso combinado com node.jsa estrutura do módulo de?

Digamos que você tenha uma classe na qual deseja usar um módulo para fins de demonstração, digamos que deseja usar fs

então você cria seu arquivo:

Animal.js

var fs = require('fs');
class Animal{

 constructor(name){
    this.name = name ;
 }

 print(){
    console.log('Name is :'+ this.name);
 }
}

Esse seria o caminho certo?

Além disso, como você expõe essa classe a outros arquivos dentro do meu projeto de nó? E você ainda seria capaz de estender esta classe se estiver usando em um arquivo separado?

Espero que alguns de vocês sejam capazes de responder a essas perguntas :)

Sim, seu exemplo funcionaria bem.

Quanto a expor suas aulas, você pode fazer exportuma aula como qualquer outra coisa:

class Animal {...}
module.exports = Animal;

Ou o mais curto:

module.exports = class Animal {

};

Depois de importado para outro módulo, você pode tratá-lo como se estivesse definido naquele arquivo:

var Animal = require('./Animal');

class Cat extends Animal {
    ...
}

Apenas trate o nome da classe ES6 da mesma forma que trataria o nome do construtor da maneira ES5. Eles são um e o mesmo.

A sintaxe ES6 é apenas um açúcar sintático e cria exatamente o mesmo protótipo subjacente, função de construtor e objetos.

Então, em seu exemplo ES6 com:

// animal.js
class Animal {
    ...
}

var a = new Animal();

module.exports = {Animal: Animal};

Você pode apenas tratar Animalcomo o construtor do seu objeto (o mesmo que faria no ES5). Você pode exportar o construtor. Você pode chamar o construtor com new Animal(). Tudo é igual para usá-lo. Apenas a sintaxe da declaração é diferente. Ainda existe um Animal.prototypeque contém todos os seus métodos. A maneira ES6 realmente cria o mesmo resultado de codificação, apenas com uma sintaxe mais sofisticada / agradável.

No lado da importação, isso seria usado assim:

const Animal = require('./animal.js').Animal;

let a = new Animal();

Este esquema exporta o construtor Animal como a .Animalpropriedade que permite exportar mais de uma coisa desse módulo.

Se você não precisa exportar mais de uma coisa, pode fazer o seguinte:

// animal.js
class Animal {
    ...
}

module.exports = Animal;

E, em seguida, importe-o com:

const Animal = require('./animal.js');

let a = new Animal();

A maneira ES6 de exigir é import. Você pode exportsua classe e importá-la para outro lugar usando a import { ClassName } from 'path/to/ClassName'sintaxe.

import fs from 'fs';
export default class Animal {

  constructor(name){
    this.name = name ;
  }

  print(){
    console.log('Name is :'+ this.name);
  }
}

import Animal from 'path/to/Animal.js';

Usando classes no nó -

Aqui, estamos exigindo o módulo ReadWrite e chamando makeObject (), que retorna o objeto da classe ReadWrite. Que estamos usando para chamar os métodos. index.js

const ReadWrite = require('./ReadWrite').makeObject();
const express = require('express');
const app = express();

class Start {
  constructor() {
    const server = app.listen(8081),
     host = server.address().address,
     port = server.address().port
    console.log("Example app listening at http://%s:%s", host, port);
    console.log('Running');

  }

  async route(req, res, next) {
    const result = await ReadWrite.readWrite();
    res.send(result);
  }
}

const obj1 = new Start();
app.get('/', obj1.route);
module.exports = Start;

ReadWrite.js

Aqui estamos fazendo um método makeObject, que garante que um objeto seja retornado, apenas se um objeto não estiver disponível.

class ReadWrite {
    constructor() {
        console.log('Read Write'); 
        this.x;   
    }
    static makeObject() {        
        if (!this.x) {
            this.x = new ReadWrite();
        }
        return this.x;
    }
    read(){
    return "read"
    }

    write(){
        return "write"
    }


    async readWrite() {
        try {
            const obj = ReadWrite.makeObject();
            const result = await Promise.all([ obj.read(), obj.write()])
            console.log(result);
            check();
            return result
        }
        catch(err) {
            console.log(err);

        }
    }
}
module.exports = ReadWrite;

Para obter mais explicações, acesse https://medium.com/@nynptel/node-js-boiler-plate-code-using-singleton-classes-5b479e513f74

No arquivo de classe, você pode usar:

module.exports = class ClassNameHere {
 print() {
  console.log('In print function');
 }
}

ou você pode usar esta sintaxe

class ClassNameHere{
 print(){
  console.log('In print function');
 }
}

module.exports = ClassNameHere;

Por outro lado, para usar esta classe em qualquer outro arquivo, você precisa seguir estas etapas. Primeiro, exija esse arquivo usando esta sintaxe: const anyVariableNameHere = require('filePathHere');

Em seguida, crie um objeto const classObject = new anyVariableNameHere();

Depois disso, você pode usar classObjectpara acessar as variáveis ​​de classe reais