Rate this post

JavaScript là một ngôn ngữ lập trình đa năng, chủ yếu được sử dụng trong phát triển web. Hiểu rõ về các operator (toán tử) trong JavaScript là điều cần thiết để thực hiện các thao tác từ đơn giản đến phức tạp một cách hiệu quả. Trong bài viết này, chúng ta sẽ tìm hiểu chi tiết về các loại toán tử khác nhau trong JavaScript cùng với các ví dụ minh họa.

Tóm tắt nội dung

Operator là gì?

Toán tử là các ký hiệu được sử dụng để thực hiện các thao tác trên các biến và giá trị. Trong JavaScript, toán tử đóng vai trò quan trọng trong việc xử lý dữ liệu và điều khiển luồng chương trình. Hiểu rõ cách sử dụng các toán tử sẽ giúp lập trình viên viết mã ngắn gọn, dễ hiểu và hiệu quả hơn.

Các loại toán tử trong JavaScript

Toán tử số học

Toán tử số học được sử dụng để thực hiện các phép tính toán học cơ bản.

+ (Cộng): Cộng hai số hoặc nối chuỗi.

  let a = 5;
  let b = 3;
  console.log(a + b); // Kết quả: 8

- (Trừ): Trừ số thứ hai khỏi số thứ nhất.

  let a = 5;
  let b = 3;
  console.log(a - b); // Kết quả: 2

* (Nhân): Nhân hai số.

  let a = 5;
  let b = 3;
  console.log(a * b); // Kết quả: 15

/ (Chia): Chia số thứ nhất cho số thứ hai.

  let a = 6;
  let b = 3;
  console.log(a / b); // Kết quả: 2

% (Chia lấy dư): Lấy phần dư của phép chia.

  let a = 5;
  let b = 3;
  console.log(a % b); // Kết quả: 2

++ (Tăng): Tăng giá trị của biến lên 1.

  let a = 5;
  a++;
  console.log(a); // Kết quả: 6

-- (Giảm): Giảm giá trị của biến đi 1.

  let a = 5;
  a--;
  console.log(a); // Kết quả: 4

Toán tử gán

Toán tử gán được sử dụng để gán giá trị cho biến.

= (Gán): Gán giá trị bên phải cho biến bên trái.

  let a = 5;

+= (Cộng và gán): Cộng giá trị bên phải với biến và gán lại cho biến.

  let a = 5;
  a += 3;
  console.log(a); // Kết quả: 8

-= (Trừ và gán): Trừ giá trị bên phải khỏi biến và gán lại cho biến.

  let a = 5;
  a -= 3;
  console.log(a); // Kết quả: 2

*= (Nhân và gán): Nhân giá trị bên phải với biến và gán lại cho biến.

  let a = 5;
  a *= 3;
  console.log(a); // Kết quả: 15

/= (Chia và gán): Chia biến cho giá trị bên phải và gán lại cho biến.

  let a = 6;
  a /= 3;
  console.log(a); // Kết quả: 2

%= (Chia lấy dư và gán): Lấy phần dư của biến chia cho giá trị bên phải và gán lại cho biến.

  let a = 5;
  a %= 3;
  console.log(a); // Kết quả: 2

Toán tử so sánh

Toán tử so sánh được sử dụng để so sánh hai giá trị.

== (Bằng): So sánh giá trị, không so sánh kiểu dữ liệu.

  let a = 5;
  let b = '5';
  console.log(a == b); // Kết quả: true

=== (Bằng tuyệt đối): So sánh cả giá trị và kiểu dữ liệu.

  let a = 5;
  let b = '5';
  console.log(a === b); // Kết quả: false

!= (Khác): So sánh giá trị, không so sánh kiểu dữ liệu.

  let a = 5;
  let b = '5';
  console.log(a != b); // Kết quả: false

!== (Khác tuyệt đối): So sánh cả giá trị và kiểu dữ liệu.

  let a = 5;
  let b = '5';
  console.log(a !== b); // Kết quả: true

> (Lớn hơn): So sánh nếu giá trị bên trái lớn hơn giá trị bên phải.

  let a = 5;
  let b = 3;
  console.log(a > b); // Kết quả: true

< (Nhỏ hơn): So sánh nếu giá trị bên trái nhỏ hơn giá trị bên phải.

  let a = 5;
  let b = 3;
  console.log(a < b); // Kết quả: false

>= (Lớn hơn hoặc bằng): So sánh nếu giá trị bên trái lớn hơn hoặc bằng giá trị bên phải.

  let a = 5;
  let b = 5;
  console.log(a >= b); // Kết quả: true

<= (Nhỏ hơn hoặc bằng): So sánh nếu giá trị bên trái nhỏ hơn hoặc bằng giá trị bên phải.

  let a = 5;
  let b = 5;
  console.log(a <= b); // Kết quả: true

Toán tử logic

Toán tử logic được sử dụng để kết hợp nhiều điều kiện.

&& (Và): Kết quả là true nếu tất cả các điều kiện đều true.

  let a = 5;
  let b = 3;
  console.log(a > 0 && b > 0); // Kết quả: true

|| (Hoặc): Kết quả là true nếu ít nhất một điều kiện là true.

  let a = 5;
  let b = -3;
  console.log(a > 0 || b > 0); // Kết quả: true

! (Phủ định): Đảo ngược giá trị boolean.

  let a = true;
  console.log(!a); // Kết quả: false

Toán tử bitwise

Toán tử bitwise thực hiện các phép toán trên các bit của số nguyên.

& (AND bitwise): So sánh từng bit của hai số và trả về 1 nếu cả hai bit đều là 1.

  let a = 5; // 0101
  let b = 3; // 0011
  console.log(a & b); // Kết quả: 1 (0001)

| (OR bitwise): So sánh từng bit của hai số và trả về 1 nếu ít nhất một bit là 1.

  let a = 5; // 0101
  let b = 3; // 0011
  console.log(a | b); // Kết quả: 7 (0111)

^ (XOR bitwise): So sánh từng bit của hai số và trả về 1 nếu chỉ một trong hai bit là 1.

  let a = 5; // 0101
  let b = 3; // 0011
  console.log(a ^ b); // Kết quả: 6 (0110)

~ (NOT bitwise): Đảo ngược từng bit của số.

  let a = 5; // 0101
  console.log(~a); // Kết quả: -6 (1010, với bit đầu tiên là bit dấu)

<< (Dịch trái): Dịch các bit của số sang trái, thêm các bit 0 vào phía bên phải.

  let a = 5; // 0101
  console.log(a << 1); // Kết quả: 10 (1010)

>> (Dịch phải): Dịch các bit của số sang phải, giữ lại bit dấu.

  let a = 5; // 0101


  console.log(a >> 1); // Kết quả: 2 (0010)

>>> (Dịch phải không dấu): Dịch các bit của số sang phải, thêm các bit 0 vào phía bên trái.

  let a = 5; // 0101
  console.log(a >>> 1); // Kết quả: 2 (0010)

Toán tử chuỗi

Toán tử chuỗi chủ yếu là toán tử nối chuỗi.

+ (Nối chuỗi): Kết hợp hai chuỗi lại với nhau.

  let str1 = "Hello";
  let str2 = "World";
  console.log(str1 + " " + str2); // Kết quả: "Hello World"

Toán tử điều kiện (ternary)

Toán tử điều kiện sử dụng để đơn giản hóa các câu lệnh điều kiện.

? : (Ternary): Kiểm tra điều kiện và trả về một trong hai giá trị tùy thuộc vào kết quả.

  let age = 18;
  let canVote = (age >= 18) ? "Yes" : "No";
  console.log(canVote); // Kết quả: "Yes"

Toán tử kiểu

Toán tử kiểu được sử dụng để kiểm tra kiểu dữ liệu.

typeof: Trả về kiểu dữ liệu của biến.

  let a = 5;
  console.log(typeof a); // Kết quả: "number"

instanceof: Kiểm tra xem một đối tượng có phải là một thể hiện của một lớp hay không.

  let arr = [1, 2, 3];
  console.log(arr instanceof Array); // Kết quả: true

Độ ưu tiên và tính kết hợp của toán tử

Độ ưu tiên của toán tử quyết định toán tử nào được thực hiện trước trong một biểu thức. Tính kết hợp xác định hướng thực hiện của các toán tử có cùng độ ưu tiên (từ trái sang phải hoặc phải sang trái).

Bảng độ ưu tiên của toán tử

Toán tử	Độ ưu tiên	Tính kết hợp
`()`	20	–
`++`, `--`	19	Từ trái sang phải
`*`, `/`, `%`	14	Từ trái sang phải
`+`, `-`	13	Từ trái sang phải
`<<`, `>>`, `>>>`	12	Từ trái sang phải
`<`, `<=`, `>`, `>=`	11	Từ trái sang phải
`==`, `!=`, `===`, `!==`	10	Từ trái sang phải
`&`	9	Từ trái sang phải
`^`	8	Từ trái sang phải
`\|`	7	Từ trái sang phải
`&&`	6	Từ trái sang phải
`\|\|`	5	Từ trái sang phải
`? :`	4	Từ phải sang trái
`=`, `+=`, `-=`, `*=`	3	Từ phải sang trái
`,`	1	Từ trái sang phải

Ví dụ thực tế và ứng dụng

Để minh họa cách sử dụng các toán tử trong thực tế, dưới đây là một ví dụ về tính toán đơn giản với các toán tử số học và điều kiện.

let score = 85;
let grade = (score >= 90) ? "A" : (score >= 80) ? "B" : (score >= 70) ? "C" : "F";
console.log(`Điểm số: ${score}, Xếp loại: ${grade}`);
// Kết quả: Điểm số: 85, Xếp loại: B

Sai lầm thường gặp và cách tránh

Một số lỗi phổ biến khi sử dụng toán tử bao gồm:

Sử dụng == thay vì ===, dẫn đến kết quả không mong muốn do không so sánh kiểu dữ liệu.
Quên dấu ngoặc khi sử dụng toán tử điều kiện, dẫn đến lỗi cú pháp.
Sử dụng toán tử logic sai cách, dẫn đến logic chương trình bị sai.

Để tránh các lỗi này, luôn kiểm tra kỹ mã nguồn và sử dụng các công cụ kiểm tra mã như ESLint.

Kết luận

Trong bài viết này, chúng ta đã tìm hiểu về các loại toán tử khác nhau trong JavaScript, từ toán tử số học, gán, so sánh, logic, đến toán tử chuỗi và điều kiện. Việc nắm vững các toán tử này sẽ giúp bạn viết mã JavaScript hiệu quả và tối ưu hơn.

Tài nguyên bổ sung

Để tìm hiểu thêm về toán tử trong JavaScript, bạn có thể tham khảo các tài liệu sau:

MDN Web Docs
Sách “JavaScript: The Good Parts” của Douglas Crockford
Khóa học trực tuyến trên freeCodeCamp

JavaScript

Operators trong JavaScript