web-dev-qa-db-fra.com

Node.js ES6 classes avec require

Donc, jusqu'à présent, j'ai créé des classes et des modules dans node.js de la manière suivante:

    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;

Maintenant, avec ES6, vous pouvez créer des classes "réelles" comme ceci:

class Animal{

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

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

Maintenant, tout d’abord, j’adore ça :) mais cela soulève une question. Comment utilisez-vous cela combiné avec la structure de module de node.js?

Disons que vous avez une classe où vous souhaitez utiliser un module à des fins de démonstration, dites que vous souhaitez utiliser fs

alors vous créez votre fichier:

Animal.js

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

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

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

Serait-ce la bonne façon?

Aussi, comment exposez-vous cette classe à d'autres fichiers de mon projet de noeud? Et seriez-vous toujours en mesure d'étendre cette classe si vous l'utilisez dans un fichier séparé?

J'espère que certains d'entre vous seront en mesure de répondre à ces questions :)

javascriptnode.jsecmascript-6
77
Marc Rasmussen

Oui, votre exemple fonctionnerait bien.

Pour exposer vos classes, vous pouvez export une classe comme n'importe quoi d'autre:

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

Ou le plus court:

module.exports = class Animal {

};

Une fois importé dans un autre module, vous pouvez le traiter comme s'il était défini dans ce fichier:

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

class Cat extends Animal {
    ...
}
113
rossipedia

Traitez simplement le nom de classe ES6 de la même manière que vous auriez traité le nom du constructeur de la même manière que ES5. Ils sont un et le même.

La syntaxe ES6 n’est qu’un sucre syntaxique et crée exactement le même prototype sous-jacent, la même fonction constructeur et les mêmes objets.

Donc, dans votre exemple ES6 avec:

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

var a = new Animal();

module.exports = {Animal: Animal};

Vous pouvez simplement traiter Animal comme le constructeur de votre objet (comme vous le feriez dans ES5). Vous pouvez exporter le constructeur. Vous pouvez appeler le constructeur avec new Animal(). Tout est pareil pour l'utiliser. Seule la syntaxe de déclaration est différente. Il y a même encore un Animal.prototype qui contient toutes vos méthodes. La méthode ES6 crée vraiment le même résultat de codage, avec une syntaxe plus sophistiquée/plus élégante.

Du côté de l'importation, ceci serait alors utilisé comme ceci:

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

let a = new Animal();

Ce schéma exporte le constructeur Animal sous la propriété .Animal, ce qui vous permet d'exporter plusieurs éléments de ce module.

Si vous n'avez pas besoin d'exporter plus d'une chose, vous pouvez le faire:

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

module.exports = Animal;

Et puis importez-le avec:

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

let a = new Animal();
8
jfriend00

La méthode ES6 requise est import. Vous pouvez export votre classe et l'importer ailleurs en utilisant import { ClassName } from 'path/to/ClassName'syntax.

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';
3
Fan Jin

Utilisation de classes dans Node -

Ici, nous demandons le module ReadWrite et appelons un makeObject (), qui retourne l'objet de la classe ReadWrite. Ce que nous utilisons pour appeler les méthodes. 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

Nous créons ici une méthode makeObject, qui s'assure qu'un objet est renvoyé, uniquement si un objet n'est pas disponible.

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;

Pour plus d'explications, allez à https://medium.com/@nynptel/node-js-boiler-plate-code-using-singleton-classes-5b479e513f74

0
Nayan Patel