Biến & kiểu dữ liệu JavaScript

Biến là cái tên bạn đặt cho một giá trị. JavaScript hiện đại có hai cách khai báo: let (đổi được) và const (không gán lại). Cả hai đều block-scope - chỉ sống trong cặp { } chứa nó.

let diem = 8;        // doi duoc
diem = 9;            // OK

const ten = "Lan";   // khong gan lai
// ten = "Hoa";      // TypeError: Assignment to constant variable

// const KHONG dong bang object - chi chan gan lai bien:
const sv = { ten: "Lan" };
sv.ten = "Hoa";      // OK (van sua duoc thuoc tinh)

• ▸Mặc định dùng const; chỉ dùng let khi thật sự cần gán lại.
• ▸let và const đều block-scope - sống trong cặp { } gần nhất.
• ▸const chặn GÁN LẠI biến, không “đóng băng” object (vẫn sửa được thuộc tính).

JavaScript có 7 kiểu nguyên thuỷ (primitive): number, string, boolean, null, undefined, bigint, symbol - cộng với object (gồm cả mảng và hàm). Toán tử typeof cho biết kiểu của một giá trị:

typeof 42            // "number"
typeof "hi"          // "string"
typeof true          // "boolean"
typeof undefined     // "undefined"
typeof 10n           // "bigint"
typeof Symbol()      // "symbol"

typeof null          // "object"    <- bug lich su!
typeof {}            // "object"
typeof [1, 2]        // "object"    (mang la object - dung Array.isArray)
typeof function(){}  // "function"

• ▸7 kiểu nguyên thuỷ: number, string, boolean, null, undefined, bigint, symbol.
• ▸Mọi thứ còn lại (mảng, hàm, ngày tháng…) đều là object.
• ▸typeof cho biết kiểu - nhưng có vài “quirk” cần nhớ (xem callout).

Khác C hay Python (có int và float riêng), JavaScript chỉ có một kiểu số dùng hằng ngày: number, chính là double IEEE 754 (64-bit). Số nguyên hay số thực đều dùng chung kiểu này (BigInt là kiểu riêng, chỉ dành cho số nguyên cực lớn) - tiện, nhưng kéo theo bẫy số thực gần đúng:

typeof 7        // "number"
typeof 7.5      // "number"   (cung mot kieu!)

0.1 + 0.2       // 0.30000000000000004
0.1 + 0.2 === 0.3   // false

1 / 0           // Infinity
0 / 0           // NaN  (Not a Number)
Number.isInteger(7)   // true

9007199254740993n     // so nguyen RAT lon -> dung BigInt (hau to n)

Hệ quả nguy hiểm nhất là khi xử lý tiền. Cộng 0.10 nhiều lần bằng number - nó trông đúng nhưng không đúng:

• ▸JS chỉ có một kiểu number = double IEEE 754; không tách int/float.
• ▸number là số GẦN ĐÚNG: đừng so hai number bằng === sau khi tính toán.
• ▸Có NaN (không phải số) và Infinity; số nguyên cực lớn dùng BigInt (10n).
• ▸TIỀN: lưu bằng số nguyên đơn vị nhỏ nhất (xu) - đừng dùng number/float.

Chuỗi (string) đặt trong nháy đôi, nháy đơn, hoặc dấu huyền ` (template literal - chèn được biến). boolean chỉ có true/false. Còn hai “giá trị rỗng” hay nhầm lẫn: undefined (chưa gán) và null (cố ý rỗng).

const ten = "Lan";
const tuoi = 16;
const cau = `Meo con ${ten}, ${tuoi} tuoi`;   // template literal
console.log(cau);                               // Meo con Lan, 16 tuoi

let x;          // chua gan -> undefined
let y = null;   // co y de rong

Boolean("")     // false  (chuoi rong la falsy)
Boolean("0")    // true   (chuoi co ky tu -> truthy!)
Boolean([])     // true   (mang rong VAN truthy)

• ▸Template literal dùng dấu huyền và chèn biến, viết chuỗi nhiều dòng dễ dàng.
• ▸undefined = chưa gán (JS tự gán); null = cố ý để rỗng (bạn gán).
• ▸Mỗi giá trị có “tính đúng/sai” (truthy/falsy) khi đứng trong if.

Đây là chỗ JavaScript làm người mới đau đầu nhất. === so sánh cả kiểu lẫn giá trị, không ép kiểu - khác kiểu là false ngay. Còn == ép kiểu (coercion) hai bên về cùng kiểu RỒI mới so, sinh ra hàng loạt kết quả bất ngờ:

"5" - 2     // 3     (chuoi -> so)
"5" + 2     // "52"  (so -> chuoi; + uu tien NOI chuoi)

1 == "1"    // true   (ep kieu roi so)
1 === "1"   // false  (khac kieu -> false ngay)

0 == ""           // true
0 === ""          // false
null == undefined  // true
null === undefined // false
NaN === NaN        // false  (NaN khong bang ca chinh no!)

• ▸LUÔN dùng === và !== - bỏ qua == để tránh bẫy ép kiểu.
• ▸Cần đổi kiểu thì làm TƯỜNG MINH: Number(x), String(x), Boolean(x).
• ▸NaN không bằng chính nó: kiểm tra bằng Number.isNaN(x).