Các phương thức xử lý số trong JavaScript

Javascript căn bản | 02/03/2025 by Học Javascript

Trong JavaScript, số (Number) là một kiểu dữ liệu quan trọng, được sử dụng rộng rãi để thực hiện các phép toán số học, xử lý dữ liệu và hiển thị kết quả. Không giống như một số ngôn ngữ lập trình khác có sự phân biệt giữa số nguyên và số thực, JavaScript sử dụng chung một kiểu dữ liệu Number để biểu diễn cả hai loại số này. Ngoài ra, JavaScript cũng hỗ trợ kiểu BigInt để làm việc với số nguyên cực lớn.

Để làm việc hiệu quả với dữ liệu số, JavaScript cung cấp một loạt các phương thức xử lý số, giúp lập trình viên dễ dàng chuyển đổi, định dạng, tính toán và kiểm tra giá trị số. Các phương thức này không chỉ giúp tăng hiệu suất lập trình mà còn giúp giảm thiểu lỗi khi làm việc với dữ liệu số lớn.

Trong thực tế, các phương thức xử lý số đóng vai trò quan trọng trong nhiều lĩnh vực như tính toán tài chính, xử lý giá trị tiền tệ trong thương mại điện tử, sinh số ngẫu nhiên cho bảo mật, làm tròn số trong báo cáo thống kê, và làm việc với dữ liệu khoa học có độ chính xác cao. Việc hiểu rõ và sử dụng đúng các phương thức này sẽ giúp lập trình viên viết mã hiệu quả, chính xác và tối ưu hơn.

Nhóm phương thức chuyển đổi lữ liệu số trong JavaScript

Trong JavaScript, có nhiều phương thức hỗ trợ chuyển đổi giữa chuỗi (string) và số (number). Những phương thức này giúp lập trình viên xử lý dữ liệu đầu vào từ biểu mẫu, API hoặc cơ sở dữ liệu một cách chính xác hơn.

Chuyển đổi chuỗi thành số

Các phương thức phổ biến để chuyển đổi chuỗi thành số bao gồm:

parseInt() – Chuyển chuỗi thành số nguyên, bỏ qua phần thập phân (nếu có).
parseFloat() – Chuyển chuỗi thành số thực, giữ nguyên phần thập phân.
Number() – Chuyển đổi chuỗi thành số theo cách tự động.

Ví dụ minh họa:

console.log(parseInt("123"));      // 123
console.log(parseInt("123.456"));  // 123 (loại bỏ phần thập phân)
console.log(parseFloat("12.34"));  // 12.34
console.log(Number("100"));        // 100
console.log(Number("100.50"));     // 100.5
console.log(parseInt("abc"));      // NaN (Không thể chuyển đổi)
console.log(Number("123abc"));     // NaN (Không thể chuyển đổi)

Lưu ý:

parseInt() có thể nhận thêm tham số thứ hai để chỉ định hệ số (radix). Ví dụ, parseInt("1010", 2) sẽ chuyển chuỗi "1010" thành số 10 theo hệ nhị phân.
Number() nghiêm ngặt hơn parseInt(), nếu chuỗi chứa ký tự không hợp lệ, nó sẽ trả về NaN (Not a Number).

Chuyển đổi số thành chuỗi

Khi cần định dạng số hoặc hiển thị kết quả dưới dạng chuỗi, ta có thể sử dụng:

toString() – Chuyển đổi số thành chuỗi.
toFixed(digits) – Làm tròn số với số chữ số thập phân nhất định.
toPrecision(digits) – Định dạng số với độ chính xác mong muốn (có thể làm tròn số).

Ví dụ minh họa:

let num = 123.456;

console.log(num.toString());      // "123.456"
console.log((100).toString());    // "100"

console.log(num.toFixed(2));      // "123.46" (làm tròn 2 chữ số thập phân)
console.log(num.toFixed(0));      // "123" (loại bỏ phần thập phân)

console.log(num.toPrecision(4));  // "123.5" (4 chữ số có ý nghĩa)
console.log(num.toPrecision(2));  // "1.2e+2" (viết dưới dạng khoa học)

Lưu ý:

toFixed(digits) rất hữu ích khi xử lý số tiền tệ, tỷ lệ phần trăm, hoặc hiển thị kết quả với định dạng cố định.
toPrecision(digits) sẽ giữ tổng số chữ số có ý nghĩa, bao gồm cả phần nguyên và phần thập phân.

Nhóm phương thức toán học (Math) trong JavaScript

Trong JavaScript, đối tượng Math cung cấp nhiều phương thức giúp thực hiện các phép toán phổ biến như làm tròn số, tính lũy thừa, căn bậc hai, tìm giá trị lớn nhất/nhỏ nhất và sinh số ngẫu nhiên. Những phương thức này rất hữu ích trong các bài toán tài chính, xử lý dữ liệu số, và nhiều ứng dụng thực tế khác.

Phương thức làm tròn số

Khi làm việc với số thực (float), đôi khi ta cần làm tròn để hiển thị dễ đọc hoặc tính toán chính xác hơn. JavaScript cung cấp nhiều phương thức để làm tròn số theo những cách khác nhau:

Phương thức	Mô tả	Ví dụ	Kết quả
`Math.round(x)`	Làm tròn số đến giá trị gần nhất	`Math.round(4.5)`	`5`
`Math.floor(x)`	Làm tròn xuống (lấy phần nguyên nhỏ hơn)	`Math.floor(4.9)`	`4`
`Math.ceil(x)`	Làm tròn lên (lấy phần nguyên lớn hơn)	`Math.ceil(4.1)`	`5`
`Math.trunc(x)`	Cắt bỏ phần thập phân, giữ nguyên phần nguyên	`Math.trunc(4.9)`	`4`

Ví dụ minh họa:

console.log(Math.round(4.5));   // 5
console.log(Math.round(4.4));   // 4
console.log(Math.floor(4.9));   // 4
console.log(Math.ceil(4.1));    // 5
console.log(Math.trunc(4.9));   // 4
console.log(Math.trunc(-4.9));  // -4 (Cắt phần thập phân giữ nguyên dấu)

Lưu ý:

Math.round(x) làm tròn đến số nguyên gần nhất, nếu số thập phân là 0.5 thì làm tròn lên.
Math.floor(x) luôn làm tròn xuống, rất hữu ích khi cần giới hạn một số về phần nguyên thấp hơn.
Math.ceil(x) luôn làm tròn lên, phù hợp khi cần tính toán số lượng tối thiểu.
Math.trunc(x) chỉ lấy phần nguyên mà không làm tròn.

Phương thức tính toán nâng cao

JavaScript cũng hỗ trợ các phép toán phức tạp hơn như lũy thừa, căn bậc hai và giá trị tuyệt đối.

Phương thức	Mô tả	Ví dụ	Kết quả
`Math.pow(x, y)`	Tính lũy thừa `x^y`	`Math.pow(2, 3)`	`8`
`Math.sqrt(x)`	Tính căn bậc hai	`Math.sqrt(25)`	`5`
`Math.abs(x)`	Lấy giá trị tuyệt đối	`Math.abs(-10)`	`10`

Lưu ý:

Math.pow(x, y) tương đương với toán tử ** (exponentiation).
Math.sqrt(x) chỉ áp dụng cho số dương, nếu x < 0 sẽ trả về NaN.
Math.abs(x) thường dùng để xử lý khoảng cách, sai số, hoặc chuẩn hóa dữ liệu.

Phương thức tìm giá trị lớn nhất/nhỏ nhất

Nếu cần tìm số lớn nhất hoặc nhỏ nhất trong danh sách, ta có thể sử dụng:

