Các lớp ES6 của Node.js với yêu cầu

Vì vậy, cho đến nay, tôi đã tạo các lớp và mô-đun node.jstheo cách sau:

    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;

Bây giờ với ES6, bạn có thể tạo các lớp "thực tế" giống như sau:

class Animal{

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

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

Bây giờ, trước hết, tôi thích điều này :) nhưng nó đặt ra một câu hỏi. Làm thế nào để bạn sử dụng điều này kết hợp với node.jscấu trúc mô-đun của?

Giả sử bạn có một lớp học mà bạn muốn sử dụng một mô-đun để trình diễn, hãy nói rằng bạn muốn sử dụng fs

vì vậy bạn tạo tệp của mình:

Animal.js

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

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

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

Đây có phải là cách đúng đắn?

Ngoài ra, làm cách nào để bạn hiển thị lớp này với các tệp khác trong dự án nút của tôi? Và bạn vẫn có thể mở rộng lớp này nếu bạn đang sử dụng nó trong một tệp riêng?

Tôi hy vọng một số bạn sẽ có thể trả lời những câu hỏi này :)

Có, ví dụ của bạn sẽ hoạt động tốt.

Đối với việc hiển thị các lớp học của bạn, bạn có thể exportmột lớp học giống như bất kỳ thứ gì khác:

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

Hoặc ngắn hơn:

module.exports = class Animal {

};

Sau khi được nhập vào một mô-đun khác, bạn có thể coi nó như thể nó đã được xác định trong tệp đó:

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

class Cat extends Animal {
    ...
}

Chỉ cần xử lý tên lớp ES6 giống như bạn đã xử lý tên phương thức khởi tạo theo cách ES5. Họ là một và giống nhau.

Cú pháp ES6 chỉ là cú pháp và tạo chính xác nguyên mẫu, hàm tạo và các đối tượng cơ bản.

Vì vậy, trong ví dụ ES6 của bạn với:

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

var a = new Animal();

module.exports = {Animal: Animal};

Bạn chỉ có thể coi Animalnhư hàm tạo của đối tượng của mình (giống như cách bạn đã làm trong ES5). Bạn có thể xuất hàm tạo. Bạn có thể gọi hàm tạo với new Animal(). Mọi thứ đều giống nhau để sử dụng nó. Chỉ khác nhau về cú pháp khai báo. Thậm chí vẫn có một Animal.prototypecó tất cả các phương pháp của bạn trên đó. Cách ES6 thực sự tạo ra cùng một kết quả mã hóa, chỉ với cú pháp đẹp hơn / đẹp hơn.

Về phía nhập khẩu, điều này sau đó sẽ được sử dụng như thế này:

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

let a = new Animal();

Lược đồ này xuất hàm tạo Animal dưới dạng thuộc .Animaltính cho phép bạn xuất nhiều thứ từ mô-đun đó.

Nếu bạn không cần xuất nhiều thứ, bạn có thể làm như sau:

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

module.exports = Animal;

Và sau đó nhập nó với:

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

let a = new Animal();

Cách yêu cầu của ES6 là import. Bạn có thể exportnhập lớp của mình và nhập vào một nơi khác bằng import { ClassName } from 'path/to/ClassName'cú pháp.

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

Sử dụng các lớp trong nút -

Ở đây chúng ta đang yêu cầu mô-đun ReadWrite và gọi một makeObject (), trả về đối tượng của lớp ReadWrite. Mà chúng tôi đang sử dụng để gọi các phương thức. 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

Ở đây chúng ta tạo một phương thức makeObject, phương thức này đảm bảo rằng một đối tượng được trả về, chỉ khi một đối tượng không có sẵn.

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;

Để biết thêm giải thích, hãy truy cập https://medium.com/@nynptel/node-js-boiler-plate-code-using-singleton-classes-5b479e513f74

Trong tệp lớp, bạn có thể sử dụng:

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

hoặc bạn có thể sử dụng cú pháp này

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

module.exports = ClassNameHere;

Mặt khác, để sử dụng lớp này trong bất kỳ tệp nào khác, bạn cần thực hiện các bước sau. Trước tiên, yêu cầu tệp đó bằng cú pháp sau: const anyVariableNameHere = require('filePathHere');

Sau đó, tạo một đối tượng const classObject = new anyVariableNameHere();

Sau đó, bạn có thể sử dụng classObjectđể truy cập các biến lớp thực tế