Tất tần tật Các Toán Tử (Operators) Trong PHP

Toán tử (Operator) là một thành phần quan trọng của mọi ngôn ngữ lập trình, bao gồm PHP. Toán tử giúp thực hiện các phép toán số học, logic, so sánh, xử lý chuỗi, và nhiều hơn nữa. Bài viết này sẽ cung cấp một hướng dẫn toàn diện về tất cả các loại toán tử trong PHP, kèm theo ví dụ minh họa.

1. Toán Tử Số Học (Arithmetic Operators)

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

1.1. Phép Cộng (+)

Mô tả: Tính tổng của hai số.
Cú pháp: $a + $b
Ví dụ:

$a = 5;
$b = 3;
$result = $a + $b; // 8
echo $result; // Kết quả: 8

1.2. Phép Trừ (-)

Mô tả: Tính hiệu của hai số.
Cú pháp: $a - $b
Ví dụ:

$a = 10;
$b = 4;
$result = $a - $b; // 6
echo $result; // Kết quả: 6

1.3. Phép Nhân (*)

Mô tả: Tính tích của hai số.
Cú pháp: $a * $b
Ví dụ:

$a = 7;
$b = 6;
$result = $a * $b; // 42
echo $result; // Kết quả: 42

1.4. Phép Chia (/)

Mô tả: Tính thương của hai số.
Cú pháp: $a / $b
Lưu ý: Nếu $b = 0, PHP sẽ báo lỗi chia cho 0.
Ví dụ:

$a = 12;
$b = 4;
$result = $a / $b; // 3
echo $result; // Kết quả: 3

1.5. Phép Chia Lấy Dư (%)

Mô tả: Tính phần dư khi chia $a cho $b.
Cú pháp: $a % $b
Ví dụ:

$a = 10;
$b = 3;
$result = $a % $b; // 1
echo $result; // Kết quả: 1

1.6. Phép Lũy Thừa (**)

Mô tả: Tính lũy thừa của $a mũ $b.
Cú pháp: $a ** $b
Ví dụ:

$a = 2;
$b = 3;
$result = $a ** $b; // 8 (2^3)
echo $result; // Kết quả: 8

2. Toán Tử Một Toán Hạng (Unary Operators)

2.1. Toán Tử Âm (-)

Mô tả: Chuyển đổi giá trị thành số âm.
Cú pháp: -$a
Ví dụ:

$a = 5;
$result = -$a; // -5
echo $result; // Kết quả: -5

2.2. Toán Tử Dương (+)

Mô tả: Chuyển đổi giá trị thành số dương (thường dùng để làm rõ ý nghĩa).
Cú pháp: +$a
Ví dụ:

$a = -7;
$result = +$a; // -7 (giữ nguyên giá trị)
echo $result; // Kết quả: -7

3. Toán Tử Tăng Giảm (Increment và Decrement Operators)

3.1. Phép Tăng Trước (++$a)

Mô tả: Tăng giá trị của $a lên 1, sau đó trả về giá trị đã tăng.
Cú pháp: ++$a
Ví dụ:

$a = 5;
echo ++$a; // Kết quả: 6 (tăng trước khi trả về)

3.2. Phép Tăng Sau ($a++)

Mô tả: Trả về giá trị của $a, sau đó tăng $a lên 1.
Cú pháp: $a++
Ví dụ:

$a = 5;
echo $a++; // Kết quả: 5 (trả về trước khi tăng)
echo $a; // Kết quả: 6 (giá trị sau khi tăng)

3.3. Phép Giảm Trước (--$a)

Mô tả: Giảm giá trị của $a xuống 1, sau đó trả về giá trị đã giảm.
Cú pháp: --$a
Ví dụ:

$a = 5;
echo --$a; // Kết quả: 4 (giảm trước khi trả về)

3.4. Phép Giảm Sau ($a--)

Mô tả: Trả về giá trị của $a, sau đó giảm $a xuống 1.
Cú pháp: $a--
Ví dụ:

$a = 5;
echo $a--; // Kết quả: 5 (trả về trước khi giảm)
echo $a; // Kết quả: 4 (giá trị sau khi giảm)