Phương thức	Mô tả	Ví dụ	Kết quả
`Math.max(a, b, c, ...)`	Tìm số lớn nhất trong danh sách	`Math.max(10, 20, 5, 8)`	`20`
`Math.min(a, b, c, ...)`	Tìm số nhỏ nhất trong danh sách	`Math.min(10, 20, 5, 8)`	`5`

Ví dụ minh họa:

console.log(Math.max(10, 20, 5, 8)); // 20 (Lớn nhất)
console.log(Math.min(10, 20, 5, 8)); // 5  (Nhỏ nhất)

// Tìm giá trị lớn nhất trong một mảng
let numbers = [3, 7, 2, 9, 4];
console.log(Math.max(...numbers)); // 9
console.log(Math.min(...numbers)); // 2

Lưu ý:

Math.max() và Math.min() nhận nhiều tham số, nếu muốn áp dụng với mảng, ta có thể dùng spread operator (...).
Nếu truyền vào danh sách rỗng (Math.max() hoặc Math.min() không có tham số), kết quả sẽ là -Infinity hoặc Infinity.

Phương thức sinh số ngẫu nhiên

Khi cần tạo số ngẫu nhiên (ví dụ: số OTP, mã xác thực, chọn ngẫu nhiên một phần tử), ta sử dụng Math.random().

Phương thức	Mô tả	Ví dụ
`Math.random()`	Trả về số ngẫu nhiên từ 0 đến 1	`Math.random()` → `0.7364`
`Math.floor(Math.random() * (max - min + 1)) + min`	Sinh số nguyên ngẫu nhiên trong khoảng `[min, max]`	`Math.floor(Math.random() * 100) + 1`

Ví dụ minh họa:

console.log(Math.random()); // Số thập phân từ 0 đến 1

// Sinh số nguyên từ 1 đến 100
let randomNum = Math.floor(Math.random() * 100) + 1;
console.log(randomNum);

// Sinh số nguyên từ 10 đến 50
let randomInRange = Math.floor(Math.random() * (50 - 10 + 1)) + 10;
console.log(randomInRange);

Lưu ý:

Math.random() chỉ tạo số từ 0 đến <1, nên ta cần nhân (* max) và dùng Math.floor() để làm tròn xuống nếu muốn tạo số nguyên trong một khoảng nhất định.
Nếu cần một số từ min đến max, công thức chung là:

Math.floor(Math.random() * (max - min + 1)) + min;

Nhóm phương thức xử lý lỗi và kiểm tra số trong JavaScript

Trong JavaScript, khi làm việc với số, ta cần kiểm tra xem một giá trị có hợp lệ hay không. Các phương thức kiểm tra số giúp tránh lỗi trong tính toán, đặc biệt khi xử lý dữ liệu đầu vào hoặc làm việc với các phép toán phức tạp.

Kiểm tra giá trị hợp lệ (NaN - Not a Number)

Khi thực hiện phép toán không hợp lệ hoặc chuyển đổi dữ liệu sai cách, JavaScript có thể trả về NaN (Not a Number). Để kiểm tra xem một giá trị có phải là NaN không, ta dùng:

isNaN(value) - Kiểm tra một giá trị có phải là số không hợp lệ

Nếu giá trị là NaN hoặc không thể chuyển thành số, trả về true.
Nếu giá trị hợp lệ, trả về false.

Ví dụ minh họa:

console.log(isNaN(100));        // false (100 là số hợp lệ)
console.log(isNaN("hello"));    // true  ("hello" không phải số)
console.log(isNaN("123"));      // false (vì chuỗi "123" có thể chuyển thành số)
console.log(isNaN(NaN));        // true  (NaN là số không hợp lệ)
console.log(isNaN(undefined));  // true  (undefined không phải số)

Lưu ý:

isNaN("123") trả về false vì chuỗi "123" có thể chuyển thành số (Number("123") → 123).
isNaN(undefined) và isNaN(NaN) trả về true vì chúng không phải số hợp lệ.
isNaN(null) trả về false vì null có thể chuyển thành 0.

