具有require的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类名一样，只需对待ES6类名即可。他们是一样的。

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来访问实际的类变量