4. Toán Tử Gán Kết Hợp (Compound Assignment Operators)

4.1. Phép Cộng và Gán (+=)

Mô tả: Cộng $b vào $a và gán kết quả cho $a.
Cú pháp: $a += $b
Ví dụ:

$a = 10;
$b = 5;
$a += $b; // $a = $a + $b
echo $a; // Kết quả: 15

4.2. Phép Trừ và Gán (-=)

Mô tả: Trừ $b khỏi $a và gán kết quả cho $a.
Cú pháp: $a -= $b
Ví dụ:

$a = 10;
$b = 5;
$a -= $b; // $a = $a - $b
echo $a; // Kết quả: 5

4.3. Phép Nhân và Gán (*=)

Mô tả: Nhân $a với $b và gán kết quả cho $a.
Cú pháp: $a *= $b
Ví dụ:

$a = 4;
$b = 3;
$a *= $b; // $a = $a * $b
echo $a; // Kết quả: 12

4.4. Phép Chia và Gán (/=)

Mô tả: Chia $a cho $b và gán kết quả cho $a.
Cú pháp: $a /= $b
Ví dụ:

$a = 12;
$b = 4;
$a /= $b; // $a = $a / $b
echo $a; // Kết quả: 3

4.5. Phép Chia Lấy Dư và Gán (%=)

Mô tả: Lấy dư của $a chia $b và gán kết quả cho $a.
Cú pháp: $a %= $b
Ví dụ:

$a = 10;
$b = 3;
$a %= $b; // $a = $a % $b
echo $a; // Kết quả: 1

2. Toán Tử Bitwise (Bitwise Operators)

Toán tử Bitwise (Bitwise Operators) được sử dụng để thực hiện các phép toán trên từng bit của số nguyên. Đây là các thao tác trực tiếp đến từng bit trong biểu diễn nhị phân của số nguyên, giúp xử lý dữ liệu ở mức thấp một cách hiệu quả.

2.1. Toán Tử Bitwise Cơ Bản

2.1.1. Toán Tử AND (&)

Mô tả: Thực hiện phép "và" (AND) trên từng bit.

• Kết quả là 1 nếu cả hai bit tương ứng đều là 1, ngược lại là 0.

Cú pháp: $a & $b
Ví dụ:

$a = 6; // 0110 (nhị phân)
$b = 3; // 0011 (nhị phân) $result = $a & $b; // 0010 (nhị phân) = 2
echo $result; // Kết quả: 2

2.1.2. Toán Tử OR (|)

Mô tả: Thực hiện phép "hoặc" (OR) trên từng bit.

• Kết quả là 1 nếu ít nhất một bit tương ứng là 1.

Cú pháp: $a | $b
Ví dụ:

$a = 6; // 0110 (nhị phân)
$b = 3; // 0011 (nhị phân) $result = $a | $b; // 0111 (nhị phân) = 7
echo $result; // Kết quả: 7

2.1.3. Toán Tử XOR (^)

Mô tả: Thực hiện phép "hoặc loại trừ" (XOR) trên từng bit.

• Kết quả là 1 nếu hai bit tương ứng khác nhau, ngược lại là 0.

Cú pháp: $a ^ $b
Ví dụ:

$a = 6; // 0110 (nhị phân)
$b = 3; // 0011 (nhị phân) $result = $a ^ $b; // 0101 (nhị phân) = 5
echo $result; // Kết quả: 5

2.1.4. Toán Tử NOT (~)

Mô tả: Đảo ngược tất cả các bit của số nguyên.

• Bit 1 sẽ trở thành 0, và bit 0 sẽ trở thành 1.

Cú pháp: ~$a
Ví dụ:

$a = 6; // 0110 (nhị phân) $result = ~$a; // 1001 (nhị phân) = -7 (trong hệ số bù 2)
echo $result; // Kết quả: -7

Lưu ý: Kết quả của toán tử NOT phụ thuộc vào cách biểu diễn số âm của máy tính (thường là hệ bù 2).

2.1.5. Toán Tử Dịch Trái (<<)

Mô tả: Dịch các bit của $a sang trái $b vị trí, thêm các bit 0 vào bên phải.

