Node.js - yapıcı olarak module.exports'un kullanılması

Node.js kılavuzuna göre:

Modül dışa aktarımının kökünün bir işlev (bir yapıcı gibi) olmasını istiyorsanız veya bir seferde bir özellik oluşturmak yerine tam bir nesneyi tek bir atamada dışa aktarmak istiyorsanız, bunu export yerine module.exports'a atayın. .

Verilen örnek şudur:

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

ve şu şekilde kullanıldı:

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

Sorum: Örnek neden kare olarak nesne kullanmıyor? Aşağıdaki geçerli midir ve örneği daha "nesne yönelimli" yapar mı?

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

CommonJS modülleri, dışa aktarılan özellikleri tanımlamak için iki yol sağlar. Her iki durumda da bir Nesne / Fonksiyon döndürüyorsunuz. Fonksiyonlar JavaScript'te birinci sınıf vatandaş olduklarından, tıpkı Nesneler gibi hareket edebilirler (teknik olarak Nesnelerdir). Bu, newanahtar kelimeleri kullanma hakkındaki sorunuzun basit bir cevabı olduğunu söyledi: Evet. Göstereceğim ...

Modül dışa aktarımı

exportsÖzellik eklemek için sağlanan değişkeni kullanabilirsiniz . Başka bir modülde gerektiğinde, bu atama özellikleri kullanılabilir hale gelir. Veya module.exports özelliğine bir nesne atayabilirsiniz. Her iki durumda da döndürülen require()şey değerine bir referanstır module.exports.

Bir modülün nasıl tanımlandığına dair sözde kod örneği:

var theModule = {
  exports: {}
};

(function(module, exports, require) {

  // Your module code goes here

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

Yukarıdaki örnekte module.exportsve exportsaynı nesnedir. İşin güzel yanı, CommonJS modüllerinizde bunlardan hiçbirini görmemenizdir, çünkü tüm sistem sizin için tüm bilmeniz gereken şey, bir dışa aktarma özelliği olan bir modül nesnesi ve module.exports'un yaptığı aynı şey.

Yapıcılar ile gerektir

Bir işlevi doğrudan module.exportssize ekleyebildiğiniz için , aslında bir işlevi döndürebilirsiniz ve herhangi bir işlev gibi, bir kurucu olarak yönetilebilir (Bu italik olarak yazılmıştır çünkü JavaScript'teki bir işlev ile yapıcı arasındaki tek fark onu nasıl kullanmayı düşündüğünüzdür. hiçbir fark yok.)

Dolayısıyla, aşağıdaki mükemmel bir kod ve ben şahsen onu teşvik ediyorum:

// 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"

Yapıcı olmayanlar için gerekli

Aynı şey yapıcı olmayan benzeri işlevler için de geçerlidir:

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

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

Kanımca, node.js örneklerinden bazıları oldukça uydurma.

Gerçek dünyada buna benzer bir şey görmeyi bekleyebilirsiniz

// 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;

kullanım

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

ES6 kullanıcıları için

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

export default Square;

ES6'da kullanma

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

Bir sınıf kullanırken, gereken kullanmak newbunu instatiate için anahtar kelime. Diğer her şey aynı kalır.

Bu sorunun gerçekten nasıl require()çalıştığıyla hiçbir ilgisi yok . Temel olarak, module.exportsmodülünüzde ayarladığınız her şey , require()çağrıdan geri dönecektir .

Bu şuna eşdeğer olacaktır:

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

newArama yaparken anahtar kelimeye gerek yoktur square. İşlev örneğinin kendisini squaredöndürmüyorsunuz, sonunda yeni bir nesne döndürüyorsunuz. Bu nedenle, bu işlevi doğrudan çağırabilirsiniz.

Daha karmaşık argümanlar için şuna bakın new: JavaScript'in "yeni" anahtar kelimesi zararlı olarak kabul ediliyor mu?

Örnek kod:

esas olarak

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

aşağıdakileri kullanmak işe yarayabilir

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

Sonunda Node, Javascript ile ilgilidir. JS'nin bir şeyi başarmanın birkaç yolu vardır, bir "kurucu" elde etmek için aynı şeydir , önemli olan bir işlevi döndürmektir .

Bu şekilde, örneğin Web Tarayıcısı ortamında JS kullanarak oluşturduğumuz gibi, aslında yeni bir işlev oluşturuyorsunuz.

Şahsen ben, Sukima'nın bu yazıda önerdiği gibi prototip yaklaşımını tercih ediyorum: Node.js - yapıcı olarak module.exports kullanımı