Kiểu dữ liệu số trong PHP

PHP Tutorial | 21/06/2025 by Học PHP

PHP, một ngôn ngữ lập trình mạnh mẽ cho phát triển web, cũng có cách riêng để làm việc với các con số. Việc hiểu rõ cách PHP lưu trữ và thao tác với dữ liệu số không chỉ giúp bạn viết code đúng mà còn hiệu quả hơn rất nhiều.

Bài viết này sẽ đưa bạn đi sâu vào tìm hiểu các kiểu dữ liệu số trong PHP, tìm hiểu hai loại chính là số nguyên (Integers) và số thực (Floats). Mình sẽ tìm hiểu cách khai báo, sử dụng, và những lưu ý quan trọng khi thực hiện các phép toán với số, đảm bảo bạn có thể xử lý mọi tác vụ liên quan đến số liệu một cách tự tin.

Kiểu dữ liệu số là gì?

Khi chúng ta lập trình, giống như việc giao tiếp với máy tính, chúng ta cần nói cho nó biết loại thông tin mà chúng ta đang muốn nó xử lý. Thông tin có thể là chữ viết, hình ảnh, âm thanh, và tất nhiên, không thể thiếu các con số.

Dữ liệu trong lập trình

Mọi thứ mà máy tính làm việc đều là dữ liệu. Nhưng máy tính không thể chỉ nhìn một "cục" dữ liệu và tự động biết nó là gì. Chúng ta cần "phân loại" nó, tức là gán cho nó một kiểu dữ liệu. Kiểu dữ liệu giúp máy tính biết cách lưu trữ thông tin đó trong bộ nhớ và biết nó có thể làm gì với thông tin đó.

Ví dụ:

Bạn muốn lưu tên một người? Đó là kiểu chuỗi (String).
Bạn muốn lưu ngày sinh nhật? Đó là kiểu ngày tháng.
Bạn muốn lưu trạng thái "đã bật/tắt"? Đó là kiểu Boolean (đúng/sai).
Và quan trọng nhất, bạn muốn lưu các giá trị để tính toán? Đó là kiểu số.

Kiểu dữ liệu số

Kiểu dữ liệu số đúng như tên gọi của nó, là loại dữ liệu được dùng để lưu trữ các con số. Đây là kiểu dữ liệu không thể thiếu trong bất kỳ chương trình nào, từ những ứng dụng đơn giản nhất đến các hệ thống phức tạp.

Tại sao cần kiểu dữ liệu số? Chúng ta cần số để thực hiện vô vàn các tác vụ quan trọng:

Thực hiện các phép tính: Cộng, trừ, nhân, chia, lũy thừa... (Ví dụ: tính tổng tiền hóa đơn, tính điểm trung bình).
Đếm: Đếm số lượng sản phẩm, số lượt truy cập, số người dùng.
So sánh giá trị: Kiểm tra xem số này có lớn hơn, nhỏ hơn, hay bằng số kia không (Ví dụ: kiểm tra xem tuổi có đủ điều kiện, giá sản phẩm có vượt ngân sách không).
Định lượng: Biểu thị các giá trị có thể đo lường được (chiều cao, cân nặng, nhiệt độ).

Ví dụ cơ bản:

<?php
$quantity = 10;       // Số lượng sản phẩm
$unitPrice = 25.50;   // Giá một sản phẩm
$discount = 5;        // Phần trăm giảm giá

$totalCost = ($quantity * $unitPrice) - $discount;
echo "Tổng chi phí là: " . $totalCost . " USD"; // Output: Tổng chi phí là: 250 USD
?>

Trong ví dụ trên, $quantity, $unitPrice, $discount đều là các con số mà chúng ta có thể thực hiện phép tính toán trên chúng.

Các loại số chính trong PHP

PHP rất linh hoạt trong việc xử lý số và tự động nhận diện loại số mà bạn đang sử dụng. Trong PHP, có hai loại kiểu dữ liệu số chính mà bạn sẽ làm việc:

Số nguyên (Integer):

Khái niệm: Là các số tròn, không có phần thập phân. Chúng có thể là số dương, số âm hoặc số 0.
Ví dụ: 5, -100, 0, 2025.
Khi dùng: Dùng cho các giá trị như số lượng đếm (không thể có nửa người), tuổi, năm, ID sản phẩm.

Số thực (Float / Double):

