--- title: "Tự học Dart: Các Dart Operators (toán tử) bạn cần biết" description: "Cập nhật nhanh các toán tử - operator quan trọng trong Dart để có thể sử dụng ngôn ngữ này một cách hiệu quả nhất nhé. " canonical: "https://200lab.io/blog/tu-hoc-ngon-ngu-dart-toan-tu-operator" published: "2023-09-02T02:34:00Z" updated: "2026-08-21T07:18:00Z" authors: ["Nguyên"] tags: ["Dart", "Flutter"] reading_minutes: 19 access: "public" --- _**Cập nhật nhanh các toán tử - operators quan trọng trong Dart để có thể sử dụng ngôn ngữ này một cách hiệu quả nhất nhé.**_ [Xem Thêm Khóa Học Lập Trình]() ## **Toán tử (Operators) trong Dart là gì?** Operators trong Dart là những ký hiệu được dùng để thực hiện một phép toán số hoặc logic nhằm để tùy chỉnh hoặc thao tác dữ liệu. Thao tác dữ liệu là một phần thiết yếu của bất kỳ ngôn ngữ lập trình nào và Dart cũng không ngoại lệ. Nó cung cấp một tập hợp các toán tử phong phú cho các kiểu cơ bản của nó. ![dart operators](https://assets.200lab.io/images/2021/07/05/photo-1566837945700-30057527ade0-55c87e84de6e9367ddf6.jpg) Toán tử trong Dart là những biểu tượng đặc biệt giúp thực hiện các phép tính với các giá trị. Ví dụ, toán tử '+' dùng để cộng hai giá trị lại với nhau. Dart có nhiều loại toán tử khác nhau như toán tử số học (thực hiện phép tính toán), toán tử gán (để định giá trị cho biến), toán tử quan hệ (so sánh giá trị), toán tử kiểm tra kiểu dữ liệu (kiểm tra loại dữ liệu), toán tử logic (thực hiện phép logic), toán tử bit (thao tác bit), và toán tử điều kiện (thực hiện kiểm tra điều kiện). Mỗi toán tử có thể hoạt động với một hoặc hai giá trị, tùy thuộc vào loại toán tử. Bạn cũng có thể tạo ra các toán tử tùy chỉnh cho lớp của mình. ## **1. Có bao nhiêu loại Dart Operators?** Trong Dart, có nhiều loại toán tử khác nhau, bao gồm các toán tử số học, gán, quan hệ, kiểm tra loại, logic, bit và điều kiện. Mỗi loại toán tử có một chức năng riêng và được sử dụng để thực hiện các thao tác khác nhau trên toán hạng. Trong phần này, chúng ta sẽ cùng tìm hiểu về các toán tử được tích hợp sẵn trong Dart: - Toán tử số học - Arithmetic operators - Toán tử so sánh - Relational operators - Toán tử gán - Assignment operators - Toán tử logic - Logical operators - Toán tử kiểm tra kiểu - Type test operators - Toán tử Bitwise và Shift - Bitwise and Shift operators ## **2. Toán tử trong Dart và các biểu thức quan trọng** Một biểu thức là một kiểu đặc biệt của câu lệnh nhằm ước lượng ra một số giá trị. Ví dụ, trong toán học, 1 + 1 là một biểu thức bởi vì nó ước lượng ra bằng 2. ### Một biểu thức thì bao gồm 2 phần: toán hạng và toán tử. Toán tử thường tuân theo một **ký hiệu trung tố** (infix notation). Ký hiệu trung tố là ký hiệu biểu diễn biểu thức, nơi toán tử nằm giữa hai toán hạng. **Toán hạng** là các đối tượng dữ liệu mà toán tử đang thực hiện một phép toán trên nó. Nói cách khác toán tử xác định cách các toán hạng được xử lý để tạo ra một giá trị. Những toán tử khác nhau thực hiện những phép tính khác nhau. Vậy nên, bạn cần biết mình muốn dữ liệu của mình được xử lý như thế nào để mà chọn đúng toán tử. ![dart operators](https://assets.200lab.io/images/2021/07/05/photo-1549692520-acc6669e2f0c-b9595f888ab158345a2d.jpg) _**Hãy cùng tìm hiểu về từng loại toán tử trong Dart ở các phần dưới đây.**_ ## **3. Toán tử số học - Arithmetic operators** Toán tử số học là những toán tử thực hiện những phép tính toán học như là cộng hoặc trừ. ### **3.1. Danh sách của những toán tử số học** Dưới đây là danh sách những toán tử số học được hỗ trợ bởi Dart. **Operator** **Use** `+` Adds two operands `-` Subtracts the second operand from the first `-`expr Reverses the sign of the expression (unary minus) `*` Multiplies both operands `/` Divides the first operand by the second operand `~/` Divides the first operand by the second operand and returns an integer value `%` Gets the remainder after division of one number by another Chúng ta lấy toán tử đầu tiên là 10 và toán tử thứ hai là 7, xem ví dụ dưới đây: ``` main() { var operand1 = 10; var operand2 = 7; print(operand1 + operand2); print(operand1 - operand2); print(- operand1); print(operand1 * operand2); print(operand1 / operand2); print(operand1 ~/ operand2); print(operand1 % operand2); } ``` Output là: ``` 173 -10 70 1.4285714285714286 1 3 ``` Hầu hết các toán tử là những dấu chúng ta thường thấy trong toán học. Chỉ có một dấu có thể mới với chúng ta đó là toán tử  `~/`. ### **3.2. Toán tử tiền tố và hậu tố** Ngôn ngữ Dart cũng hỗ trợ cả toán tử tăng giảm dạng tiền tố và hậu tố. Dưới đây là danh sách các toán tử tăng giảm dạng tiền tố và hậu tố được hỗ trợ bởi Dart. **Operator** **Use** `++`var var = var + 1 var`++` var = var + 1 `--`var var = var - 1 var`--` var = var - 1 Hãy xem thử cách mà mỗi toán tử hoạt động ở một vài ví dụ bên dưới nhé: #### ++var Giá trị biểu thức của `++var` là `var+1`. Khi bạn chèn biểu thức vào một câu lệnh in, đầu tiên trình biên dịch sẽ tăng biến thêm 1 đơn vị sau đó mới in ra giá trị của biến đó. ``` main() { var prefixIncrement = 5; print(++prefixIncrement); } ``` Output: `6` Giá trị sau khi tăng là 6, tức là 5+1, được hiển thị ra output. #### var++ Giá trị biểu thức của `var++` là `var`. Khi bạn chèn biểu thức vào một câu lệnh in, đầu tiên trình biên dịch sẽ in ra giá trị của biến đó rồi sau đó mới tăng thêm 1. ``` main() { var postfixIncrement = 5; print(postfixIncrement++); print(postfixIncrement); } ``` Output: `5` `6` Trong trường hợp này, câu lệnh `print` sẽ hiển thị giá trị của biến trước sau đó mới tăng nó lên. 5 là output của dòng `print(postfixIncrement++);`, trong khi đó câu lệnh `print` được gọi lại thì giá trị của biến sẽ được tăng lên. Dòng `print(postfixIncrement);` sẽ cho ra ouput là 6. #### --var Giá trị biểu thức của `--var` là `var-1`. Khi chúng ta chèn biểu thức vào câu lệnh in, đầu tiên trình biên dịch sẽ giảm biến đi một 1 đơn vị sau đó mới in ra giá trị của biến. ``` main() { var prefixDecrement = 5; print(--prefixDecrement); } ``` Output: `4` Giá trị được hiển thị sau khi giảm là 4, tức là 5-1. #### var-- Giá trị biểu thức của `var--` là `var`. Khi chúng ta chèn biểu thức vào câu lệnh in, đầu tiên trình biên dịch sẽ in ra giá trị của biến đó rồi sau đó mới giảm đi 1 ``` main() { var postfixDecrement = 5; print(postfixDecrement--); print(postfixDecrement); } ``` Output: `5` `4` Trong trường hợp này, câu lệnh `print` sẽ hiển thị giá trị của biến trước sau đó mới giảm nó đi. 5 là output của dòng `print(postfixDecrement--);`, trong khi đó câu lệnh `print` được gọi lại thì giá trị của biến sẽ giảm xuống. Dòng `print(postfixDecrement);` sẽ cho ra ouput là 4. ## **4. Toán tử so sánh (toán tử quan hệ và đẳng thức) - Relational operators** Toán tử quan hệ là những toán tử thực hiện những phép so sánh giữa các toán hạng của kiểu numeric. Ví dụ như so sánh lớn hơn hay nhỏ hơn. Toán tử đẳng thức có thể so sánh các toán hạng thuộc bất kỳ kiểu **_Dưới đây là danh sách các toán tử so sánh được hỗ trợ bởi Dart: _** **Operator** **Use** `==` Checks if the values of the two operands are equal (true if equal) `!=` Checks if the values of the two operands are not equal (true if not equal) `>` Checks if the value of the left operand is greater than the value of the right operand `<` Checks if the value of the left operand is less than the value of the right operand `>=` Checks if the value of the left operand is greater than or equal to the value of the right operand `<=` Checks if the value of the left operand is less than or equal to the value of the right operand > _Toán tử so sánh mang lại kết quả kiểu `boolean`_ Lấy toán tử đầu tiên là 10, toán tử thứ hai là 7. Hãy xem thử ví dụ sau đây: ### **Toán tử quan hệ** ``` main() { var operand1 = 10; var operand2 = 7; print(operand1 > operand2); print(operand1 < operand2); print(operand1 >= operand2); print(operand1 <= operand2); } ``` Output: `true` `false` `true` `false` ### **Toán tử đẳng thức** ``` main() { var operand1 = 10; var operand2 = 7; print(operand1 == operand2); print(operand1 != operand2); } ``` Output: `false` `true` Chúng ta có thể sử dụng các toán tử đẳng thức trên với các ký tự không phải là số nguyên ví dụ như các ký tự `string`. Hãy xem ví dụ dưới đây. Toán tử đầu tiên là `a` và toán tử thứ hai là `b` ``` main() { var operand1 = 'a'; var operand2 = 'b'; print(operand1 == operand2); print(operand1 != operand2); } ``` Output: `false` `true` ## **5. Toán tử kiểm tra kiểu - Type test operators** Toán tử kiểm tra kiểu là những toán tử có thể sử dụng để kiểm tra kiểu của một đối tượng tại thời gian chạy. Dưới đây là danh sách các toán tử kiểm tra kiểu được hỗ trợ bởi Dart: Operator Use `as` typecast `is` True if the object has the specified type `is!` False if the object has the specified type > _Chúng ta sẽ không đề cập đến toán tử _`as` trong series bài viết này. Mặc dù toán tử kiểm tra kiểu chỉ có hai toán hạng nhưng thứ tự của toán hạng thì rất quan trọng và chúng ta cần phân biệt rõ ràng. Giá trị của kiểu cần được kiểm tra phải ở bên trái của toán tử. Còn bên phải của toán tử chính là bản thân của kiểu. **_Đây là syntax cơ bản:_** ![operator dart](https://assets.200lab.io/images/2024/12/05/image-40-f8fbe965d1e07b42661f.webp) **_Hãy xem ví dụ dưới đây để hiểu hơn cách sử dụng toán tử kiểm tra kiểu trong ngôn ngữ Dart:_** ``` main() { double type1 = 5.0; int type2 = 87; String type3 = "educative"; bool type4 = true; print(type1 is int); print(type2 is int); print(type3 is String); print(type4 is double); print(type4 is! double); } ``` Output: `false` `true` `true` `false` `true` - Dòng `print(type1 is int);` hiển thị `false` vì `type1` là kiểu `doubl` mà chúng ta đang hỏi trình biên dịch là liệu nó có phải là kiểu `int` hay không - Dòng `print(type2 is int);` hiển thị `true` vì `type2` là kiểu `int` và chúng ta cũng đang hỏi trình biên dịch là liệu nó có phải là kiểu `int` hay không - Dòng `print(type3 is String);` hiển thị `true` vì `type3` là kiểu `String` và chúng ta cũng đang hỏi trình biên dịch là liệu nó có phải là kiểu `String` hay không - Dòng `print(type4 is double);` hiển thị `false` vì `type4` là kiểu `bool` mà chúng ta đang hỏi trình biên dịch là liệu nó có phải là kiểu `doubl` hay không - Dòng `print(type4 is! double);` hiển thị `true` vì `type4` không phải là kiểu `bool` và chúng ta cũng đang hỏi trình biên dịch là liệu nó không phải là kiểu `String` đúng không ## **6. Toán tử gán - Assignment operators** Toán tử gán là những toán tử được dùng để thực hiện những phép gán một giá trị cho một toán hạng. Trong phần này chúng ta sẽ gặp lại những toán tử mà chúng ta đã thảo luận, đặc biệt là toán tử `=`. Bên cạnh đó, chúng ta cũng sẽ tập trung vào những toán tử gán kết hợp (compound assignment operators). ### **6.1. Toán tử gán kết hợp (Compound Assignment Operators)** Toán tử gán kết hợp sẽ kết hợp những toán tử khác với toán tử gán (`=`). = -= /= %= \>\>= ^= += \*= ~/= \<\<= &= |= _**Dưới đây là syntax chung:**_ ![dart operators](https://assets.200lab.io/images/2024/12/05/image-42-aedb647592255bc48784.webp) Ở cú pháp trên, toán tử đang đang thực hiện phép toán giữa **operand1** và **operand2** rồi sau đó gán giá trị kết quả cho **operand1**. **_Nó cũng tương tự như syntax sau:_** ![dart operators](https://assets.200lab.io/images/2024/12/05/image-43-c1f73c9d0893237c10f9.webp) Để ý mô hình ở trên. Các toán tử gán yêu cầu rằng các toán hạng của nó phải là các biến vì kết quả của phép toán được chứa trong toán hạng bên trái / đầu tiên. #### _**Ví dụ về toán tử gán trong Dart:**_ #### `+=` Trong ví dụ dưới đây, chúng ta sẽ lấy toán hạng bên trái  `A` là 10, toán hạng bên phải `B` là 7. Thử sử dụng cả toán tử gán và toán tử gán kết hợp xem thử như thế nào nhé: ``` main() { var A = 10; var B = 7; print("Before using a compound assignment operator:"); print(A); A += B; print("After using a compound assignment operator:"); print(A); } ``` Output: `Before using a compound assignment operator:` `10` `After using a compound assignment operator:` `17` Trước khi chúng ta gán lại biến `A` thì giá trị của nó là 10. Sau khi sử dụng toán tử gán kết hợp `+=` thì giá trị mới của nó là 17. Phép `A += B` thì cũng giống như `A = A + B`. **_Hãy xem thêm một vài ví dụ nữa nhé:_** #### `&=` ``` main() { var A = 10; var B = 7; print("Before using a compound assignment operator:"); print(A); A &= B; print("After using a compound assignment operator:"); print(A); } ``` Output: `Before using a compound assignment operator: ` `10 ` `After using a compound assignment operator: ` `2` `A &= B` cũng tương tự `A = A & B` #### `~/=` ``` main() { var A = 10; var B = 7; print("Before using a compound assignment operator:"); print(A); A ~/= B; print("After using a compound assignment operator:"); print(A); } ``` Output: `Before using a compound assignment operator: ` `10 ` `After using a compound assignment operator: ` `1` `A ~/= B` cũng tương tự `A = A ~/ B` ## **7. Toán tử logic - Logical operators** Toán tử logic là những toán tử thực hiện các phép toán logic như là **logic và (and)**, **logic hoặc (or)**. Chúng lấy toán hạng kiểu `bool` và mang lại kết quả kiểu `bool`. Dưới đây là danh sách các toán tử logic được hỗ trợ bởi ngôn ngữ Dart. **Operator** **Name** **Use** `!` Logical NOT Reverses the logical state of its operand. If a condition is true, then the Logical _NOT_ operator will make it false `||` Logical OR If any of the two operands is not false, then the result is true `&&` Logical AND If both the operands are not false, then the result is true ### **7.1.  Những quy tắc sử dụng toán tử logic trong Dart** Dưới đây là danh sách các quy tắc ngắn gọn cho các toán tử logic. Danh sách này rất hữu ích vì nó sẽ tóm tắt cách mỗi toán tử trả các biểu thức về kết quả cuối cùng của nó. _expr_ là một biểu thức tùy ý có thể được thay thế bằng một toán hạng kiểu `Boolean`. Toán hạng có thể là `true` hoặc `false` hoặc có thể là một biểu thức rút gọn thành `true` hoặc `false`. ### **7.2. Ví dụ về logical operators trong Dart** Hãy xem những quy tắc trên được thực hiện như thế nào trong ví dụ dưới đây nhé. Biểu thức `expr` sẽ là `A && B` trong đó `A` là `true` và `B` là `false`. ``` main() { var A = true; var B = false; var expr = A && B; //false print(!A); // !true --> false print(!B); // !false --> true print(true || expr); // true || expr --> true print(false || expr); // false || expr --> expr print(true && expr); // true && expr --> expr print(false && expr); // false && expr --> false } ``` Output: `false ` `true ` `true ` `false ` `false ` `false` `A && B` trả về `false` vì `B` là `false` và từ danh sách các quy tắc ở trên chúng ta biết rằng `false && expr --> false`. ## **8. Toán tử Bitwise và Shift - Bitwise and Shift operators** Toán tử Bitwise và toán tử Shift là những toán tử thực hiện những phép toán trên những bit riêng rẻ của kiểu integer. Trong lập trình máy tính kỹ thuật số. Phép toán bitwise hoạt động trên một hoặc nhiều số nhị phân (binary numbers), hoặc các chuỗi giống số nhị phân. Đây là một phép toán đơn giản và nhanh, được hỗ trợ trực tiếp bởi bộ xử lý (processor). Thông thường các phép tính bitwise nhanh hơn rất nhiều so với phép nhân, phép chia, đôi khi nhanh hơn đáng kể so với phép cộng. Các phép tính bitwise sử dụng ít năng lượng hơn bởi nó ít sử dụng tài nguyên **_Dưới đây là danh sách các toán tử bitwise được hỗ trợ bởi Dart:_** **Operator** **Name** **Use** `&` Bitwise **AND** If the corresponding bit in both operands is **1** it will give a **1**, else **0** `|` Bitwise **OR** If the corresponding bit in at least one operand is **1** it will give a **1**, else **0** `^` Bitwise **XOR** If the corresponding bit in only one operand is **1** it will give a **1**, else **0** `~` Unary Bitwise **Complement** Bits which are **0** become **1** and bits which are **1** become **0** **_Dưới đây là danh sách các toán tử shift được Dart hỗ trợ:_** **Operator** **Name** **Use** `<<` Shift Left Shifts all the bits of its operand to the left by the specified amount `>>` Shift Right Shifts all the bits of its operand to the right by the specified amount > _Cả hai toán tử Bitwise và Shift đều hoạt động trên số nhị phân._ ### **8.1. Những quy tắc sử dụng Bitwise and Shift operators** Dưới đây chúng ta có một danh sách các quy tắc mà mỗi toán tử bitwise tuân theo. Đối với toán tử bitwise, chúng ta làm việc với số nhị phân. Do đó, thay vì false và true, chúng ta sẽ sử dụng **1** và **0** trong đó **1** đóng vai trò là true và **0** đóng vai trò là false. **bit** có thể là** 1** hoặc **0**. ### **8.2. Ví dụ về Bitwise and Shift operators trong Dart** Bây giờ chúng ta hãy xem các quy tắc trên trong hoạt động như thế nào nhé. Chúng ta sẽ lấy toán hạng đầu tiên `A`  là 12 và toán hạng thứ hai `B` là 5. ``` main() { var A = 12; var B = 5; print(~A); // A complement print(~B); // B complement print(A & B); // A AND B print(A | B); // A OR B print(A ^ B); // A XOR B print(B << 2); // B Shift Left 2 print(A >> 2); // A Shift Right 2 } ``` Output: `-13 ` `-6 ` `4 ` `13 ` `9 ` `20 ` `3` ### **8.3. Phân tích code** Output của đoạn code trên có thể không rõ ràng như những output mà chúng ta đã thấy trước đây trong series này. Nhưng đừng lo quá nhé! Từng bước một chúng ta sẽ chia nhỏ những gì mà các toàn tử đang làm. #### **A & B** Đầu tiên toán tử sẽ chuyển các số thập phân sang dạng nhị phân. - **12** trong dạng nhị phân sẽ là 0000 1100 - **5** trong dạng nhị phân sẽ là 0000 0101 Từ đó, nó sẽ áp dụng những quy tắc trên vào toán tử nhị phân AND (`&`) trên từng cặp bits, tức là, áp dụng toán tử `&` lên bit đầu tiên của 12 và bit đầu tiên của 5 rồi cứ tiếp tục như thế. Đó là cách mà `A & B` sẽ trả về kết quả là `4`. Thử áp dụng những quy tắc trên vào những toán tử khác và xem liệu bạn có nhận được kết quả cùng với output ở trên hay không? ### **8.4. Toán tử Shift** Toán tử Shift dịch chuyển các bit của toán hạng. Số lượng bit được dịch chuyển được chỉ định bằng cách sử dụng toán hạng bên phải. Vì vậy, trên dòng `print(B << 2); // B Shift Left 2` của mã, `B` được dịch sang trái bằng `2`. Hãy xem cách này hoạt động như thế nào ở hình dưới nhé. Và đó là cách mà `B << 2` trả về kết quả là `20` Hãy thử giải thích biểu thức ở dòng `print(A >> 2); // A Shift Right 2` và hiểu cách mà `A >> 2` trả về `3` ## **9. Mức độ ưu tiên của các toán tử trong Dart** Mức độ ưu tiên của toán tử xác định thứ tự mà các phần khác nhau của code hay biểu thức sẽ được thực hiện. Ví dụ, biểu thức **1 + 1 \* 5 **sẽ cho kết quả là 6 thay vì 10. Vì `*` có mức độ ưu tiên cao hơn `+`. Nếu chúng ta muốn ra kết quá là 10 thì phải viết **(1 + 1) \* 5 **vì `()` có mức độ ưu tiên cao hơn `*`. Dưới đây là bảng mức độ ưu tiên của các toán tử. Với mức độ ưu tiên cao nhất sẽ nằm ở trên cùng và thứ tự sẽ giảm dần xuống. Mỗi toán tử có mức độ ưu tiên cao hơn các toán tử trong các hàng theo sau nó. **Description** **Operator** Unary postfix `.`, `?.`, `++`, `--`, `[\`\`]`, `()` Unary prefix `-`, `!`, `˜`, `++`, `--`, `await` Multiplicative `*`, `/`, `˜/`, `%` Additive `+`, `-` Shift `<<`, `>>`, `>>>` Bitwise AND `&` Bitwise XOR `ˆ` Bitwise OR `|` Relational `<`, `>`, `<=`, `>=`, `as`, `is`, `is!` Equality `==`, `!=` Logical AND `&&` Logical Or `||` If-null `??` Conditional `?` `:` Cascade `..` Assignment `=`, `*=`, `/=`, `+=`, `-=`, `&=`, `ˆ=`, etc. Có thể có một số toán tử trong danh sách trên bạn không quen thuộc, nhưng không sao cả; chúng sẽ được đề cập đến trong các bài viết sau. Mục đích của danh sách này là cung cấp cho bạn một thứ tự ưu tiên toán tử toàn diện để bạn có thể quay lại xem bất cứ khi nào bạn cần. Chúng ta hãy tiếp tục tìm hiểu về Collection của Dart trong bài viết tiếp theo nhé. Bạn mới “nhập môn” ngôn ngữ Dart? Hãy tham khảo thêm các bài viết liên quan trên trang [Blog Lập Trình và Dữ Liệu của 200Lab]() nhé. Những kiến thức này sẽ là hành trang tuyệt vời cho bạn trên cho đường học tập đấy. [Xem Thêm Khóa Học Lập Trình]() Bây giờ thì thuộc nằm lòng các Dart Operators và thực hành thôi! **Một vài bài viết có thể bạn sẽ thích:** > [Dart là gì? Giới thiệu cơ bản về ngôn ngữ lập trình Dart]() > [Dart 2.15 có gì mới?]() > [Dart Null safety tối ưu ứng dụng Flutter như thế nào?]() > [Dart Cheat Sheet - Full bộ "bỏ túi" các syntax trong ngôn ngữ Dart]() > [Flutter cơ bản: Hiểu về Dart]()