Запропонувати правку

Покращити цю статтю

Допрацюйте відповідь до «Що робить об'єкт module?». Ваші зміни проходять модерацію перед публікацією.

Потрібне підтвердження

Контент

Що ви змінюєте

Заголовок (UA)

Коротка відповідь (UA)

Показується над повною відповіддю для швидкого нагадування.

Відповідь (UA)

## 1. Що таке `module`

> `module` - це вбудований об'єкт у Node.js, який представляє **поточний модуль (поточний файл)**.
>
> Кожен `.js` файл у Node.js - це **окремий модуль**, і для кожного з них Node автоматично створює об'єкт `module`.

### Приклад:

```javascript
console.log(module);
```

Виведе (спрощено):

```javascript
Module {
  id: '.',
  path: '/Users/tim/project',
  exports: {},
  filename: '/Users/tim/project/app.js',
  loaded: false,
  children: [],
  parent: null
}
```

Це "службовий об'єкт", який містить **метадані**:

- `id` - унікальний ідентифікатор модуля (зазвичай шлях);
- `filename` - абсолютний шлях до файлу;
- `loaded` - чи завантажений модуль повністю;
- `exports` - об'єкт, що експортується;
- `children` - список модулів, які цей модуль завантажив;
- `parent` - хто завантажив цей модуль.

## 2. Що робить `module.exports`

> `module.exports` - це об'єкт, який визначає, **що саме буде повернуто**, коли хтось робить `require()` цього файлу.

Те, що ти запишеш у `module.exports`,
стає результатом виклику `require()`.

### math.js

```javascript
const PI = 3.14;
function add(a, b) {
  return a + b;
}

// експортуємо назовні
module.exports = { PI, add };
```

### app.js

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

console.log(math.add(2, 3)); // 5
console.log(math.PI);        // 3.14
```

Тобто:

> `require('./math')` повертає **значення** `module.exports` із файлу `math.js`.

## 3. Як пов'язані `module` і `exports`

Node.js **обгортає кожен файл** у внутрішню функцію:

```javascript
(function (exports, require, module, __filename, __dirname) {
  // твій код
});
```

Тут:

- `exports` - це **посилання** (аліас) на `module.exports`;
- `module.exports` - реальний об'єкт, який буде експортовано.

### Схематично:

```javascript
exports  ──►  { }  ◄── module.exports
```

Поки ти робиш:

```javascript
exports.foo = 42;
```

чи

```javascript
module.exports.foo = 42;
```

- це те саме (обидва додають властивості до спільного об'єкта).

## 4. Але є пастка!

Якщо ти **переприсвоїш** `exports` напряму, зв'язок із `module.exports` втрачається.

### Приклад неправильного використання:

```javascript
// math.js
exports = { add: (a, b) => a + b };
```

### app.js

```javascript
const math = require('./math');
console.log(math); // {}
```

Чому?
Тому що ти просто переназначив змінну `exports`,
а `module.exports` лишився порожнім об'єктом.

### Правильні способи експорту:

**Варіант 1. Через** `module.exports`**:**

```javascript
module.exports = {
  add: (a, b) => a + b
};
```

**Варіант 2. Через** `exports`**:**

```javascript
exports.add = (a, b) => a + b;
exports.sub = (a, b) => a - b;
```

**Варіант 3. Експорт функції напряму:**

```javascript
module.exports = function (a, b) {
  return a + b;
};
```

## 5. Під капотом `require()` та `module.exports`

Коли ти викликаєш:

```javascript
const user = require('./user');
```

Node.js робить таке:

1. Завантажує `user.js`;
2. Створює об'єкт:

```javascript
  const module = { exports: {} };
  const exports = module.exports;
  ```
3. Виконує код файлу;
4. Повертає `module.exports`.

## 6. Приклад повного циклу

### user.js

```javascript
console.log('Модуль user завантажується...');

module.exports = {
  name: 'Tim',
  sayHi() {
    console.log('Hi!');
  }
};
```

### app.js

```javascript
const user = require('./user');

console.log(user.name); // Tim
user.sayHi();           // Hi!
```

**Вивід:**

```javascript
Модуль user завантажується...
Tim
Hi!
```

## 7. Часті помилки

| Помилка | Чому | Як виправити |
|---|---|---|
| `exports = {...}` | Втрачено посилання на `module.exports` | Використовуй `module.exports = {...}` |
| Експорт усередині функції | Не експортується за межі функції | Визнач `module.exports` на верхньому рівні |
| Кілька експортів підряд | Останній перезапише попередні | Експортуй об'єкт з усіма властивостями |

## 8. Приклад: різниця між додаванням і переприсвоєнням

### Додавання:

```javascript
exports.a = 1;
exports.b = 2;
```

Результат:

```javascript
{ a: 1, b: 2 }
```

### Переприсвоєння:

```javascript
module.exports = { a: 1, b: 2 };
```

Результат:

```javascript
{ a: 1, b: 2 }
```

Обидва працюють, але `exports = ...` **без** `module.exports = ...` **не працює!**

## 9. Метадані об'єкта `module`

| Властивість | Призначення |
|---|---|
| `id` | Унікальний ідентифікатор модуля |
| `filename` | Абсолютний шлях до файлу |
| `loaded` | Прапорець, що модуль повністю завантажено |
| `parent` | Модуль, який викликав `require()` |
| `children` | Модулі, завантажені цим модулем |
| `exports` | Об'єкт, що повертається через `require()` |
| `path` | Папка, де знаходиться модуль |

## 10. Візуально

```javascript
┌────────────────────────────┐
│         module             │
│  ┌──────────────────────┐  │
│  │ module.exports = {}  │◄─┼─── повертається при require()
│  └──────────────────────┘  │
│  exports ─────► (посилання)│
└────────────────────────────┘
```

## Коротке резюме

| Об'єкт | Призначення |
|---|---|
| `module` | Службовий об'єкт, що представляє поточний файл-модуль |
| `module.exports` | Об'єкт, який реально експортується назовні |
| `exports` | Посилання на `module.exports` (зручний короткий доступ) |
| `require()` | Завантажує модуль і повертає `module.exports` |

Головне правило:

> Усе, що ти хочеш віддати назовні - **поклади в** `module.exports`.
>
> Усе решта лишається приватним усередині модуля.

Markdown · перетягуйте зображення · ⌘B / ⌘I шорткати768 слів

Для рев’юера

Примітка для модератора (необов’язково)

Бачить лише модератор. Прискорює рев’ю.