Cách sử dụng số (Numbers) trong JavaScript

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

Trong JavaScript, Number là kiểu dữ liệu quan trọng được sử dụng để đại diện cho tất cả các giá trị số, bao gồm cả số nguyên và số thực. 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 (Integer) và số thực (Float), JavaScript chỉ có một kiểu dữ liệu số duy nhất – Number.

Số đóng vai trò quan trọng trong hầu hết các ứng dụng lập trình, từ các phép toán cơ bản, tính toán tài chính, xử lý dữ liệu khoa học, đến các ứng dụng phức tạp như trò chơi, đồ họa và trí tuệ nhân tạo. Hiểu rõ cách JavaScript xử lý số sẽ giúp lập trình viên làm việc hiệu quả hơn và tránh được các lỗi thường gặp, chẳng hạn như lỗi về độ chính xác của số thực hoặc cách chuyển đổi giữa chuỗi và số.

Trong bài viết này, mình sẽ tìm hiểu chi tiết về kiểu dữ liệu Number, các phép toán số học, cách chuyển đổi số, đối tượng Math, cũng như những lỗi thường gặp khi làm việc với số trong JavaScript.

Các kiểu dữ liệu số trong JavaScript

JavaScript sử dụng kiểu dữ liệu Number để biểu diễn tất cả các loại số, bao gồm số nguyên (Integer), số thực (Float) và các giá trị số đặc biệt như Infinity và NaN.

Số nguyên (Integer)

Số nguyên là những số không có phần thập phân, bao gồm:

Số nguyên dương: 1, 2, 100, 9999
Số nguyên âm: -1, -20, -999
Số 0

Ví dụ về số nguyên trong JavaScript:

let x = 10;     // Số nguyên dương
let y = -5;     // Số nguyên âm
let z = 0;      // Số 0
console.log(x, y, z); // Output: 10 -5 0

JavaScript có thể xử lý các số nguyên lớn, nhưng khi vượt quá phạm vi an toàn của Number (2^53 - 1 hoặc -2^53 + 1), chúng ta cần sử dụng BigInt để làm việc với số lớn hơn.

Ví dụ về BigInt:

let bigNumber = 123456789012345678901234567890n;
console.log(bigNumber); // Output: 123456789012345678901234567890n

Lưu ý: BigInt không thể kết hợp với Number trong các phép toán.

Số thực (Float - Số thập phân)

Số thực là những số có dấu thập phân, chẳng hạn như:

3.14
-4.5
0.001

JavaScript hỗ trợ các số thực với độ chính xác lên đến 15-17 chữ số nhưng có thể gặp lỗi làm tròn do cách máy tính lưu trữ số thực theo hệ nhị phân.

Ví dụ về số thực trong JavaScript:

let pi = 3.14159;
let temperature = -4.5;
console.log(pi, temperature); // Output: 3.14159 -4.5

Lưu ý về lỗi làm tròn khi làm việc với số thực:

console.log(0.1 + 0.2); // Output: 0.30000000000000004
console.log(0.1 + 0.7); // Output: 0.7999999999999999

Lỗi này xảy ra do cách JavaScript xử lý số thực theo hệ nhị phân. Để khắc phục, ta có thể làm tròn số bằng toFixed() hoặc toPrecision().

console.log((0.1 + 0.2).toFixed(2)); // Output: 0.30

Số đặc biệt trong JavaScript

Infinity và -Infinity

Infinity: Đại diện cho số lớn hơn bất kỳ số nào khác.
-Infinity: Đại diện cho số nhỏ hơn bất kỳ số nào khác.
Infinity xuất hiện khi chia một số cho 0 hoặc vượt quá giới hạn của Number.

Ví dụ về Infinity:

console.log(10 / 0);  // Output: Infinity
console.log(-10 / 0); // Output: -Infinity

NaN (Not a Number)

NaN xuất hiện khi một phép toán toán học không thể thực hiện được.
Một số trường hợp dẫn đến NaN:
- Chia một số cho một chuỗi không phải là số.
- Cố gắng thực hiện phép toán với undefined.

Ví dụ về NaN:

console.log("Hello" / 2);  // Output: NaN
console.log(Math.sqrt(-1)); // Output: NaN
console.log(undefined + 5); // Output: NaN

Kiểm tra giá trị có phải là NaN không?

Dùng isNaN(value) để kiểm tra một giá trị có phải là NaN không.

console.log(isNaN("Hello" / 2)); // Output: true
console.log(isNaN(100));         // Output: false

Loại số	Mô tả
Số nguyên (Integer)	Số không có phần thập phân, có thể là dương, âm hoặc 0.
Số thực (Float)	Số có phần thập phân, có thể gặp lỗi làm tròn.
Infinity	Đại diện cho số lớn vô hạn.
-Infinity	Đại diện cho số nhỏ vô hạn.
NaN (Not a Number)	Giá trị không hợp lệ khi thực hiện phép toán số học.

Hiểu rõ các kiểu dữ liệu số trong JavaScript giúp chúng ta xử lý toán học chính xác hơn và tránh những lỗi phổ biến khi lập trình.

Các phép toán số học trong JavaScript

JavaScript hỗ trợ nhiều phép toán số học giúp thực hiện các phép tính từ đơn giản đến phức tạp. Dưới đây là các phép toán quan trọng khi làm việc với số trong JavaScript.

Các phép toán cơ bản

JavaScript hỗ trợ các phép toán số học cơ bản như cộng, trừ, nhân, chia và chia lấy dư.

Toán tử	Chức năng	Ví dụ
`+`	Cộng hai số	`10 + 5 = 15`
`-`	Trừ hai số	`10 - 5 = 5`
`*`	Nhân hai số	`10 * 5 = 50`
`/`	Chia hai số	`10 / 2 = 5`
`%`	Chia lấy phần dư	`10 % 3 = 1`

Ví dụ về các phép toán số học cơ bản:

let a = 10, b = 5;
console.log(a + b);  // Output: 15
console.log(a - b);  // Output: 5
console.log(a * b);  // Output: 50
console.log(a / b);  // Output: 2
console.log(a % 3);  // Output: 1

Lưu ý:

Phép chia / trong JavaScript không làm tròn kết quả, ngay cả khi kết quả là số thực.

console.log(5 / 2); // Output: 2.5

Lũy thừa và căn bậc hai

JavaScript hỗ trợ tính lũy thừa bằng toán tử ** hoặc hàm Math.pow(), và tính căn bậc hai bằng Math.sqrt().

Toán tử/Hàm	Chức năng	Ví dụ
`**`	Lũy thừa	`2 ** 3 = 8`
`Math.pow(x, y)`	Lũy thừa (cách cũ)	`Math.pow(2, 3) = 8`
`Math.sqrt(x)`	Căn bậc hai	`Math.sqrt(9) = 3`

Ví dụ về lũy thừa và căn bậc hai:

console.log(2 ** 3);       // Output: 8
console.log(Math.pow(2, 3)); // Output: 8
console.log(Math.sqrt(16));  // Output: 4

Làm tròn số

Trong JavaScript, có nhiều cách làm tròn số với Math.round(), Math.ceil(), Math.floor() và toFixed().

Hàm	Chức năng	Ví dụ
`Math.round(x)`	Làm tròn đến số nguyên gần nhất	`Math.round(4.6) = 5`
`Math.ceil(x)`	Làm tròn lên	`Math.ceil(4.2) = 5`
`Math.floor(x)`	Làm tròn xuống	`Math.floor(4.9) = 4`
`toFixed(n)`	Làm tròn đến `n` chữ số thập phân	`(4.678).toFixed(2) = "4.68"`

Ví dụ về làm tròn số:

console.log(Math.round(4.6));  // Output: 5
console.log(Math.ceil(4.2));   // Output: 5
console.log(Math.floor(4.9));  // Output: 4
console.log((4.678).toFixed(2)); // Output: "4.68"

Lưu ý:

toFixed(n) trả về chuỗi chứ không phải số. Nếu cần chuyển về số, dùng parseFloat().

let num = parseFloat((4.678).toFixed(2)); // Output: 4.68

Các phép toán tăng giảm giá trị

JavaScript hỗ trợ các toán tử tăng (++) và giảm (--), giúp tăng hoặc giảm giá trị của một biến.

Toán tử	Chức năng	Ví dụ
`++`	Tăng giá trị lên 1	`a++` hoặc `++a`
`--`	Giảm giá trị đi 1	`a--` hoặc `--a`

Ví dụ về phép toán tăng giảm:

let a = 5;
a++;  // Hậu tố: Giá trị của `a` tăng lên 1 sau khi sử dụng
console.log(a); // Output: 6

