Búsqueda de sitios web

javascript - Clases ES6 de Node.js con require

Así que hasta ahora, he creado clases y módulos en node.js de la siguiente manera:

    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;

Ahora con ES6, puedes crear clases "reales" justo así:

class Animal{

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

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

Ahora, primero que nada, me encanta esto :) pero surge una pregunta. ¿Cómo se usa esto combinado con la estructura de módulos de node.js?

Supongamos que tienes una clase donde deseas usar un módulo para fines de demostración, digamos que deseas usar fs

así que creas tu archivo:

Animal.js

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

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

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

¿Sería este el camino correcto?

Además, ¿cómo expones esta clase a otros archivos dentro de mi proyecto de Node? ¿Y todavía podrías extender esta clase si la estás usando en un archivo separado?

Espero que algunos de ustedes puedan responder estas preguntas :)

Respuesta #1

Sí, tu ejemplo funcionaría bien.

En cuanto a exponer tus clases, puedes exportar una clase igual que cualquier otra cosa:

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

O el más corto:

module.exports = class Animal {

};

Una vez importado en otro módulo, entonces puedes tratarlo como si estuviera definido en ese archivo:

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

class Cat extends Animal {
    ...
}

Respuesta #2

Simplemente trata el nombre de la clase ES6 de la misma manera en que habrías tratado el nombre del constructor en la forma ES5. Son uno y lo mismo.

La sintaxis de ES6 es solo azúcar sintáctico y crea exactamente el mismo prototipo subyacente, función constructora y objetos.

Entonces, en tu ejemplo de ES6 con:

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

var a = new Animal();

module.exports = {Animal: Animal};

O la declaración de exportación se puede abreviar a:

module.exports = { Animal };

Puedes simplemente tratar a Animal como el constructor de tu objeto (lo mismo que habrías hecho en ES5). Puedes exportar el constructor. Puedes llamar al constructor con new Animal(). Todo es igual al usarlo. Solo la sintaxis de declaración es diferente. Incluso todavía hay un Animal.prototype que tiene todos tus métodos. La manera de ES6 realmente crea el mismo resultado de código, solo que con una sintaxis más elegante/agradable.

En el lado de la importación, esto luego se usaría así:

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

let a = new Animal();

O, simplemente puede ser:

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

let a = new Animal();

Este esquema exporta el constructor Animal como la propiedad .Animal, lo que te permite exportar más de una cosa desde ese módulo.

Si no necesitas exportar más de una cosa, puedes hacer esto:

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

module.exports = Animal;

Y, luego impórtalo con:

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

let a = new Animal();

Artículos relacionados