Node.js ES6-Klassen mit require

Bisher habe ich also Klassen und Module in erstellt node.js folgender Weg:

    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;

Mit ES6 können Sie jetzt “tatsächliche” Klassen wie folgt erstellen:

class Animal{

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

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

Nun, zuallererst liebe ich das :), aber es wirft eine Frage auf. Wie verwenden Sie dies kombiniert mit node.js‘s Modulstruktur?

Angenommen, Sie haben eine Klasse, in der Sie ein Modul zu Demonstrationszwecken verwenden möchten. Sagen Sie, Sie möchten es verwenden fs

so erstellen Sie Ihre Datei:

Tier.js

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

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

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

Wäre das der richtige Weg?

Wie stellen Sie diese Klasse auch anderen Dateien in meinem Knotenprojekt zur Verfügung? Und könnten Sie diese Klasse immer noch erweitern, wenn Sie sie in einer separaten Datei verwenden?

Ich hoffe, einige von euch können diese Fragen beantworten 🙂

Ja, dein Beispiel würde gut funktionieren.

Was die Offenlegung Ihrer Klassen betrifft, können Sie export eine Klasse wie alles andere:

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

Oder kürzer:

module.exports = class Animal {

};

Einmal in ein anderes Modul importiert, können Sie es so behandeln, als wäre es in dieser Datei definiert:

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

class Cat extends Animal {
    ...
}

Behandeln Sie den ES6-Klassennamen einfach genauso, wie Sie den Konstruktornamen auf ES5-Weise behandelt hätten. Sie sind ein und dasselbe.

Die ES6-Syntax ist nur syntaktischer Zucker und erstellt genau den gleichen zugrunde liegenden Prototyp, die gleiche Konstruktorfunktion und die gleichen Objekte.

Also, in Ihrem ES6-Beispiel mit:

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

var a = new Animal();

module.exports = {Animal: Animal};

Du kannst einfach behandeln Animal wie der Konstruktor Ihres Objekts (dasselbe, wie Sie es in ES5 getan hätten). Sie können den Konstruktor exportieren. Sie können den Konstruktor mit aufrufen new Animal(). Für die Verwendung ist alles gleich. Nur die Deklarationssyntax ist anders. Es gibt sogar noch einen Animal.prototype das hat alle Ihre Methoden drauf. Der ES6-Weg erzeugt wirklich das gleiche Codierungsergebnis, nur mit schickerer/schönerer Syntax.

Auf der Importseite würde dies dann so verwendet werden:

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

let a = new Animal();

Dieses Schema exportiert den Animal-Konstruktor als die .Animal -Eigenschaft, mit der Sie mehr als eine Sache aus diesem Modul exportieren können.

Wenn Sie nicht mehr als eine Sache exportieren müssen, können Sie dies tun:

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

module.exports = Animal;

Und dann importieren Sie es mit:

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

let a = new Animal();

Die ES6-Methode ist erforderlich import. Du kannst export Ihre Klasse und importieren Sie sie woanders mit import { ClassName } from 'path/to/ClassName'Syntax.

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

Klassen im Knoten verwenden –

Hier benötigen wir das ReadWrite-Modul und rufen ein makeObject() auf, das das Objekt der ReadWrite-Klasse zurückgibt. Womit wir die Methoden aufrufen.
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("https://stackoverflow.com/", obj1.route);
module.exports = Start;

ReadWrite.js

Hier erstellen wir eine makeObject-Methode, die sicherstellt, dass ein Objekt zurückgegeben wird, nur wenn ein Objekt nicht verfügbar ist.

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;

Weitere Erklärungen finden Sie unter https://medium.com/@nynptel/node-js-boiler-plate-code-using-singleton-classes-5b479e513f74

In der Klassendatei können Sie entweder verwenden:

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

oder Sie können diese Syntax verwenden

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

module.exports = ClassNameHere;

Andererseits müssen Sie diese Schritte ausführen, um diese Klasse in einer anderen Datei zu verwenden. Fordern Sie zuerst diese Datei mit dieser Syntax an:
const anyVariableNameHere = require('filePathHere');

Erstellen Sie dann ein Objekt
const classObject = new anyVariableNameHere();

Danach können Sie verwenden classObject um auf die eigentlichen Klassenvariablen zuzugreifen