Tổng hợp các kiểu dữ liệu trong JavaScript

delete person.isMarried;
console.log(person);

for (let key in person) {
    console.log(`${key}: ${person[key]}`);
}

console.log("age" in person); // true
console.log("salary" in person); // false

Chức năng (Function) trong JavaScript

Định nghĩa và ví dụ sử dụng

Chức năng (Function) là một khối mã có thể tái sử dụng, giúp tổ chức chương trình dễ dàng hơn.

Ví dụ:

function greet(name) {
    return `Hello, ${name}!`;
}

console.log(greet("Alice")); // "Hello, Alice!"

Function là đối tượng đầu tiên trong JavaScript

Trong JavaScript, Function cũng là một đối tượng. Điều này có nghĩa là có thể:

• Gán function vào một biến.
• Truyền function như một đối số cho function khác.
• Trả về function từ một function.

Gán hàm vào biến

let sayHello = function(name) {
    return `Hello, ${name}!`;
};

console.log(sayHello("Bob"));

Truyền hàm làm đối số

function executeFunction(fn, value) {
    console.log(fn(value));
}

executeFunction(sayHello, "Charlie"); // "Hello, Charlie!"

Trả về một hàm

function multiplier(factor) {
    return function (number) {
        return number * factor;
    };
}

let double = multiplier(2);
console.log(double(5)); // 10

Kiểu dữ liệu và toán tử kiểu dữ liệu trong JavaScript

Trong JavaScript, việc kiểm tra và so sánh kiểu dữ liệu là rất quan trọng để đảm bảo chương trình hoạt động đúng cách. JavaScript cung cấp các toán tử giúp kiểm tra kiểu dữ liệu và hỗ trợ so sánh giữa các kiểu dữ liệu khác nhau.

Kiểm tra kiểu dữ liệu với toán tử typeof

Toán tử typeof trong JavaScript được sử dụng để xác định kiểu dữ liệu của một biến hoặc giá trị.

Cú pháp:

typeof variable;

Ví dụ:

console.log(typeof 42);            // "number"
console.log(typeof "Hello");       // "string"
console.log(typeof true);          // "boolean"
console.log(typeof undefined);     // "undefined"
console.log(typeof null);          // "object" (đây là một lỗi trong JavaScript)
console.log(typeof {});            // "object"
console.log(typeof []);            // "object"
console.log(typeof function() {}); // "function"

Lưu ý:

• typeof null trả về "object", mặc dù null không phải là đối tượng. Đây là một lỗi trong JavaScript nhưng vẫn được giữ lại vì lý do tương thích ngược.
• Mảng (Array) và đối tượng (Object) đều có kết quả là "object", nên để kiểm tra xem một biến có phải là mảng không, bạn nên sử dụng Array.isArray().

Kiểm tra mảng đúng cách:

let arr = [1, 2, 3];
console.log(Array.isArray(arr)); // true

So sánh các kiểu dữ liệu nguyên thủy và tham chiếu trong JavaScript

Ví dụ về sự khác biệt:

// Kiểu dữ liệu nguyên thủy
let a = 10;
let b = a; // Sao chép giá trị
b = 20;
console.log(a); // 10 (Không bị thay đổi)
console.log(b); // 20

// Kiểu dữ liệu tham chiếu
let obj1 = { name: "Alice" };
let obj2 = obj1; // Tham chiếu đến cùng một vùng nhớ
obj2.name = "Bob";
console.log(obj1.name); // "Bob" (Bị thay đổi)
console.log(obj2.name); // "Bob"

Khi nào nên sử dụng kiểu dữ liệu nguyên thủy và tham chiếu?

• Kiểu nguyên thủy: Dùng khi lưu trữ giá trị đơn lẻ, không cần thay đổi nội dung.
• Kiểu tham chiếu: Dùng khi lưu trữ dữ liệu có cấu trúc (danh sách, đối tượng) và cần thay đổi nội dung động.

Phân biệt khi so sánh kiểu dữ liệu trong JavaScript (== vs ===) trong JavaScript

JavaScript có hai toán tử so sánh chính:

• == (so sánh lỏng lẻo - Loose Equality): So sánh giá trị, tự động chuyển đổi kiểu dữ liệu nếu cần.
• === (so sánh chặt chẽ - Strict Equality): So sánh cả giá trị và kiểu dữ liệu, không có sự chuyển đổi kiểu.

