Kiểm tra số thực trong JavaScript

Kiểu bigInt là kiểu số đặc biết nên mình sẽ tìm hiểu sau. Bài viết này chỉ tập trung vào number thông thường.

Cách khác để biểu diễn number trong JavaScript

Giả sử bạn cần biểu diễn số 1 tỷ:

let oneBillion = 1000000000;

Nếu bạn chỉ nhìn qua thì rất khó nhận biết đó là số 1 tỷ. Có thể bạn sẽ phải đếm xem có bao nhiêu số 0 trong đó.

Thay vì phải đếm như vậy, JavaScript cho phép bạn sử dụng kí tự gạch chân

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

6 để phân tách các chữ số:

let oneBillion = 1_000_000_000;

Rõ ràng cách viết này dễ nhìn hơn. Và kết quả thì vẫn không thay đổi. Vì JavaScript engine sẽ bỏ qua, không xử lý kí tự

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

6 trong number.

Trong thực tế cuộc sống, chúng ta thường không muốn viết hết các chữ số

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

8 mà thường viết tắt, ví dụ: 1000 thành 1K, 1000000 thành 1M,...

Với JavaScript cũng vậy, bạn có thể dùng chữ cái

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

9 để biểu diễn số lượng chữ số

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

8, ví dụ:

let a = 1e3; // 1_000 - 1 nghìn
let b = 1e6; // 1_000_000 - 1 triệu
let c = 1e9; // 1_000_000_000 - 1 tỷ
let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ

Nói cách khác,

0.000001 === 1e-6;

1 thực hiện nhân số (trước

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

9) bởi với số 10 mũ N.

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

Tương tự, bạn cũng có thể dùng

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

9 để biểu diễn những số rất nhỏ bằng cách thay

0.000001 === 1e-6;

4 ở trên bằng số âm:

0.000001 === 1e-6;

Nói cách khác,

0.000001 === 1e-6;

5 thực hiện chia số (trước

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

9) bởi số 10 mũ N.

1e-3 === 1 / 1000; // e3 tương đương /1000
1.23e-4 === 1.23 / 10000; // e4 tương đương /10000

Biểu diễn số ở hệ cơ số 16, 8 và 2

Các số mình thường viết trên đây là biểu diễn ở hệ thập phân (cơ số 10). Ngoài ra, bạn có thể biểu diễn number trong JavaScript ở hệ thập lục phân (cơ số 16), bát phân (cơ số 8) và nhị phân (cơ số 2).

• Hệ thập lục phân sử dụng tiền tố là

  0.000001 === 1e-6;
  

  7.
• Hệ bát phân sử dụng tiền tố là

  0.000001 === 1e-6;
  

  8.
• Hệ nhị phân sử dụng tiền tố là

  0.000001 === 1e-6;
  

  9.

biểu diễn số ở hệ 16, 8 và 2 là:

// Hệ cơ số 16
console.log(0xff); // 255
console.log(0xff); // 255 - không phân biệt hoa thường

// Hệ cơ số 8
console.log(0o377); // 255

// Hệ cơ số 2
console.log(0b11111111); // 255

Phương thức

1e-3 === 1 / 1000; // e3 tương đương /1000
1.23e-4 === 1.23 / 10000; // e4 tương đương /10000

0 trả về string biểu diễn số

1e-3 === 1 / 1000; // e3 tương đương /1000
1.23e-4 === 1.23 / 10000; // e4 tương đương /10000

1 ở hệ cơ số

1e-3 === 1 / 1000; // e3 tương đương /1000
1.23e-4 === 1.23 / 10000; // e4 tương đương /10000

2, ví dụ:

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

Trong đó,

1e-3 === 1 / 1000; // e3 tương đương /1000
1.23e-4 === 1.23 / 10000; // e4 tương đương /10000

2 có giá trị nằm trong đoạn từ 2 đến 36. Mặc định,

1e-3 === 1 / 1000; // e3 tương đương /1000
1.23e-4 === 1.23 / 10000; // e4 tương đương /10000

2 là 10.

Một số trường hợp phổ biến:

• 1e-3 === 1 / 1000; // e3 tương đương /1000
  1.23e-4 === 1.23 / 10000; // e4 tương đương /10000
  

  5 hay dùng để biểu diễn mã màu hexa, string đã được encode,... với các chữ số từ

  1e-3 === 1 / 1000; // e3 tương đương /1000
  1.23e-4 === 1.23 / 10000; // e4 tương đương /10000
  

  6 hoặc

  1e-3 === 1 / 1000; // e3 tương đương /1000
  1.23e-4 === 1.23 / 10000; // e4 tương đương /10000
  

  7 (không phân biệt hoa thường).

• 1e-3 === 1 / 1000; // e3 tương đương /1000
  1.23e-4 === 1.23 / 10000; // e4 tương đương /10000
  

  8 thường dùng để debug các số sử dụng trong toán tử bitwise... với các chữ số là

  1e3 === 1 * 1000; // e3 tương đương *1000
  1.23e4 === 1.23 * 10000; // e4 tương đương *10000
  

  8 hoặc

  // Hệ cơ số 16
  console.log(0xff); // 255
  console.log(0xff); // 255 - không phân biệt hoa thường
  
  // Hệ cơ số 8
  console.log(0o377); // 255
  
  // Hệ cơ số 2
  console.log(0b11111111); // 255
  

  0.

• // Hệ cơ số 16
  console.log(0xff); // 255
  console.log(0xff); // 255 - không phân biệt hoa thường
  
  // Hệ cơ số 8
  console.log(0o377); // 255
  
  // Hệ cơ số 2
  console.log(0b11111111); // 255
  

  1 là giá trị lớn nhất, thường được dùng để biểu diễn các số dài thành dạng ngắn gọn hơn, với các chữ số từ

  1e-3 === 1 / 1000; // e3 tương đương /1000
  1.23e-4 === 1.23 / 10000; // e4 tương đương /10000
  

  6 và

  // Hệ cơ số 16
  console.log(0xff); // 255
  console.log(0xff); // 255 - không phân biệt hoa thường
  
  // Hệ cơ số 8
  console.log(0o377); // 255
  
  // Hệ cơ số 2
  console.log(0b11111111); // 255
  

  3, ví dụ:

console.log((1234567890).toString(36)); // kf12oi

cách viết dùng hai dấu chấm

// Hệ cơ số 16
console.log(0xff); // 255
console.log(0xff); // 255 - không phân biệt hoa thường

// Hệ cơ số 8
console.log(0o377); // 255

// Hệ cơ số 2
console.log(0b11111111); // 255

4 như trên không phải lỗi chính tả. Nếu bạn muốn gọi phương thức của number, ví dụ

// Hệ cơ số 16
console.log(0xff); // 255
console.log(0xff); // 255 - không phân biệt hoa thường

// Hệ cơ số 8
console.log(0o377); // 255

// Hệ cơ số 2
console.log(0b11111111); // 255

5, bạn cần phải dùng hai dấu chấm

Nếu bạn dùng một dấu chấm thì sẽ có lỗi cú pháp:

console.log(1234567890.toString(36));
    // Uncaught SyntaxError: Invalid or unexpected token

Bởi vì, JavaScript hiểu rằng sau dấu

// Hệ cơ số 16
console.log(0xff); // 255
console.log(0xff); // 255 - không phân biệt hoa thường

// Hệ cơ số 8
console.log(0o377); // 255

// Hệ cơ số 2
console.log(0b11111111); // 255

6 đầu tiên là phần thập phân của số thực. Mà đằng sau

// Hệ cơ số 16
console.log(0xff); // 255
console.log(0xff); // 255 - không phân biệt hoa thường

// Hệ cơ số 8
console.log(0o377); // 255

// Hệ cơ số 2
console.log(0b11111111); // 255

6 lại là

// Hệ cơ số 16
console.log(0xff); // 255
console.log(0xff); // 255 - không phân biệt hoa thường

// Hệ cơ số 8
console.log(0o377); // 255

// Hệ cơ số 2
console.log(0b11111111); // 255

8 thì chắc chắn sai cú pháp.

Ngược lại, khi bạn viết hai dấu chấm

// Hệ cơ số 16
console.log(0xff); // 255
console.log(0xff); // 255 - không phân biệt hoa thường

// Hệ cơ số 8
console.log(0o377); // 255

// Hệ cơ số 2
console.log(0b11111111); // 255

