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à
7.0.000001 === 1e-6;
- Hệ bát phân sử dụng tiền tố là
8.0.000001 === 1e-6;
- Hệ nhị phân sử dụng tiền tố là
9.0.000001 === 1e-6;
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:
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ặc1e-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à1e-3 === 1 / 1000; // e3 tương đương /1000 1.23e-4 === 1.23 / 10000; // e4 tương đương /10000
8 hoặc1e3 === 1 * 1000; // e3 tương đương *1000 1.23e4 === 1.23 * 10000; // e4 tương đương *10000
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ừ// 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 và1e-3 === 1 / 1000; // e3 tương đương /1000 1.23e-4 === 1.23 / 10000; // e4 tương đương /10000
3, 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
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ấmNế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
1Là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.
- 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- Sử dụng phương thức
04:let oneBillion = 1_000_000_000;
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;
2Trườ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;
4Sai 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 [
8 - số dương và1e3 === 1 * 1000; // e3 tương đương *1000 1.23e4 === 1.23 * 10000; // e4 tương đương *10000
0 - số â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
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;
6Kế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;
7Hiể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;
8Rõ 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;
9Kiểm tra số với let oneBillion = 1_000_000_000;
24 và let oneBillion = 1_000_000_000;
25
let oneBillion = 1_000_000_000;
let oneBillion = 1_000_000_000;
Để 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ỷ
0Vấ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ỷ
1Nghĩ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ỷ
2Hà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ỷ
3String 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:- Phương thức này sử dụng được với
30:let oneBillion = 1_000_000_000;
48 bằnglet oneBillion = 1_000_000_000;
38.let oneBillion = 1_000_000_000;
- Hai giá trị
8 và1e3 === 1 * 1000; // e3 tương đương *1000 1.23e4 === 1.23 * 10000; // e4 tương đương *10000
51 là khác nhau:let oneBillion = 1_000_000_000;
52 bằnglet oneBillion = 1_000_000_000;
16. Bởi vì JavaScript sử dụng 1 bit để biểu diễn dấu [let oneBillion = 1_000_000_000;
8 - số dương và1e3 === 1 * 1000; // e3 tương đương *1000 1.23e4 === 1.23 * 10000; // e4 tương đương *10000
0 - số âm], nên hai giá trị// 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 và1e3 === 1 * 1000; // e3 tương đương *1000 1.23e4 === 1.23 * 10000; // e4 tương đương *10000
51 khác nhau.let oneBillion = 1_000_000_000;
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
let oneBillion = 1_000_000_000;
let oneBillion = 1_000_000_000;
Có thể bạn đã biết hai cách để chuyển đổi string thành dạng số là:
- Sử dụng hàm
10.let oneBillion = 1_000_000_000;
- Sử dụng toán tử một ngôi
11.let oneBillion = 1_000_000_000;
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ỷ
4Tuy 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ỷ
5Thự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
60 tách lấy số nguyên.let oneBillion = 1_000_000_000;
- Hàm
61 tách lấy số thực.let oneBillion = 1_000_000_000;
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ỷ
6Nế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ỷ
7hà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ỷ
8Mộ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;
84Phươ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;
89Hai 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;
90Trả 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
4 dương thì0.000001 === 1e-6;
1 tương đương nhân với 10 mũ N, ví dụ:0.000001 === 1e-6;
02 bằnglet 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.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ỷ
- Với
4 âm thì0.000001 === 1e-6;
1 tương đương chia cho 10 mũ N, ví dụ:0.000001 === 1e-6;
06 bằnglet 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.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ỷ
JavaScript hỗ trợ biểu diễn số ở hệ cơ số khác:
- Hệ cơ số 16 sử dụng tiền tồ
7.0.000001 === 1e-6;
- Hệ cơ số 8 sử dụng tiền tố
8.0.000001 === 1e-6;
- Hệ cơ số 2 sử dụng tiền tố
9.0.000001 === 1e-6;
Để 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
60: tách lấy phần số nguyên.let oneBillion = 1_000_000_000;
- Hàm
61: tách lấy phần số thực.let oneBillion = 1_000_000_000;
Đố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ư: