Классы Node.js ES6 с требованием

Итак, до сих пор я создавал классы и модули node.jsследующим образом:

    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;

Теперь с ES6 вы можете создавать «настоящие» классы следующим образом:

class Animal{

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

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

Сейчас, во-первых, мне это нравится :) но возникает вопрос. Как вы используете это в сочетании со node.jsструктурой модулей?

Скажем, у вас есть класс, в котором вы хотите использовать модуль для демонстрации, скажем, вы хотите использовать fs

поэтому вы создаете свой файл:

Animal.js

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

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

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

Будет ли это правильный путь?

Кроме того, как предоставить этот класс другим файлам в моем проекте узла? И сможете ли вы расширить этот класс, если будете использовать его в отдельном файле?

Надеюсь, некоторые из вас ответят на эти вопросы :)

Да, ваш пример подойдет.

Что касается раскрытия ваших классов, вы можете exportиспользовать класс, как и все остальное:

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

Или короче:

module.exports = class Animal {

};

После импорта в другой модуль вы можете рассматривать его так, как если бы он был определен в этом файле:

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

class Cat extends Animal {
    ...
}

Просто обращайтесь с именем класса ES6 так же, как с именем конструктора в ES5. Они одно и то же.

Синтаксис ES6 - это просто синтаксический сахар и создает точно такой же базовый прототип, функцию конструктора и объекты.

Итак, в вашем примере ES6 с:

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

var a = new Animal();

module.exports = {Animal: Animal};

Вы можете рассматривать его Animalкак конструктор вашего объекта (так же, как вы поступили бы в ES5). Вы можете экспортировать конструктор. Вы можете вызвать конструктор с помощью new Animal(). Все то же самое и с его использованием. Отличается только синтаксис объявления. Даже Animal.prototypeесть все ваши методы. Способ ES6 действительно дает тот же результат кодирования, только с более красивым / красивым синтаксисом.

На стороне импорта это будет использоваться следующим образом:

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

let a = new Animal();

Эта схема экспортирует конструктор Animal как .Animalсвойство, которое позволяет вам экспортировать более одного объекта из этого модуля.

Если вам не нужно экспортировать более одного объекта, вы можете сделать это:

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

module.exports = Animal;

А затем импортируйте его с помощью:

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

let a = new Animal();

Способ запроса ES6 - import. Вы можете exportимпортировать свой класс в другое место, используя import { ClassName } from 'path/to/ClassName'синтаксис.

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

Использование классов в узле -

Здесь нам нужен модуль ReadWrite и вызывается makeObject (), который возвращает объект класса ReadWrite. Которые мы используем для вызова методов. 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

Здесь мы создаем метод makeObject, который гарантирует, что объект будет возвращен, только если объект недоступен.

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;

Для получения дополнительных объяснений перейдите на https://medium.com/@nynptel/node-js-boiler-plate-code-using-singleton-classes-5b479e513f74.

В файле класса вы можете использовать:

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

или вы можете использовать этот синтаксис

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

module.exports = ClassNameHere;

С другой стороны, чтобы использовать этот класс в любом другом файле, вам необходимо выполнить следующие действия. Сначала потребуйте этот файл, используя этот синтаксис: const anyVariableNameHere = require('filePathHere');

Затем создайте объект const classObject = new anyVariableNameHere();

После этого вы можете использовать classObjectдля доступа к фактическим переменным класса