Ở bài trước, chúng ta đã tìm hiểu quan hệ One To One, trong đó mỗi bản ghi chỉ liên kết với duy nhất một bản ghi khác.

Trong thực tế, quan hệ One To Many xuất hiện thường xuyên hơn rất nhiều. 

Ví dụ, một người dùng có thể viết nhiều bài viết, một danh mục có thể chứa nhiều bài viết hoặc một đơn hàng có nhiều sản phẩm.

Laravel hỗ trợ kiểu quan hệ này rất đơn giản thông qua hai phương thức hasMany() và belongsTo().

One To Many là gì?

One To Many là quan hệ một - nhiều.

Ví dụ:

• Một User có nhiều Post.

• Một Category có nhiều Post.

• Một Customer có nhiều Order.

Sơ đồ quan hệ:

User (1)
   │
   ├── Post 1
   ├── Post 2
   ├── Post 3
   └── ...

Cơ sở dữ liệu

Bảng users

Bảng posts

Mỗi bài viết chỉ thuộc về một User, nhưng một User có thể sở hữu nhiều bài viết.

Migration

Trong bảng posts, tạo khóa ngoại:

$table->foreignId('user_id')
      ->constrained()
      ->cascadeOnDelete();

Laravel sẽ tự liên kết tới bảng users.

hasMany()

Trong model User:

class User extends Authenticatable
{
    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}

Ý nghĩa:

Một User có nhiều Post.

Laravel sẽ mặc định tìm khóa ngoại user_id.

belongsTo()

Trong model Post:

class Post extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

Ý nghĩa:

Mỗi Post thuộc về một User.

Lấy tất cả bài viết của User

$user = User::find(1);

$posts = $user->posts;

Hiển thị:

foreach ($user->posts as $post) {

    echo $post->title;

}

Laravel sẽ tự truy vấn bảng posts.

Lấy User của một Post

$post = Post::find(1);

echo $post->user->name;

Laravel sẽ truy vấn bảng users.

Tạo Post cho User

Thay vì tự gán user_id, có thể tạo trực tiếp thông qua Relationship.

$user = User::find(1);

$user->posts()->create([
    'title' => 'Laravel 12',
    'content' => 'Bài viết đầu tiên'
]);

Laravel sẽ tự động thêm:

user_id = 1

Đây là cách được khuyến khích sử dụng trong Eloquent.

Đếm số lượng Post

Có thể đếm nhanh:

$user->posts()->count();

Hoặc:

echo $user->posts->count();

Cách đầu tiên tối ưu hơn vì Laravel chỉ thực hiện câu lệnh COUNT(*) trên cơ sở dữ liệu.

eager loading

Nếu hiển thị danh sách User cùng các Post:

$users = User::with('posts')->get();

Sau đó:

foreach ($users as $user) {

    echo $user->name;

    foreach ($user->posts as $post) {

        echo $post->title;

    }

}

Sử dụng with() giúp tránh hiện tượng N+1 Query, giảm số lượng truy vấn và tăng hiệu năng.

Lấy User cùng số lượng Post

Laravel hỗ trợ withCount():

$users = User::withCount('posts')->get();

Sau đó:

echo $user->posts_count;

Rất hữu ích khi hiển thị thống kê.

Một ví dụ khác

Quan hệ One To Many không chỉ dùng cho User và Post.

Ví dụ:

Category
   │
   ├── Laravel
   ├── PHP
   ├── MySQL
   └── JavaScript

Model Category:

public function posts()
{
    return $this->hasMany(Post::class);
}

Model Post:

public function category()
{
    return $this->belongsTo(Category::class);
}

Đây cũng là một quan hệ One To Many rất phổ biến trong các hệ thống Blog hoặc CMS.

Tổng kết

Trong bài này chúng ta đã học:

• Quan hệ One To Many.

• hasMany().

• belongsTo().

• Lấy danh sách bản ghi liên quan.

• Tạo dữ liệu thông qua Relationship.

• with() để tối ưu truy vấn.

• withCount() để thống kê số lượng bản ghi.

One To Many là kiểu Relationship được sử dụng nhiều nhất trong Laravel và là nền tảng cho hầu hết các ứng dụng quản lý dữ liệu.

Bài tập

1. Khai báo quan hệ hasMany() trong model User.

2. Khai báo quan hệ belongsTo() trong model Post.

3. Hiển thị tất cả bài viết của User có id = 1.

4. Hiển thị tên tác giả của một Post.

5. Tạo một Post mới thông qua $user->posts()->create().

6. Hiển thị số lượng bài viết của từng User bằng withCount().

Bài tiếp theo

Ở bài sau, chúng ta sẽ tìm hiểu Many To Many, kiểu quan hệ cho phép nhiều bản ghi của bảng này liên kết với nhiều bản ghi của bảng khác thông qua bảng trung gian (Pivot Table).

x1

"Module là nền tảng giúp chia nhỏ chương trình thành nhiều tệp, dễ quản lý, dễ tái sử dụng và dễ bảo trì. Hầu hết mọi ứng dụng Node.js đều được xây dựng từ các module."

Mục tiêu bài học

Sau bài học này, bạn sẽ:

• Hiểu Module là gì.

• Biết tại sao phải chia chương trình thành nhiều file.

• Hiểu CommonJS.

• Hiểu ES Module.

• Sử dụng require().

• Sử dụng module.exports.

• Sử dụng import.

• Sử dụng export.

• Hiểu vai trò của package.json.

  

Module là gì?

Module là một file JavaScript chứa:

• biến

• hằng số

• hàm

• class

• đối tượng

để có thể sử dụng lại ở nhiều nơi.

Ví dụ:

project
│
├── app.js
├── math.js
└── string.js

Thay vì viết toàn bộ chương trình trong một file, chúng ta chia thành nhiều module.

Ưu điểm:

• dễ đọc

• dễ bảo trì

• dễ mở rộng

• tái sử dụng

• nhiều người cùng làm việc

Vì sao cần Module?

Giả sử bạn viết toàn bộ chương trình trong một file:

app.js

Sau vài tháng:

3000 dòng

5000 dòng

10000 dòng

Việc tìm kiếm và sửa lỗi sẽ trở nên rất khó khăn.

Module giúp chia chương trình thành từng phần nhỏ.

Ví dụ:

controllers/

models/

routes/

services/

utils/

Đây cũng là cách tổ chức mà Express và NestJS sử dụng.

CommonJS

Trong nhiều năm, Node.js sử dụng hệ thống module mặc định là:

CommonJS

CommonJS sử dụng:

require()

module.exports

Đây vẫn là hệ thống rất phổ biến và bạn sẽ gặp trong nhiều dự án cũ.

Tạo Module đầu tiên

Tạo file:

math.js

function sum(a, b) {
    return a + b;
}

module.exports = sum;

Trong app.js

const sum = require("./math");

console.log(sum(10, 20));

Kết quả:

30

Export nhiều hàm

function sum(a, b) {
    return a + b;
}

function sub(a, b) {
    return a - b;
}

module.exports = {
    sum,
    sub
};

Import:

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

console.log(math.sum(10, 5));

console.log(math.sub(10, 5));

Kết quả:

15

5

Destructuring

Có thể viết ngắn hơn:

const { sum, sub } = require("./math");

console.log(sum(5, 5));

console.log(sub(10, 3));

Export biến

const PI = 3.14;

module.exports = PI;

Import:

const PI = require("./math");

console.log(PI);

Export Object

module.exports = {

    name: "Node.js",

    version: "2026"

};

Import:

const app = require("./math");

console.log(app.name);

console.log(app.version);

ES Module

JavaScript hiện đại đã có hệ thống module riêng.

Đó là:

ES Module

Sử dụng:

import

export

Đây là chuẩn chính thức của JavaScript và ngày càng được sử dụng rộng rãi trong các dự án mới.

Kích hoạt ES Module

Mở file:

package.json

Thêm:

{
    "type": "module"
}

Từ bây giờ Node.js sẽ hiểu rằng project sử dụng ES Module.

Export

Ví dụ:

export function sum(a, b) {

    return a + b;

}

Import:

import { sum } from "./math.js";

console.log(sum(20, 30));

Kết quả:

50

Export nhiều hàm

export function sum(a, b) {

    return a + b;

}

export function sub(a, b) {

    return a - b;

}

Import:

import { sum, sub } from "./math.js";

console.log(sum(10, 2));

console.log(sub(10, 2));

Default Export

export default function hello() {

    console.log("Hello Node.js");

}

Import:

import hello from "./hello.js";

hello();

So sánh CommonJS và ES Module

package.json là gì?

Mỗi project Node.js đều có:

package.json

Đây là "chứng minh thư" của project.

Nó chứa:

• tên project

• phiên bản

• tác giả

• dependencies

• scripts

• license

• type

Ví dụ:

{
    "name": "node-basic",

    "version": "1.0.0",

    "type": "module"
}

Tạo package.json

Chạy:

npm init

Hoặc nhanh hơn:

npm init -y

Node.js sẽ tự sinh:

package.json

Cấu trúc thư mục

Ví dụ:

node-basic
│
├── package.json
├── app.js
├── math.js
├── string.js
└── utils.js

Đây là cách tổ chức cơ bản của hầu hết các dự án Node.js.

Khi nào dùng CommonJS?

Nên dùng khi:

• bảo trì dự án cũ

• làm việc với package chưa hỗ trợ ES Module

• cần tương thích với mã nguồn cũ

Khi nào dùng ES Module?

Đối với các dự án mới, nên ưu tiên ES Module vì:

• là chuẩn chính thức của JavaScript

• cú pháp hiện đại

• đồng nhất với trình duyệt

• được các framework mới như Express 5, Vite và Next.js hỗ trợ tốt

Trong khóa học này, chúng ta sẽ ưu tiên sử dụng ES Module, đồng thời vẫn tìm hiểu CommonJS để có thể đọc và bảo trì các dự án cũ.

Một số lỗi thường gặp

Không thêm "type": "module"

Ví dụ:

import { sum } from "./math.js";

Sẽ báo lỗi nếu project vẫn đang dùng CommonJS.

Quên phần mở rộng .js

Sai:

import { sum } from "./math";

Đúng:

import { sum } from "./math.js";

Sai đường dẫn

import { sum } from "./utils/math.js";

Hãy kiểm tra lại vị trí file và đường dẫn tương đối.

Trộn CommonJS và ES Module

Không nên viết:

const fs = require("fs");

import { sum } from "./math.js";

Hãy thống nhất sử dụng một hệ thống module trong cùng một project.

Tổng kết

Qua bài học này, bạn đã biết:

• ✅ Module giúp chia chương trình thành nhiều file nhỏ.

• ✅ Hiểu cách sử dụng require() và module.exports trong CommonJS.

• ✅ Hiểu cách sử dụng import và export trong ES Module.

• ✅ Biết vai trò của package.json.

• ✅ Biết khi nào nên dùng CommonJS và khi nào nên dùng ES Module.

Module là nền tảng quan trọng của Node.js. Từ bài học này trở đi, hầu hết các chương trình trong khóa học sẽ được tổ chức thành nhiều module thay vì chỉ một file duy nhất.

Bài tập thực hành

Bài 1

Tạo file math.js chứa hàm:

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

Import vào app.js và hiển thị kết quả của:

sum(10, 20)
//bài giải:
import {sum} from "./math.js";

console.log(sum(10, 20));

Bài 2

Thêm hai hàm:

• sub()

• mul()

Import cả ba hàm và tính:

• 20 + 5

• 20 - 5

• 20 × 5

Bài giải:

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

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

export function mul(a, b) {
    return a * b;
}

import {sum, sub, mul} from "./math.js";

console.log(sum(20, 5));

console.log(sub(20, 5));

console.log(mul(20, 5));

Bài 3

Tạo hello.js sử dụng Default Export để in:

Hello Node.js!

Sau đó import và gọi hàm trong app.js.

Bài giải:

export default function hello() {
    console.log("Hello Node.js");
}

import hello from "./hello.js";

hello();

Bài 4

Khởi tạo một project mới bằng:

npm init -y

Mở package.json và giải thích ý nghĩa của các trường:

• name (tên project)

• version (phiên bản)

• type (kiểu module)

Bài 5 ⭐ Thử thách

Tạo project với cấu trúc:

node-basic
│
├── app.js
├── package.json
└── utils
    ├── math.js
    └── string.js

Trong đó:

• math.js chứa các hàm tính toán (sum, sub).

• string.js chứa hàm chuyển chuỗi thành chữ in hoa (toUpperCase).

Import các module vào app.js và kiểm tra kết quả.

Bài Giải:

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

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

export function inHoa (s) {
    return String(s).toUpperCase();
}

import {sum, sub} from "./utils/math.js";

import {inHoa} from "./utils/string.js";

console.log(sum(5, 10));

console.log(sub(5, 10));

console.log(inHoa("hello node.js"));

📖 Bài tiếp theo: Bài 05 — npm: package.json, package-lock.json, dependencies, devDependencies và scripts.

x1

quay về MỤC LỤC

"Mọi lập trình viên Node.js đều bắt đầu từ một dòng lệnh đơn giản: node app.js. Từ đó, bạn sẽ khám phá cách chương trình giao tiếp với hệ điều hành và người dùng thông qua console, process, argv và readline."

Mục tiêu bài học

Sau bài học này, bạn sẽ:

• Biết cách tạo chương trình Node.js đầu tiên.

• Chạy file JavaScript bằng lệnh node.

• Sử dụng console để hiển thị thông tin.

• Hiểu đối tượng process.

• Đọc tham số dòng lệnh bằng process.argv.

• Nhập dữ liệu từ bàn phím bằng readline.
  

  

Chuẩn bị

Tạo thư mục mới:

node-basic

Mở thư mục bằng VS Code.

Tạo file:

app.js

Cấu trúc thư mục:

node-basic
│
└── app.js

Chương trình Node.js đầu tiên

Mở file app.js:

console.log("Hello Node.js!");

Lưu lại.

Mở Terminal:

node app.js

Kết quả:

Hello Node.js!

Xin chúc mừng!

Bạn vừa chạy thành công chương trình Node.js đầu tiên.

Chú ý: nhớ cd vào thư mục node-basic

Lệnh node

Node.js thực thi file JavaScript bằng lệnh:

node tên_file.js

Ví dụ:

node app.js

hoặc

node hello.js

Node sẽ:

1. Đọc file.

2. Biên dịch JavaScript bằng V8 Engine.

3. Thực thi chương trình.

4. Hiển thị kết quả.

Console

console là đối tượng dùng để hiển thị thông tin ra Terminal.

Ví dụ:

console.log("Xin chào!");

console.log(100);

console.log(true);

Kết quả:

Xin chào!
100
true

console.log()

Đây là hàm được sử dụng nhiều nhất.

const name = "An";

console.log(name);

Kết quả:

An

Hiển thị nhiều giá trị

const name = "An";
const age = 20;

console.log(name, age);

Kết quả:

An 20

Template Literal

const name = "An";
const age = 20;

console.log(`Tên: ${name}`);

console.log(`Tuổi: ${age}`);

Kết quả:

Tên: An

Tuổi: 20

Chú ý: dấu huyền backtick chứ k phải nháy đơn

Process

Node.js cung cấp đối tượng toàn cục:

process

Đây là cầu nối giữa chương trình Node.js và hệ điều hành.

Thông qua process, chúng ta có thể:

• biết hệ điều hành

• biết thư mục hiện tại

• đọc biến môi trường

• lấy tham số dòng lệnh

• kết thúc chương trình

process.version

Hiển thị phiên bản Node.js.

console.log(process.version);

Ví dụ:

v24.3.0

process.platform

Hiển thị hệ điều hành.

console.log(process.platform);

Ví dụ:

Windows

win32

Linux

linux

macOS

darwin

process.cwd()

Thư mục hiện tại.

console.log(process.cwd());

Ví dụ:

D:\Projects\node-basic

process.exit()

Kết thúc chương trình.

console.log("Bắt đầu");

process.exit();

console.log("Dòng này sẽ không chạy");

Kết quả:

Bắt đầu

process.argv

Đây là một trong những tính năng thú vị của Node.js.

argv là mảng chứa các tham số truyền vào từ Terminal.

Ví dụ:

node app.js Hello NodeJS

Trong chương trình:

console.log(process.argv);

Ví dụ kết quả:

[
'C:\\Program Files\\nodejs\\node.exe',
'D:\\node-basic\\app.js',
'Hello',
'NodeJS'
]

Lấy tham số đầu tiên

console.log(process.argv[2]);

Chạy:

node app.js ChatGPT

Kết quả:

ChatGPT

Ví dụ

const name = process.argv[2];

console.log(`Xin chào ${name}!`);

Chạy:

node app.js Minh

Kết quả:

Xin chào Minh!

Readline

Nếu argv nhận dữ liệu ngay khi chạy chương trình thì readline cho phép nhập dữ liệu trong lúc chương trình đang chạy.

Đầu tiên import module:

const readline = require("readline");

Tạo đối tượng:

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

Ví dụ nhập tên

const readline = require("readline");

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question("Tên của bạn là gì? ", (name) => {

    console.log(`Xin chào ${name}!`);

    rl.close();

});

Kết quả:

Tên của bạn là gì?

An

Xin chào An!

Nhập hai giá trị

const readline = require("readline");

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question("Số thứ nhất: ", (a) => {

    rl.question("Số thứ hai: ", (b) => {

        console.log(Number(a) + Number(b));

        rl.close();

    });

});

Kết quả:

Số thứ nhất: 10

Số thứ hai: 20

30

argv hay readline?

Một số lỗi thường gặp

Quên lưu file

Hello Node.js không thay đổi

Do chưa lưu file.

Sai tên file

node ap.js

Kết quả:

Cannot find module

Hãy kiểm tra đúng tên file.

Sai đường dẫn

Đang ở thư mục khác:

node app.js

Sẽ báo lỗi.

Kiểm tra bằng:

pwd

hoặc trên Windows:

cd

Thiếu rl.close()

Nếu quên:

rl.close();

Chương trình sẽ tiếp tục chờ nhập dữ liệu và không tự kết thúc.

Tổng kết

Qua bài học này, bạn đã biết:

• ✅ Tạo và chạy chương trình Node.js đầu tiên.

• ✅ Sử dụng lệnh node app.js.

• ✅ Hiểu cách dùng console.log() để hiển thị thông tin.

• ✅ Làm quen với đối tượng process và một số thuộc tính quan trọng như version, platform, cwd() và exit().

• ✅ Đọc tham số dòng lệnh bằng process.argv.

• ✅ Nhập dữ liệu từ bàn phím với readline.

Đây là những công cụ cơ bản nhưng sẽ xuất hiện thường xuyên trong suốt quá trình học Node.js.

Bài tập thực hành

Bài 1

Tạo file hello.js và hiển thị:

Xin chào Node.js!

Chạy chương trình bằng Terminal.

Bài 2

Viết chương trình hiển thị:

• Phiên bản Node.js.

• Hệ điều hành.

• Thư mục hiện tại.

Gợi ý:

• process.version

• process.platform

• process.cwd()

Bài 3

Viết chương trình nhận tên từ dòng lệnh và hiển thị:

Xin chào <tên>!

Ví dụ:

node app.js Lan

Kết quả:

Xin chào Lan!

Bài 4

Sử dụng readline để nhập:

• Họ tên

• Tuổi

Sau đó hiển thị:

Xin chào Nguyễn Văn A!

Bạn 20 tuổi.

Bài 5 ⭐ Thử thách

Viết chương trình nhập hai số bằng readline và hiển thị:

• Tổng

• Hiệu

• Tích

• Thương

Ví dụ:

Số thứ nhất: 12

Số thứ hai: 4

Tổng: 16

Hiệu: 8

Tích: 48

Thương: 3

📖 Bài tiếp theo: Bài 04 — Module trong Node.js: CommonJS, ES Module, export, import và package.json.

x1

quay về MỤC LỤC

"Một môi trường phát triển được cài đặt đúng ngay từ đầu sẽ giúp bạn tập trung vào việc học và xây dựng ứng dụng, thay vì mất thời gian xử lý các lỗi cấu hình."

Mục tiêu bài học

Sau bài học này bạn sẽ:

• Hiểu Node.js LTS là gì.

• Biết sự khác nhau giữa LTS và Current.

• Cài đặt Node.js thành công.

• Hiểu npm và npx.

• Cài đặt Visual Studio Code.

• Làm quen với Terminal.

• Kiểm tra môi trường phát triển đã sẵn sàng.

Node.js LTS là gì?

Node.js luôn có hai nhánh phát hành chính:

• LTS (Long Term Support)

• Current

LTS (Khuyến nghị)

Đây là phiên bản ổn định, được hỗ trợ lâu dài.

Phù hợp cho:

• học tập

• dự án thực tế

• doanh nghiệp

• production

Ưu điểm:

• ổn định

• ít lỗi

• tương thích nhiều thư viện

• được cập nhật bản vá bảo mật

Trong toàn bộ khóa học này, chúng ta sẽ sử dụng Node.js LTS (2026).

Current

Đây là phiên bản mới nhất.

Có:

• tính năng mới

• API mới

• hiệu năng mới

Tuy nhiên:

• chưa ổn định bằng LTS

• một số package có thể chưa hỗ trợ

Nếu mới học Node.js, không nên sử dụng Current.

Tải Node.js

Truy cập trang chủ:

https://nodejs.org

Bạn sẽ thấy hai nút:

Node.js LTS   ✅

Node.js Current

Hãy tải Node.js LTS.

Cài đặt Node.js

Windows

Chạy file:

node-vxx.x.x-x64.msi

Sau đó:

Next

↓

Next

↓

Install

↓

Finish

Không cần thay đổi thiết lập mặc định.

macOS

Có thể:

• tải trực tiếp từ website

• hoặc dùng Homebrew

Ví dụ:

brew install node

Linux

Ubuntu

sudo apt update

sudo apt install nodejs npm

Hoặc cài bằng Node Version Manager (nvm) để dễ quản lý nhiều phiên bản.

Kiểm tra cài đặt

Mở Terminal.

Gõ:

node -v

Ví dụ:

v24.x.x

Tiếp theo:

npm -v

Ví dụ:

11.x.x

Nếu xuất hiện số phiên bản nghĩa là cài đặt thành công.

Node.js và npm

Rất nhiều người mới học nhầm hai khái niệm này.

Node.js

Là JavaScript Runtime.

Ví dụ:

node app.js

Node sẽ chạy file JavaScript.

npm

npm là Node Package Manager.

Nó dùng để:

• cài thư viện

• cập nhật thư viện

• gỡ thư viện

• quản lý project

Ví dụ:

npm install express

npm sẽ tải Express về project.

Package là gì?

Package có thể hiểu là:

Một thư viện hoặc công cụ được cộng đồng Node.js phát triển và chia sẻ.

Ví dụ:

• Express

• Prisma

• Jest

• Socket.IO

• Multer

• dotenv

Thay vì tự viết mọi thứ từ đầu, chúng ta chỉ cần cài package phù hợp.

npx là gì?

Ngoài npm còn có:

npx

Rất nhiều người mới học thường nhầm giữa hai lệnh này.

npm

Dùng để cài đặt package.

Ví dụ:

npm install express

npx

Dùng để chạy package mà không cần cài đặt toàn cục.

Ví dụ:

npx create-next-app

hoặc:

npx prisma init

npx sẽ tải công cụ cần thiết (nếu chưa có) và chạy ngay.

Điều này giúp máy tính luôn gọn gàng và tránh cài đặt quá nhiều package toàn cục.

Cài đặt Visual Studio Code

Visual Studio Code (VS Code) là trình soạn thảo mã nguồn phổ biến nhất cho Node.js.

Ưu điểm:

• miễn phí

• nhẹ

• nhiều tiện ích mở rộng

• hỗ trợ Git

• tích hợp Terminal

• IntelliSense

• Debug

Đây sẽ là trình soạn thảo được sử dụng xuyên suốt khóa học.

Một số Extension nên cài

Sau khi cài VS Code, bạn nên cài thêm:

• ESLint — Kiểm tra lỗi cú pháp và các quy tắc viết mã JavaScript, giúp phát hiện lỗi sớm khi lập trình.

• Prettier - Code formatter — Tự động định dạng (format) mã nguồn theo một chuẩn thống nhất, giúp code dễ đọc và nhất quán.

• Error Lens — Hiển thị lỗi và cảnh báo trực tiếp ngay trên dòng mã trong VS Code, không cần di chuột để xem.

• GitLens — Mở rộng khả năng làm việc với Git, cho biết ai sửa dòng code gần nhất, lịch sử commit và so sánh thay đổi.

• Material Icon Theme — Thay đổi biểu tượng (icon) của file và thư mục trong VS Code, giúp nhận biết loại file nhanh hơn.

• Docker (sẽ cài ở phần Docker của khóa học) — Hỗ trợ tạo, quản lý và chạy container Docker ngay trong VS Code, thuận tiện khi triển khai ứng dụng.

💡 Lời khuyên cho người mới học: Chỉ cần cài ESLint, Prettier, Error Lens và Material Icon Theme là đủ để bắt đầu. GitLens sẽ hữu ích khi học Git, còn Docker hãy cài khi đến Phần 15 — Triển khai để tránh làm môi trường phát triển trở nên phức tạp quá sớm.

Terminal là gì?

Terminal là nơi chúng ta giao tiếp với hệ điều hành bằng dòng lệnh.

Trong khóa học, gần như mọi thao tác đều sử dụng Terminal.

Ví dụ:

Khởi tạo project:

npm init

Cài package:

npm install express

Chạy chương trình:

node app.js

Chạy script:

npm run dev

Mở Terminal trong VS Code

Có nhiều cách:

Menu

Terminal

↓

New Terminal

Hoặc phím tắt:

Windows/Linux

Ctrl + `

macOS

Control + `

Terminal sẽ xuất hiện ở phía dưới VS Code.

Kiểm tra môi trường phát triển

Hãy chạy lần lượt các lệnh sau:

node -v

npm -v

npx -v

Nếu cả ba đều hiển thị phiên bản, môi trường của bạn đã sẵn sàng để học Node.js.

Một số lỗi thường gặp

Không nhận lệnh node

Ví dụ:

'node' is not recognized as an internal or external command

Nguyên nhân:

• Node.js chưa được cài đặt.

• Chưa thêm vào biến môi trường (PATH).

• Cần mở lại Terminal sau khi cài đặt.

Không nhận lệnh npm

Ví dụ:

'npm' is not recognized...

Thường xảy ra khi:

• cài đặt Node.js chưa hoàn tất

• PATH bị lỗi

Hãy cài đặt lại Node.js LTS và khởi động lại Terminal.

Sai phiên bản Node.js

Nếu máy đã cài nhiều phiên bản Node.js, bạn có thể gặp lỗi không đúng phiên bản mong muốn.

Giải pháp phổ biến là sử dụng nvm (Node Version Manager) để quản lý nhiều phiên bản Node.js trên cùng một máy.

Tổng kết

Qua bài học này, bạn đã biết:

• ✅ Node.js LTS là phiên bản ổn định, phù hợp cho học tập và phát triển ứng dụng.

• ✅ Biết cách cài đặt Node.js trên Windows, macOS và Linux.

• ✅ Hiểu sự khác nhau giữa Node.js, npm và npx.

• ✅ Cài đặt Visual Studio Code và làm quen với Terminal.

• ✅ Kiểm tra môi trường phát triển bằng các lệnh node -v, npm -v và npx -v.

Đến đây, máy tính của bạn đã sẵn sàng để bắt đầu viết những chương trình Node.js đầu tiên.

Bài tập thực hành

Bài 1

Cài đặt Node.js LTS trên máy tính của bạn và kiểm tra bằng các lệnh:

node -v
npm -v
npx -v

Ghi lại kết quả hiển thị.

Bài 2

Giải thích ngắn gọn sự khác nhau giữa:

• Node.js

• npm

• npx

Bài 3

Cho biết sự khác nhau giữa Node.js LTS và Node.js Current. Theo bạn, người mới học nên sử dụng phiên bản nào? Vì sao?

Bài 4

Mở Terminal trong VS Code và thực hiện các lệnh sau:

node -v

npm -v

npx -v

Chụp màn hình hoặc ghi lại kết quả để xác nhận môi trường phát triển của bạn đã được cài đặt thành công.

📖 Bài tiếp theo: Bài 03 — Chương trình Node.js đầu tiên: node app.js, console, process, argv và readline.

Errors log:

VSCode k suggest các objects của NodeJS.

Điều này bình thường. ESLint không có chức năng gợi ý (IntelliSense) cho process hay các API của Node.js.

Nguyên nhân thường là VS Code chưa biết project của bạn là môi trường Node.js.

Hãy kiểm tra từng bước:

1. Bạn đang mở thư mục project hay chỉ mở một file app.js?

Nên mở:

File
└── Open Folder...

Ví dụ:

node-basic/
├── app.js
└── package.json

Không nên chỉ mở riêng app.js.

2. Đã có package.json chưa?

Nếu chưa:

npm init -y

3. Cài Type Definitions của Node.js

Trong Terminal:

npm install -D @types/node

Mặc dù bạn viết JavaScript, package này giúp VS Code hiểu các API của Node.js (process, Buffer, setTimeout,...).

4. Kiểm tra Language Mode

Góc dưới bên phải VS Code phải là:

JavaScript

hoặc

TypeScript

Không phải:

Plain Text

5. Thử gõ

process.

Sau dấu . có hiện:

• argv

• cwd

• env

• exit

• platform

• version

không?

x1

quay về MỤC LỤC

Mình sẽ thiết kế theo cùng triết lý: từ nền tảng → thực chiến → triển khai, cập nhật theo hệ sinh thái Node.js năm 2026 (Node.js LTS, Express 5, TypeScript, Prisma, Docker...). 

Lộ trình này cũng phù hợp để tiếp nối sau khóa JavaScript ES2026 hoặc dành cho người đã biết PHP/Laravel muốn chuyển sang Node.js.

Nếu cập nhật theo Node.js LTS (2026) thì mình sẽ chia thành các phần như sau để người học đi từ JavaScript → Node.js → Xây dựng REST API → Triển khai dự án thực tế.

Tiếp nối khóa "JavaScript ES2026 — Tự học JavaScript từ ZERO đến Web Developer"

📘 PHẦN 1 — LÀM QUEN VỚI NODE.JS

Bài 01 — Node.js là gì?

• JavaScript Runtime

• V8 Engine

• Event Loop

• Non-blocking I/O

• Khi nào nên dùng Node.js?

Bài 02 — Cài đặt Node.js

• Node.js LTS

• npm

• npx

• VS Code

• Terminal

Bài 03 — Chương trình Node đầu tiên

• node app.js

• console

• process

• argv

• readline

Bài 04 — Module

• CommonJS

• ES Module

• export

• import

• package.json

Bài 05 — npm

• package.json

• package-lock.json

• dependencies

• devDependencies

• scripts

📘 PHẦN 2 — NODE.JS CORE

Bài 06 — File System (fs)

Bài 07 — Path

Bài 08 — OS

Bài 09 — Events

Bài 10 — Streams & Buffer

📘 PHẦN 3 — ASYNCHRONOUS

Bài 11 — Callback

Bài 12 — Promise

Bài 13 — Async / Await

Bài 14 — Event Loop

Bài 15 — Error Handling

📘 PHẦN 4 — HTTP SERVER

Bài 16 — HTTP Module

Bài 17 — Request

Bài 18 — Response

Bài 19 — Routing thủ công

Bài 20 — JSON API

📘 PHẦN 5 — EXPRESS.JS

Bài 21 — Express là gì?

Bài 22 — Routing

Bài 23 — Middleware

Bài 24 — Static Files

Bài 25 — Template Engine (EJS)

📘 PHẦN 6 — DATABASE

Bài 26 — MongoDB

Bài 27 — Mongoose

Bài 28 — CRUD MongoDB

Bài 29 — PostgreSQL

Bài 30 — Prisma ORM

📘 PHẦN 7 — REST API

Bài 31 — RESTful API

Bài 32 — HTTP Status Code

Bài 33 — CRUD API

Bài 34 — API Testing (Postman)

Bài 35 — Validation

📘 PHẦN 8 — AUTHENTICATION

Bài 36 — Password Hash

Bài 37 — JWT

Bài 38 — Login

Bài 39 — Register

Bài 40 — Authorization

📘 PHẦN 9 — UPLOAD & STORAGE

Bài 41 — Multer

Bài 42 — Upload Image

Bài 43 — Cloudinary

Bài 44 — Static File

📘 PHẦN 10 — NÂNG CAO

Bài 45 — Environment (.env)

Bài 46 — Logging

Bài 47 — CORS

Bài 48 — Cookie

Bài 49 — Session

Bài 50 — Rate Limit

📘 PHẦN 11 — TESTING

Bài 51 — Jest

Bài 52 — Unit Test

Bài 53 — Integration Test

📘 PHẦN 12 — REALTIME

Bài 54 — WebSocket

Bài 55 — Socket.IO

Bài 56 — Chat Realtime

📘 PHẦN 13 — CACHE

Bài 57 — Redis

Bài 58 — Cache API

Bài 59 — Queue

📘 PHẦN 14 — TYPESCRIPT

Bài 60 — TypeScript cơ bản

Bài 61 — Interface

Bài 62 — Generic

Bài 63 — Type cho Express

Bài 64 — Build Project

📘 PHẦN 15 — TRIỂN KHAI

Bài 65 — PM2

Bài 66 — Docker

Bài 67 — Docker Compose

Bài 68 — Nginx Reverse Proxy

Bài 69 — VPS Linux

Bài 70 — Production Tips

🎯 DỰ ÁN CUỐI KHÓA

🛒 RESTful E-Commerce API

• Authentication (JWT)

• Users

• Products

• Categories

• Orders

• Upload Images

• Pagination

• Search

• Filter

• Role Admin/User

• Redis Cache

• Docker

• Deploy VPS

🎯 MỤC TIÊU SAU KHÓA

✅ Thành thạo Node.js LTS

✅ Hiểu Event Loop và Asynchronous Programming

✅ Xây dựng REST API chuyên nghiệp

✅ Làm việc với MongoDB và PostgreSQL

✅ Thành thạo Express.js

✅ Xác thực bằng JWT

✅ Upload và quản lý file

✅ Viết Unit Test và Integration Test

✅ Triển khai ứng dụng bằng Docker và PM2

✅ Đủ nền tảng để học tiếp:

• NestJS

• Fastify

• GraphQL

• Microservices

• RabbitMQ

• Kafka

• gRPC

• Kubernetes

• CI/CD

• AWS

• Azure

• Google Cloud

📚 Tổng kết

• 70 bài học từ cơ bản đến nâng cao.

• Bám sát hệ sinh thái Node.js hiện đại năm 2026.

• Đi từ Node.js Core → Express → Database → REST API → Authentication → Docker → Deploy.

• Có dự án cuối khóa đủ quy mô để đưa vào portfolio hoặc làm nền tảng phát triển các ứng dụng thực tế.

Sau khi hoàn thành, người học có thể tự tin phát triển các backend hiện đại hoặc tiếp tục học NestJS để xây dựng các hệ thống lớn theo kiến trúc doanh nghiệp.