Khái niệm: Là các số có phần thập phân (số lẻ). Chúng cũng có thể bao gồm các số rất lớn hoặc rất nhỏ được biểu diễn dưới dạng khoa học.
Ví dụ: 3.14, -0.5, 99.99, 1.2e3 (tức là 1.2 * 10^3 = 1200), 0.000000001.
Khi dùng: Dùng cho các giá trị như giá tiền, nhiệt độ, chiều cao, kết quả của phép chia. PHP gọi chúng là "Float" hoặc "Double" (thực ra là giống nhau trong PHP, chỉ là tên gọi khác nhau để tương thích với các ngôn ngữ khác).

Số Nguyên (Integers) trong PHP

Sau khi hiểu tổng quan về kiểu dữ liệu số, chúng ta sẽ đi sâu vào loại số đầu tiên và phổ biến nhất: số nguyên (Integer).

Số nguyên là gì?

Số nguyên là các số "tròn", không có bất kỳ phần thập phân nào. Chúng có thể là số dương, số âm hoặc số 0.

Ví dụ:

Số dương: 1, 10, 1000, 500000
Số âm: -1, -50, -1234
Số không: 0

Bạn sẽ dùng số nguyên cho những giá trị không thể có phần lẻ, như: số lượng người, số lượt truy cập, tuổi, năm, hoặc các mã ID.

Cách khai báo

Trong PHP, việc khai báo một số nguyên rất đơn giản. Bạn chỉ cần viết trực tiếp con số đó, và PHP sẽ tự động nhận diện nó là một số nguyên.

Ví dụ:

<?php
$age = 30; // 30 là một số nguyên
$numberOfStudents = 45; // 45 là một số nguyên
$score = -5; // -5 là một số nguyên âm
$year = 2024; // 2024 là một số nguyên

echo "Tuổi của tôi là: " . $age . " <br>";
echo "Số lượng sinh viên: " . $numberOfStudents . " <br>";
echo "Điểm phạt: " . $score . " <br>";
echo "Năm hiện tại: " . $year . " <br>";
?>

Giới hạn của số nguyên

Dù trông có vẻ vô hạn, nhưng các số nguyên trong máy tính lại có một giới hạn nhất định. Điều này là do máy tính có một lượng bộ nhớ hữu hạn để lưu trữ các con số.

Giới hạn: Giới hạn của số nguyên phụ thuộc vào hệ điều hành mà PHP đang chạy (hệ thống 32-bit hay 64-bit).

Trên hệ thống 32-bit, số nguyên thường nằm trong khoảng từ khoảng -2 tỷ đến +2 tỷ.
Trên hệ thống 64-bit, giới hạn lớn hơn rất nhiều, khoảng từ -9 tỷ tỷ đến +9 tỷ tỷ.

Cách kiểm tra giới hạn trên máy của bạn: PHP cung cấp các hằng số tiện lợi để bạn biết chính xác giới hạn này trên môi trường của mình:

PHP_INT_MAX: Giá trị lớn nhất mà một số nguyên có thể đạt được.
PHP_INT_MIN: Giá trị nhỏ nhất mà một số nguyên có thể đạt được.

<?php
echo "Số nguyên lớn nhất có thể lưu trữ: " . PHP_INT_MAX . "<br>";
echo "Số nguyên nhỏ nhất có thể lưu trữ: " . PHP_INT_MIN . "<br>";
?>

(Kết quả sẽ khác nhau tùy vào hệ thống của bạn).

Điều gì xảy ra khi vượt quá giới hạn? Nếu bạn cố gắng lưu trữ một số nguyên lớn hơn PHP_INT_MAX hoặc nhỏ hơn PHP_INT_MIN, PHP sẽ tự động chuyển đổi kiểu dữ liệu của số đó thành số thực (Float/Double). Điều này thường diễn ra một cách "im lặng", có thể khiến bạn không nhận ra.

Ví dụ minh họa vượt quá giới hạn:

<?php
$largeNumber = PHP_INT_MAX + 100; // Số này lớn hơn giới hạn của số nguyên

echo "Số lớn hơn PHP_INT_MAX là: " . $largeNumber . "<br>";
echo "Kiểu dữ liệu của \$largeNumber là: " . gettype($largeNumber) . "<br>";
// Kết quả: Kiểu dữ liệu của $largeNumber là: double (hoặc float)
// Dù bạn khai báo nó như một số nguyên, PHP đã tự động chuyển đổi nó.
?>

