Node.js ES6 sınıfları gerektirir

Şimdiye kadar node.jsaşağıdaki şekilde sınıflar ve modüller oluşturdum :

    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;

Artık ES6 ile şu şekilde "gerçek" sınıflar oluşturabilirsiniz:

class Animal{

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

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

Şimdi, her şeyden önce, bunu seviyorum :) ama bir soruyu gündeme getiriyor. Bunu node.jsmodül yapısıyla birlikte nasıl kullanıyorsunuz ?

Gösteri amacıyla bir modülü kullanmak istediğiniz bir sınıfınız olduğunu varsayalım, kullanmak istediğinizi söyleyin. fs

böylece dosyanızı yaratırsınız:

Animal.js

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

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

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

Bu doğru yol olur mu?

Ayrıca, bu sınıfı düğüm projemdeki diğer dosyalara nasıl açıklarsınız? Ayrı bir dosyada kullanıyorsanız, bu sınıfı yine de genişletebilir misiniz?

Umarım bazılarınız bu soruları cevaplayabilir :)

Evet, örneğiniz iyi sonuç verir.

Derslerinizi ifşa etmeye gelince, exporther şey gibi bir sınıf yapabilirsiniz :

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

Veya daha kısa olanı:

module.exports = class Animal {

};

Başka bir modüle aktarıldıktan sonra, onu o dosyada tanımlanmış gibi ele alabilirsiniz:

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

class Cat extends Animal {
    ...
}

ES6 sınıf adını, kurucu adını ES5 yöntemiyle ele aldığınız gibi ele alın. Onlar bir ve aynı.

ES6 sözdizimi sadece sözdizimsel şekerdir ve tamamen aynı temel prototipi, yapıcı işlevi ve nesneleri oluşturur.

Öyleyse, ES6 örneğinizde:

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

var a = new Animal();

module.exports = {Animal: Animal};

Sadece davranabilirsiniz Animalsenin nesnenin kurucusu (siz ES5 içinde yapardı aynı) gibi. Yapıcıyı dışa aktarabilirsiniz. Yapıcıyı ile arayabilirsiniz new Animal(). Kullanmak için her şey aynı. Yalnızca bildirim sözdizimi farklıdır. Hala Animal.prototypeüzerinde tüm yöntemlerinizi içeren bir tane bile var. ES6 yöntemi, sadece daha süslü / daha hoş sözdizimiyle gerçekten aynı kodlama sonucunu yaratır.

İthalat tarafında, bu daha sonra şu şekilde kullanılacaktır:

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

let a = new Animal();

Bu şema, Animal yapıcısını .Animalo modülden birden fazla şeyi dışa aktarmanıza izin veren özellik olarak dışa aktarır .

Birden fazla şeyi dışa aktarmanız gerekmiyorsa, bunu yapabilirsiniz:

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

module.exports = Animal;

Ve sonra şununla içe aktarın:

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

let a = new Animal();

ES6'nın gerektirdiği yol import. Şunları yapabilirsiniz exportsınıfınızı ve kullanma başka bir yere aktarmak import { ClassName } from 'path/to/ClassName'sözdizimi.

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

Düğümde Sınıfları Kullanma -

Burada ReadWrite modülünü gerekli kılıyoruz ve ReadWrite sınıfının nesnesini döndüren bir makeObject () çağırıyoruz. Yöntemleri aramak için kullandığımız. 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

Burada, yalnızca bir nesne mevcut olmadığında bir nesnenin döndürülmesini sağlayan bir makeObject yöntemi yapıyoruz.

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;

Daha fazla açıklama için https://medium.com/@nynptel/node-js-boiler-plate-code-using-singleton-classes-5b479e513f74 adresine gidin.

Sınıf dosyasında aşağıdakilerden birini kullanabilirsiniz:

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

veya bu sözdizimini kullanabilirsiniz

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

module.exports = ClassNameHere;

Öte yandan bu sınıfı başka herhangi bir dosyada kullanmak için şu adımları uygulamanız gerekir. Öncelikle bu dosyayı şu sözdizimini kullanarak gerekli kılın: const anyVariableNameHere = require('filePathHere');

Sonra bir nesne oluşturun const classObject = new anyVariableNameHere();

Bundan sonra classObjectgerçek sınıf değişkenlerine erişmek için kullanabilirsiniz