Classi ES6 Node.js con require

Quindi, fino ad ora, ho creato classi e moduli nel node.jsmodo seguente:

    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;

Ora con ES6, puoi creare classi "effettive" proprio come questa:

class Animal{

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

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

Ora, prima di tutto, mi piace questo :) ma solleva una domanda. Come lo usi combinato con node.jsla struttura del modulo di?

Supponiamo che tu abbia una classe in cui desideri utilizzare un modulo a scopo dimostrativo, diciamo che desideri utilizzare fs

quindi crei il tuo file:

Animal.js

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

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

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

Sarebbe questo il modo giusto?

Inoltre, come esponi questa classe ad altri file all'interno del mio progetto nodo? E saresti ancora in grado di estendere questa classe se la utilizzi in un file separato?

Spero che alcuni di voi sapranno rispondere a queste domande :)

Sì, il tuo esempio funzionerebbe bene.

Per quanto riguarda l'esposizione delle tue classi, puoi exportuna lezione come qualsiasi altra cosa:

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

O il più breve:

module.exports = class Animal {

};

Una volta importato in un altro modulo, puoi trattarlo come se fosse definito in quel file:

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

class Cat extends Animal {
    ...
}

Tratta semplicemente il nome della classe ES6 nello stesso modo in cui avresti trattato il nome del costruttore nel modo ES5. Sono la stessa cosa.

La sintassi ES6 è solo zucchero sintattico e crea esattamente lo stesso prototipo sottostante, la funzione di costruzione e gli oggetti.

Quindi, nel tuo esempio ES6 con:

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

var a = new Animal();

module.exports = {Animal: Animal};

Puoi semplicemente trattare Animalcome il costruttore del tuo oggetto (lo stesso che avresti fatto in ES5). Puoi esportare il costruttore. Puoi chiamare il costruttore con new Animal(). Tutto è uguale per usarlo. Solo la sintassi della dichiarazione è diversa. C'è anche ancora uno Animal.prototypeche ha tutti i tuoi metodi su di esso. Il modo ES6 crea davvero lo stesso risultato di codifica, solo con una sintassi più elaborata / piacevole.

Sul lato dell'importazione, questo verrebbe quindi utilizzato in questo modo:

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

let a = new Animal();

Questo schema esporta il costruttore Animal come .Animalproprietà che ti permette di esportare più di una cosa da quel modulo.

Se non hai bisogno di esportare più di una cosa, puoi farlo:

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

module.exports = Animal;

E poi importalo con:

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

let a = new Animal();

Il modo ES6 di richiedere è import. Puoi la exporttua classe e importarla da qualche altra parte usando la import { ClassName } from 'path/to/ClassName'sintassi.

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';

Utilizzo delle classi in Node -

Qui stiamo richiedendo il modulo ReadWrite e chiamando un makeObject (), che restituisce l'oggetto della classe ReadWrite. Che stiamo usando per chiamare i metodi. 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

Qui creiamo un metodo makeObject, che assicura che un oggetto venga restituito, solo se un oggetto non è disponibile.

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;

Per ulteriori spiegazioni vai a https://medium.com/@nynptel/node-js-boiler-plate-code-using-singleton-classes-5b479e513f74

Nel file di classe puoi utilizzare:

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

oppure puoi usare questa sintassi

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

module.exports = ClassNameHere;

D'altra parte per utilizzare questa classe in qualsiasi altro file è necessario eseguire questi passaggi. Per prima cosa richiedi quel file usando questa sintassi: const anyVariableNameHere = require('filePathHere');

Quindi crea un oggetto const classObject = new anyVariableNameHere();

Successivamente è possibile utilizzare classObjectper accedere alle variabili di classe effettive