Node.js module.exports ve exports Farkı, Örneklerle

module.exports, bir Node.js dosyasının onu require() ile yükleyen her dosyaya verdiği değerdir. Boş bir nesne olarak başlar: birden fazla şeyi export etmek için ona property ekle, tek bir şeyi export etmek için ona yeni bir değer (bir fonksiyon, bir class) ata. exports aynı nesneyi gösteren kısaltma bir değişkendir; bu yüzden exports.add = ... çalışır, ama exports = ... bağı koparır ve hiçbir şey export etmez.

const fs = require('fs');

// setup: write a second module next to index.js
fs.writeFileSync('math.js', `
module.exports.add = (a, b) => a + b;
exports.multiply = (a, b) => a * b;
module.exports.PI = 3.14159;
`);

const math = require('./math');

console.log(math.add(2, 3), math.multiply(4, 5), math.PI);
console.log(Object.keys(math));

Program 5 20 3.14159, ardından [ 'add', 'multiply', 'PI' ] yazdırdı. math.js içindeki üç satırın üçü de, module.exports üzerinden de gitse exports üzerinden de gitse, aynı nesneye property ekledi ve require('./math') o nesneyi döndürdü.

Fonksiyon, class ya da nesne export etmek

Bir modülün tek bir ana parçası varsa onu doğrudan module.exports'a ata. Çağıran taraf o zaman etrafında bir nesne değil, fonksiyonun kendisini alır:

const fs = require('fs');

// setup: two modules, one exports a function, one a class
fs.writeFileSync('greet.js', `
module.exports = function greet(name) {
    return 'Hello, ' + name;
};
`);
fs.writeFileSync('user.js', `
class User {
    constructor(name) { this.name = name; }
    describe() { return this.name + ' (user)'; }
}
module.exports = User;
`);

const greet = require('./greet');
const User = require('./user');

console.log(greet('Ada'));
console.log(new User('Grace').describe());

Program Hello, Ada ve Grace (user) yazdırdı. TypeError: greet is not a function görürsen çağıran taraf yanlış şekli kullanmıştır: nesne property'si için const { greet } = require(...), atanmış bir değer için const greet = require(...) yaz.

module.exports ve exports: yeniden atama tuzağı

Dosyan çalışmadan önce Node.js exports = module.exports atamasını yapar. İki isim de tek bir nesneyi gösterir ve require, module.exports'u döndürür. exports'a yeni bir değer atamak yalnızca yerel değişkeni değiştirir:

const fs = require('fs');

// setup: the same export written two ways
fs.writeFileSync('broken.js', 'exports = { version: 2 };');
fs.writeFileSync('working.js', 'module.exports = { version: 2 };');

console.log('broken:', require('./broken'));
console.log('working:', require('./working'));

broken.js, {} export etti, çünkü exports artık hiçbir şeyin döndürmediği yeni bir nesneyi gösteriyor. working.js ise { version: 2 } export etti.

En basit kural: her zaman module.exports yaz. Her durumda çalışır ve kod ne yaptığını açıkça söyler.

require aynı cache'lenmiş nesneyi döndürür

Node.js bir modülün kodunu yalnızca bir kez, ilk require edildiğinde çalıştırır ve module.exports'u cache'ler. Aynı dosyanın sonraki her require'ı aynı nesneyi döndürür, yani bir modülün içindeki state onu yükleyen her dosya tarafından paylaşılır:

const fs = require('fs');

// setup: a module that counts and logs when it loads
fs.writeFileSync('counter.js', `
console.log('counter.js is running');
let count = 0;
module.exports = { next: () => ++count };
`);

const a = require('./counter');
const b = require('./counter.js');

a.next();
a.next();
console.log('b sees', b.next());
console.log('same object:', a === b);

counter.js is running bir kez göründü, b.next() 3 döndürdü ve a === b ifadesi true'dur, çünkü cache anahtarı çözümlenmiş dosya yoludur ve ./counter ile ./counter.js aynı dosyaya çözümlenir. Bir modülde oluşturulan veritabanı bağlantısının ya da config nesnesinin tüm uygulamada paylaşılmasının nedeni budur.

module.exports ve ES modules

ES modules bunun yerine export ve import kullanır. İki biçim birbirine şöyle karşılık gelir:

// CommonJS                              // ES modules
module.exports = greet;                  export default greet;
module.exports.add = add;                export { add };
const greet = require('./greet');        import greet from './greet.js';
const { add } = require('./math');       import { add } from './math.js';

Bir ES module, bir CommonJS dosyasını import edebilir: o dosyanın module.exports'u default import olarak gelir. Node.js 22.12'den beri require(), top-level await içermeyen bir ES module'ü de yükleyebilir. Hangisini ne zaman seçeceğin için CommonJS vs ES modules sayfasına bak.

Sık yapılan hatalar

Bir dosyada exports.x ile module.exports = ...'u karıştırmak. Atama nesnenin yerini alır, bu yüzden ondan önce yazılan her exports.x kaybolur. Her dosyada tek bir stil seç.

Sonradan değişen bir değeri export etmek. module.exports = { count } sayıyı yükleme anında kopyalar; modül count'u güncellediğinde çağıranlar hâlâ eski değeri görür. Yukarıdaki counter.js gibi, değeri döndüren bir fonksiyon export et.

./'ı unutmak. require('math') dosyanın yanındaki math.js'i değil, node_modules içinde bir paketi arar. Yerel dosyalar her zaman ./ ya da ../ ile başlar.