let b = 5;
++b;  // Tiền tố: Giá trị của `b` tăng lên 1 trước khi sử dụng
console.log(b); // Output: 6

Lưu ý sự khác biệt giữa hậu tố và tiền tố:

let x = 5;
console.log(x++); // Output: 5 (dùng x trước, sau đó mới tăng)
console.log(x);   // Output: 6

let y = 5;
console.log(++y); // Output: 6 (tăng trước, sau đó mới dùng)

Toán tử/Hàm	Chức năng	Ví dụ
`+`, `-`, `*`, `/`, `%`	Phép toán cơ bản	`10 + 5 = 15`
`**` hoặc `Math.pow(x, y)`	Lũy thừa	`2 ** 3 = 8`
`Math.sqrt(x)`	Căn bậc hai	`Math.sqrt(16) = 4`
`Math.round(x)`	Làm tròn gần nhất	`Math.round(4.6) = 5`
`Math.ceil(x)`	Làm tròn lên	`Math.ceil(4.2) = 5`
`Math.floor(x)`	Làm tròn xuống	`Math.floor(4.9) = 4`
`toFixed(n)`	Làm tròn đến `n` số thập phân	`(4.678).toFixed(2) = "4.68"`
`++`	Tăng giá trị lên 1	`a++` hoặc `++a`
`--`	Giảm giá trị đi 1	`a--` hoặc `--a`

Chuyển đổi dữ liệu số trong JavaScript

Trong JavaScript, có nhiều cách để chuyển đổi giữa chuỗi (string) và số (number). Việc hiểu rõ cách chuyển đổi này rất quan trọng khi làm việc với dữ liệu đầu vào từ biểu mẫu, API hoặc khi cần thực hiện các phép toán số học.

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

JavaScript cung cấp các phương thức để chuyển đổi chuỗi (string) thành số (number), bao gồm:

parseInt() – Chuyển đổi chuỗi thành số nguyên.
parseFloat() – Chuyển đổi chuỗi thành số thực (số có dấu thập phân).
Number() – Chuyển đổi chuỗi thành số (hỗ trợ cả số nguyên và số thực).

Sử dụng parseInt() để chuyển đổi thành số nguyên

parseInt() chỉ giữ lại phần số nguyên từ chuỗi, bỏ qua phần thập phân (nếu có). Nếu chuỗi chứa ký tự không phải số, JavaScript sẽ dừng lại tại ký tự đó.

Cú pháp:

parseInt(string, [radix]);

string: Chuỗi cần chuyển đổi.
radix (tùy chọn): Hệ số của số cần chuyển đổi (mặc định là hệ 10).

Ví dụ:

console.log(parseInt("100"));     // Output: 100
console.log(parseInt("100.99"));  // Output: 100 (bỏ phần thập phân)
console.log(parseInt("50px"));    // Output: 50 (bỏ "px")
console.log(parseInt("abc50"));   // Output: NaN (Không phải số)

Ví dụ với hệ số (radix)

console.log(parseInt("110", 2));  // Output: 6 (110 trong hệ nhị phân = 6 hệ thập phân)
console.log(parseInt("1A", 16));  // Output: 26 (1A trong hệ 16 = 26 trong hệ 10)

Sử dụng `parseFloat()` để chuyển đổi thành số thực

parseFloat() giữ lại phần thập phân của số, khác với parseInt().

Ví dụ:

console.log(parseFloat("100.99"));  // Output: 100.99
console.log(parseFloat("50px"));    // Output: 50 (bỏ "px")
console.log(parseFloat("3.14abc")); // Output: 3.14 (bỏ "abc")
console.log(parseFloat("abc3.14")); // Output: NaN (Không phải số)

Sử dụng `Number()` để chuyển đổi chuỗi thành số

Number() hoạt động giống parseFloat(), nhưng nếu chuỗi chứa bất kỳ ký tự không hợp lệ nào thì sẽ trả về NaN ngay lập tức.

Ví dụ:

console.log(Number("100"));      // Output: 100
console.log(Number("100.99"));   // Output: 100.99
console.log(Number("50px"));     // Output: NaN (Không hợp lệ)
console.log(Number("3.14abc"));  // Output: NaN (Không hợp lệ)

So sánh parseInt(), parseFloat() và Number()

Phương thức	Hành vi
`parseInt("50px")`	Trả về `50`
`parseFloat("50.5px")`	Trả về `50.5`
`Number("50px")`	Trả về `NaN`

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