4, JavaScript ngầm định phần thập phân là rỗng, rồi sau đó đến phương thức.

Nói cách khác, cách viết hai dấu chấm

// Hệ cơ số 16
console.log(0xff); // 255
console.log(0xff); // 255 - không phân biệt hoa thường

// Hệ cơ số 8
console.log(0o377); // 255

// Hệ cơ số 2
console.log(0b11111111); // 255

4 tương đương với cách viết sử dụng

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

1 như sau:

let oneBillion = 1_000_000_000;

0

Để code rõ ràng và an toàn hơn, bạn nên sử dụng

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

1

Làm tròn number trong JavaScript

Một trong những phép toán hay sử dụng với number trong JavaScript nhất là làm tròn số. JavaScript có sẵn một số hàm giúp bạn làm tròn số như:

►

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

3:

Từ floor dịch ra là sàn nhà - suy ra hàm

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

3 dùng để làm tròn xuống. Ví dụ:

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

5 trở thành

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

6 và

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

7 trở thành

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

8.

►

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

9:

Từ ceil dịch ra là trần nhà - suy ra hàm

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

9 dùng để làm tròn lên. Ví dụ:

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

5 trở thành

console.log((1234567890).toString(36)); // kf12oi

2 và

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

7 trở thành

console.log((1234567890).toString(36)); // kf12oi

4.

►

console.log((1234567890).toString(36)); // kf12oi

5:

Hàm này trả về số nguyên gần nhất (có thể làm tròn lên hoặc làm tròn xuống). Ví dụ:

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

5 trả về

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

6,

console.log((1234567890).toString(36)); // kf12oi

8 trở thành

console.log((1234567890).toString(36)); // kf12oi

2 và giá trị ở giữa

console.log(1234567890.toString(36));
    // Uncaught SyntaxError: Invalid or unexpected token

0 cũng trở thành

console.log((1234567890).toString(36)); // kf12oi

2.

►

console.log(1234567890.toString(36));
    // Uncaught SyntaxError: Invalid or unexpected token

2 (không hỗ trợ bởi trình duyệt IE):

Hàm này trả về số nguyên bằng cách xóa bỏ đi tất cả thành phần sau dấu phẩy. Ví dụ:

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

5 trở thành

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

6 và

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

7 trở thành

console.log((1234567890).toString(36)); // kf12oi

4.

Trên đây là những hàm giúp làm tròn thành số nguyên. Vậy làm sao để làm tròn thành số thực với chính xác

console.log(1234567890.toString(36));
    // Uncaught SyntaxError: Invalid or unexpected token

7 chữ số sau dấu phẩy.

làm sao để làm tròn số

console.log(1234567890.toString(36));
    // Uncaught SyntaxError: Invalid or unexpected token

8 thành

console.log(1234567890.toString(36));
    // Uncaught SyntaxError: Invalid or unexpected token

9 (2 chữ số sau dấu phẩy)?

Có hai cách để giải quyết vấn đề trên.

1. Phương pháp nhân-rồi-chia:

Ví dụ để làm tròn 2 chữ số sau dấu phẩy, bạn nhân số ban đầu với

let oneBillion = 1_000_000_000;

00 (2 chữ số

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

8). Sau đó, bạn dùng

console.log((1234567890).toString(36)); // kf12oi

5 để làm tròn kết quả về số nguyên gần nhất. Cuối cùng, bạn chia kết quả cho

let oneBillion = 1_000_000_000;

00 sẽ thu được kết quả như mong muốn.

let oneBillion = 1_000_000_000;

1

1. Sử dụng phương thức

   let oneBillion = 1_000_000_000;
   

   04:

Phương thức này sẽ làm tròn số và trả về string với chính xác

console.log(1234567890.toString(36));
    // Uncaught SyntaxError: Invalid or unexpected token

7 chữ số sau dấu phẩy.

let oneBillion = 1_000_000_000;

2

Trường hợp phần thập phân không đủ

console.log(1234567890.toString(36));
    // Uncaught SyntaxError: Invalid or unexpected token

7 chữ số thì phương thức

let oneBillion = 1_000_000_000;

04 tự động thêm các chữ số

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

8 phía sau cho đủ

console.log(1234567890.toString(36));
    // Uncaught SyntaxError: Invalid or unexpected token

7 chữ số.

