Entonces, 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, puede crear clases "reales" como esta:
class Animal{ constructor(name){ this.name = name ; } print(){ console.log('Name is :'+ this.name); } } Ahora, antes que nada, me encanta esto :) pero plantea una pregunta. ¿Cómo se usa esto combinado con la estructura del módulo de node.js ?
Digamos que tiene una clase en la que desea usar un módulo por el bien de la demostración, diga que desea usar fs
entonces 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 esta la forma correcta?
Además, ¿cómo expone esta clase a otros archivos dentro de mi proyecto de nodo? ¿Y aún podría extender esta clase si la está usando en un archivo separado?
Espero que alguno de ustedes pueda responder a estas preguntas :)
Sí, tu ejemplo funcionaría bien.
En cuanto a exponer sus clases, puede export una clase como cualquier otra cosa:
class Animal {...} module.exports = Animal;O el más corto:
module.exports = class Animal { };Una vez importado a otro módulo, puede tratarlo como si estuviera definido en ese archivo:
var Animal = require('./Animal'); class Cat extends Animal { ... }Simplemente trate el nombre de la clase ES6 de la misma manera que hubiera tratado el nombre del constructor en la forma ES5. Son uno y lo mismo.
La sintaxis de ES6 es simplemente azúcar sintáctica y crea exactamente el mismo prototipo subyacente, función constructora y objetos.
Entonces, en su ejemplo ES6 con:
// animal.js class Animal { ... } var a = new Animal(); module.exports = {Animal: Animal}; Puede simplemente tratar a Animal como el constructor de su objeto (lo mismo que hubiera hecho en ES5). Puede exportar el constructor. Puede llamar al constructor con new Animal() . Todo es igual para usarlo. Solo la sintaxis de la declaración es diferente. Incluso hay un Animal.prototype que tiene todos tus métodos. La forma ES6 realmente crea el mismo resultado de codificación, solo que con una sintaxis más elegante/mejor.
En el lado de la importación, esto se usaría así:
const Animal = require('./animal.js').Animal; let a = new Animal(); Este esquema exporta el constructor Animal como la propiedad .Animal que le permite exportar más de una cosa de ese módulo.
Si no necesita exportar más de una cosa, puede hacer esto:
// animal.js class Animal { ... } module.exports = Animal;Y luego importarlo con:
const Animal = require('./animal.js'); let a = new Animal();La forma de ES6 de require es import . Puede export su clase e importarla en otro lugar utilizando la sintaxis 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';