Klasy Node.js ES6 z require

Do tej pory tworzyłem klasy i moduły w node.jsnastępujący sposób:

    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;

Teraz z ES6 możesz tworzyć „rzeczywiste” klasy, takie jak to:

class Animal{

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

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

Przede wszystkim uwielbiam to :), ale rodzi pytanie. Jak to wykorzystać w połączeniu ze node.jsstrukturą modułu?

Powiedzmy, że masz klasę, w której chcesz użyć modułu do celów demonstracyjnych, powiedz, że chcesz użyć fs

więc tworzysz swój plik:

Animal.js

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

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

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

Czy to byłby właściwy sposób?

Ponadto, jak udostępnić tę klasę innym plikom w moim projekcie węzła? Czy nadal byłbyś w stanie rozszerzyć tę klasę, jeśli używasz jej w osobnym pliku?

Mam nadzieję, że część z Was będzie w stanie odpowiedzieć na te pytania :)

Tak, twój przykład zadziała dobrze.

Jeśli chodzi o eksponowanie swoich zajęć, możesz je exporttraktować jak wszystko inne:

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

Lub krócej:

module.exports = class Animal {

};

Po zaimportowaniu do innego modułu możesz traktować go tak, jakby był zdefiniowany w tym pliku:

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

class Cat extends Animal {
    ...
}

Po prostu potraktuj nazwę klasy ES6 tak samo, jakbyś traktował nazwę konstruktora w sposób ES5. Są jednym i tym samym.

Składnia ES6 jest po prostu cukrem składniowym i tworzy dokładnie ten sam podstawowy prototyp, funkcję konstruktora i obiekty.

A więc w przykładzie z ES6 z:

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

var a = new Animal();

module.exports = {Animal: Animal};

Możesz po prostu traktować Animaljak konstruktor swojego obiektu (tak samo, jak zrobiłbyś to w ES5). Możesz wyeksportować konstruktora. Możesz wywołać konstruktora za pomocą new Animal(). Korzystanie z niego jest takie samo. Jedynie składnia deklaracji jest inna. Nadal istnieje taki, Animal.prototypektóry zawiera wszystkie twoje metody. Sposób ES6 naprawdę tworzy ten sam wynik kodowania, tylko z bardziej wyszukaną / ładniejszą składnią.

Po stronie importu byłoby to używane w następujący sposób:

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

let a = new Animal();

Ten schemat eksportuje konstruktora Animal jako .Animalwłaściwość, która pozwala wyeksportować więcej niż jedną rzecz z tego modułu.

Jeśli nie musisz eksportować więcej niż jednej rzeczy, możesz to zrobić:

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

module.exports = Animal;

A następnie zaimportuj go za pomocą:

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

let a = new Animal();

Sposób wymagania ES6 to import. Możesz exportswoją klasę i zaimportować ją gdzie indziej, używając import { ClassName } from 'path/to/ClassName'składni.

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

Używanie klas w węźle -

Tutaj wymagamy modułu ReadWrite i wywołujemy metodę makeObject (), która zwraca obiekt klasy ReadWrite. Które używamy do wywoływania metod. 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

Tutaj tworzymy metodę makeObject, która zapewnia, że ​​obiekt zostanie zwrócony, tylko jeśli obiekt nie jest dostępny.

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;

Więcej wyjaśnień można znaleźć pod adresem https://medium.com/@nynptel/node-js-boiler-plate-code-using-singleton-classes-5b479e513f74

W pliku klasy możesz użyć:

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

lub możesz użyć tej składni

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

module.exports = ClassNameHere;

Z drugiej strony, aby użyć tej klasy w jakimkolwiek innym pliku, musisz wykonać następujące kroki. Najpierw wymagaj tego pliku przy użyciu następującej składni: const anyVariableNameHere = require('filePathHere');

Następnie utwórz obiekt const classObject = new anyVariableNameHere();

Następnie możesz użyć, classObjectaby uzyskać dostęp do rzeczywistych zmiennych klas