Kiểm tra số hữu hạn và vô hạn

JavaScript cũng hỗ trợ kiểm tra xem một số có thuộc tập số hữu hạn hay không (để tránh lỗi khi làm việc với Infinity hoặc NaN).

isFinite(value) - Kiểm tra số có phải là số hữu hạn không

Trả về true nếu giá trị là một số hữu hạn (finite number).
Trả về false nếu giá trị là Infinity, -Infinity hoặc NaN.

Ví dụ minh họa:

console.log(isFinite(100));      // true  (100 là số hữu hạn)
console.log(isFinite(-2000.5));  // true  (-2000.5 là số hữu hạn)
console.log(isFinite(Infinity)); // false (Infinity không phải số hữu hạn)
console.log(isFinite(-Infinity));// false (-Infinity không phải số hữu hạn)
console.log(isFinite(NaN));      // false (NaN không phải số hữu hạn)
console.log(isFinite("50"));     // true  (chuỗi "50" chuyển thành số 50)
console.log(isFinite("hello"));  // false ("hello" không thể chuyển thành số)

Lưu ý:

isFinite("50") trả về true vì chuỗi "50" có thể chuyển thành số 50.
isFinite("hello") trả về false vì "hello" không thể chuyển thành số.

Kiểm tra số nguyên (isInteger)

Khi cần kiểm tra xem một số có phải là số nguyên hay không, ta sử dụng:

`Number.isInteger(value)` - Kiểm tra số nguyên

Trả về true nếu giá trị là số nguyên.
Trả về false nếu giá trị là số thực (có phần thập phân) hoặc không phải số.

Ví dụ minh họa:

console.log(Number.isInteger(10));    // true  (10 là số nguyên)
console.log(Number.isInteger(10.5));  // false (10.5 là số thực)
console.log(Number.isInteger(-7));    // true  (-7 là số nguyên)
console.log(Number.isInteger("10"));  // false ("10" là chuỗi, không phải số)
console.log(Number.isInteger(NaN));   // false (NaN không phải số nguyên)
console.log(Number.isInteger(Infinity)); // false (Infinity không phải số hữu hạn)

Lưu ý:

Number.isInteger(10.0) trả về true vì 10.0 thực chất vẫn là 10.
Number.isInteger("10") trả về false vì "10" là chuỗi, không phải số.

Phương thức	Mô tả	Ví dụ	Kết quả
`isNaN(value)`	Kiểm tra giá trị có phải là NaN không	`isNaN("abc")`	`true`
`isFinite(value)`	Kiểm tra số có phải hữu hạn không	`isFinite(1000)`	`true`
`Number.isInteger(value)`	Kiểm tra số có phải số nguyên không	`Number.isInteger(10.5)`	`false`

Các lỗi thường gặp khi cử lý số trong JavaScript

Trong JavaScript, xử lý số không đơn giản như ta nghĩ, do cách lưu trữ số và các cơ chế ép kiểu. Dưới đây là một số lỗi phổ biến mà lập trình viên thường gặp phải khi làm việc với số, cùng với cách khắc phục.

Lỗi NaN khi thực hiện phép toán

Nguyên nhân:

Khi thực hiện phép toán với dữ liệu không phải số (string, undefined, object, v.v.), JavaScript sẽ trả về NaN.
Khi cố gắng chuyển đổi một chuỗi không hợp lệ sang số bằng parseInt() hoặc Number().

Ví dụ minh họa:

console.log("abc" * 5); // NaN (vì "abc" không phải số)
console.log(parseInt("abc")); // NaN (không thể chuyển "abc" thành số)
console.log(Number(undefined)); // NaN (undefined không thể chuyển thành số)
console.log(Math.sqrt(-1)); // NaN (căn bậc hai của số âm không hợp lệ)

