Đã đăng vào thg 11 19, 2:51 SA 10 phút đọc

Giải mã ép kiểu trong JavaScript: từ cơ bản đến chuyên sâu

Trong JavaScript, các biến không yêu cầu khai báo kiểu cụ thể và có thể chứa giá trị của bất kỳ kiểu dữ liệu nào. Là một ngôn ngữ kiểu động, JavaScript tự động chuyển đổi các giá trị từ kiểu này sang kiểu khác trong hậu trường để đảm bảo mã của bạn chạy trơn tru. Mặc dù hành vi này giúp JavaScript linh hoạt hơn, nhưng nó cũng có thể dẫn đến những kết quả không mong muốn và lỗi khó tìm nếu bạn không quen thuộc với cách thức hoạt động của nó.

Đọc thêm: Cơ bản về Async Await trong Javascript

Trong bài đăng này, chúng ta sẽ tìm hiểu về ép kiểu trong JavaScript, bao gồm các loại ép kiểu khác nhau, các ví dụ và các phương pháp hay nhất để giúp bạn hiểu và kiểm soát mã của mình hiệu quả hơn.

Vậy ép kiểu là gì?

Ép kiểu đề cập đến việc chuyển đổi tự động hoặc thủ công một giá trị từ kiểu dữ liệu này sang kiểu dữ liệu khác. Ví dụ: chuyển đổi một chuỗi như “123” thành một số 123. Trong JavaScript, ép kiểu có thể thuộc hai loại:

Ép kiểu ngầm: Khi JavaScript tự động chuyển đổi một giá trị.
Ép kiểu tường minh: Khi bạn cố ý chuyển đổi một giá trị bằng cách sử dụng các hàm hoặc toán tử tích hợp sẵn.

Trước khi tìm hiểu về các loại ép kiểu khác nhau, điều quan trọng là phải hiểu các kiểu dữ liệu chính của JavaScript, vì ép kiểu luôn liên quan đến việc chuyển đổi giữa chúng.

Kiểu dữ liệu trong JavaScript

1. Kiểu nguyên thủy:

Number (ví dụ: 42, 3.14, NaN)
String (ví dụ: "hello", '123')
Boolean (ví dụ: true, false)
Undefined
Null
Symbol
BigInt (ví dụ: 123n)

2. Đối tượng (Object):

Mảng, hàm, đối tượng, v.v..

Bây giờ, chúng ta hãy xem xét các loại ép kiểu.

Ép kiểu ngầm

Ép kiểu ngầm xảy ra khi JavaScript tự động chuyển đổi kiểu của một giá trị sang một kiểu khác để phù hợp với các yêu cầu của một phép toán hoặc biểu thức. Quá trình này còn được gọi là chuyển đổi kiểu.

Sau đây là một số ví dụ về ép kiểu ngầm:

VD1: Ép kiểu chuỗi với toán tử +

Trong JavaScript, khi bạn sử dụng toán tử + và một trong các giá trị là chuỗi, JavaScript sẽ tự động chuyển đổi giá trị còn lại thành chuỗi và kết hợp chúng. Quá trình này được gọi là ép kiểu chuỗi.

console.log(3 + "7"); 
// Output: "37" (3 is coerced to "3")

VD2: Ép kiểu số với toán tử số học

Khi bạn sử dụng các toán tử số học như -, *, / hoặc %, chúng hoạt động với các số. Nếu bạn cung cấp cho chúng một thứ gì đó không phải là số (như một chuỗi), JavaScript sẽ tự động chuyển đổi nó thành số trước khi thực hiện phép toán. Đây được gọi là ép kiểu số.

console.log("7" - 3); 
// Output: 4 (string "7" coerced to number 7)

console.log(true * 3);
// Output: 3 (true coerced to 1)

VD3: Ép kiểu trong điều kiện

Trong JavaScript khi một giá trị được sử dụng trong một điều kiện (như trong câu lệnh if hoặc while), nó sẽ tự động được chuyển đổi thành boolean (true hoặc false).

Giá trị truthy: Bất cứ thứ gì không phải là 0, NaN, null, undefined, false hoặc một chuỗi rỗng ("") đều được coi là true.
Giá trị falsy: 0, NaN, null, undefined, false và một chuỗi rỗng ("") đều được coi là false.

if ("Hello") { 
  console.log("This is truthy!"); // This will run because "Hello" is truthy 
}

if (27) { 
  console.log("This is also truthy!"); // This will run because 27 is truthy 
}

if (0) { 
  console.log("This won't run"); // This will not run because 0 is falsy 
}

if (null) { 
  console.log("This won't run either"); // This will not run because null is falsy 
}

