JavaScript nổi tiếng không chỉ vì khả năng xây dựng các ứng dụng web hiện đại, mà còn bởi những biểu thức “khó tin” khiến nhiều lập trình viên phải dừng lại suy nghĩ. Một ví dụ kinh điển là:
{} + [] // 0
Thoạt nhìn, kết quả này có vẻ giống một lỗi của ngôn ngữ. Làm sao một object rỗng cộng với một array rỗng lại cho ra số 0? Câu trả lời nằm ở hai cơ chế quan trọng của JavaScript:
- Quy tắc phân tích cú pháp dựa trên ngữ cảnh.
- Cơ chế chuyển đổi kiểu dữ liệu ngầm, hay còn gọi là type coercion.
JavaScript không bị hỏng. Trình thông dịch chỉ đang áp dụng chính xác các quy tắc đã được đặc tả từ lâu để duy trì khả năng tương thích với hàng triệu đoạn mã cũ.
Mục lục
{} + [] thực sự được JavaScript hiểu như thế nào?
Khi đặt biểu thức sau ở đầu một câu lệnh trong một script JavaScript thông thường:
{} + []
JavaScript không nhất thiết hiểu {} là một object literal. Thay vào đó, trình phân tích cú pháp có thể tách nó thành hai phần:
{} // Một block rỗng
+[] // Toán tử cộng một ngôi áp dụng cho array rỗng
Điều này có nghĩa là biểu thức trên tương đương về mặt logic với:
{
// Không có lệnh nào bên trong block
}
+[] // Kết quả là 0
Phần {} đầu tiên là một empty block, tức một khối lệnh rỗng. Nó không phải object và không tạo ra giá trị nào để tham gia phép cộng.
Phần thực sự tạo ra kết quả là +[].
Tại sao +[] lại bằng 0?
Dấu cộng đứng trước một giá trị được gọi là unary plus, hay toán tử cộng một ngôi. Không giống dấu cộng nhị phân dùng để cộng hai toán hạng hoặc nối chuỗi, unary plus có nhiệm vụ chính là chuyển giá trị sang kiểu số.
+value
Về cơ bản, biểu thức này tương tự:
Number(value)
Vì vậy:
+[]
có thể được hiểu gần như:
Number([])
Nhưng một array là object, không phải kiểu nguyên thủy như number hoặc string. Trước khi chuyển sang số, JavaScript cần chuyển array thành một giá trị nguyên thủy.
Bước 1: Array rỗng được chuyển thành chuỗi rỗng
Khi JavaScript cần biểu diễn một array dưới dạng chuỗi, phương thức toString() của array được sử dụng. Với array rỗng:
[].toString() // ""
Do đó, array rỗng được chuyển thành chuỗi rỗng:
[] → ""
Bước 2: Chuỗi rỗng được chuyển thành số 0
Tiếp theo, JavaScript chuyển chuỗi rỗng thành number:
Number("") // 0
Vì vậy, toàn bộ quá trình có thể mô tả như sau:
+[]
↓
Number([])
↓
Number("")
↓
0
Kết quả cuối cùng:
+[] // 0
Và đó chính là lý do biểu thức ban đầu cho ra:
{} + [] // 0
Vai trò của quy tắc phân tích cú pháp trong JavaScript
Điểm gây nhầm lẫn lớn nhất không nằm ở phép chuyển đổi array sang số, mà nằm ở cách JavaScript đọc dấu ngoặc nhọn {}.
Trong JavaScript, cùng một ký hiệu có thể mang ý nghĩa khác nhau tùy vào vị trí xuất hiện:
{}có thể là một object literal.{}cũng có thể là một block rỗng.{}có thể xuất hiện trong destructuring hoặc trong phần thân hàm.
Khi một câu lệnh bắt đầu bằng dấu ngoặc nhọn, parser thường ưu tiên cách hiểu nó như một block lệnh. Đây là lý do biểu thức:
{} + []
có thể được diễn giải là:
{} // block rỗng
+[] // unary plus
Trong khi đó, nếu đặt {} trong một ngữ cảnh chắc chắn là biểu thức, JavaScript sẽ hiểu nó là object.
Cách buộc JavaScript hiểu {} là object
Để tránh việc dấu ngoặc nhọn bị phân tích thành block, bạn có thể đặt toàn bộ biểu thức trong dấu ngoặc tròn:
({} + [])
Lúc này, kết quả thường là:
"[object Object]"
Dấu ngoặc tròn cho parser biết rằng nội dung bên trong là một biểu thức. Vì vậy, {} được hiểu là object literal chứ không phải block.
Một số ví dụ khác:
console.log({} + []); // "[object Object]"
const result = ({} + []);
console.log(result); // "[object Object]"
Trong lời gọi hàm, phần bên trong dấu ngoặc của hàm cũng là một biểu thức. Do đó, đoạn mã sau được hiểu theo cách khác:
console.log({} + []);
Ở đây, {} là object rỗng và [] là array rỗng. Hai giá trị này được xử lý bởi toán tử cộng nhị phân.
Vì sao [] + [] lại trả về chuỗi rỗng?
Hãy xét biểu thức:
[] + []
Đây là phép cộng nhị phân. Khi sử dụng toán tử +, JavaScript phải xác định nên thực hiện phép cộng số học hay phép nối chuỗi.
Hai array rỗng lần lượt được chuyển thành chuỗi:
[].toString() // ""
[].toString() // ""
Sau đó JavaScript thực hiện:
"" + "" // ""
Vì thế:
[] + [] // ""
Không có phép cộng số học nào thực sự xảy ra. Đây là phép nối hai chuỗi rỗng.
Vì sao [] + {} cho kết quả khác {} + []?
Hai biểu thức sau trông gần như giống nhau:
{} + []
[] + {}
Tuy nhiên, kết quả lại khác:
{} + [] // 0, trong một số ngữ cảnh script
[] + {} // "[object Object]"
Nguyên nhân là biểu thức thứ nhất có thể bị tách thành block rỗng và unary plus, trong khi biểu thức thứ hai rõ ràng là phép cộng giữa hai toán hạng.
Phân tích [] + {}
Array rỗng được chuyển thành chuỗi:
[].toString() // ""
Object thông thường được chuyển thành chuỗi:
({}).toString() // "[object Object]"
Do đó, JavaScript thực hiện tương đương:
"" + "[object Object]"
Kết quả:
[] + {} // "[object Object]"
Phân tích ({} + [])
Trong trường hợp này, cả hai toán hạng đều nằm trong một biểu thức rõ ràng:
({} + [])
Object rỗng được chuyển thành chuỗi:
({}).toString() // "[object Object]"
Array rỗng được chuyển thành chuỗi rỗng:
[].toString() // ""
Sau đó:
"[object Object]" + "" // "[object Object]"
Toán tử + trong JavaScript hoạt động như thế nào?
Toán tử cộng trong JavaScript có hai vai trò chính:
- Cộng số học.
- Nối chuỗi.
Việc lựa chọn hành vi nào phụ thuộc vào kiểu dữ liệu sau quá trình chuyển đổi.
Ví dụ về phép cộng số học
2 + 3 // 5
Ví dụ về phép nối chuỗi
"2" + 3 // "23"
3 + "2" // "32"
Nếu một trong hai toán hạng sau khi chuyển đổi là string, toán tử + thường thực hiện nối chuỗi thay vì cộng số.
Đây là lý do các biểu thức với array và object có thể tạo ra kết quả khó đoán:
[] + 1 // "1"
[1] + 1 // "11"
[1, 2] + 1 // "1,21"
{} + "" // phụ thuộc ngữ cảnh
Array được chuyển thành chuỗi bằng cách nối các phần tử bằng dấu phẩy:
[1, 2, 3].toString() // "1,2,3"
[1].toString() // "1"
[].toString() // ""
Cơ chế ToPrimitive: JavaScript lấy giá trị nguyên thủy như thế nào?
Đằng sau các kết quả trên là cơ chế gọi là ToPrimitive. JavaScript sử dụng cơ chế này khi cần chuyển một object thành giá trị nguyên thủy, chẳng hạn như string, number hoặc bigint.
Với nhiều object thông thường, quá trình này có thể liên quan đến:
valueOf()toString()- Phương thức đặc biệt
Symbol.toPrimitive, nếu object có định nghĩa
Ví dụ với array:
const values = [];
values.toString(); // ""
values.valueOf(); // chính array values
Trong nhiều tình huống liên quan đến chuỗi, array được chuyển thành kết quả từ toString().
Với object thông thường:
const object = {};
object.toString(); // "[object Object]"
object.valueOf(); // object
Chuỗi "[object Object]" là biểu diễn mặc định của object thông thường khi chuyển sang string. Nó không có nghĩa object chứa một thuộc tính đặc biệt tên là object; đây chỉ là định dạng chuỗi mặc định do Object.prototype.toString() trả về.
So sánh unary plus và binary plus
Hai biểu thức sau sử dụng cùng một ký hiệu nhưng có vai trò khác nhau:
+[] // unary plus
[] + [] // binary plus
Unary plus
Unary plus chỉ có một toán hạng và thường dùng để chuyển đổi giá trị thành number:
+"42" // 42
+true // 1
+false // 0
+"" // 0
+[] // 0
+[5] // 5
Binary plus
Binary plus có hai toán hạng và có thể thực hiện phép cộng hoặc nối chuỗi:
1 + 2 // 3
"Hello " + "JS" // "Hello JS"
[] + [] // ""
[] + {} // "[object Object]"
Việc phân biệt hai dạng toán tử này giúp giải thích chính xác vì sao {} + [] có thể tạo ra số 0.
Các kết quả JavaScript “kỳ lạ” liên quan đến ép kiểu
Biểu thức {} + [] chỉ là một trong nhiều ví dụ cho thấy type coercion trong JavaScript đôi khi tạo ra kết quả bất ngờ.
Number("") // 0
Number(" ") // 0
Number(null) // 0
Number(false) // 0
Number(undefined) // NaN
Number("hello") // NaN
Một số phép so sánh cũng có hành vi khác nhau tùy toán tử:
0 == false // true
0 === false // false
"" == 0 // true
"" === 0 // false
Toán tử == cho phép chuyển đổi kiểu trước khi so sánh, trong khi === yêu cầu cả kiểu dữ liệu và giá trị phải giống nhau.
Trong mã nguồn thực tế, sử dụng === và !== thường giúp giảm các lỗi phát sinh từ chuyển đổi kiểu ngầm.
Kiểm tra bằng trình duyệt hoặc Node.js
Khi thử các biểu thức này, bạn cần chú ý môi trường thực thi. Console của trình duyệt, Node.js, script cổ điển và JavaScript module có thể hiển thị kết quả khác nhau vì cách chúng bao quanh hoặc phân tích đoạn mã không hoàn toàn giống nhau.
Ví dụ, hãy thử đặt biểu thức trong các hình thức khác nhau:
// Có thể được phân tích như block rỗng + unary plus
{} + []
// Ép {} trở thành object literal
({} + [])
// Đặt trong lời gọi hàm
console.log({} + [])
// Gán vào biến
const result = {} + [];
console.log(result);
Trong môi trường tương tác như DevTools Console, trình duyệt có thể áp dụng quy tắc đặc biệt để đánh giá biểu thức được nhập. Vì vậy, kết quả quan sát trực tiếp trong console không phải lúc nào cũng phản ánh chính xác cách một file JavaScript độc lập được parser xử lý.
Vì sao JavaScript vẫn giữ những quy tắc này?
JavaScript được tạo ra vào giữa thập niên 1990 và phải phát triển trong thời kỳ trình duyệt cạnh tranh gay gắt. Qua nhiều năm, ngôn ngữ này đã được bổ sung hàng loạt tính năng mới, nhưng vẫn phải duy trì khả năng chạy các website cũ.
Đây là nguyên tắc quan trọng trong quá trình phát triển ECMAScript: hạn chế phá vỡ hành vi hiện có. Nếu một thay đổi nhỏ khiến các website cũ ngừng hoạt động, tác động sẽ rất lớn vì JavaScript được sử dụng trên hầu như mọi nền tảng web.
Những hành vi như:
- Cách parser phân biệt block và object literal.
- Cách array chuyển thành string.
- Cách toán tử
+xử lý nhiều kiểu dữ liệu. - Cách các object thực hiện ToPrimitive.
đều đã trở thành một phần của hành vi được chuẩn hóa và được nhiều chương trình phụ thuộc.
Vì vậy, “sự kỳ quặc” của JavaScript không dễ dàng biến mất. Thay đổi chúng có thể làm hỏng mã nguồn đang chạy ổn định trong nhiều năm.
Những cách viết mã nên ưu tiên trong dự án thực tế
Dù các biểu thức như {} + [] rất thú vị để tìm hiểu về JavaScript, bạn không nên sử dụng chúng trong mã nguồn sản xuất. Chúng khó đọc, dễ gây hiểu nhầm và phụ thuộc nhiều vào ngữ cảnh.
Thay vì dựa vào ép kiểu ngầm, hãy chuyển đổi kiểu dữ liệu một cách rõ ràng:
const numberValue = Number(input);
const stringValue = String(value);
const booleanValue = Boolean(value);
Nếu muốn kiểm tra array:
Array.isArray(value)
Nếu cần kiểm tra kiểu dữ liệu cơ bản:
typeof value === "string"
typeof value === "number"
typeof value === "object"
Để kiểm tra object không phải null:
value !== null && typeof value === "object"
Ngoài ra, nên đặt object literal trong ngữ cảnh rõ ràng:
const object = {};
const combined = object + [];
Hoặc sử dụng template literal khi cần nối chuỗi:
const message = `${object}${array}`;
Bảng tóm tắt các biểu thức quan trọng
| Biểu thức | Kết quả thường gặp | Giải thích |
|---|---|---|
+[] |
0 |
Array rỗng → chuỗi rỗng → số 0 |
[] + [] |
"" |
Hai array trở thành hai chuỗi rỗng |
[] + {} |
"[object Object]" |
Chuỗi rỗng nối với chuỗi mặc định của object |
({} + []) |
"[object Object]" |
Dấu ngoặc tròn buộc {} được hiểu là object |
{} + [] |
0 trong một số ngữ cảnh |
{} được phân tích thành block, còn +[] cho kết quả 0 |
Kết luận: JavaScript không bị lỗi, chỉ đang tuân thủ đặc tả
Biểu thức:
{} + [] // 0
không phải là bằng chứng cho thấy JavaScript hoạt động ngẫu nhiên. Kết quả này xuất phát từ sự kết hợp của nhiều quy tắc hợp lệ:
{}ở đầu câu lệnh có thể được hiểu là một block rỗng.+[]sử dụng unary plus để chuyển array rỗng thành number.- Array rỗng được chuyển thành chuỗi rỗng.
- Chuỗi rỗng khi chuyển sang number sẽ trở thành
0.
Nếu viết:
({} + [])
thì dấu ngoặc tròn thay đổi ngữ cảnh phân tích cú pháp và kết quả trở thành:
"[object Object]"
Đây là một ví dụ điển hình cho thấy JavaScript chịu ảnh hưởng mạnh bởi ngữ cảnh, ép kiểu và khả năng tương thích ngược. Hiểu được các nguyên tắc này sẽ giúp bạn đọc mã JavaScript chính xác hơn, tránh những lỗi khó tìm và viết chương trình rõ ràng, an toàn hơn.



