Kelas Node.js ES6 dengan membutuhkan

Jadi sampai saat ini, saya telah membuat kelas dan modul node.jsdengan cara sebagai berikut:

    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;

Sekarang dengan ES6, Anda dapat membuat kelas "sebenarnya" seperti ini:

class Animal{

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

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

Sekarang, pertama-tama, saya suka ini :) tetapi ini menimbulkan pertanyaan. Bagaimana Anda menggunakan ini yang dikombinasikan dengan node.jsstruktur modul?

Katakanlah Anda memiliki kelas di mana Anda ingin menggunakan modul untuk kepentingan demonstrasi, katakanlah Anda ingin menggunakannya fs

jadi Anda membuat file Anda:

Animal.js

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

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

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

Apakah ini cara yang benar?

Juga, bagaimana Anda mengekspos kelas ini ke file lain dalam proyek node saya? Dan apakah Anda masih dapat memperluas kelas ini jika Anda menggunakannya dalam file terpisah?

Saya harap beberapa dari Anda dapat menjawab pertanyaan-pertanyaan ini :)

Ya, teladan Anda akan bekerja dengan baik.

Adapun untuk mengekspos kelas Anda, Anda dapat exportmembuat kelas seperti yang lainnya:

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

Atau lebih pendek:

module.exports = class Animal {

};

Setelah diimpor ke modul lain, Anda dapat memperlakukannya seolah-olah itu didefinisikan dalam file itu:

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

class Cat extends Animal {
    ...
}

Perlakukan saja nama kelas ES6 sama seperti Anda akan memperlakukan nama konstruktor dengan cara ES5. Mereka satu dan sama.

Sintaks ES6 hanyalah gula sintaksis dan membuat prototipe dasar, fungsi dan objek konstruktor yang sama persis.

Jadi, dalam contoh ES6 Anda dengan:

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

var a = new Animal();

module.exports = {Animal: Animal};

Anda bisa memperlakukan Animalseperti konstruktor objek Anda (sama seperti yang Anda lakukan di ES5). Anda dapat mengekspor konstruktor. Anda dapat memanggil konstruktor dengan new Animal(). Semuanya sama untuk menggunakannya. Hanya sintaks deklarasi yang berbeda. Bahkan masih ada Animal.prototypeyang memiliki semua metode Anda di atasnya. Cara ES6 benar-benar membuat hasil pengkodean yang sama, hanya dengan sintaks yang lebih bagus / lebih bagus.

Di sisi impor, ini kemudian akan digunakan seperti ini:

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

let a = new Animal();

Skema ini mengekspor konstruktor Animal sebagai .Animalproperti yang memungkinkan Anda mengekspor lebih dari satu hal dari modul itu.

Jika Anda tidak perlu mengekspor lebih dari satu hal, Anda dapat melakukan ini:

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

module.exports = Animal;

Dan, kemudian impor dengan:

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

let a = new Animal();

Cara kebutuhan ES6 adalah import. Anda dapat exportkelas Anda dan mengimpornya di tempat lain menggunakan import { ClassName } from 'path/to/ClassName'sintaks.

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

Menggunakan Kelas di Node -

Di sini kita membutuhkan modul ReadWrite dan memanggil makeObject (), yang mengembalikan objek kelas ReadWrite. Yang kami gunakan untuk memanggil metode. 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

Di sini kami membuat metode makeObject, yang memastikan bahwa suatu objek dikembalikan, hanya jika objek tidak tersedia.

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;

Untuk penjelasan lebih lanjut, buka https://medium.com/@nynptel/node-js-boiler-plate-code-using-singleton-classes-5b479e513f74

Dalam file kelas, Anda dapat menggunakan:

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

atau Anda dapat menggunakan sintaks ini

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

module.exports = ClassNameHere;

Di sisi lain untuk menggunakan kelas ini di file lain, Anda perlu melakukan langkah-langkah ini. Pertama, minta file itu menggunakan sintaks ini: const anyVariableNameHere = require('filePathHere');

Kemudian buatlah sebuah objek const classObject = new anyVariableNameHere();

Setelah ini, Anda dapat menggunakan classObjectuntuk mengakses variabel kelas yang sebenarnya