Để chuyển đổi một số thành chuỗi (string), JavaScript cung cấp các phương thức sau:

toString()
String()

Sử dụng `toString()`

Phương thức toString() chuyển đổi một số thành chuỗi. Có thể chỉ định hệ số (radix) nếu muốn chuyển đổi số sang hệ nhị phân, bát phân, thập lục phân,...

Ví dụ:

let num = 123;
console.log(num.toString());  // Output: "123"
console.log((100).toString()); // Output: "100"

// Chuyển đổi sang hệ nhị phân, bát phân, thập lục phân
console.log((255).toString(2));  // Output: "11111111" (hệ nhị phân)
console.log((255).toString(8));  // Output: "377" (hệ bát phân)
console.log((255).toString(16)); // Output: "ff" (hệ thập lục phân)

Lưu ý:

Nếu sử dụng số trực tiếp, hãy bọc trong dấu ngoặc ( ), nếu không, JavaScript có thể hiểu dấu chấm . là dấu thập phân.

Lỗi phổ biến:

console.log(100.toString()); //  Lỗi

Cách đúng:

console.log((100).toString()); //  Output: "100"
console.log(100..toString());  // Output: "100" (dùng 2 dấu chấm)

Sử dụng `String()`

Phương thức String() có thể chuyển đổi bất kỳ kiểu dữ liệu nào thành chuỗi, bao gồm cả số.

Ví dụ:

console.log(String(123));     // Output: "123"
console.log(String(100.99));  // Output: "100.99"
console.log(String(true));    // Output: "true"
console.log(String(null));    // Output: "null"
console.log(String(undefined)); // Output: "undefined"

Khác biệt giữa toString() và String()

Phương thức	Áp dụng được cho	Ví dụ
`toString()`	Chỉ áp dụng cho số hợp lệ	`(123).toString() → "123"`
`String()`	Áp dụng cho mọi kiểu dữ liệu	`String(null) → "null"`

Chuyển đổi	Phương thức	Ví dụ	Kết quả
Chuỗi → Số nguyên	`parseInt()`	`parseInt("100px")`	`100`
Chuỗi → Số thực	`parseFloat()`	`parseFloat("3.14abc")`	`3.14`
Chuỗi → Số	`Number()`	`Number("50px")`	`NaN`
Số → Chuỗi	`toString()`	`(255).toString(2)`	`"11111111"`
Số → Chuỗi	`String()`	`String(123)`	`"123"`

Việc hiểu rõ cách chuyển đổi giữa số và chuỗi giúp bạn tránh lỗi khi làm việc với dữ liệu, đặc biệt là khi xử lý đầu vào từ người dùng hoặc kết quả từ API.

Đối tượng Math trong JavaScript

JavaScript cung cấp đối tượng Math để hỗ trợ các phép toán toán học phổ biến. Đối tượng này có sẵn trong JavaScript và không cần khởi tạo trước khi sử dụng.

Math có rất nhiều phương thức hữu ích, giúp bạn thực hiện các phép tính từ đơn giản đến phức tạp như tính giá trị tuyệt đối, tìm min/max, sinh số ngẫu nhiên, tính căn bậc hai, lũy thừa,...

Math là một đối tượng tĩnh trong JavaScript, tức là bạn không thể tạo một thể hiện (instance) của nó như new Math().
Bạn có thể sử dụng các phương thức của Math trực tiếp thông qua Math.methodName().
Đối tượng này hỗ trợ các hằng số toán học và các phương thức tính toán.

Một số phương thức phổ biến của Math

Tính giá trị tuyệt đối – `Math.abs(x)`

Phương thức Math.abs(x) trả về giá trị tuyệt đối của số x.

Ví dụ:

console.log(Math.abs(10));   // Output: 10
console.log(Math.abs(-10));  // Output: 10
console.log(Math.abs(0));    // Output: 0
console.log(Math.abs(-3.5)); // Output: 3.5

Tính khoảng cách giữa hai điểm.
Chuyển đổi số âm thành số dương khi làm việc với đơn vị đo lường.

Tìm giá trị lớn nhất/nhỏ nhất – `Math.max()` và `Math.min()`

Math.max(a, b, c, ...) trả về giá trị lớn nhất trong danh sách.
Math.min(a, b, c, ...) trả về giá trị nhỏ nhất trong danh sách.

Ví dụ:

console.log(Math.max(10, 5, 20, 30)); // Output: 30
console.log(Math.min(10, 5, 20, 30)); // Output: 5

let numbers = [8, 3, 12, 6];
console.log(Math.max(...numbers)); // Output: 12 (dùng toán tử spread)
console.log(Math.min(...numbers)); // Output: 3

Tìm điểm số cao nhất/thấp nhất trong một danh sách.
Tìm giá trị lớn nhất hoặc nhỏ nhất trong mảng dữ liệu.

Sinh số ngẫu nhiên – `Math.random()`

Phương thức Math.random() trả về một số thập phân ngẫu nhiên trong khoảng từ 0 đến nhỏ hơn 1 (0 ≤ x < 1).

Ví dụ:

console.log(Math.random()); // Output: Số thập phân ngẫu nhiên (0.0 - 0.999999)

Tạo số nguyên ngẫu nhiên trong khoảng cụ thể:

function getRandomInt(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

console.log(getRandomInt(1, 10)); // Output: Số ngẫu nhiên từ 1 đến 10

Sinh số ngẫu nhiên trong game.
Chọn một phần tử ngẫu nhiên từ danh sách.
Tạo mật khẩu hoặc mã xác thực ngẫu nhiên.

Tính căn bậc hai – `Math.sqrt(x)`

Phương thức Math.sqrt(x) trả về căn bậc hai của x.

Ví dụ:

console.log(Math.sqrt(16));  // Output: 4
console.log(Math.sqrt(25));  // Output: 5
console.log(Math.sqrt(2));   // Output: 1.41421356237
console.log(Math.sqrt(-1));  // Output: NaN (Không hợp lệ)

Tính khoảng cách giữa hai điểm trong không gian 2D hoặc 3D.
Tính cạnh của một hình vuông dựa trên diện tích.

Tính lũy thừa – `Math.pow(base, exponent)` và ``**

Phương thức Math.pow(base, exponent) trả về lũy thừa của base mũ exponent.

Ví dụ:

console.log(Math.pow(2, 3));  // Output: 8 (2^3 = 8)
console.log(Math.pow(5, 2));  // Output: 25 (5^2 = 25)

// Dùng toán tử ** (ES6+)
console.log(2 ** 3);  // Output: 8 (tương đương Math.pow(2,3))
console.log(5 ** 2);  // Output: 25

Tính toán trong công thức vật lý, tài chính.
Mô phỏng phép nhân lặp đi lặp lại.

Làm tròn số – `Math.round()`, `Math.ceil()`, `Math.floor()`

Phương thức	Chức năng
`Math.round(x)`	Làm tròn `x` đến số nguyên gần nhất
`Math.ceil(x)`	Làm tròn lên (luôn lên số nguyên lớn hơn)
`Math.floor(x)`	Làm tròn xuống (luôn về số nguyên nhỏ hơn)

Ví dụ:

console.log(Math.round(4.5));  // Output: 5
console.log(Math.round(4.4));  // Output: 4

console.log(Math.ceil(4.1));   // Output: 5
console.log(Math.floor(4.9));  // Output: 4

Làm tròn số tiền khi tính toán tài chính.
Định dạng hiển thị dữ liệu số một cách hợp lý.

Hằng số toán học trong Math

Math cung cấp một số hằng số toán học phổ biến:

Hằng số	Giá trị
`Math.PI`	3.141592653589793 (Số π)
`Math.E`	2.718281828459045 (Hằng số Euler)
`Math.LN2`	0.6931471805599453 (Logarit tự nhiên của 2)
`Math.LN10`	2.302585092994046 (Logarit tự nhiên của 10)

Ví dụ:

console.log(Math.PI);  // Output: 3.141592653589793
console.log(Math.E);   // Output: 2.718281828459045
console.log(Math.LN2); // Output: 0.6931471805599453

Tính chu vi, diện tích hình tròn.
Các phép tính khoa học và kỹ thuật.

Phương thức	Chức năng
`Math.abs(x)`	Trả về giá trị tuyệt đối
`Math.max(a, b, c, ...)`	Trả về giá trị lớn nhất
`Math.min(a, b, c, ...)`	Trả về giá trị nhỏ nhất
`Math.random()`	Sinh số ngẫu nhiên từ 0 đến < 1
`Math.sqrt(x)`	Tính căn bậc hai
`Math.pow(x, y)`	Tính lũy thừa x^y
`Math.round(x)`	Làm tròn số
`Math.ceil(x)`	Làm tròn lên
`Math.floor(x)`	Làm tròn xuống

Các lỗi thường gặp khi làm việc với số trong JavaScript

Làm việc với kiểu dữ liệu số trong JavaScript có thể gặp một số vấn đề phổ biến. Hiểu rõ những lỗi này giúp bạn tránh các sai sót trong lập trình và tối ưu mã nguồn.

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

Nguyên nhân:

NaN (Not a Number) xuất hiện khi cố gắng thực hiện phép toán với một giá trị không hợp lệ.
Ví dụ: Nhân một chuỗi không phải số với một số, phép toán toán học trên undefined, hoặc kết quả của một phép chia không hợp lệ.

Ví dụ:

console.log("abc" * 5);  // Output: NaN
console.log(undefined + 10);  // Output: NaN
console.log(Math.sqrt(-1));  // Output: NaN

Giải pháp:

Kiểm tra giá trị trước khi thực hiện phép toán bằng isNaN().
Chuyển đổi chuỗi thành số trước khi sử dụng.

let value = "abc";
if (isNaN(value)) {
    console.log("Giá trị không hợp lệ!");
} else {
    console.log(value * 5);
}

Lỗi số chính xác (Floating Point Precision)

Nguyên nhân:

JavaScript sử dụng chuẩn IEEE 754 để biểu diễn số thực (floating-point), có thể gây ra lỗi chính xác khi tính toán.
Ví dụ: 0.1 + 0.2 !== 0.3 do cách lưu trữ số trong hệ nhị phân.

Ví dụ:

console.log(0.1 + 0.2);  // Output: 0.30000000000000004
console.log(0.1 + 0.2 === 0.3);  // Output: false

Giải pháp:

Sử dụng toFixed() để làm tròn số.
Chuyển đổi kết quả về số bằng Number() hoặc parseFloat().

let result = Number((0.1 + 0.2).toFixed(2));  
console.log(result);  // Output: 0.3

Ứng dụng thực tế của kiểu dữ liệu số trong JavaScript

Kiểu dữ liệu số là một phần quan trọng trong JavaScript và được sử dụng trong nhiều ứng dụng thực tế. Dưới đây là một số ví dụ phổ biến:

Xử lý giá trị tiền tệ trong ứng dụng thương mại điện tử

Ứng dụng:

Tính tổng tiền của đơn hàng.
Làm tròn số tiền để tránh sai lệch khi thanh toán.

Ví dụ:

let price = 199.99;
let quantity = 3;
let total = price * quantity;

console.log(total.toFixed(2));  // Output: "599.97" (định dạng tiền tệ)

Tính toán số học trong các ứng dụng kế toán, tài chính

Tính lãi suất ngân hàng.
Chuyển đổi tỷ giá tiền tệ.
Phân tích dữ liệu tài chính.

Ví dụ:

let principal = 1000; // Số tiền gốc
let rate = 5 / 100; // Lãi suất 5%
let years = 3;

// Công thức tính lãi kép: A = P * (1 + r)^t
let finalAmount = principal * Math.pow((1 + rate), years);

console.log(finalAmount.toFixed(2));  // Output: "1157.63"

Lỗi Thường Gặp	Nguyên Nhân	Giải Pháp
`NaN` khi thực hiện phép toán	Phép toán với giá trị không hợp lệ	Kiểm tra bằng `isNaN()`, chuyển đổi chuỗi thành số
Sai số khi làm việc với số thực	Hệ thống IEEE 754 lưu số thực dưới dạng nhị phân	Sử dụng `toFixed()`, `Number()` để làm tròn
So sánh `==` thay vì `===`	JavaScript ép kiểu khi dùng `==`	Luôn sử dụng `===` để so sánh chính xác

Kết bài

Kiểu dữ liệu số (Number) trong JavaScript đóng vai trò quan trọng trong hầu hết các ứng dụng, từ xử lý dữ liệu đơn giản đến các phép toán tài chính, đo lường, và bảo mật. Việc nắm vững cách sử dụng số, các phép toán toán học, phương thức hỗ trợ của đối tượng Math, cũng như cách xử lý lỗi phổ biến 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.

Bên cạnh đó, hiểu rõ các vấn đề như lỗi số chính xác (Floating Point Precision), lỗi NaN, và sự khác biệt giữa == và === khi so sánh số sẽ giúp tránh các lỗi không mong muốn trong quá trình phát triển phần mềm.