let oneBillion = 1_000_000_000;

3

Để chuyển đổi kiểu dữ liệu string về number, bạn có thể dùng hàm

let oneBillion = 1_000_000_000;

10 hoặc toán tử một ngôi

let oneBillion = 1_000_000_000;

11, ví dụ:

let oneBillion = 1_000_000_000;

4

Sai số với number trong JavaScript

Trong JavaScript, số thông thường được biểu diễn dưới dạng số thực dấu phẩy động theo chuẩn IEEE-754. Định dạng này sử dụng 64 bit để lưu trữ một số, trong đó:

• 52 bit dùng để lưu trữ các chữ số phần nguyên.
• 11 bit để lưu trữ phần thập phân.
• 1 bit để lưu trữ dấu (

  1e3 === 1 * 1000; // e3 tương đương *1000
  1.23e4 === 1.23 * 10000; // e4 tương đương *10000
  

  8 - số dương và

  // Hệ cơ số 16
  console.log(0xff); // 255
  console.log(0xff); // 255 - không phân biệt hoa thường
  
  // Hệ cơ số 8
  console.log(0o377); // 255
  
  // Hệ cơ số 2
  console.log(0b11111111); // 255
  

  0 - số âm).

Nếu một số quá lớn, vượt ngoài khả năng biểu diễn của 64 bit thì sẽ trở thành

let oneBillion = 1_000_000_000;

14 hoặc

let oneBillion = 1_000_000_000;

15:

let oneBillion = 1_000_000_000;

5

Đối với các số thực, một vấn đề thường xuyên xảy ra là sự sai số.

Một ví dụ kinh điển:

let oneBillion = 1_000_000_000;

6

Kết quả là

let oneBillion = 1_000_000_000;

16 vì thực tế

let oneBillion = 1_000_000_000;

17 bằng số khác:

let oneBillion = 1_000_000_000;

7

Hiểu đơn giản là: khi biểu diễn số thực dưới dạng nhị phân trong máy tính, không có cách nào để biểu diễn chính xác số

let oneBillion = 1_000_000_000;

18 và

let oneBillion = 1_000_000_000;

19. Dẫn đến kết quả bị sai số như trên.

Ví dụ mình sử dụng phương thức

let oneBillion = 1_000_000_000;

20 để xem giá trị thực sự của các số thế nào:

let oneBillion = 1_000_000_000;

8

Rõ ràng là chúng không thực sự bằng

let oneBillion = 1_000_000_000;

18 và

let oneBillion = 1_000_000_000;

19.

Để giải quyết vấn đề này, bạn có thể sử dụng phương pháp nhân-rồi-chia hoặc phương thức

let oneBillion = 1_000_000_000;

23 như mình đã đề cập ở trên:

let oneBillion = 1_000_000_000;

9

Kiểm tra số với let oneBillion = 1_000_000_000; 24 và let oneBillion = 1_000_000_000; 25

Để kiểm tra number trong JavaScript, bạn có thể dùng một trong hai hàm là:

let oneBillion = 1_000_000_000;

24 hoặc

let oneBillion = 1_000_000_000;

25.

► Hàm

let oneBillion = 1_000_000_000;

28:

Hàm này chuyển đổi

let oneBillion = 1_000_000_000;

29 thành dạng số rồi kiểm tra xem có bằng

let oneBillion = 1_000_000_000;

30 hay không.

let a = 1e3; // 1_000 - 1 nghìn
let b = 1e6; // 1_000_000 - 1 triệu
let c = 1e9; // 1_000_000_000 - 1 tỷ
let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ

0

Vấn đề là hàm

let oneBillion = 1_000_000_000;

24 có thật sự cần thiết hay không?

Câu trả lời là CÓ. Bởi vì giá trị

let oneBillion = 1_000_000_000;

30 là duy nhất.

let oneBillion = 1_000_000_000;

30 không bằng bất kỳ giá trị nào khác:

let a = 1e3; // 1_000 - 1 nghìn
let b = 1e6; // 1_000_000 - 1 triệu
let c = 1e9; // 1_000_000_000 - 1 tỷ
let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ

1

Nghĩa là bạn không thể dùng toán tử so sánh bằng

let oneBillion = 1_000_000_000;

34 để so sánh số với

