No.classes js ES6 com necessidades

Até agora, criei classes e módulos em node.jsda seguinte forma:

    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;
Agora com o ES6, você é capaz de fazer aulas "reais"assim: 
class Animal{

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

 print(){
    console.log('Name is :'+ this.name);
 }
}
Mas isso levanta uma questão. Como é que se utiliza esta combinação com a estrutura do módulo de node.js?

Diga que tem uma aula onde deseja usar um módulo para demonstração diga que deseja usar fs

Então você cria o seu ficheiro:

Animal.js

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

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

 print(){
    console.log('Name is :'+ this.name);
 }
}
Este seria o caminho certo?

também, como é que expões esta classe a outros ficheiros dentro do meu projecto de nó? E você ainda seria capaz de estender esta classe se você estiver usando-a em um arquivo separado?

([7]}espero que alguns de vocês possam responder a estas perguntas:)

Author: mscdex, 2017-03-09
Source

3 answers

Sim, o teu exemplo funcionaria bem. Quanto a expor as suas aulas, pode ter uma aula como qualquer outra coisa. 
class Animal {...}
module.exports = Animal;

Ou o mais curto: 

module.exports = class Animal {

};

Uma vez importado para outro módulo, então você pode tratá-lo como se estivesse definido nesse arquivo:

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

class Cat extends Animal {
    ...
}
 65
Author: rossipedia, 2018-01-29 17:29:24
Trata o nome da classe ES6 da mesma forma que tratarias o nome do construtor da forma ES5. Eles são um e o mesmo. A sintaxe ES6 é apenas açúcar sintático e cria exatamente o mesmo protótipo subjacente, função construtora e objetos.

Então, no seu exemplo ES6 com: 

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

var a = new Animal();

module.exports = {Animal: Animal};

Você pode apenas tratar Animal como o construtor do seu objeto (o mesmo que você teria feito em ES5). Você pode exportar o construtor. Pode ligar para o ... construtor com new Animal(). Tudo é o mesmo para usá-lo. Apenas a sintaxe da declaração é diferente. Ainda há um que tem todos os teus métodos. A maneira ES6 realmente cria o mesmo resultado de codificação, apenas com uma sintaxe mais elegante/melhor.

No lado da importação, isto seria então usado assim: 

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

let a = new Animal();
Este regime exporta o construtor de animais para a propriedade que lhe permite exportar mais do que uma coisa dessa propriedade. modulo.

Se não precisar de exportar mais do que uma coisa, pode fazer isto: 

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

module.exports = Animal;

E, em seguida, importá-lo com: 

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

let a = new Animal();
 4
Author: jfriend00, 2018-07-11 22:33:39

A forma de exigência do ES6 é import. Você pode export a sua classe e importá-la noutro lugar, usando a sintaxe 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';
 2
Author: Fan Jin, 2017-03-08 23:59:50