Cách khắc phục:

Kiểm tra dữ liệu trước khi thực hiện phép toán bằng isNaN().
Xử lý ngoại lệ khi nhập dữ liệu đầu vào.

let value = "abc";
if (isNaN(value)) {
    console.log("Dữ liệu không hợp lệ!");
} else {
    console.log(value * 5);
}

Lỗi số thực không chính xác

Nguyên nhân:

JavaScript sử dụng chuẩn IEEE 754 để lưu trữ số thực, nên có thể xảy ra lỗi làm tròn.
Một số phép toán số thực có thể cho kết quả không chính xác.

Ví dụ minh họa:

console.log(0.1 + 0.2); // 0.30000000000000004 (lỗi do lưu trữ số thực)
console.log(0.3 - 0.2); // 0.09999999999999998
console.log(0.1 * 0.2); // 0.020000000000000004

Cách khắc phục:

Dùng toFixed() hoặc toPrecision() để làm tròn số.
Chuyển số thành số nguyên tạm thời rồi chia lại.

console.log(Number((0.1 + 0.2).toFixed(2))); // 0.3 (làm tròn)
console.log((0.1 * 100 + 0.2 * 100) / 100); // 0.3 (chuyển thành số nguyên tạm thời)

So sánh số không chính xác

Nguyên nhân:

JavaScript tự động ép kiểu khi sử dụng ==, nên "10" == 10 sẽ trả về true.
Khi làm việc với số thực, do lỗi làm tròn nên phép so sánh có thể không chính xác.

Ví dụ minh họa:

console.log(10 == "10");  // true (do ép kiểu)
console.log(10 === "10"); // false (vì khác kiểu dữ liệu)

console.log(0.1 + 0.2 === 0.3); // false (lỗi số thực)
console.log(Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON); // true (so sánh chính xác)

Cách khắc phục:

Dùng === thay vì == để so sánh chính xác.
Sử dụng Number.EPSILON để so sánh số thực.

const a = 0.1 + 0.2;
const b = 0.3;
console.log(Math.abs(a - b) < Number.EPSILON); // true

Ứng dụng thực tế của các phương thức xử lý số trong JavaScript

Các phương thức xử lý số của JavaScript có nhiều ứng dụng quan trọng trong lập trình thực tế, từ tài chính, khoa học dữ liệu đến bảo mật.

Xử lý số trong ứng dụng tài chính

Tính toán lãi suất, tiền tệ, hóa đơn yêu cầu độ chính xác cao.
Giải pháp: Dùng toFixed() để kiểm soát số thập phân.

let price = 1999.999;
console.log(price.toFixed(2)); // "2000.00"

Làm tròn số để hiển thị đẹp hơn

Khi hiển thị số liệu trên báo cáo hoặc giao diện, số quá dài có thể gây khó hiểu.
Giải pháp: toPrecision() giúp làm tròn nhưng vẫn giữ độ chính xác cần thiết.

let revenue = 123456.789;
console.log(revenue.toPrecision(5)); // "123460"

Kết bài

Xử lý số trong JavaScript là một kỹ năng quan trọng, ảnh hưởng đến độ chính xác và hiệu suất của các ứng dụng. Từ việc chuyển đổi số, làm tròn, thực hiện phép toán, kiểm tra dữ liệu đến xử lý lỗi, mỗi phương thức đều có vai trò riêng giúp lập trình viên làm việc hiệu quả hơn.

Việc hiểu rõ cách JavaScript xử lý số không chỉ giúp tránh các lỗi phổ biến như NaN, sai số thập phân hay so sánh số không chính xác, mà còn giúp tối ưu mã nguồn trong các ứng dụng thực tế như tài chính, khoa học dữ liệu và bảo mật.

Bằng cách áp dụng đúng phương thức trong từng tình huống cụ thể, bạn có thể xây dựng các chương trình chính xác, hiệu quả và đáng tin cậy hơn.