let oneBillion = 1_000_000_000;

30.

► Hàm

let oneBillion = 1_000_000_000;

36:

Hàm này chuyển đổi giá trị

let oneBillion = 1_000_000_000;

29 thành dạng số và trả về

let oneBillion = 1_000_000_000;

38 nếu số đó khác

let oneBillion = 1_000_000_000;

14,

let oneBillion = 1_000_000_000;

15 và

let oneBillion = 1_000_000_000;

30, ngược lại thì trả về

let oneBillion = 1_000_000_000;

16.

let a = 1e3; // 1_000 - 1 nghìn
let b = 1e6; // 1_000_000 - 1 triệu
let c = 1e9; // 1_000_000_000 - 1 tỷ
let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ

2

Hàm

let oneBillion = 1_000_000_000;

36 cũng thường dùng để kiểm tra một giá trị string có phải là số bình thường hay không.

Ví dụ khi nhập vào một số với hàm

let oneBillion = 1_000_000_000;

44:

let a = 1e3; // 1_000 - 1 nghìn
let b = 1e6; // 1_000_000 - 1 triệu
let c = 1e9; // 1_000_000_000 - 1 tỷ
let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ

3

String rỗng hoặc string toàn dấu cách chuyển sang dạng số thành số

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

8.

Để so sánh hai number trong JavaScript, bạn cũng có thể dùng phương thức

let oneBillion = 1_000_000_000;

46:

1. Phương thức này sử dụng được với

   let oneBillion = 1_000_000_000;
   

   30:

   let oneBillion = 1_000_000_000;
   

   48 bằng

   let oneBillion = 1_000_000_000;
   

   38.
2. Hai giá trị

   1e3 === 1 * 1000; // e3 tương đương *1000
   1.23e4 === 1.23 * 10000; // e4 tương đương *10000
   

   8 và

   let oneBillion = 1_000_000_000;
   

   51 là khác nhau:

   let oneBillion = 1_000_000_000;
   

   52 bằng

   let oneBillion = 1_000_000_000;
   

   16. Bởi vì JavaScript sử dụng 1 bit để biểu diễn dấu (

   1e3 === 1 * 1000; // e3 tương đương *1000
   1.23e4 === 1.23 * 10000; // e4 tương đương *10000
   

   8 - số dương và

   // Hệ cơ số 16
   console.log(0xff); // 255
   console.log(0xff); // 255 - không phân biệt hoa thường
   
   // Hệ cơ số 8
   console.log(0o377); // 255
   
   // Hệ cơ số 2
   console.log(0b11111111); // 255
   

   0 - số âm), nên hai giá trị

   1e3 === 1 * 1000; // e3 tương đương *1000
   1.23e4 === 1.23 * 10000; // e4 tương đương *10000
   

   8 và

   let oneBillion = 1_000_000_000;
   

   51 khác nhau.

Trong hầu hết các trường hợp, phương thức

let oneBillion = 1_000_000_000;

46 tương đương với so sánh bằng nghiêm ngặt

let oneBillion = 1_000_000_000;

34.

Hàm let oneBillion = 1_000_000_000; 60 và hàm let oneBillion = 1_000_000_000; 61

Có thể bạn đã biết hai cách để chuyển đổi string thành dạng số là:

• Sử dụng hàm

  let oneBillion = 1_000_000_000;
  

  10.
• Sử dụng toán tử một ngôi

  let oneBillion = 1_000_000_000;
  

  11.

let a = 1e3; // 1_000 - 1 nghìn
let b = 1e6; // 1_000_000 - 1 triệu
let c = 1e9; // 1_000_000_000 - 1 tỷ
let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ

4

Tuy nhiên, nếu trong string chứa kí tự không phải dạng số thì kết quả là

let oneBillion = 1_000_000_000;

30:

let a = 1e3; // 1_000 - 1 nghìn
let b = 1e6; // 1_000_000 - 1 triệu
let c = 1e9; // 1_000_000_000 - 1 tỷ
let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ

5

Thực tế, có một số trường hợp string chứa cả số và đơn vị phía sau như

let oneBillion = 1_000_000_000;

65,

let oneBillion = 1_000_000_000;

66,

let oneBillion = 1_000_000_000;

67,... Làm sao để tách lấy phần số từ các string này?

