Import Statement Node.js: 'Triệu Hồi Sức Mạnh' cho code Gen Z

Này các 'dev-er' tương lai của Creyt! Hôm nay chúng ta sẽ 'triệu hồi' một khái niệm cực kỳ 'sức mạnh' mà không có nó, code của các bạn sẽ 'nát như tương' – đó chính là import statement trong Node.js. Nghe có vẻ 'hàn lâm' nhưng thực ra nó 'chill' hơn các bạn nghĩ nhiều!

1. import statement là gì mà 'hot' vậy?

Tưởng tượng thế này nhé: Các bạn đang làm một project 'khủng long' với hàng trăm, hàng nghìn dòng code. Nếu các bạn cứ viết tất cả mọi thứ vào một file duy nhất thì 'thôi rồi lượm ơi', tìm bug thì 'khóc một dòng sông', nâng cấp thì 'đau tim' luôn. import statement sinh ra để giải cứu chúng ta khỏi cái 'ác mộng' đó.

import chính là cái 'chìa khóa thần kỳ' giúp các bạn 'mượn đồ' từ những file khác, những module khác. Thay vì phải tự tay code lại mọi thứ, các bạn chỉ cần 'triệu hồi' những chức năng, những biến mà người khác (hoặc chính bạn ở một file khác) đã viết và export ra. Nó giống như việc các bạn có một team siêu anh hùng, mỗi người chuyên một việc. Khi cần sức mạnh của Thor, bạn chỉ cần 'triệu hồi' Thor chứ không cần tự biến mình thành Thor.

Trong Node.js hiện đại, khi nói đến import, chúng ta đang nói về ES Modules (ECMAScript Modules) – chuẩn module mới nhất của JavaScript. Nó giúp code của bạn trở nên:

• Sạch sẽ hơn: Mỗi file chỉ làm một nhiệm vụ cụ thể.
• Dễ đọc hơn: Dễ hiểu luồng logic của ứng dụng.
• Dễ bảo trì hơn: Sửa một phần không ảnh hưởng đến toàn bộ.
• Dễ tái sử dụng hơn: Viết một lần, dùng muôn nơi.

2. Code Ví Dụ Minh Họa: 'Triệu Hồi' như thế nào?

Để dùng import trong Node.js, điều quan trọng đầu tiên là các bạn phải 'bật chế độ' ES Modules cho project của mình. Đơn giản thôi, mở file package.json và thêm dòng này vào:

{
  "name": "my-awesome-project",
  "version": "1.0.0",
  "type": "module",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  }
}

Khi đã có "type": "module", Node.js sẽ hiểu rằng các file .js trong project của bạn sẽ dùng cú pháp ES Modules (import/export) thay vì CommonJS (require/module.exports).

Bây giờ, hãy tạo hai file: utils.js (chứa các hàm tiện ích) và app.js (file chính sẽ sử dụng các hàm đó).

File: utils.js (File này sẽ 'export' ra các chức năng)

// utils.js

// Export named: Giống như bạn có nhiều siêu năng lực, và bạn muốn chia sẻ từng cái một
export const PI = 3.14159;

export function add(a, b) {
  return a + b;
}

export function subtract(a, b) {
  return a - b;
}

// Export default: Giống như bạn có một siêu anh hùng chính của team, mặc định ai cũng biết
const multiply = (a, b) => a * b;
export default multiply;

File: app.js (File này sẽ 'import' và sử dụng các chức năng)

// app.js

// Import named: Gọi đúng tên siêu năng lực bạn cần
import { PI, add } from './utils.js';

// Import default: Gọi siêu anh hùng mặc định. Có thể đặt tên tùy ý (ở đây là 'mathMultiply')
import mathMultiply from './utils.js';

// Import tất cả các named exports dưới dạng một object: Giống như bạn gọi cả team siêu anh hùng về
import * as utils from './utils.js';

console.log('Giá trị của PI:', PI); // Output: Giá trị của PI: 3.14159
console.log('Tổng 5 + 3:', add(5, 3)); // Output: Tổng 5 + 3: 8

console.log('Tích 4 * 6 (default export):', mathMultiply(4, 6)); // Output: Tích 4 * 6 (default export): 24

