javascript - tag - jsdoc tutorial

Node.js-uso de module.exports como constructor

Question

De acuerdo con el manual Node.js:

Si desea que la raíz de la exportación de su módulo sea una función (como un constructor) o si desea exportar un objeto completo en una asignación en lugar de compilar una propiedad a la vez, asígnelo a module.exports en lugar de exportar .

El ejemplo dado es:

// file: square.js
module.exports = function(width) {
  return {
    area: function() {
      return width * width;
    }
  };
}

y usado así:

var square = require(''./square.js'');
var mySquare = square(2);
console.log(''The area of my square is '' + mySquare.area());

Mi pregunta: ¿por qué el ejemplo no usa el cuadrado como un objeto? ¿Es válido lo siguiente y hace que el ejemplo sea más "orientado a objetos"?

var Square = require(''./square.js'');
var mySquare = new Square(2);
console.log(''The area of my square is '' + mySquare.area());

Answer 1

El código de ejemplo es:

en principal

square(width,function (data)
{
   console.log(data.squareVal);
});

utilizando lo siguiente puede funcionar

exports.square = function(width,callback)
{
     var aa = new Object();
     callback(aa.squareVal = width * width);    
}

Answer 2

En mi opinión, algunos de los ejemplos de node.js son bastante artificiales.

Es probable que veas algo más así en el mundo real

// square.js
function Square(width) {

  if (!(this instanceof Square)) {
    return new Square(width);
  }

  this.width = width;
};

Square.prototype.area = function area() {
  return Math.pow(this.width, 2);
};

module.exports = Square;

Uso

var Square = require("./square");

// you can use `new` keyword
var s = new Square(5);
s.area(); // 25

// or you can skip it!
var s2 = Square(10);
s2.area(); // 100

Para las personas ES6

class Square {
  constructor(width) {
    this.width = width;
  }
  area() {
    return Math.pow(this.width, 2);
  }
}

export default Square;

Utilizándolo en ES6

import Square from "./square";
// ...

Al usar una clase, debe usar la new palabra clave para instalarla. Todo lo demás se queda igual.

Answer 3

Esta pregunta realmente no tiene nada que ver con cómo require() funciona. Básicamente, cualquier cosa que configure module.exports en su módulo se devolverá desde la llamada a require() .

Esto sería equivalente a:

var square = function(width) {
  return {
    area: function() {
      return width * width;
    }
  };
}

No hay necesidad de la new palabra clave al llamar a square . No devuelve la instancia de función propiamente dicha de forma square , está devolviendo un nuevo objeto al final. Por lo tanto, simplemente puede llamar a esta función directamente.

Para argumentos más complejos acerca de los new , mira esto: ¿La palabra clave "nueva" de JavaScript se considera dañina?

Answer 4

Los módulos CommonJS permiten dos formas de definir las propiedades exportadas. En cualquier caso, está devolviendo un Objeto / Función. Como las funciones son ciudadanos de primera clase en JavaScript, pueden actuar como Objetos (técnicamente son Objetos). Dicho esto, su pregunta sobre el uso de las new palabras clave tiene una respuesta simple: sí. Ilustraré ...

Exportaciones de módulos

Puede usar la variable de exports proporcionada para adjuntarle propiedades. Una vez requerido en otro módulo, las propiedades asignadas estarán disponibles. O puede asignar un objeto a la propiedad module.exports. En cualquier caso, lo que se devuelve mediante require() es una referencia al valor de module.exports .

Un ejemplo de pseudocódigo de cómo se define un módulo:

var theModule = {
  exports: {}
};

(function(module, exports, require) {

  // Your module code goes here

})(theModule, theModule.exports, theRequireFunction);

En el ejemplo anterior, module.exports y exports son el mismo objeto. Lo bueno es que no ve nada de eso en los módulos de CommonJS, ya que todo el sistema se encarga de que todo lo que necesita saber es que hay un objeto de módulo con una propiedad de exportación y una variable de exportación que apunta al Lo mismo que el módulo.exports.

Requerir con constructores

Como puede adjuntar una función directamente a module.exports , puede devolver una función y, como cualquier función, puede administrarse como un constructor (Esto está en cursiva, ya que la única diferencia entre una función y un constructor en JavaScript es cómo piensa usar técnicamente no hay diferencia).

Entonces el siguiente es un código perfectamente bueno y yo personalmente lo animo:

// My module
function MyObject(bar) {
  this.bar = bar;
}

MyObject.prototype.foo = function foo() {
  console.log(this.bar);
};

module.exports = MyObject;

// In another module:
var MyObjectOrSomeCleverName = require("./my_object.js");
var my_obj_instance = new MyObjectOrSomeCleverName("foobar");
my_obj_instance.foo(); // => "foobar"

Requerir para no constructores

Lo mismo ocurre con las funciones que no son del constructor:

// My Module
exports.someFunction = function someFunction(msg) {
  console.log(msg);
}

// In another module
var MyModule = require("./my_module.js");
MyModule.someFunction("foobar"); // => "foobar"