Clases de Node.js ES6 con require

Entonces, hasta ahora, he creado clases y módulos de node.jsla siguiente manera:

    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;

Ahora, con ES6, puede crear clases "reales" como esta:

class Animal{

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

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

Ahora, en primer lugar, me encanta esto :) pero plantea una pregunta. ¿Cómo se usa esto combinado con node.jsla estructura del módulo de '?

Supongamos que tiene una clase en la que desea utilizar un módulo por motivos de demostración, digamos que desea utilizar fs

para que crees tu archivo:

Animal.js

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

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

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

¿Sería esta la forma correcta?

Además, ¿cómo expones esta clase a otros archivos dentro de mi proyecto de nodo? ¿Y aún podría extender esta clase si la usa en un archivo separado?

Espero que algunos de ustedes puedan responder estas preguntas :)

Sí, tu ejemplo funcionaría bien.

En cuanto a exponer sus clases, puede exportuna clase como cualquier otra cosa:

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

O el más corto:

module.exports = class Animal {

};

Una vez importado a otro módulo, puede tratarlo como si estuviera definido en ese archivo:

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

class Cat extends Animal {
    ...
}

Simplemente trate el nombre de la clase ES6 de la misma manera que hubiera tratado el nombre del constructor en la forma ES5. Son uno y lo mismo.

La sintaxis de ES6 es simplemente azúcar sintáctica y crea exactamente el mismo prototipo subyacente, función de constructor y objetos.

Entonces, en su ejemplo de ES6 con:

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

var a = new Animal();

module.exports = {Animal: Animal};

Puede tratarlo Animalcomo el constructor de su objeto (lo mismo que lo hubiera hecho en ES5). Puede exportar el constructor. Puede llamar al constructor con new Animal(). Todo es igual para usarlo. Solo la sintaxis de la declaración es diferente. Incluso todavía hay un Animal.prototypeque tiene todos tus métodos. La forma ES6 realmente crea el mismo resultado de codificación, solo que con una sintaxis más elegante / agradable.

En el lado de la importación, esto se usaría así:

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

let a = new Animal();

Este esquema exporta el constructor Animal como la .Animalpropiedad que le permite exportar más de una cosa de ese módulo.

Si no necesita exportar más de una cosa, puede hacer esto:

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

module.exports = Animal;

Y luego importarlo con:

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

let a = new Animal();

La forma de ES6 de require es import. Puede exportsu clase e importarla en otro lugar usando la import { ClassName } from 'path/to/ClassName'sintaxis.

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 clases en el nodo -

Aquí estamos solicitando el módulo ReadWrite y llamando a makeObject (), que devuelve el objeto de la clase ReadWrite. Que estamos usando para llamar a los 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

Aquí hacemos un método makeObject, que asegura que se devuelva un objeto, solo si un objeto no está disponible.

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 obtener más explicaciones, vaya a https://medium.com/@nynptel/node-js-boiler-plate-code-using-singleton-classes-5b479e513f74

En el archivo de clase, puede usar:

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

o puedes usar esta sintaxis

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

module.exports = ClassNameHere;

Por otro lado, para usar esta clase en cualquier otro archivo, debe seguir estos pasos. Primero requiere ese archivo usando esta sintaxis: const anyVariableNameHere = require('filePathHere');

Luego crea un objeto const classObject = new anyVariableNameHere();

Después de esto, puede usar classObjectpara acceder a las variables de clase reales