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);
 }
}

Правильно ли это будет?

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

Я надеюсь, что некоторые из вас смогут ответить на эти вопросы:)

Ответы

Ответ 1

Да, ваш пример будет работать нормально.

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

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

Или короче

module.exports = class Animal {

};

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

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

class Cat extends Animal {
    ...
}

Ответ 2

Просто обработайте имя класса 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 которое позволяет экспортировать более одного объекта из этого модуля.

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

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

module.exports = Animal;

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

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

let a = new Animal();

Ответ 3

Необходимый для 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';

Ответ 4

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

Здесь нам требуется модуль 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