Ví dụ về sự khác biệt giữa == và ===

console.log(5 == "5");  // true  (JavaScript tự động chuyển đổi "5" thành số 5)
console.log(5 === "5"); // false (Kiểu dữ liệu khác nhau: số vs chuỗi)

console.log(null == undefined);  // true  (Do JavaScript coi chúng là tương đương)
console.log(null === undefined); // false (Kiểu khác nhau: null vs undefined)

console.log(0 == false);  // true  (0 được coi là false trong JavaScript)
console.log(0 === false); // false (Số và boolean là kiểu khác nhau)

console.log([] == false);  // true  (Mảng rỗng được ép kiểu thành `""`, rồi thành `0`)
console.log([] === false); // false (Kiểu khác nhau: mảng vs boolean)

Quy tắc khi so sánh kiểu dữ liệu

• Luôn ưu tiên dùng === thay vì == để tránh các lỗi khó phát hiện.
• Dùng typeof trước khi so sánh nếu không chắc về kiểu dữ liệu.
• Cẩn thận khi so sánh với null và undefined, nên dùng ===.

Ví dụ: Kiểm tra giá trị hợp lệ trước khi so sánh

let input = "100";

if (typeof input === "number" && input === 100) {
    console.log("Giá trị hợp lệ");
} else {
    console.log("Giá trị không hợp lệ");
}

Chuyển đổi kiểu dữ liệu (Type Conversion) trong JavaScript

Trong JavaScript, kiểu dữ liệu của một giá trị có thể được chuyển đổi từ dạng này sang dạng khác. Có hai loại chuyển đổi kiểu dữ liệu:

• Chuyển đổi kiểu dữ liệu tự động (Implicit Conversion - Type Coercion)
• Chuyển đổi kiểu dữ liệu thủ công (Explicit Conversion - Type Casting)

Việc hiểu rõ các loại chuyển đổi này giúp lập trình viên kiểm soát tốt hơn cách JavaScript xử lý dữ liệu.

Chuyển đổi kiểu dữ liệu tự động (Implicit Conversion)

Chuyển đổi kiểu dữ liệu tự động xảy ra khi JavaScript tự động thay đổi kiểu của một giá trị để phù hợp với ngữ cảnh sử dụng. Điều này thường xảy ra trong các phép toán và so sánh.

Chuyển đổi chuỗi sang số

Khi thực hiện phép toán với chuỗi và số, JavaScript có thể tự động chuyển đổi chuỗi thành số nếu phép toán yêu cầu số học.

Ví dụ:

console.log("10" - 5); // 5  (Chuỗi "10" tự động chuyển thành số 10)
console.log("10" * 2); // 20 (Chuỗi "10" tự động chuyển thành số 10)
console.log("10" / 2); // 5  (Chuỗi "10" tự động chuyển thành số 10)
console.log("10" + 2); // "102" (Chuỗi + Số → Kết quả là chuỗi)

Lưu ý:

• Phép + trong JavaScript ưu tiên nối chuỗi nếu có ít nhất một toán hạng là chuỗi.
• Các toán tử -, *, / sẽ cố gắng chuyển đổi chuỗi thành số trước khi thực hiện phép toán.

Chuyển đổi số sang chuỗi

Nếu một số được sử dụng trong phép nối chuỗi, JavaScript sẽ tự động chuyển đổi số thành chuỗi.

Ví dụ:

console.log(5 + "5"); // "55" (Số 5 chuyển thành chuỗi "5", rồi nối với chuỗi "5")
console.log(true + " is a boolean"); // "true is a boolean"

Chuyển đổi boolean sang số và chuỗi

• Boolean → Số: true được chuyển thành 1, false được chuyển thành 0.
• Boolean → Chuỗi: true và false được chuyển thành "true" và "false" khi nối chuỗi.

Ví dụ:

console.log(true + 1); // 2  (true → 1, rồi 1 + 1 = 2)
console.log(false + 1); // 1  (false → 0, rồi 0 + 1 = 1)
console.log(true + " is correct"); // "true is correct"

Chuyển đổi null và undefined

• null được chuyển thành 0 khi sử dụng trong phép toán số học.
• undefined trở thành NaN (Not-a-Number) nếu tham gia phép toán số học.

Ví dụ:

console.log(null + 5); // 5  (null → 0)
console.log(undefined + 5); // NaN  (undefined không thể chuyển thành số)