// Sử dụng các hàm từ import * as utils
console.log('Hiệu 10 - 2:', utils.subtract(10, 2)); // Output: Hiệu 10 - 2: 8
console.log('PI từ utils object:', utils.PI); // Output: PI từ utils object: 3.14159

Để chạy app.js, các bạn chỉ cần gõ lệnh:

node app.js

Và 'boom!', các bạn sẽ thấy kết quả 'ngon lành cành đào' hiện ra trên console.

Gợi Ý Đọc Tiếp

DevDependencies: Phụ Tùng 'Hậu Trường' Của Dân Dev Node.js

1 Lượt xem

3. Mẹo (Best Practices) để import 'chuẩn không cần chỉnh'

Anh Creyt có vài 'tip & trick' bỏ túi để các bạn 'combat' với import một cách 'pro' nhất:

• Nhất quán một phong cách: Trong một project, hãy thống nhất dùng import (ES Modules) hoặc require (CommonJS). Đừng 'nửa nạc nửa mỡ' kẻo 'tẩu hỏa nhập ma' đó! Đối với project mới, cứ ES Modules mà 'triển' nhé.
• Chỉ import những gì cần: Đừng có 'tham lam' import * as xyz nếu bạn chỉ cần một, hai hàm. Việc import cụ thể import { tenHam } from './file.js' giúp code của bạn gọn gàng hơn và quan trọng là giúp các bundler (như Webpack, Vite) thực hiện 'tree-shaking' (loại bỏ code không dùng) hiệu quả hơn, làm cho ứng dụng của bạn 'nhẹ tênh' hơn.
• Đổi tên khi cần (as): Nếu có hai hàm cùng tên từ hai file khác nhau, hoặc tên hàm hơi dài dòng, hãy dùng as để đổi tên: import { someLongFunctionName as slf } from './module.js';
• Sắp xếp import: Để code 'ngăn nắp' như phòng của 'idol', hãy nhóm các import lại:
  1. Core modules (ví dụ: import fs from 'node:fs';)
  2. Third-party modules (ví dụ: import express from 'express';)
  3. Local modules (ví dụ: import { myFunction } from './my-local-file.js';)
• Tránh 'vòng lặp luẩn quẩn' (Circular Dependencies): Đừng để file A import file B, rồi file B lại import file A. Nó sẽ tạo ra một vòng lặp vô tận và 'sập nguồn' ứng dụng của bạn đó.
• Nhớ .js ở cuối: Khi import các file local, trong ES Modules, bạn phải chỉ rõ phần mở rộng .js (hoặc .mjs, .mts). Ví dụ: import { func } from './myFile.js'; chứ không phải import { func } from './myFile';. Đây là một điểm khác biệt lớn so với CommonJS.

4. Góc 'Harvard': Vì sao 'Modular Programming' lại quan trọng?

Từ góc độ học thuật mà nói, import statement không chỉ là một cú pháp đơn thuần, mà nó là 'xương sống' của Modular Programming (Lập trình mô-đun) – một trong những nguyên tắc thiết kế phần mềm cốt lõi.

Hãy nghĩ về một chiếc xe hơi. Nó không phải là một khối kim loại duy nhất, mà là tập hợp của nhiều mô-đun: động cơ, hệ thống phanh, hệ thống điện, v.v. Mỗi mô-đun có một chức năng riêng biệt, được thiết kế độc lập nhưng có thể 'giao tiếp' với các mô-đun khác thông qua các 'giao diện' (API) rõ ràng.

Trong lập trình, import cho phép chúng ta:

• Phân tách mối quan tâm (Separation of Concerns): Mỗi file/module chỉ tập trung vào một nhiệm vụ cụ thể. Điều này giúp giảm độ phức tạp, dễ dàng kiểm thử và sửa lỗi từng phần.
• Tính tái sử dụng (Reusability): Khi bạn có một hàm tính toán 'xịn sò' ở utils.js, bạn có thể import nó vào bất kỳ đâu mà không cần viết lại. Giống như bạn có một công thức nấu ăn ngon, bạn dùng nó cho mọi bữa tiệc vậy.
• Dễ bảo trì (Maintainability): Nếu có lỗi ở hàm add, bạn chỉ cần vào utils.js sửa, không cần 'đụng chạm' đến các file khác.
• Khả năng mở rộng (Scalability): Khi dự án lớn lên, bạn có thể dễ dàng thêm module mới mà không làm ảnh hưởng đến cấu trúc hiện có.