Các hệ cơ số (ít dùng hơn trong thực tế)

Mặc dù trong thực tế bạn chủ yếu làm việc với các số nguyên ở hệ thập phân (cơ số 10), PHP cũng cho phép bạn khai báo số nguyên ở các hệ cơ số khác:

Hệ nhị phân (Binary): Bắt đầu bằng 0b. Chỉ chứa các chữ số 0 và 1.

<?php
$binaryNumber = 0b1011; // Tương đương với 11 trong hệ thập phân (8+0+2+1)
echo "Số nhị phân 0b1011 là: " . $binaryNumber . "<br>"; // Output: 11
?>

Hệ bát phân (Octal): Bắt đầu bằng 0o (hoặc chỉ 0 trong các phiên bản PHP cũ hơn). Chỉ chứa các chữ số từ 0 đến 7.

<?php
$octalNumber = 0o12; // Tương đương với 10 trong hệ thập phân (1*8 + 2*1)
echo "Số bát phân 0o12 là: " . $octalNumber . "<br>"; // Output: 10
?>

Hệ thập lục phân (Hexadecimal): Bắt đầu bằng 0x. Chứa các chữ số từ 0 đến 9 và các chữ cái từ A đến F (hoặc a đến f).

<?php
$hexNumber = 0xFF; // Tương đương với 255 trong hệ thập phân (15*16 + 15*1)
echo "Số thập lục phân 0xFF là: " . $hexNumber . "<br>"; // Output: 255
?>

Các hệ cơ số này thường được dùng trong các tác vụ cấp thấp hơn hoặc khi làm việc với các dữ liệu đặc thù (ví dụ: màu sắc trong web thường dùng mã thập lục phân). Trong lập trình thông thường, bạn hiếm khi phải khai báo trực tiếp chúng, nhưng biết về chúng cũng rất hữu ích.

Số thực (Floats / Doubles) trong PHP

Sau khi tìm hiểu về số nguyên, chúng ta sẽ chuyển sang loại số thứ hai trong PHP: số thực, còn được gọi là Float hoặc Double. Đây là kiểu dữ liệu bạn sẽ dùng cho các giá trị có phần lẻ hoặc rất lớn/rất nhỏ.

Số thực là gì?

Số thực (Floating-point numbers) là các con số có phần thập phân. Chúng biểu thị các giá trị không phải là số nguyên mà có độ chính xác sau dấu phẩy.

Ví dụ: 3.14, -0.5, 123.45, 0.001, 99.99.

Ngoài ra, số thực còn bao gồm các số cực kỳ lớn hoặc cực kỳ nhỏ mà được biểu diễn dưới dạng khoa học (Exponential form).

1.2e3 có nghĩa là $1.2 t im es 1 0^{3} = 1200$ .
5.6e-2 có nghĩa là $5.6 t im es 1 0^{- 2} = 0.056$ .

Bạn sẽ dùng số thực cho những giá trị như giá tiền, nhiệt độ, kết quả của phép chia, hoặc các phép đo lường cần độ chính xác sau dấu phẩy.

Cách khai báo

Giống như số nguyên, việc khai báo số thực trong PHP cũng rất đơn giản. Bạn chỉ cần viết số với dấu chấm thập phân (.) hoặc sử dụng dạng khoa học. PHP sẽ tự động nhận diện đó là một số thực.

Ví dụ:

<?php
$price = 19.99;         // Giá sản phẩm
$pi = 3.14159;          // Hằng số Pi
$temperature = -10.5;   // Nhiệt độ âm
$verySmall = 0.00001;   // Số rất nhỏ
$largeNumber = 1.5e6;   // Tương đương 1,500,000 (1.5 x 10^6)

echo "Giá: " . $price . "<br>";
echo "Pi: " . $pi . "<br>";
echo "Nhiệt độ: " . $temperature . "<br>";
echo "Số rất nhỏ: " . $verySmall . "<br>";
echo "Số lớn: " . $largeNumber . "<br>";
?>

Lưu ý về độ chính xác của số thực

Đây là một điểm cực kỳ quan trọng cần nhớ khi làm việc với số thực trong bất kỳ ngôn ngữ lập trình nào, không riêng gì PHP. Máy tính lưu trữ số thực dưới dạng nhị phân, và không phải mọi số thập phân đều có thể được biểu diễn chính xác tuyệt đối trong hệ nhị phân. Điều này đôi khi dẫn đến sai số nhỏ trong các phép tính.

