Khái niệm
Toán tử là ký hiệu hoặc từ khóa dùng để tạo ra một phép tính mới từ một hoặc nhiều toán hạng. Trong các bài nhập môn, bốn nhóm toán tử quan trọng nhất là số học, so sánh, logic và gán ghép.
Toán tử số học
a = 12
b = 5
print(a + b) # 17
print(a - b) # 7
print(a * b) # 60
print(a / b) # 2.4 (chia thực)
print(a // b) # 2 (chia lấy phần nguyên)
print(a % b) # 2 (phần dư)
program ArithmeticDemo;
var
a, b: Integer;
begin
a := 12;
b := 5;
Writeln(a + b); { 17 }
Writeln(a - b); { 7 }
Writeln(a * b); { 60 }
Writeln(a / b:0:2); { 2.40 chia thực }
Writeln(a div b); { 2 chia lấy phần nguyên }
Writeln(a mod b); { 2 phần dư }
end.
#include <stdio.h>
int main(void) {
int a = 12;
int b = 5;
printf("%d\n", a + b); /* 17 */
printf("%d\n", a - b); /* 7 */
printf("%d\n", a * b); /* 60 */
printf("%.2f\n", (double)a / b); /* 2.40 chia thực */
printf("%d\n", a / b); /* 2 chia lấy phần nguyên */
printf("%d\n", a % b); /* 2 phần dư */
return 0;
}
#include <iostream>
using namespace std;
int main() {
int a = 12, b = 5;
cout << a + b << endl; // 17
cout << a - b << endl; // 7
cout << a * b << endl; // 60
cout << (double)a / b << endl; // 2.4 chia thực
cout << a / b << endl; // 2 chia lấy phần nguyên
cout << a % b << endl; // 2 phần dư
return 0;
}
int a = 12, b = 5;
Console.WriteLine(a + b); // 17
Console.WriteLine(a - b); // 7
Console.WriteLine(a * b); // 60
Console.WriteLine((double)a / b); // 2.4 chia thực
Console.WriteLine(a / b); // 2 chia lấy phần nguyên
Console.WriteLine(a % b); // 2 phần dư
const a = 12;
const b = 5;
console.log(a + b); // 17
console.log(a - b); // 7
console.log(a * b); // 60
console.log(a / b); // 2.4 chia thực
console.log(Math.trunc(a / b)); // 2 chia lấy phần nguyên
console.log(a % b); // 2 phần dư
const a: number = 12;
const b: number = 5;
console.log(a + b); // 17
console.log(a - b); // 7
console.log(a * b); // 60
console.log(a / b); // 2.4 chia thực
console.log(Math.trunc(a / b)); // 2 chia lấy phần nguyên
console.log(a % b); // 2 phần dư
package main
import "fmt"
func main() {
a, b := 12, 5
fmt.Println(a + b) // 17
fmt.Println(a - b) // 7
fmt.Println(a * b) // 60
fmt.Println(float64(a) / float64(b)) // 2.4 chia thực
fmt.Println(a / b) // 2 chia lấy phần nguyên
fmt.Println(a % b) // 2 phần dư
}
fn main() {
let a = 12;
let b = 5;
println!("{}", a + b); // 17
println!("{}", a - b); // 7
println!("{}", a * b); // 60
println!("{:.2}", a as f64 / b as f64); // 2.40 chia thực
println!("{}", a / b); // 2 chia lấy phần nguyên
println!("{}", a % b); // 2 phần dư
}
Toán tử so sánh và logic
Toán tử so sánh trả về giá trị đúng/sai (true/false): ==, !=, <, >, <=, >=. Toán tử logic kết hợp nhiều điều kiện với nhau: và (&&/and), hoặc (||/or), phủ (!/not).
age = 20
has_card = True
print(age >= 18)
print(age >= 18 and has_card)
program LogicDemo;
var
age: Integer;
hasCard: Boolean;
begin
age := 20;
hasCard := True;
Writeln(age >= 18);
Writeln((age >= 18) and hasCard);
end.
#include <stdbool.h>
#include <stdio.h>
int main(void) {
int age = 20;
bool hasCard = true;
printf("%d\n", age >= 18);
printf("%d\n", (age >= 18) && hasCard);
return 0;
}
#include <iostream>
using namespace std;
int main() {
int age = 20;
bool hasCard = true;
cout << (age >= 18) << endl;
cout << ((age >= 18) && hasCard) << endl;
return 0;
}
int age = 20;
bool hasCard = true;
Console.WriteLine(age >= 18);
Console.WriteLine(age >= 18 && hasCard);
const age = 20;
const hasCard = true;
console.log(age >= 18);
console.log(age >= 18 && hasCard);
const age: number = 20;
const hasCard: boolean = true;
console.log(age >= 18);
console.log(age >= 18 && hasCard);
package main
import "fmt"
func main() {
age := 20
hasCard := true
fmt.Println(age >= 18)
fmt.Println(age >= 18 && hasCard)
}
fn main() {
let age = 20;
let has_card = true;
println!("{}", age >= 18);
println!("{}", age >= 18 && has_card);
}
Toán tử gán ghép
Toán tử gán ghép kết hợp phép tính với phép gán. x += 3 là cách viết tắt của x = x + 3 — ngắn hơn và rõ ý hơn khi cần cập nhật giá trị biến.
x = 10
x += 3 # x = 13
x -= 2 # x = 11
x *= 4 # x = 44
x //= 5 # x = 8 (chia lấy phần nguyên)
print(x) # 8
Pascal không có toán tử gán ghép. Phải viết đầy đủ:
program AssignDemo;
var
x: Integer;
begin
x := 10;
x := x + 3; { x = 13 }
x := x - 2; { x = 11 }
x := x * 4; { x = 44 }
x := x div 5; { x = 8 }
Writeln(x); { 8 }
end.
#include <stdio.h>
int main(void) {
int x = 10;
x += 3; /* x = 13 */
x -= 2; /* x = 11 */
x *= 4; /* x = 44 */
x /= 5; /* x = 8 */
printf("%d\n", x); /* 8 */
return 0;
}
#include <iostream>
using namespace std;
int main() {
int x = 10;
x += 3; // x = 13
x -= 2; // x = 11
x *= 4; // x = 44
x /= 5; // x = 8
cout << x << endl; // 8
return 0;
}
int x = 10;
x += 3; // x = 13
x -= 2; // x = 11
x *= 4; // x = 44
x /= 5; // x = 8
Console.WriteLine(x); // 8
let x = 10;
x += 3; // x = 13
x -= 2; // x = 11
x *= 4; // x = 44
x /= 5; // x = 8.8 (JS không có kiểu int riêng)
console.log(x); // 8.8
let x: number = 10;
x += 3; // x = 13
x -= 2; // x = 11
x *= 4; // x = 44
x /= 5; // x = 8.8
console.log(x); // 8.8
package main
import "fmt"
func main() {
x := 10
x += 3 // x = 13
x -= 2 // x = 11
x *= 4 // x = 44
x /= 5 // x = 8 (kiểu int, tự động cắt phần thập phân)
fmt.Println(x) // 8
}
fn main() {
let mut x = 10;
x += 3; // x = 13
x -= 2; // x = 11
x *= 4; // x = 44
x /= 5; // x = 8 (kiểu integer, cắt phần thập phân)
println!("{}", x); // 8
}
Nguyên tắc sử dụng
- Ưu tiên biểu thức rõ nghĩa hơn biểu thức quá ngắn.
- Dùng ngoặc khi biểu thức có nhiều toán tử để giảm nhầm lẫn về thứ tự ưu tiên.
- Kiểm tra kiểu dữ liệu của toán hạng trước khi thực hiện phép chia hoặc so sánh.
- Nhớ phân biệt
/(chia thực) và///div(chia lấy phần nguyên) khi cần kết quả là số nguyên.
Ghi chú theo ngôn ngữ
Python phân biệt phép chia thực / (luôn trả về float) và chia lấy phần nguyên // (trả về int). Toán tử logic viết bằng từ khóa tiếng Anh: and, or, not. Giá trị boolean dùng True/False (viết hoa chữ cái đầu).
Pascal dùng div cho chia lấy phần nguyên và mod cho phần dư. Giá trị boolean là True/False. Toán tử logic viết bằng từ khóa: and, or, not. Pascal không có toán tử gán ghép như +=; phải viết đầy đủ x := x + 1.
C dùng &&, ||, ! cho logic. Chia hai int cho nhau sẽ tự động cắt phần thập phân — cần ép kiểu (double) trước khi chia nếu muốn có kết quả thực. Kiểu bool có từ C99 (#include <stdbool.h>); trước đó dùng 0/1.
C++ có kiểu bool gốc với giá trị true/false. Giống C, chia hai int sẽ cắt phần thập phân. C++ cũng chấp nhận and, or, not như tên thay thế cho &&, ||, !.
C# có kiểu bool gốc. Chia hai int tự động cắt phần thập phân, cần ép kiểu (double) nếu muốn kết quả thực. Không thể dùng số nguyên như giá trị boolean như trong C.
JavaScript chỉ có một kiểu số number (64-bit float) — không phân biệt int và float. Do đó 10 / 3 luôn cho 3.333..., và 10 % 3 cho 1. Để lấy phần nguyên, dùng Math.trunc() hoặc dùng toán tử |0 (bitwise OR 0).
TypeScript kế thừa hệ thống số của JavaScript: kiểu number là 64-bit float. Tất cả quy tắc của JavaScript về chia số đều áp dụng. TypeScript chỉ thêm kiểm tra kiểu tại compile time, không thay đổi hành vi runtime.
Go phân biệt kiểu số nguyên (int) và thực (float64). Chia hai int sẽ cắt phần thập phân. Muốn chia thực, cần ép kiểu tường minh float64(a) / float64(b). Go không có toán tử ++a hay --a (chỉ có a++ và a-- là câu lệnh, không phải biểu thức).
Rust có các kiểu số nguyên (i32, i64, u32…) và số thực (f32, f64) hoàn toàn riêng biệt. Không được phép chia i32 với f64 trực tiếp — phải ép kiểu tường minh a as f64 / b as f64. Chia số nguyên cho 0 gây panic ở runtime.
Kết luận
Toán tử là công cụ để tạo điều kiện, cập nhật biến và xây dựng phép tính. Bài kế tiếp là Nhập xuất dữ liệu, nơi các biểu thức này được dùng với dữ liệu lấy từ người dùng.
Bình luận