• Mỗi lần dịch trái tương đương nhân số đó với 2^b.

Cú pháp: $a << $b
Ví dụ:

$a = 3; // 0011 (nhị phân)
$b = 2; $result = $a << $b; // 1100 (nhị phân) = 12
echo $result; // Kết quả: 12

2.1.6. Toán Tử Dịch Phải (>>)

Mô tả: Dịch các bit của $a sang phải $b vị trí, bỏ các bit dư bên phải.

• Mỗi lần dịch phải tương đương chia số đó cho 2^b.

Cú pháp: $a >> $b
Ví dụ:

$a = 12; // 1100 (nhị phân)
$b = 2; $result = $a >> $b; // 0011 (nhị phân) = 3
echo $result; // Kết quả: 3

2.2. Toán Tử Gán Kết Hợp Bitwise

2.2.1. Toán Tử AND và Gán (&=)

Mô tả: Gán kết quả phép AND giữa $a và $b cho $a.
Cú pháp: $a &= $b
Ví dụ:

$a = 6; // 0110 (nhị phân)
$b = 3; // 0011 (nhị phân) $a &= $b; // $a = $a & $b = 0010 (nhị phân) = 2
echo $a; // Kết quả: 2

2.2.2. Toán Tử OR và Gán (|=)

Mô tả: Gán kết quả phép OR giữa $a và $b cho $a.
Cú pháp: $a |= $b
Ví dụ:

$a = 6; // 0110 (nhị phân)
$b = 3; // 0011 (nhị phân) $a |= $b; // $a = $a | $b = 0111 (nhị phân) = 7
echo $a; // Kết quả: 7

2.2.3. Toán Tử XOR và Gán (^=)

Mô tả: Gán kết quả phép XOR giữa $a và $b cho $a.
Cú pháp: $a ^= $b
Ví dụ:

$a = 6; // 0110 (nhị phân)
$b = 3; // 0011 (nhị phân) $a ^= $b; // $a = $a ^ $b = 0101 (nhị phân) = 5
echo $a; // Kết quả: 5

2.2.4. Toán Tử Dịch Trái và Gán (<<=)

Mô tả: Gán kết quả phép dịch trái $a << $b cho $a.
Cú pháp: $a <<= $b
Ví dụ:

$a = 3; // 0011 (nhị phân)
$b = 2; $a <<= $b; // $a = $a << $b = 1100 (nhị phân) = 12
echo $a; // Kết quả: 12

2.2.5. Toán Tử Dịch Phải và Gán (>>=)

Mô tả: Gán kết quả phép dịch phải $a >> $b cho $a.
Cú pháp: $a >>= $b
Ví dụ:

$a = 12; // 1100 (nhị phân)
$b = 2; $a >>= $b; // $a = $a >> $b = 0011 (nhị phân) = 3
echo $a; // Kết quả: 3

3. Toán Tử So Sánh (Comparison Operators)

Toán tử so sánh (Comparison Operators) trong PHP được sử dụng để so sánh hai giá trị. Chúng trả về giá trị kiểu boolean (true hoặc false) dựa trên kết quả của phép so sánh.

3.1. Các Toán Tử So Sánh Cơ Bản

3.1.1. Toán Tử Bằng Nhau (==)

Mô tả: Kiểm tra nếu hai giá trị bằng nhau (không xét kiểu dữ liệu).
Cú pháp: $a == $b

Ví dụ:

$a = 5;
$b = '5'; var_dump($a == $b); // true (giá trị bằng nhau, kiểu không được kiểm tra)

3.1.2. Toán Tử Khác Nhau (!=)

Mô tả: Kiểm tra nếu hai giá trị không bằng nhau (không xét kiểu).
Cú pháp: $a != $b

Ví dụ:

$a = 5;
$b = 10; var_dump($a != $b); // true (giá trị khác nhau)

3.1.3. Toán Tử Khác Nhau (<>)

Mô tả: Là một cách khác để kiểm tra nếu hai giá trị không bằng nhau (không xét kiểu).
Cú pháp: $a <> $b

Ví dụ:

$a = 5;
$b = 10; var_dump($a <> $b); // true (giá trị khác nhau)

3.1.4. Toán Tử Bằng Và Cùng Kiểu (===)

Mô tả: Kiểm tra nếu hai giá trị bằng nhau và có cùng kiểu dữ liệu.
Cú pháp: $a === $b

Ví dụ:

$a = 5;
$b = '5'; var_dump($a === $b); // false (giá trị bằng nhau nhưng kiểu khác nhau)

3.1.5. Toán Tử Không Bằng Hoặc Khác Kiểu (!==)

Mô tả: Kiểm tra nếu hai giá trị không bằng nhau hoặc khác kiểu dữ liệu.
Cú pháp: $a !== $b

Ví dụ:

$a = 5;
$b = '5'; var_dump($a !== $b); // true (giá trị bằng nhau nhưng kiểu khác nhau)

3.2. Toán Tử So Sánh Lớn Nhỏ

3.2.1. Toán Tử Nhỏ Hơn (<)

Mô tả: Kiểm tra nếu $a nhỏ hơn $b.
Cú pháp: $a < $b

Ví dụ:

$a = 5;
$b = 10; var_dump($a < $b); // true

3.2.2. Toán Tử Lớn Hơn (>)

Mô tả: Kiểm tra nếu $a lớn hơn $b.
Cú pháp: $a > $b

Ví dụ:

$a = 5;
$b = 10; var_dump($a > $b); // false

3.2.3. Toán Tử Nhỏ Hơn Hoặc Bằng (<=)

Mô tả: Kiểm tra nếu $a nhỏ hơn hoặc bằng $b.
Cú pháp: $a <= $b

Ví dụ:

$a = 5;
$b = 5; var_dump($a <= $b); // true

3.2.4. Toán Tử Lớn Hơn Hoặc Bằng (>=)

Mô tả: Kiểm tra nếu $a lớn hơn hoặc bằng $b.
Cú pháp: $a >= $b

Ví dụ:

$a = 10;
$b = 5; var_dump($a >= $b); // true

3.3. Toán Tử So Sánh Ba Chiều (<=>)

Mô tả: Toán tử "spaceship" trả về:

• -1 nếu $a nhỏ hơn $b.
• 0 nếu $a bằng $b.
• 1 nếu $a lớn hơn $b.

Cú pháp: $a <=> $b

Ví dụ:

$a = 5;
$b = 10; var_dump($a <=> $b); // -1 (vì $a nhỏ hơn $b) $a = 10;
$b = 10; var_dump($a <=> $b); // 0 (vì $a bằng $b) $a = 15;
$b = 10; var_dump($a <=> $b); // 1 (vì $a lớn hơn $b)

4. Toán Tử Logic (Logical Operators)

Toán tử logic (Logical Operators) trong PHP được sử dụng để kết hợp các điều kiện hoặc đảo ngược điều kiện trong các câu lệnh điều kiện và vòng lặp. Chúng trả về giá trị kiểu boolean (true hoặc false).

4.1. Các Toán Tử Logic Cơ Bản

4.1.1. Toán Tử AND (&&)

Mô tả: Trả về true nếu cả hai điều kiện đều đúng.
Cú pháp: $a && $b
Ví dụ:

$a = true;
$b = false; var_dump($a && $b); // false (vì $b là false)

4.1.2. Toán Tử OR (||)

Mô tả: Trả về true nếu ít nhất một điều kiện đúng.
Cú pháp: $a || $b
Ví dụ:

$a = true;
$b = false; var_dump($a || $b); // true (vì $a là true)

4.1.3. Toán Tử NOT (!)

Mô tả: Đảo ngược giá trị boolean của một điều kiện.
Cú pháp: !$a
Ví dụ:

$a = true; var_dump(!$a); // false (vì $a là true, NOT sẽ đảo ngược thành false)

4.1.4. Toán Tử XOR (xor)

Mô tả: Trả về true nếu một và chỉ một điều kiện đúng.
Cú pháp: $a xor $b
Ví dụ:

$a = true;
$b = false; var_dump($a xor $b); // true (vì chỉ một trong hai giá trị là true)

4.2. Toán Tử Logic Thay Thế (Thấp Ưu Tiên)

4.2.1. Toán Tử AND (and)

Mô tả: Tương tự như &&, nhưng có độ ưu tiên thấp hơn.
Cú pháp: $a and $b
Ví dụ:

$a = true;
$b = false; var_dump($a and $b); // false (vì $b là false)

4.2.2. Toán Tử OR (or)

Mô tả: Tương tự như ||, nhưng có độ ưu tiên thấp hơn.
Cú pháp: $a or $b
Ví dụ:

$a = true;
$b = false; var_dump($a or $b); // true (vì $a là true)

4.3. Toán Tử Ternary (Điều Kiện Ba Ngôi)

4.3.1. Toán Tử Ternary (? :)

Mô tả: Trả về $b nếu $a là true, ngược lại trả về $c.
Cú pháp: $a ? $b : $c
Ví dụ:

$a = true;
$b = "Đúng";
$c = "Sai"; echo $a ? $b : $c; // Kết quả: "Đúng" (vì $a là true)

4.3.2. Null Coalescing Shorthand (?:)

Mô tả: Nếu $a là true, trả về $a, ngược lại trả về $b. Đây là phiên bản rút gọn của ? :.
Cú pháp: $a ?: $b
Ví dụ:

$a = null;
$b = "Giá trị mặc định"; echo $a ?: $b; // Kết quả: "Giá trị mặc định" (vì $a là null)

5. Toán Tử Chuỗi (String Operators)

Toán tử chuỗi (String Operators) trong PHP được sử dụng để thao tác và kết hợp chuỗi. Chúng cho phép bạn nối các chuỗi hoặc gán chuỗi một cách hiệu quả và linh hoạt.

5.1. Các Toán Tử Chuỗi Cơ Bản

5.1.1. Toán Tử Nối Chuỗi (.)

Mô tả: Dùng để nối (kết hợp) hai chuỗi với nhau.
Cú pháp: $a . $b
Ví dụ:

$a = "Hello";
$b = " World"; $result = $a . $b; // Nối $a và $b
echo $result; // Kết quả: "Hello World"

5.1.2. Toán Tử Nối Chuỗi Và Gán (.=)

Mô tả: Dùng để nối chuỗi $b vào cuối chuỗi $a và gán kết quả lại cho $a.
Cú pháp: $a .= $b
Ví dụ:

$a = "Hello";
$b = " World"; $a .= $b; // Nối $b vào cuối $a và gán lại cho $a
echo $a; // Kết quả: "Hello World"

5.2. Sử Dụng Cú Pháp Dấu Ngoặc Nhọn {}

Cú pháp dấu ngoặc nhọn {} được sử dụng để nhúng biến vào chuỗi, đặc biệt khi cần làm rõ cú pháp hoặc kết hợp nhiều biến/phần tử trong một chuỗi.

5.2.1. Nhúng Biến Vào Chuỗi

Mô tả: Nhúng giá trị của biến vào chuỗi bằng cách bao quanh biến bằng dấu {}.
Cú pháp: {$a}
Ví dụ:

$a = "PHP"; echo "I love {$a} programming!"; // Kết quả: "I love PHP programming!"

5.2.2. Kết Hợp Nhiều Biến

Mô tả: Kết hợp nhiều biến hoặc biểu thức trong một chuỗi sử dụng dấu ngoặc nhọn {}.
Cú pháp: {$a}{$b}
Ví dụ:

$a = "Hello";
$b = "World"; echo "{$a} {$b}!"; // Kết quả: "Hello World!"

6. Toán Tử Null Coalescing Trong PHP

Toán tử Null Coalescing trong PHP được sử dụng để kiểm tra và xử lý các giá trị null (không tồn tại). Đây là một cách ngắn gọn và hiệu quả để cung cấp giá trị thay thế cho một biến khi nó không tồn tại hoặc có giá trị null.

6.1. Toán Tử Null Coalescing (??)

Mô tả

• Toán tử ?? trả về giá trị của biến đầu tiên không phải null trong danh sách các biến được kiểm tra.
• Nếu biến đầu tiên không được đặt hoặc có giá trị là null, toán tử sẽ trả về giá trị thay thế ở phía sau.

Cú pháp

$a ?? $b

• $a: Biến cần kiểm tra.
• $b: Giá trị thay thế nếu $a không tồn tại hoặc có giá trị null.

Ví dụ

$a = null;
$b = "Giá trị mặc định"; $result = $a ?? $b; // $a là null, trả về $b
echo $result; // Kết quả: "Giá trị mặc định"

$a = "Hello";
$b = "Giá trị mặc định"; $result = $a ?? $b; // $a không phải null, trả về $a
echo $result; // Kết quả: "Hello"

6.2. Toán Tử Gán Null Coalescing (??=)

Mô tả

• Toán tử ??= là một phiên bản kết hợp của toán tử ?? và phép gán =.
• Nó kiểm tra xem biến có giá trị không (tồn tại và không phải null). Nếu không, nó sẽ gán giá trị thay thế cho biến đó.

Cú pháp

$a ??= $b

• $a: Biến cần kiểm tra và có thể được gán giá trị.
• $b: Giá trị thay thế để gán nếu $a không tồn tại hoặc có giá trị null.

Ví dụ

$a = null;
$b = "Giá trị thay thế"; $a ??= $b; // $a là null, gán giá trị $b cho $a
echo $a; // Kết quả: "Giá trị thay thế"

$a = "Đã tồn tại giá trị";
$b = "Giá trị thay thế"; $a ??= $b; // $a đã có giá trị, không thay đổi
echo $a; // Kết quả: "Đã tồn tại giá trị"

7. Giống và khác nhau giữa một số toán tử

Dưới đây là sự so sánh giữa các toán tử trong PHP có sự tương đồng về mục đích hoặc cách sử dụng.

7.1. Toán tử so sánh bằng nhau (==) và so sánh bằng và cùng kiểu (===)

Điểm giống nhau: Cả hai đều được sử dụng để kiểm tra sự bằng nhau giữa hai giá trị.

Điểm khác nhau:

• == (so sánh bằng nhau): Kiểm tra giá trị, bỏ qua kiểu dữ liệu.
• === (so sánh bằng và cùng kiểu): Kiểm tra giá trị và kiểu dữ liệu.

$a = 5; // integer
$b = "5"; // string var_dump($a == $b); // true (giá trị bằng nhau, kiểu bị bỏ qua)
var_dump($a === $b); // false (giá trị bằng nhau nhưng kiểu khác nhau)

7.2. Toán tử khác nhau (!=) và khác nhau và khác kiểu (!==)

Điểm giống nhau: Cả hai đều được sử dụng để kiểm tra sự khác nhau giữa hai giá trị.

Điểm khác nhau

• != (khác nhau): Kiểm tra giá trị, bỏ qua kiểu dữ liệu.
• !==(khác nhau và khác kiểu): Kiểm tra giá trị và kiểu dữ liệu.

$a = 5; // integer
$b = "5"; // string var_dump($a != $b); // false (giá trị không khác nhau, kiểu bị bỏ qua)
var_dump($a !== $b); // true (giá trị bằng nhau nhưng kiểu khác nhau)

7.3. Toán tử khác (!=) và (<>)

Điểm giống nhau: Cả hai đều kiểm tra sự khác nhau giữa hai giá trị (không xét kiểu dữ liệu).

Điểm khác nhau: Không có khác biệt về chức năng, chỉ là hai cách viết khác nhau.

$a = 5;
$b = 10; var_dump($a != $b); // true (giá trị khác nhau)
var_dump($a <> $b); // true (giá trị khác nhau)

7.4. Toán tử AND (&&) và (and)

Điểm giống nhau: Cả hai đều kiểm tra nếu cả hai điều kiện đúng thì trả về true.

Điểm khác nhau

• && có độ ưu tiên cao hơn.
• and có độ ưu tiên thấp hơn, thường dùng trong các câu lệnh gán giá trị.

$a = true;
$b = false; // Sử dụng `&&` (ưu tiên cao hơn)
$result1 = $a && $b;
var_dump($result1); // false // Sử dụng `and` (ưu tiên thấp hơn)
$result2 = $a and $b;
var_dump($result2); // false // Sự khác biệt về ưu tiên
$c = true || false and false; var_dump($c); // true (do `||` có độ ưu tiên cao hơn `and`)

7.5. Toán tử OR (||) và (or)

Điểm giống nhau: Cả hai đều kiểm tra nếu ít nhất một điều kiện đúng thì trả về true.

Điểm khác nhau

• ||có độ ưu tiên cao hơn.
• or có độ ưu tiên thấp hơn, thường dùng trong các câu lệnh gán giá trị.

$a = true;
$b = false; // Sử dụng `||` (ưu tiên cao hơn)
$result1 = $a || $b;
var_dump($result1); // true // Sử dụng `or` (ưu tiên thấp hơn)
$result2 = $a or $b;
var_dump($result2); // true // Sự khác biệt về ưu tiên
$c = false && true or true; var_dump($c); // true (do `and` có độ ưu tiên cao hơn `or`)

7.6. Toán tử Null Coalescing (??) và Ternary Rút Gọn (?

Điểm giống nhau: Cả hai đều được sử dụng để kiểm tra giá trị của $a và cung cấp giá trị thay thế $b nếu $a không hợp lệ.

Điểm khác nhau

• ?? chỉ kiểm tra xem $a có phải là null hay không.
• ?: kiểm tra tất cả các giá trị falsy, bao gồm null, 0, "", false, và [].

$a = null;
$b = "Giá trị mặc định"; // Sử dụng `??` (chỉ kiểm tra giá trị null)
$result1 = $a ?? $b;
echo $result1; // Kết quả: "Giá trị mặc định" // Sử dụng `?:` (kiểm tra tất cả giá trị falsy)
$a = 0;
$result2 = $a ?: $b;
echo $result2; // Kết quả: "Giá trị mặc định"

Lưu ý về sự khác biệt

$a = 0;
$b = "Giá trị mặc định"; // Null Coalescing (??): Không coi `0` là null
$result1 = $a ?? $b; echo $result1; // Kết quả: 0 // Ternary Rút Gọn (?:): Coi `0` là falsy
$result2 = $a ?: $b;
echo $result2; // Kết quả: "Giá trị mặc định"

7.7. Spaceship (<=>) vs Các Toán Tử Lớn Nhỏ (<, >, <=, >=)

Ví dụ:

$a = 5;
$b = 10; // So sánh ba chiều
var_dump($a <=> $b); // -1 (vì $a nhỏ hơn $b)
var_dump($b <=> $a); // 1 (vì $b lớn hơn $a)
var_dump($a <=> $a); // 0 (vì bằng nhau)

7.8. Toán Tử Tăng Giảm (++, --) và Toán Tử Gán Cộng (+=)

Điểm giống nhau: Các toán tử này đều dùng để thay đổi giá trị của biến $a, thông qua việc tăng, giảm hoặc cộng thêm một giá trị khác.

Điểm khác nhau

// Ví dụ minh họa // Tăng trước và tăng sau
$a = 5;
echo ++$a; // Kết quả: 6 (tăng trước, trả về giá trị sau khi tăng)
echo $a++; // Kết quả: 6 (trả về giá trị hiện tại, sau đó mới tăng) // Giảm trước và giảm sau
$b = 5;
echo --$b; // Kết quả: 4 (giảm trước, trả về giá trị sau khi giảm)
echo $b--; // Kết quả: 4 (trả về giá trị hiện tại, sau đó mới giảm) // Gán cộng và phép cộng đầy đủ
$c = 5;
$d = 10;
$c += $d; // Tương đương với $c = $c + $d
echo $c; // Kết quả: 15

Tổng kết

Các toán tử trong PHP rất đa dạng, phục vụ cho nhiều mục đích từ xử lý số học, logic đến thao tác chuỗi. Việc hiểu rõ cách hoạt động của từng toán tử sẽ giúp bạn viết mã hiệu quả và tối ưu hơn. Hãy thực hành thường xuyên để làm quen và thành thạo các toán tử này!

Tham khảo thêm: https://php-operators.com/