Giải thích: Giống như 1/3 là 0.333... và không thể biểu diễn chính xác bằng số thập phân hữu hạn, một số phân số thập phân (như 0.1) cũng không có biểu diễn chính xác hoàn hảo trong hệ nhị phân. Khi máy tính thực hiện các phép tính với những số này, có thể phát sinh sai số rất nhỏ.
Ví dụ đơn giản về sai số nhỏ:

<?php
$a = 0.1;
$b = 0.2;
$c = 0.3;

$sum = $a + $b; // Bạn mong đợi là 0.3

echo "0.1 + 0.2 = " . $sum . "<br>";       // Có thể cho ra 0.3
echo "(0.1 + 0.2) == 0.3: ";
var_dump($sum == $c); // Kết quả: bool(false) hoặc bool(true) tùy phiên bản PHP và môi trường
                      // Rất dễ là false vì 0.1 + 0.2 có thể là 0.30000000000000004
?>

Nếu bạn chạy đoạn code trên, bạn có thể thấy (0.1 + 0.2) == 0.3 trả về false. Điều này là do $sum thực tế có thể là một số rất gần 0.3 nhưng không hoàn toàn chính xác tuyệt đối, ví dụ như 0.30000000000000004.

Lời khuyên quan trọng: TRÁNH so sánh trực tiếp số thực bằng toán tử == hoặc === khi độ chính xác là tối quan trọng (ví dụ: trong các phép tính tài chính). Thay vào đó, hãy so sánh xem sự khác biệt giữa hai số có nằm trong một khoảng sai số cho phép (epsilon) hay không.

<?php
// So sánh số thực một cách an toàn hơn
$epsilon = 0.00001; // Một khoảng sai số rất nhỏ

if (abs(($a + $b) - $c) < $epsilon) {
    echo "0.1 + 0.2 gần bằng 0.3 (đúng)<br>";
} else {
    echo "0.1 + 0.2 không gần bằng 0.3 (sai)<br>";
}
// Sử dụng bcmath extension trong PHP cho các phép tính tài chính cần độ chính xác cao.
?>

Giá trị đặc biệt của số thực

PHP có hai giá trị đặc biệt mà số thực có thể nhận:

INF (Infinity - Vô cực):

Khi một phép tính tạo ra kết quả quá lớn (dương vô cực) hoặc quá nhỏ (âm vô cực) đến mức không thể biểu diễn được bằng kiểu float.
Ví dụ: Chia một số dương cho 0.

<?php
$positiveInfinity = 10 / 0;
echo "10 / 0 = " . $positiveInfinity . "<br>"; // Output: INF
echo "Kiểu dữ liệu của INF: " . gettype($positiveInfinity) . "<br>"; // Output: double

$negativeInfinity = -10 / 0;
echo "-10 / 0 = " . $negativeInfinity . "<br>"; // Output: -INF
?>

NAN (Not a Number - Không phải là một số):

Khi kết quả của một phép tính là không xác định hoặc không hợp lệ.
Ví dụ: Căn bậc hai của một số âm, hoặc chia 0 cho 0.

<?php
$notANumber = sqrt(-1); // Căn bậc hai của số âm
echo "sqrt(-1) = " . $notANumber . "<br>"; // Output: NAN
echo "Kiểu dữ liệu của NAN: " . gettype($notANumber) . "<br>"; // Output: double

$nanDivision = 0 / 0;
echo "0 / 0 = " . $nanDivision . "<br>"; // Output: NAN
?>

Bạn có thể dùng hàm is_finite() để kiểm tra xem một số có phải là hữu hạn hay không (không phải INF hay NAN), và is_nan() để kiểm tra xem có phải là NAN hay không.

Các phép toán với số trong PHP

Trong lập trình, khả năng thực hiện các phép toán trên số là cốt lõi của mọi ứng dụng. PHP cung cấp đầy đủ các toán tử số học cơ bản và nhiều cách tiện lợi để thao tác với các giá trị số.

Phép toán số học cơ bản

Đây là những phép toán mà bạn đã quá quen thuộc từ thời đi học:

Cộng (+): Tổng của hai số.

<?php
$sum = 10 + 5;
echo "10 + 5 = " . $sum . "<br>"; // Output: 10 + 5 = 15
?>

Trừ (-): Hiệu của hai số.

<?php
$difference = 20 - 7;
echo "20 - 7 = " . $difference . "<br>"; // Output: 20 - 7 = 13
?>