Trong JavaScript, bạn có thể sử dụng hai hàm

let oneBillion = 1_000_000_000;

60 và

let oneBillion = 1_000_000_000;

61. Hai hàm này sẽ đọc string từ trái sang phải cho đến khi gặp kí tự không thỏa mãn thì dừng lại.

• Hàm

  let oneBillion = 1_000_000_000;
  

  60 tách lấy số nguyên.
• Hàm

  let oneBillion = 1_000_000_000;
  

  61 tách lấy số thực.

Một số ví dụ:

let a = 1e3; // 1_000 - 1 nghìn
let b = 1e6; // 1_000_000 - 1 triệu
let c = 1e9; // 1_000_000_000 - 1 tỷ
let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ

6

Nếu không thể tách được số nào thì

let oneBillion = 1_000_000_000;

60 và

let oneBillion = 1_000_000_000;

61 trả về

let oneBillion = 1_000_000_000;

30:

let a = 1e3; // 1_000 - 1 nghìn
let b = 1e6; // 1_000_000 - 1 triệu
let c = 1e9; // 1_000_000_000 - 1 tỷ
let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ

7

hàm

let oneBillion = 1_000_000_000;

75 có tham số thứ hai

let oneBillion = 1_000_000_000;

76 biểu diễn hệ cơ số (từ

let oneBillion = 1_000_000_000;

77 đến

let oneBillion = 1_000_000_000;

78)

Ví dụ tách lấy số nguyên ở các hệ cơ số khác nhau:

let a = 1e3; // 1_000 - 1 nghìn
let b = 1e6; // 1_000_000 - 1 triệu
let c = 1e9; // 1_000_000_000 - 1 tỷ
let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ

8

Một số hàm toán học

Ngoài các phương thức

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

3,

let num = 255;

// chuyển sang hệ cơ số 16
console.log(num.toString(16)); // ff

// chuyển sang hệ cơ số 2
console.log(num.toString(2)); // 11111111

9,

console.log((1234567890).toString(36)); // kf12oi

5 và

console.log(1234567890.toString(36));
    // Uncaught SyntaxError: Invalid or unexpected token

2 đã trình bày ở trên, đối tượng

let oneBillion = 1_000_000_000;

83 còn có các phương thức khác giúp bạn thực hiện một số hàm toán học.

►

let oneBillion = 1_000_000_000;

84

Phương thức này trả về một giá trị ngẫu nhiên từ

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

8 đến

// Hệ cơ số 16
console.log(0xff); // 255
console.log(0xff); // 255 - không phân biệt hoa thường

// Hệ cơ số 8
console.log(0o377); // 255

// Hệ cơ số 2
console.log(0b11111111); // 255

0 (không bao gồm

// Hệ cơ số 16
console.log(0xff); // 255
console.log(0xff); // 255 - không phân biệt hoa thường

// Hệ cơ số 8
console.log(0o377); // 255

// Hệ cơ số 2
console.log(0b11111111); // 255

0), ví dụ:

let a = 1e3; // 1_000 - 1 nghìn
let b = 1e6; // 1_000_000 - 1 triệu
let c = 1e9; // 1_000_000_000 - 1 tỷ
let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ

9

►

let oneBillion = 1_000_000_000;

88 và

let oneBillion = 1_000_000_000;

89

Hai phương thức này trả về giá trị lớn nhất (nhỏ nhất) từ một dãy số đầu vào.

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

0

►

let oneBillion = 1_000_000_000;

90

Trả về số

console.log(1234567890.toString(36));
    // Uncaught SyntaxError: Invalid or unexpected token

7 mũ

1e-3 === 1 / 1000; // e3 tương đương /1000
1.23e-4 === 1.23 / 10000; // e4 tương đương /10000

2.

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

1

Đối tượng

let oneBillion = 1_000_000_000;

83 còn rất nhiều phương thức hữu ích khác. Bạn có thể tham khảo thêm tại bài viết: Math.

Tổng kết

Sau đây là một số kiến thức về number trong JavaScript.

Bạn có thể dùng kí tự

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

6 để ngăn cách các chữ số cho dễ nhìn. Ví dụ

let oneBillion = 1_000_000_000;

95 tương đương

let oneBillion = 1_000_000_000;

96.

Trường hợp có nhiều chữ số

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

8 đằng sau, bạn có thể dùng kí tự

1e3 === 1 * 1000; // e3 tương đương *1000
1.23e4 === 1.23 * 10000; // e4 tương đương *10000

9 theo sau là một số

0.000001 === 1e-6;

4 để biểu diễn:

• Với

  0.000001 === 1e-6;
  

  4 dương thì

  0.000001 === 1e-6;
  

  1 tương đương nhân với 10 mũ N, ví dụ:

  let a = 1e3; // 1_000 - 1 nghìn
  let b = 1e6; // 1_000_000 - 1 triệu
  let c = 1e9; // 1_000_000_000 - 1 tỷ
  let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ
  

  02 bằng

  let a = 1e3; // 1_000 - 1 nghìn
  let b = 1e6; // 1_000_000 - 1 triệu
  let c = 1e9; // 1_000_000_000 - 1 tỷ
  let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ
  

  03.
• Với

  0.000001 === 1e-6;
  

  4 âm thì

  0.000001 === 1e-6;
  

  1 tương đương chia cho 10 mũ N, ví dụ:

  let a = 1e3; // 1_000 - 1 nghìn
  let b = 1e6; // 1_000_000 - 1 triệu
  let c = 1e9; // 1_000_000_000 - 1 tỷ
  let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ
  

  06 bằng

  let a = 1e3; // 1_000 - 1 nghìn
  let b = 1e6; // 1_000_000 - 1 triệu
  let c = 1e9; // 1_000_000_000 - 1 tỷ
  let d = 4.6e9; // 4_600_000_000 - 4.6 tỷ
  

  07.

JavaScript hỗ trợ biểu diễn số ở hệ cơ số khác:

• Hệ cơ số 16 sử dụng tiền tồ

  0.000001 === 1e-6;
  

  7.
• Hệ cơ số 8 sử dụng tiền tố

  0.000001 === 1e-6;
  

  8.
• Hệ cơ số 2 sử dụng tiền tố

  0.000001 === 1e-6;
  

  9.

Để chuyển một số sang string với hệ cơ số tương ứng, bạn dùng

1e-3 === 1 / 1000; // e3 tương đương /1000
1.23e-4 === 1.23 / 10000; // e4 tương đương /10000

0, với

1e-3 === 1 / 1000; // e3 tương đương /1000
1.23e-4 === 1.23 / 10000; // e4 tương đương /10000

2 là hệ cơ số có giá trị từ

let oneBillion = 1_000_000_000;

77 đến

let oneBillion = 1_000_000_000;

78.

Để kiểm tra xem một số có phải

let oneBillion = 1_000_000_000;

30 hay không, bạn dùng hàm

let oneBillion = 1_000_000_000;

24. Hàm

let oneBillion = 1_000_000_000;

28 chuyển giá trị

let oneBillion = 1_000_000_000;

29 thành dạng số, rồi trả về

let oneBillion = 1_000_000_000;

38 nếu số đó là

let oneBillion = 1_000_000_000;

30, ngược lại thì trả về

let oneBillion = 1_000_000_000;

16.

Để kiểm tra xem một số có phải số thông thường hay không, bạn dùng

let oneBillion = 1_000_000_000;

25. Hàm

let oneBillion = 1_000_000_000;

36 chuyển giá trị

let oneBillion = 1_000_000_000;

29 thành dạng số, rồi trả về

let oneBillion = 1_000_000_000;

38 nếu số đó khác

let oneBillion = 1_000_000_000;

14,

let oneBillion = 1_000_000_000;

15 và

let oneBillion = 1_000_000_000;

30.

Để chuyển đổi string thành dạng số, bạn có thể dùng hàm

let oneBillion = 1_000_000_000;

60 hoặc hàm

let oneBillion = 1_000_000_000;

61. Cả hai hàm này đều đọc string từ trái sang phải cho đến khi gặp kí tự không thỏa mãn thì dừng lại:

• Hàm

  let oneBillion = 1_000_000_000;
  

  60: tách lấy phần số nguyên.
• Hàm

  let oneBillion = 1_000_000_000;
  

  61: tách lấy phần số thực.

Đối tượng

let oneBillion = 1_000_000_000;

83 có các phương thức giúp bạn thực hiện các phép toán số học với number trong JavaScript như: