Khác biệt giữa Primitive Data Types và Objects trong JavaScript

JavaScript chia kiểu dữ liệu thành 2 nhóm chính: Primitive (nguyên thủy) và Object (tham chiếu). Hiểu sự khác biệt cốt lõi giúp tránh bug về so sánh, gán giá trị và truyền tham số.

Primitive Data Types (7 kiểu)

Giá trị bất biến (immutable), lưu trực tiếp trong stack, so sánh bằng giá trị.

Kiểu	Ví dụ	Mô tả
`string`	"hello", 'world', `hi`	Chuỗi ký tự
`number`	42, 3.14, NaN, Infinity	Số (có NaN, Infinity)
`boolean`	true, false	Logic
`undefined`	undefined	Chưa gán giá trị
`null`	null	Rỗng cố ý
`symbol`	Symbol('id')	Duy nhất, không thể trùng (ES6)
`bigint`	9007199254740991n	Số nguyên lớn (ES2020)

Object (Kiểu tham chiếu)

Có thể biến đổi (mutable), lưu trong heap, biến lưu tham chiếu (địa chỉ), so sánh bằng tham chiếu.

// Object literal
const user = { name: "An", age: 25 };

// Array (cũng là object)
const colors = ["red", "green"];

// Function (cũng là object)
function greet() {}

// Date, RegExp, Map, Set, WeakMap, WeakSet...

So sánh cốt lõi

Đặc điểm	Primitive	Object
Lưu trữ	Stack (giá trị trực tiếp)	Heap (tham chiếu)
Gán biến	Copy giá trị	Copy tham chiếu
So sánh `===`	So sánh giá trị	So sánh tham chiếu
Tính bất biến	Immutable	Mutable
Phương thức	Có (tự động wrap tạm)	Có (method thực sự)

Ví dụ minh họa

// Primitive: copy giá trị
let a = 10;
let b = a;
b = 20;
console.log(a); // 10 (không đổi)

// Object: copy tham chiếu
let obj1 = { x: 10 };
let obj2 = obj1;
obj2.x = 20;
console.log(obj1.x); // 20! (đã thay đổi)

// So sánh object
{} === {}; // false (khác tham chiếu)
const o = {}; o === o; // true (cùng tham chiếu)

Primitive Wrapper Objects

JS tự động wrap primitive thành object khi truy cập phương thức:


"hello".toUpperCase(); // Tạo tạm String object, gọi method, rồi hủy
// Tương tự: new String("hello").toUpperCase()

Khi nào dùng Object wrapper?

Hầu như không bao giờ cần new String(), new Number(), new Boolean(). Chúng gây nhầm lẫn:


typeof "hello";        // "string"
typeof new String("hello"); // "object"
new String("a") === new String("a"); // false!

Tóm tắt

Primitive: đơn giản, nhanh, an toàn, bất biến.
Object: phức tạp, linh hoạt, mutable, chia sẻ trạng thái.
Luôn ưu tiên primitive khi có thể.