Nhân (*): Tích của hai số.

<?php
$product = 4 * 6;
echo "4 * 6 = " . $product . "<br>"; // Output: 4 * 6 = 24
?>

Chia (/): Thương của hai số. Lưu ý rằng kết quả của phép chia luôn là số thực (float), ngay cả khi phép chia hết.

<?php
$quotient1 = 10 / 2;
echo "10 / 2 = " . $quotient1 . " (Kiểu: " . gettype($quotient1) . ")<br>"; // Output: 10 / 2 = 5 (Kiểu: double)

$quotient2 = 10 / 3;
echo "10 / 3 = " . $quotient2 . "<br>"; // Output: 10 / 3 = 3.3333333333333
?>

Chia lấy dư (%) (Modulo): Trả về phần dư của phép chia giữa hai số. Lưu ý: Toán tử này chỉ hoạt động với số nguyên (integers). Nếu bạn dùng với số thực, PHP sẽ tự động chuyển đổi chúng thành số nguyên trước khi tính toán.

<?php
$remainder1 = 10 % 3; // 10 chia 3 được 3 dư 1
echo "10 % 3 = " . $remainder1 . "<br>"; // Output: 10 % 3 = 1

$remainder2 = 15 % 5; // 15 chia 5 được 3 dư 0
echo "15 % 5 = " . $remainder2 . "<br>"; // Output: 15 % 5 = 0
?>

Lũy thừa (**): Nâng một số lên một lũy thừa nhất định (ví dụ: $2^{3}$ , $5^{2}$ ). Toán tử này có sẵn từ PHP 5.6 trở lên.

<?php
$power1 = 2 ** 3; // 2 mũ 3 = 2 * 2 * 2 = 8
echo "2 ** 3 = " . $power1 . "<br>"; // Output: 2 ** 3 = 8

$power2 = 5 ** 2; // 5 mũ 2 = 5 * 5 = 25
echo "5 ** 2 = " . $power2 . "<br>"; // Output: 5 ** 2 = 25
?>

Thứ tự ưu tiên phép toán

Khi bạn kết hợp nhiều phép toán trong một biểu thức, PHP sẽ tuân theo một thứ tự ưu tiên nhất định, giống như các quy tắc toán học thông thường (nhân chia trước, cộng trừ sau).

Quy tắc:

Dấu ngoặc đơn (): Mọi thứ trong dấu ngoặc đơn sẽ được tính toán trước tiên.
Lũy thừa **.
Nhân (*), Chia (/), Chia lấy dư (%): Các phép toán này có ưu tiên như nhau và được thực hiện từ trái sang phải.
Cộng (+), Trừ (-): Các phép toán này có ưu tiên như nhau và được thực hiện từ trái sang phải.

Ví dụ minh họa:

<?php
$result1 = 5 + 3 * 2;
echo "5 + 3 * 2 = " . $result1 . "<br>"; // Output: 11 (vì 3 * 2 = 6, sau đó 5 + 6 = 11)

// Dùng dấu ngoặc đơn để thay đổi thứ tự
$result2 = (5 + 3) * 2;
echo "(5 + 3) * 2 = " . $result2 . "<br>"; // Output: 16 (vì 5 + 3 = 8, sau đó 8 * 2 = 16)

$result3 = 10 / 2 + 3 ** 2; // (10 / 2) + (3 ** 2) = 5 + 9 = 14
echo "10 / 2 + 3 ** 2 = " . $result3 . "<br>"; // Output: 14
?>

Luôn sử dụng dấu ngoặc đơn () để đảm bảo phép tính được thực hiện đúng theo ý muốn của bạn, đặc biệt là với các biểu thức phức tạp. Điều này cũng làm cho code dễ đọc hơn.

Toán tử gán kết hợp

Đây là các toán tử viết tắt rất tiện lợi, giúp bạn thực hiện một phép toán và gán kết quả trở lại chính biến đó trong một bước.

Cú pháp: biến toán_tử= giá_trị; tương đương với biến = biến toán_tử giá_trị;

Các toán tử gán kết hợp phổ biến:

+= (Cộng rồi gán)
-= (Trừ rồi gán)
*= (Nhân rồi gán)
/= (Chia rồi gán)
%= (Chia lấy dư rồi gán)
**= (Lũy thừa rồi gán)

Ví dụ đơn giản:

<?php
$x = 10;
echo "Giá trị ban đầu của \$x: " . $x . "<br>"; // Output: 10

$x += 5; // Tương đương: $x = $x + 5;
echo "Sau \$x += 5: " . $x . "<br>"; // Output: 15

$x *= 2; // Tương đương: $x = $x * 2;
echo "Sau \$x *= 2: " . $x . "<br>"; // Output: 30

$y = 20;
$y /= 4; // Tương đương: $y = $y / 4;
echo "Sau \$y /= 4: " . $y . "<br>"; // Output: 5

$z = 17;
$z %= 5; // Tương đương: $z = $z % 5;
echo "Sau \$z %= 5: " . $z . "<br>"; // Output: 2
?>

Hàm xử lý số thường dùng trong PHP

PHP cung cấp nhiều hàm tích hợp sẵn để giúp bạn kiểm tra, chuyển đổi và định dạng các giá trị số.

`is_int()`, `is_float()`, `is_numeric()`

Các hàm này dùng để kiểm tra kiểu dữ liệu của một biến có phải là số hay không.

is_int(biến): Kiểm tra xem biến có phải là số nguyên hay không. Trả về true hoặc false.
is_float(biến): Kiểm tra xem biến có phải là số thực hay không. Trả về true hoặc false.
is_numeric(biến): Kiểm tra xem biến có phải là một số nói chung không (bao gồm cả số nguyên, số thực, và chuỗi có thể chuyển đổi thành số, ví dụ: "123", "3.14"). Trả về true hoặc false.
Ví dụ:

<?php
$a = 10;
$b = 3.14;
$c = "abc";
$d = "123";
$e = "5.5";

echo "Là số nguyên (\$a=10)? " . (is_int($a) ? "Có" : "Không") . "<br>"; // Output: Có
echo "Là số thực (\$a=10)? " . (is_float($a) ? "Có" : "Không") . "<br>"; // Output: Không

echo "Là số nguyên (\$b=3.14)? " . (is_int($b) ? "Có" : "Không") . "<br>"; // Output: Không
echo "Là số thực (\$b=3.14)? " . (is_float($b) ? "Có" : "Không") . "<br>"; // Output: Có

echo "Là số (\$c=\"abc\")? " . (is_numeric($c) ? "Có" : "Không") . "<br>"; // Output: Không
echo "Là số (\$d=\"123\")? " . (is_numeric($d) ? "Có" : "Không") . "<br>"; // Output: Có
echo "Là số (\$e=\"5.5\")? " . (is_numeric($e) ? "Có" : "Không") . "<br>"; // Output: Có
?>

`round()`, `ceil()`, `floor()`

Các hàm này dùng để làm tròn số thực theo các quy tắc khác nhau.

round(số, [số_chữ_số_thập_phân]): Làm tròn số đến số nguyên gần nhất hoặc đến một số chữ số thập phân cụ thể. Theo quy tắc "làm tròn lên nếu phần thập phân >= 0.5".
ceil(số): Luôn làm tròn lên đến số nguyên lớn nhất gần nhất. (Ceil = trần nhà).
floor(số): Luôn làm tròn xuống đến số nguyên nhỏ nhất gần nhất. (Floor = sàn nhà).
Ví dụ:

<?php
$num1 = 3.4;
$num2 = 3.6;
$num3 = 3.5;
$num4 = 5.789;

echo "round(3.4): " . round($num1) . "<br>";    // Output: 3
echo "round(3.6): " . round($num2) . "<br>";    // Output: 4
echo "round(3.5): " . round($num3) . "<br>";    // Output: 4 (làm tròn lên khi là .5)
echo "round(5.789, 2): " . round($num4, 2) . "<br>"; // Output: 5.79 (làm tròn đến 2 chữ số TP)

echo "ceil(3.4): " . ceil($num1) . "<br>";     // Output: 4
echo "ceil(3.6): " . ceil($num2) . "<br>";     // Output: 4
echo "ceil(3.0): " . ceil(3.0) . "<br>";      // Output: 3

echo "floor(3.4): " . floor($num1) . "<br>";   // Output: 3
echo "floor(3.6): " . floor($num2) . "<br>";   // Output: 3
echo "floor(3.0): " . floor(3.0) . "<br>";     // Output: 3
?>

. `abs()`

abs(số): Trả về giá trị tuyệt đối của một số (luôn là số dương).
Ví dụ:

<?php
echo "abs(-10): " . abs(-10) . "<br>"; // Output: 10
echo "abs(5): " . abs(5) . "<br>";   // Output: 5
?>

`max()`, `min()`

max(số1, số2, ...) hoặc max(mảng_số): Tìm giá trị lớn nhất trong một danh sách các số hoặc trong một mảng số.
min(số1, số2, ...) hoặc min(mảng_số): Tìm giá trị nhỏ nhất trong một danh sách các số hoặc trong một mảng số.
Ví dụ:

<?php
echo "max(10, 5, 20, 15): " . max(10, 5, 20, 15) . "<br>"; // Output: 20
echo "min(10, 5, 20, 15): " . min(10, 5, 20, 15) . "<br>"; // Output: 5

$scores = [85, 92, 78, 95, 88];
echo "Điểm cao nhất: " . max($scores) . "<br>"; // Output: 95
echo "Điểm thấp nhất: " . min($scores) . "<br>"; // Output: 78
?>

`number_format()`

Hàm này cực kỳ hữu ích để định dạng các con số lớn (đặc biệt là tiền tệ) để chúng dễ đọc hơn bằng cách thêm dấu phẩy hoặc dấu chấm phân cách hàng nghìn.

number_format(số, [số_chữ_số_thập_phân], [dấu_phân_cách_thập_phân], [dấu_phân_cách_hàng_nghìn]):

số: Con số bạn muốn định dạng.
số_chữ_số_thập_phân (tùy chọn): Số chữ số sau dấu thập phân.
dấu_phân_cách_thập_phân (tùy chọn): Ký tự dùng làm dấu phân cách phần thập phân (mặc định là .).
dấu_phân_cách_hàng_nghìn (tùy chọn): Ký tự dùng làm dấu phân cách hàng nghìn (mặc định là ,).

Ví dụ:

<?php
$largeAmount = 12345678.901;
$priceUSD = 250.75;

// Định dạng mặc định (không có số thập phân, dùng dấu phẩy cho nghìn)
echo "Mặc định (VN): " . number_format($largeAmount) . " VNĐ<br>"; // Output: 12,345,679 VNĐ

// Định dạng 2 chữ số thập phân, dấu chấm cho thập phân, dấu phẩy cho nghìn (kiểu USD)
echo "Kiểu USD: " . number_format($largeAmount, 2, '.', ',') . " USD<br>"; // Output: 12,345,678.90 USD

// Định dạng 0 chữ số thập phân, dấu phẩy cho thập phân, dấu chấm cho nghìn (kiểu Việt Nam)
echo "Kiểu Việt Nam: " . number_format($largeAmount, 0, ',', '.') . " VNĐ<br>"; // Output: 12.345.679 VNĐ

echo "Giá tiền: " . number_format($priceUSD, 2) . " USD<br>"; // Output: 250.75 USD
?>

number_format() là hàm rất hữu ích để hiển thị các con số tài chính hoặc thống kê một cách thân thiện với người dùng.

Kết bài

Kiểu dữ liệu số là một trong những nền tảng cơ bản và không thể thiếu trong bất kỳ ngôn ngữ lập trình nào, và PHP cũng không ngoại lệ. Qua bài viết này, bạn đã được trang bị những kiến thức vững chắc về:

Hai loại số chính trong PHP: Số nguyên (Integers) dùng cho các số tròn và Số thực (Floats/Doubles) cho các số có phần thập phân hoặc giá trị rất lớn/nhỏ.
Cách khai báo và giới hạn của chúng: Nắm được cách PHP tự động nhận diện kiểu số và những gì xảy ra khi số nguyên vượt quá giới hạn.
Các phép toán số học: Từ cộng, trừ, nhân, chia cơ bản đến lũy thừa và chia lấy dư, cùng với quy tắc ưu tiên và toán tử gán kết hợp tiện lợi.
Những lưu ý quan trọng về số thực: Hiểu về sai số tiềm ẩn và cách so sánh số thực một cách an toàn.
Các hàm xử lý số hữu ích: is_int(), is_float(), round(), ceil(), floor(), abs(), max(), min(), và đặc biệt là number_format() để định dạng số dễ đọc.

Việc nắm vững cách PHP làm việc với các con số không chỉ giúp bạn thực hiện các phép tính toán chính xác mà còn là chìa khóa để xây dựng các ứng dụng có khả năng xử lý dữ liệu định lượng một cách hiệu quả và đáng tin cậy.