if (!0) { 
  console.log("This will run"); // This will run because !0 is true (0 coerced to false, then negated) 
}

VD4: So sánh lỏng lẻo (==) và ép kiểu

Toán tử so sánh lỏng lẻo (==) so sánh hai giá trị bằng cách chuyển đổi chúng sang cùng một kiểu nếu chúng khác nhau. Nói cách khác, nó cố gắng làm cho các giá trị khớp bằng cách thay đổi một hoặc cả hai trước khi so sánh chúng.

console.log(5 == "5"); 
// Output: true (string "5" coerced to number 5)

console.log(null == undefined); 
// Output: true (both are considered "empty")

Ép kiểu tường minh

Ép kiểu tường minh xảy ra khi bạn cố ý chuyển đổi một giá trị từ kiểu này sang kiểu khác, sử dụng các hàm hoặc toán tử tích hợp sẵn.

Sau đây là một số phương thức phổ biến cho ép kiểu tường minh:

1. Chuyển đổi sang Chuỗi

Sử dụng String():

  console.log(String(37)); 
  // Output: "37"

Sử dụng .toString():

  console.log((37).toString()); 
  // Output: "37"

Nối với Chuỗi Rỗng:

  console.log(37 + ""); 
  // Output: "37"

2. Chuyển đổi sang Số

Sử dụng Number():

  console.log(Number("37")); 
  // Output: 37

Sử dụng toán tử đơn nhất +: Được sử dụng để chuyển đổi một giá trị thành số.

 // If the value is a string that can be converted to a number, it returns the number representation.
  console.log(+"37"); 
  // Output: 37

  // If the value is a boolean, true becomes 1 and false becomes 0.
  console.log(+true);   // Output: 1 (true becomes 1)
  console.log(+false);  // Output: 0 (false becomes 0)

  // If the value cannot be converted to a valid number, it returns NaN (Not-a-Number).
  console.log(+undefined);  // Output: NaN (undefined cannot be converted)
  console.log(+null);       // output: 0 (null is converted to 0)
  console.log(+{});         // Output: NaN (object cannot be converted)

Sử dụng toán tử đơn nhất -: Được sử dụng để chuyển đổi một giá trị thành số và phủ định nó.

// If the value is a number, it simply negates the number.
  console.log(-3);  // Output: -3 (negates the number)

  // If the value is a string that can be converted to a number, it first converts it and then negates it.
  console.log(-"37"); // Output: -37 (string "37" is converted to number and negated)

  // If the value is a boolean, true becomes -1 and false becomes -0.
  console.log(-true);   // Output: -1
  console.log(-false);  // Output: -0 

  // If the value cannot be converted to a valid number, it returns NaN (Not-a-Number).
  console.log(-undefined);  // Output: NaN (undefined cannot be converted)
  console.log(-null);       // Output: -0 (null is converted to 0 and negated to -0)
  console.log(-{});         // Output: NaN (object cannot be converted)

Sử dụng parseInt() hoặc parseFloat():

  // parseInt(): Converts a string to an integer.
  console.log(parseInt("123.45")); 
  // Output: 123

  // parseFloat(): Converts a string to a floating-point number.
  console.log(parseFloat("123.45")); 
  // Output: 123.45

3. Chuyển đổi sang Boolean

Sử dụng Boolean():

  console.log(Boolean(0)); 
  // Output: false

  console.log(Boolean(1)); 
  // Output: true

  console.log(Boolean(""));  
  // Output: false (empty string is falsy)

Sử dụng Phủ Định Kép (!!): Phủ định kép là một cách nhanh chóng để chuyển đổi bất kỳ giá trị nào thành boolean. Nó hoạt động bằng cách phủ định giá trị đầu tiên (sử dụng toán tử !), chuyển đổi giá trị thành boolean (true hoặc false), sau đó phủ định lại để lấy giá trị boolean ban đầu.

  console.log(!!"hello"); 
  // Output: true (non-empty string is truthy)

  console.log(!!"");  
  // Output: false (empty string is falsy)

Tại sao ép kiểu ngầm có thể gây ra vấn đề?

Ép kiểu ngầm có thể làm cho mã khó hiểu, đặc biệt là đối với người mới bắt đầu hoặc khi xem lại mã cũ. Vì ép kiểu xảy ra tự động nên khó biết ý định ban đầu là gì.

Chúng ta hãy tìm hiểu điều này với một số ví dụ:

1. Kết quả không mong muốn:

Ép kiểu ngầm có thể gây ra kết quả không mong muốn, đặc biệt là khi làm việc với các kiểu dữ liệu khác nhau. Điều này gây khó khăn cho việc dự đoán cách một số biểu thức sẽ hoạt động. Ví dụ:

console.log("7" + 3); // "73" (string concatenation, not numeric addition)
console.log("7" - 3); // 4 (coerces "7" to a number and subtracts)

Trong ví dụ trên, biểu thức đầu tiên thực hiện nối chuỗi vì toán tử +, nhưng biểu thức thứ hai thực hiện phép trừ số vì - kích hoạt ép kiểu thành số.

2. Trộn kiểu dữ liệu:

Khi bạn trộn các kiểu dữ liệu trong các phép toán, điều này có thể dẫn đến kết quả không mong muốn hoặc lỗi, đặc biệt là khi bạn mong đợi một kiểu nhưng lại nhận được một kiểu khác. Ví dụ:

console.log(1 + true);   // 2 (true is coerced to 1)
 console.log(1 + null);  // 1 (null is coerced to 0)
 console.log("5" - true); // 4 (string "5" is coerced to number 5, and true to 1, then subtracted)

3. Gỡ lỗi khó khăn:

Có thể khó tìm ra nơi xảy ra chuyển đổi không mong muốn, khiến việc gỡ lỗi trở nên khó khăn hơn. Ví dụ:

// The string "0" is coerced to false because of the loose equality operator (==), leading to this block being executed when it might not be expected.
 if ("0" == false) {
   console.log("This will run!"); // unexpected behavior
 }

4. Giá trị Falsy và so sánh kiểu:

JavaScript có một số giá trị falsy như 0, "", null, undefined, NaN, false. Khi các giá trị này được sử dụng trong so sánh hoặc các phép toán logic, việc chuyển đổi kiểu ngầm định có thể gây nhầm lẫn. Nếu bạn không hiểu cách JavaScript diễn giải các giá trị này, nó có thể dẫn đến các lỗi không mong muốn. Ví dụ:

console.log(0 == false);   // true (0 is coerced to false)
 console.log("" == false);  // true (empty string is coerced to false)
 console.log(null == undefined);  // true (coerced to equal during comparison)

Cách tránh các vấn đề về ép kiểu

Dưới đây là một số phương pháp hay nhất để giúp bạn tránh các vấn đề do ép kiểu ngầm gây ra:

1. Sử dụng so sánh nghiêm ngặt (===):

Ưu tiên === hơn == để tránh ép kiểu không mong muốn trong quá trình so sánh.

 console.log(3 === "3"); 
 // Output: false (no coercion)

2. Tường minh khi chuyển đổi kiểu:

Sử dụng các phương thức chuyển đổi kiểu tường minh để chỉ định rõ ràng sự thay đổi kiểu mong muốn.

 console.log(Number("37")); 
 // Output: 37

3. Tránh trộn kiểu trong các phép toán:

Viết mã không phụ thuộc vào ép kiểu ngầm bằng cách đảm bảo các toán hạng cùng kiểu.

 console.log(7 + Number("3")); 
 // Output: 10

4. Xác thực đầu vào:

Khi bạn nhận đầu vào của người dùng hoặc dữ liệu từ API, hãy đảm bảo xác minh và chuyển đổi nó sang kiểu đúng, chẳng hạn như số hoặc chuỗi.

function parseAge(input) {
   const age = Number(input);  // Convert the input to a number
   if (isNaN(age)) {  // Check if the conversion failed (NaN means Not-a-Number)
     throw new Error("Invalid age");  // If not a valid number, throw an error
   }
   return age;  // Return the converted number
 }

Hiểu rõ hành vi của mảng và đối tượng

Mảng và đối tượng hoạt động khác nhau khi bị ép kiểu thành chuỗi.

Mảng: Khi bị ép kiểu thành chuỗi, JavaScript chuyển đổi một mảng thành chuỗi với các phần tử của nó được nối bằng dấu phẩy. Ví dụ:

  console.log([1, 2, 3] + "");  
  // Output: "1,2,3"

Đối tượng: Theo mặc định, khi một đối tượng bị ép kiểu thành chuỗi, nó trả về "[object Object]", trừ khi đối tượng có phương thức toString() tùy chỉnh. Ví dụ:

  console.log({a: 1, b: 2} + "");  
  // Output: "[object Object]"

Kết luận

Ép kiểu ngầm trong JavaScript có thể hữu ích, nhưng nó cũng có thể dẫn đến hành vi không mong muốn, gây ra lỗi và khiến mã khó bảo trì hơn. Để tránh các vấn đề này, hãy sử dụng so sánh nghiêm ngặt, chuyển đổi kiểu tường minh và xác thực đầu vào. Bằng cách này, bạn có thể viết mã JavaScript sạch hơn, đáng tin cậy hơn và dễ bảo trì hơn.

JavaScript