Chuyển đổi kiểu dữ liệu thủ công (Explicit Conversion)

Chuyển đổi kiểu dữ liệu thủ công giúp lập trình viên kiểm soát cách dữ liệu được chuyển đổi bằng cách sử dụng các phương thức có sẵn trong JavaScript.

Chuyển đổi sang số (Number)

Có thể chuyển đổi một giá trị về dạng số bằng cách sử dụng:

• Number(value)
• parseInt(value) (chuyển thành số nguyên)
• parseFloat(value) (chuyển thành số thực)

Ví dụ:

console.log(Number("123")); // 123
console.log(Number("123.45")); // 123.45
console.log(Number("ABC")); // NaN (Không thể chuyển đổi chuỗi không chứa số)
console.log(parseInt("123.45")); // 123 (Chỉ lấy phần nguyên)
console.log(parseFloat("123.45")); // 123.45 (Lấy cả phần thập phân)
console.log(Number(true)); // 1
console.log(Number(false)); // 0
console.log(Number(null)); // 0
console.log(Number(undefined)); // NaN

Lưu ý:

• parseInt() chỉ lấy phần nguyên của số.
• parseFloat() giữ nguyên số thập phân.
• Nếu chuỗi chứa ký tự không phải số ("123abc"), parseInt() chỉ lấy phần số (123), còn Number() trả về NaN.

Chuyển đổi sang chuỗi (String)

Có thể chuyển đổi giá trị sang chuỗi bằng cách sử dụng:

• String(value)
• value.toString()

Ví dụ:

console.log(String(123)); // "123"
console.log(String(true)); // "true"
console.log((123).toString()); // "123"
console.log((false).toString()); // "false"

Lưu ý: null và undefined không thể sử dụng .toString(), chỉ có thể dùng String(value).

Chuyển đổi sang boolean (Boolean)

Có thể chuyển đổi giá trị sang boolean bằng cách sử dụng Boolean(value).

Giá trị "falsy" (trả về false):

• 0, -0
• "" (chuỗi rỗng)
• null, undefined
• NaN

Giá trị "truthy" (trả về true):

• Bất kỳ số nào khác 0
• Bất kỳ chuỗi nào khác ""
• true
• Các đối tượng ({}, [])

Ví dụ:

console.log(Boolean(0)); // false
console.log(Boolean(1)); // true
console.log(Boolean("")); // false
console.log(Boolean("Hello")); // true
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
console.log(Boolean([])); // true
console.log(Boolean({})); // true

Quy tắc quan trọng

• JavaScript có thể tự động chuyển đổi kiểu dữ liệu khi thực hiện phép toán hoặc so sánh.
• + có thể nối chuỗi, còn các phép toán khác sẽ cố gắng chuyển đổi thành số.
• Dùng Number(), String(), Boolean() để chuyển đổi thủ công thay vì dựa vào chuyển đổi tự động.
• Hạn chế sử dụng ==, thay vào đó nên dùng === để tránh lỗi do chuyển đổi kiểu không mong muốn.

Kết bài

Kiểu dữ liệu đóng vai trò quan trọng trong JavaScript, giúp lập trình viên quản lý và xử lý dữ liệu hiệu quả. Việc hiểu rõ sự khác biệt giữa kiểu dữ liệu nguyên thủy (Primitive Types) và kiểu dữ liệu tham chiếu (Reference Types) giúp tránh những lỗi phổ biến khi so sánh, gán giá trị hoặc chuyển đổi kiểu dữ liệu.

Ngoài ra, việc sử dụng đúng kiểu dữ liệu trong từng tình huống giúp tối ưu hóa hiệu suất và đảm bảo tính nhất quán của chương trình. Bằng cách áp dụng các kiến thức về kiểu dữ liệu vào thực tế, như xử lý dữ liệu đầu vào từ người dùng, tính toán trong ứng dụng thương mại điện tử hoặc quản lý danh sách sản phẩm, bạn có thể xây dựng những ứng dụng web mạnh mẽ và chính xác hơn.

Hãy luôn kiểm tra kiểu dữ liệu bằng typeof, sử dụng so sánh chặt chẽ (=== thay vì ==), và hiểu rõ cơ chế chuyển đổi kiểu để tránh các lỗi không mong muốn. Nắm vững kiến thức này sẽ giúp bạn viết code JavaScript hiệu quả, tối ưu và dễ bảo trì hơn.