ES Modules còn có một lợi thế lớn là static analysis (phân tích tĩnh). Tức là, các công cụ có thể biết được những module nào được import vào một file ngay cả trước khi code được chạy. Điều này mở ra cánh cửa cho các tối ưu hóa mạnh mẽ như tree-shaking (loại bỏ code chết) và code splitting (chia nhỏ code để tải hiệu quả hơn), giúp ứng dụng của bạn 'bay' nhanh hơn trên trình duyệt.

5. Ứng dụng thực tế: Ai đang 'xài' import?

Nói thật là, hầu hết các ứng dụng và website 'đỉnh cao' mà các bạn đang dùng hàng ngày đều 'xài' import (hoặc require ở các dự án cũ) đó. Từ những website thương mại điện tử lớn, mạng xã hội, cho đến các công cụ phát triển phần mềm.

• Các framework Node.js: Như Express.js, NestJS, Next.js (khi chạy ở phía server) đều sử dụng hệ thống module để tổ chức code của họ. Mỗi controller, service, model... đều là một module riêng biệt được import vào khi cần.
• Các thư viện UI/UX: React, Vue, Angular – tất cả đều dựa vào import để bạn có thể dùng các component, hook, service từ các thư viện đó hoặc từ các file bạn tự tạo.
• Các công cụ build/bundler: Webpack, Vite, Rollup... chúng 'ngốn' các import statement của bạn để tạo ra một bundle cuối cùng hiệu quả nhất cho trình duyệt.

Bất cứ khi nào bạn thấy import React from 'react'; hay import { useState } from 'react'; trong các project frontend, đó chính là import statement đang 'làm nhiệm vụ' đấy.

6. Thử nghiệm và Nên dùng cho case nào?

Anh Creyt đã từng 'chinh chiến' qua cả thời require 'thống trị' và bây giờ là thời 'hoàng kim' của import. Mỗi cái có ưu nhược điểm riêng, nhưng xu hướng rõ ràng là import.

• Nếu bạn đang làm dự án Node.js mới toanh: 'Chơi' liền ES Modules (import) bằng cách thêm "type": "module" vào package.json. Đây là tương lai, là tiêu chuẩn mới, và nó mang lại nhiều lợi ích về tối ưu hóa và cú pháp hiện đại.
• Nếu bạn đang làm việc với một dự án Node.js cũ: Rất có thể nó đang dùng require. Trong trường hợp này, hãy tiếp tục dùng require để tránh 'phá vỡ' cấu trúc hiện có. Việc chuyển đổi từ CommonJS sang ES Modules có thể hơi 'khoai' nếu project lớn, cần cân nhắc kỹ lưỡng.
• Sử dụng import() động (Dynamic Import): Đôi khi bạn chỉ muốn tải một module khi thực sự cần nó (ví dụ: một thư viện nặng chỉ dùng cho một tính năng ít khi được truy cập). Khi đó, bạn có thể dùng import('./path/to/module.js') như một hàm trả về Promise. Nó giúp ứng dụng của bạn khởi động nhanh hơn và tải tài nguyên hiệu quả hơn.

// Dynamic Import example in Node.js
async function loadAndUseHeavyModule() {
  if (userClicksButton) { // Chỉ tải khi người dùng thực hiện hành động này
    const { someHeavyFunction } = await import('./heavyModule.js');
    console.log(someHeavyFunction());
  }
}

Tóm lại, import statement không chỉ là một cú pháp, nó là một 'triết lý' về cách chúng ta tổ chức và xây dựng phần mềm. Nắm vững nó, các bạn sẽ có trong tay 'siêu năng lực' để tạo ra những ứng dụng 'đỉnh của chóp', 'mượt mà' và dễ bảo trì. Giờ thì, 'go forth and code', các 'dev-er' tương lai của anh Creyt!