Các số thông thường trong JavaScript được lưu trữ ở định dạng 64 bit IEEE-754, còn được gọi là "số dấu phẩy động chính xác kép". Đây là những con số mà chúng tôi sử dụng hầu hết thời gian và chúng tôi sẽ nói về chúng trong chương này
Số BigInt đại diện cho số nguyên có độ dài tùy ý. Đôi khi chúng cần thiết vì một số nguyên thông thường không thể an toàn vượt quá
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
6 hoặc nhỏ hơn 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
7, như chúng tôi đã đề cập trước đó trong chương Kiểu dữ liệu. Vì bigint được sử dụng trong một số lĩnh vực đặc biệt, chúng tôi dành cho chúng một chương đặc biệt BigIntVì vậy, ở đây chúng ta sẽ nói về các số thông thường. Hãy mở rộng kiến thức của chúng ta về chúng
Nhiều cách khác để viết một số
Hãy tưởng tượng chúng ta cần viết 1 tỷ. Cách rõ ràng là
let billion = 1000000000;
Chúng ta cũng có thể sử dụng dấu gạch dưới
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
8 làm dấu phân cáchlet billion = 1_000_000_000;
Ở đây, dấu gạch dưới
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
8 đóng vai trò “đường cú pháp”, nó làm cho số dễ đọc hơn. Công cụ JavaScript chỉ cần bỏ qua 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
8 giữa các chữ số, do đó, nó chính xác bằng một tỷ như trênTuy nhiên, trong cuộc sống thực, chúng tôi cố gắng tránh viết các chuỗi số 0 dài. Chúng tôi quá lười biếng cho việc đó. Chúng tôi sẽ cố gắng viết một cái gì đó như
let mсs = 0.000001;
1 cho một tỷ hoặc let mсs = 0.000001;
2 cho 7 tỷ 300 triệu. Điều này cũng đúng với hầu hết các số lớnTrong JavaScript, chúng ta có thể rút ngắn một số bằng cách thêm chữ cái
let mсs = 0.000001;
3 vào nó và chỉ định số lượng số 01e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
0Nói cách khác,
let mсs = 0.000001;
4 nhân số với let mсs = 0.000001;
5 với số 0 đã cho1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
Bây giờ chúng ta hãy viết một cái gì đó rất nhỏ. Nói, 1 micro giây [một phần triệu giây]
let mсs = 0.000001;
Giống như trước đây, sử dụng
let mсs = 0.000001;
3 có thể giúp. Nếu chúng tôi muốn tránh viết các số 0 một cách rõ ràng, chúng tôi có thể viết giống như1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
6Nếu chúng ta đếm số 0 trong
let mсs = 0.000001;
7, thì có 6 số. Vì vậy, tự nhiên nó là let mсs = 0.000001;
8Nói cách khác, một số âm sau
let mсs = 0.000001;
3 có nghĩa là một phép chia cho 1 với số lượng các số 0 đã cholet billion = 1000000000;
0Số hex, nhị phân và bát phân
Số thập lục phân được sử dụng rộng rãi trong JavaScript để thể hiện màu sắc, mã hóa ký tự và cho nhiều thứ khác. Vì vậy, một cách tự nhiên, tồn tại một cách ngắn hơn để viết chúng.
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
60 và sau đó là sốVí dụ
let billion = 1000000000;
2Các hệ thống số nhị phân và bát phân hiếm khi được sử dụng, nhưng cũng được hỗ trợ bằng cách sử dụng tiền tố
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
61 và 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
62let billion = 1000000000;
5Chỉ có 3 hệ thống số có hỗ trợ như vậy. Đối với các hệ thống số khác, chúng ta nên sử dụng hàm
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
63 [mà chúng ta sẽ thấy ở phần sau của chương này]toString[cơ sở]
Phương thức
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
64 trả về một chuỗi đại diện của 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
65 trong hệ thống số với 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
66 đã choVí dụ
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
01e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
66 có thể thay đổi từ 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
68 đến 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
69. Theo mặc định, đó là let billion = 1000000000;
00Các trường hợp sử dụng phổ biến cho việc này là
base=16 được sử dụng cho màu hex, mã hóa ký tự, v.v., các chữ số có thể là
01 hoặclet billion = 1000000000;
02let billion = 1000000000;
cơ sở = 2 chủ yếu để gỡ lỗi các hoạt động theo bit, các chữ số có thể là
03 hoặclet billion = 1000000000;
5let mсs = 0.000001;
base=36 là giá trị lớn nhất, các chữ số có thể là
01 hoặclet billion = 1000000000;
06. Toàn bộ bảng chữ cái Latinh được sử dụng để đại diện cho một số. Một trường hợp buồn cười nhưng hữu ích cholet billion = 1000000000;
69 là khi chúng ta cần biến một số nhận dạng dài thành một thứ gì đó ngắn hơn, ví dụ: để tạo một url ngắn. Có thể đơn giản biểu diễn nó trong hệ thống số với cơ sở1e3 === 1 * 1000; // e3 means *1000 1.23e6 === 1.23 * 1000000; // e6 means *1000000
691e3 === 1 * 1000; // e3 means *1000 1.23e6 === 1.23 * 1000000; // e6 means *1000000
0let billion = 1_000_000_000;
Hai dấu chấm để gọi một phương thức
Xin lưu ý rằng hai dấu chấm trong
let billion = 1000000000;
09 không phải là lỗi đánh máy. Nếu chúng ta muốn gọi một phương thức trực tiếp trên một số, chẳng hạn như let billion = 1000000000;
20 trong ví dụ trên, thì chúng ta cần đặt hai dấu chấm let billion = 1000000000;
21 sau nóNếu chúng ta đặt một dấu chấm.
let billion = 1000000000;
22, thì sẽ có lỗi, vì cú pháp JavaScript ngụ ý phần thập phân sau dấu chấm đầu tiên. Và nếu chúng ta đặt thêm một dấu chấm, thì JavaScript sẽ biết rằng phần thập phân trống và bây giờ sẽ chuyển sang phương thứcCũng có thể viết
let billion = 1000000000;
23làm tròn
Một trong những phép toán được sử dụng nhiều nhất khi làm việc với số là làm tròn
Có một số chức năng tích hợp để làm tròn
let billion = 1000000000;
24Làm tròn xuống. let billion = 1000000000;
25 trở thành let billion = 1000000000;
26 và let billion = 1000000000;
27 trở thành let billion = 1000000000;
28. let billion = 1000000000;
29Làm tròn. let billion = 1000000000;
25 trở thành let billion = 1000000000;
51 và let billion = 1000000000;
27 trở thành let billion = 1000000000;
53. let billion = 1000000000;
54Làm tròn đến số nguyên gần nhất. let billion = 1000000000;
25 trở thành let billion = 1000000000;
26, let billion = 1000000000;
57 trở thành let billion = 1000000000;
51, trường hợp giữa. let billion = 1000000000;
59 cũng làm tròn lên tới let billion = 1000000000;
51. 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
01 [không được Internet Explorer hỗ trợ] Xóa mọi thứ sau dấu thập phân mà không làm tròn. let billion = 1000000000;
25 trở thành let billion = 1000000000;
26, let billion = 1000000000;
27 trở thành let billion = 1000000000;
53Đây là bảng để tóm tắt sự khác biệt giữa chúng
____224let billion = 1000000000;
29let billion = 1000000000;
541e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
01let billion = 1000000000;
25let billion = 1000000000;
26let billion = 1000000000;
51let billion = 1000000000;
26let billion = 1000000000;
26let billion = 1000000000;
57let billion = 1000000000;
26let billion = 1000000000;
51let billion = 1000000000;
51let billion = 1000000000;
26let billion = 1000000000;
27let billion = 1000000000;
28let billion = 1000000000;
53let billion = 1000000000;
53let billion = 1000000000;
53let billion = 1_000_000_000;
15let billion = 1000000000;
28let billion = 1000000000;
53let billion = 1000000000;
28let billion = 1000000000;
53Các chức năng này bao gồm tất cả các cách có thể để xử lý phần thập phân của một số. Nhưng nếu chúng ta muốn làm tròn số thành
let billion = 1_000_000_000;
20 chữ số sau dấu thập phân thì sao?Chẳng hạn, chúng tôi có
let billion = 1_000_000_000;
21 và muốn làm tròn nó thành 2 chữ số, chỉ nhận được let billion = 1_000_000_000;
22Có hai cách để làm như vậy
Nhân và chia
Ví dụ, để làm tròn số đến chữ số thứ 2 sau dấu thập phân, chúng ta có thể nhân số đó với
23, gọi hàm làm tròn rồi chia lạilet billion = 1_000_000_000;
1let billion = 1_000_000_000;
Phương thức toFixed[n] làm tròn số thành
24 chữ số sau dấu chấm và trả về một chuỗi biểu diễn kết quảlet billion = 1_000_000_000;
2let billion = 1_000_000_000;
Điều này làm tròn lên hoặc xuống giá trị gần nhất, tương tự như
54let billion = 1000000000;
3let billion = 1_000_000_000;
Xin lưu ý rằng kết quả của
26 là một chuỗi. Nếu phần thập phân ngắn hơn yêu cầu, các số 0 sẽ được thêm vào cuốilet billion = 1_000_000_000;
4let billion = 1_000_000_000;
Chúng tôi có thể chuyển đổi nó thành một số bằng cách sử dụng phép cộng đơn nguyên hoặc cuộc gọi
27, e. g viếtlet billion = 1_000_000_000;
28let billion = 1_000_000_000;
tính toán không chính xác
Bên trong, một số được thể hiện ở định dạng 64 bit IEEE-754, do đó, có chính xác 64 bit để lưu trữ một số. 52 trong số chúng được sử dụng để lưu trữ các chữ số, 11 trong số chúng lưu trữ vị trí của dấu thập phân và 1 bit dành cho dấu
Nếu một số thực sự lớn, nó có thể tràn bộ nhớ 64-bit và trở thành một giá trị số đặc biệt
let billion = 1_000_000_000;
29let billion = 1_000_000_000;
5Điều có thể ít rõ ràng hơn một chút, nhưng xảy ra khá thường xuyên, đó là sự mất chính xác
Hãy xem xét điều này [giả. ] kiểm tra bình đẳng
let billion = 1_000_000_000;
6Đúng vậy, nếu chúng ta kiểm tra xem tổng của
let billion = 1_000_000_000;
30 và let billion = 1_000_000_000;
31 có phải là let billion = 1_000_000_000;
32 hay không, chúng ta sẽ nhận được let billion = 1_000_000_000;
33Lạ lùng. Vậy thì nó là gì nếu không phải là
let billion = 1_000_000_000;
32?let billion = 1_000_000_000;
7ôi. Hãy tưởng tượng bạn đang tạo một trang web mua sắm điện tử và khách truy cập đặt hàng hóa
let billion = 1_000_000_000;
35 và let billion = 1_000_000_000;
36 vào giỏ hàng của họ. Tổng đơn hàng sẽ là let billion = 1_000_000_000;
37. Điều đó sẽ làm bất ngờ bất cứ aiNhưng tại sao điều này lại xảy ra?
Một số được lưu trữ trong bộ nhớ ở dạng nhị phân, một chuỗi các bit – số đơn vị và số không. Nhưng những phân số như
let billion = 1_000_000_000;
30, let billion = 1_000_000_000;
31 trông có vẻ đơn giản trong hệ thống số thập phân thực ra là những phân số vô tận ở dạng nhị phân của chúnglet billion = 1_000_000_000;
30 là gì? . Trong hệ thống số thập phân, những số như vậy có thể dễ dàng biểu diễn. So sánh nó với một phần ba. let billion = 1_000_000_000;
42. Nó trở thành phân số vô tận let billion = 1_000_000_000;
43Vì vậy, phép chia cho lũy thừa
let billion = 1000000000;
00 được đảm bảo hoạt động tốt trong hệ thập phân, nhưng phép chia cho let billion = 1000000000;
26 thì không. Vì lý do tương tự, trong hệ thống số nhị phân, phép chia cho lũy thừa của 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
68 được đảm bảo hoạt động, nhưng let billion = 1_000_000_000;
41 trở thành một phân số nhị phân vô tậnKhông có cách nào để lưu trữ chính xác 0. 1 hoặc chính xác là 0. 2 bằng hệ thống nhị phân, giống như không có cách nào để lưu trữ một phần ba dưới dạng phân số thập phân
Định dạng số IEEE-754 giải quyết vấn đề này bằng cách làm tròn đến số gần nhất có thể. Các quy tắc làm tròn này thường không cho phép chúng ta nhìn thấy "độ mất chính xác nhỏ" đó, nhưng nó tồn tại
Chúng ta có thể thấy điều này trong hành động
let billion = 1_000_000_000;
8Và khi chúng ta tính tổng hai số, "tổn thất chính xác" của chúng cộng lại
Đó là lý do tại sao
let billion = 1_000_000_000;
48 không chính xác là let billion = 1_000_000_000;
32Không chỉ JavaScript
Vấn đề tương tự tồn tại ở nhiều ngôn ngữ lập trình khác
PHP, Java, C, Perl, Ruby cho kết quả chính xác như nhau, bởi vì chúng dựa trên cùng một định dạng số
Chúng ta có thể giải quyết vấn đề không?
let billion = 1_000_000_000;
9Xin lưu ý rằng
let billion = 1_000_000_000;
26 luôn trả về một chuỗi. Nó đảm bảo rằng nó có 2 chữ số sau dấu thập phân. Điều đó thực sự tiện lợi nếu chúng ta có một trang mua sắm điện tử và cần hiển thị let billion = 1_000_000_000;
51. Đối với các trường hợp khác, chúng ta có thể sử dụng phép cộng đơn vị để biến nó thành một số1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
00Chúng ta cũng có thể tạm thời nhân các số với 100 [hoặc một số lớn hơn] để biến chúng thành số nguyên, làm phép tính rồi chia lại. Sau đó, khi chúng ta làm toán với các số nguyên, sai số giảm đi phần nào, nhưng chúng ta vẫn mắc lỗi khi chia
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
01Vì vậy, phương pháp nhân/chia giúp giảm lỗi, nhưng không loại bỏ hoàn toàn
Đôi khi chúng ta có thể cố gắng trốn tránh các phân số. Giống như nếu chúng ta đang giao dịch với một cửa hàng, thì chúng ta có thể lưu trữ giá bằng xu thay vì đô la. Nhưng nếu chúng tôi áp dụng giảm giá 30% thì sao? . Chỉ cần làm tròn chúng để cắt “đuôi” khi cần thiết
điều buồn cười
Hãy thử chạy cái này
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
02Điều này bị cùng một vấn đề. mất độ chính xác. Có 64 bit cho số, 52 trong số đó có thể được sử dụng để lưu trữ các chữ số, nhưng điều đó là không đủ. Vì vậy, các chữ số ít quan trọng nhất biến mất
JavaScript không gây ra lỗi trong các sự kiện như vậy. Nó cố gắng hết sức để khớp số vào định dạng mong muốn, nhưng thật không may, định dạng này không đủ lớn
hai số 0
Một hệ quả buồn cười khác của biểu diễn bên trong các số là sự tồn tại của hai số không.
let billion = 1000000000;
03 và let billion = 1_000_000_000;
53Đó là bởi vì một dấu hiệu được biểu thị bằng một bit duy nhất, do đó, nó có thể được đặt hoặc không được đặt cho bất kỳ số nào kể cả số không
Trong hầu hết các trường hợp, sự khác biệt là không đáng chú ý, bởi vì các toán tử phù hợp để coi chúng như nhau.
bài kiểm tra. isFinite và isNaN
Hãy nhớ hai giá trị số đặc biệt này?
29 [vàlet billion = 1_000_000_000;
55] là một giá trị số đặc biệt lớn hơn [nhỏ hơn] bất kỳ giá trị nàolet billion = 1_000_000_000;
56 đại diện cho một lỗilet billion = 1_000_000_000;
Chúng thuộc loại
let billion = 1_000_000_000;
57, nhưng không phải là số “bình thường”, vì vậy có các chức năng đặc biệt để kiểm tra chúng
58 chuyển đổi đối số của nó thành một số và sau đó kiểm tra xem nó có phải làlet billion = 1_000_000_000;
56 khônglet billion = 1_000_000_000;
031e3 === 1 * 1000; // e3 means *1000 1.23e6 === 1.23 * 1000000; // e6 means *1000000
Nhưng chúng ta có cần chức năng này không? . Giá trị
56 là duy nhất ở chỗ nó không bằng bất cứ thứ gì, kể cả chính nólet billion = 1_000_000_000;
041e3 === 1 * 1000; // e3 means *1000 1.23e6 === 1.23 * 1000000; // e6 means *1000000
62 chuyển đổi đối số của nó thành một số và trả vềlet billion = 1_000_000_000;
63 nếu đó là một số thông thường, không phải làlet billion = 1_000_000_000;
64let billion = 1_000_000_000;
051e3 === 1 * 1000; // e3 means *1000 1.23e6 === 1.23 * 1000000; // e6 means *1000000
Đôi khi,
let billion = 1_000_000_000;
65 được sử dụng để xác thực xem giá trị chuỗi có phải là số thông thường hay không1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
06Xin lưu ý rằng một chuỗi trống hoặc chỉ có khoảng trắng được coi là
let billion = 1000000000;
03 trong tất cả các hàm số bao gồm cả let billion = 1_000_000_000;
65
68 và let billion = 1_000_000_000;
69let billion = 1_000_000_000;
Con số. isNaN và số. Các phương thức isFinite là phiên bản "nghiêm ngặt" hơn của các hàm
let billion = 1_000_000_000;
70 và let billion = 1_000_000_000;
65. Họ không tự động chuyển đổi đối số của mình thành một số, nhưng thay vào đó hãy kiểm tra xem nó có thuộc loại let billion = 1_000_000_000;
57 không
73 trả vềlet billion = 1_000_000_000;
63 nếu đối số thuộc loạilet billion = 1_000_000_000;
57 và nó làlet billion = 1_000_000_000;
56. Trong mọi trường hợp khác, nó trả vềlet billion = 1_000_000_000;
33let billion = 1_000_000_000;
071e3 === 1 * 1000; // e3 means *1000 1.23e6 === 1.23 * 1000000; // e6 means *1000000
78 trả vềlet billion = 1_000_000_000;
63 nếu đối số thuộc loạilet billion = 1_000_000_000;
57 và nó không phải làlet billion = 1_000_000_000;
64. Trong mọi trường hợp khác, nó trả vềlet billion = 1_000_000_000;
33let billion = 1_000_000_000;
081e3 === 1 * 1000; // e3 means *1000 1.23e6 === 1.23 * 1000000; // e6 means *1000000
Theo một cách nào đó,
let billion = 1_000_000_000;
68 và let billion = 1_000_000_000;
69 đơn giản và dễ hiểu hơn các hàm let billion = 1_000_000_000;
70 và let billion = 1_000_000_000;
65. Tuy nhiên, trong thực tế, let billion = 1_000_000_000;
70 và let billion = 1_000_000_000;
65 hầu hết được sử dụng, vì chúng ngắn hơn để viếtSo sánh với
89let billion = 1_000_000_000;
Có một phương pháp tích hợp đặc biệt
let billion = 1_000_000_000;
89 so sánh các giá trị như let billion = 1_000_000_000;
91, nhưng đáng tin cậy hơn cho hai trường hợp cạnh- Nó hoạt động với
56.let billion = 1_000_000_000;
93, đó là một điều tốtlet billion = 1_000_000_000;
- Các giá trị
03 vàlet billion = 1000000000;
53 khác nhau.let billion = 1_000_000_000;
96, về mặt kỹ thuật, điều đó đúng, bởi vì bên trong số này có một bit dấu có thể khác ngay cả khi tất cả các bit khác đều là số 0let billion = 1_000_000_000;
Trong tất cả các trường hợp khác, ________ 497 giống như ________ 498
Chúng tôi đề cập đến
let billion = 1_000_000_000;
89 ở đây, vì nó thường được sử dụng trong đặc tả JavaScript. Khi một thuật toán nội bộ cần so sánh hai giá trị giống hệt nhau, nó sẽ sử dụng let billion = 1_000_000_000;
89 [được gọi nội bộ là SameValue]parseInt và parseFloat
Chuyển đổi số bằng cách sử dụng dấu cộng
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
001 hoặc let billion = 1_000_000_000;
27 là nghiêm ngặt. Nếu một giá trị không chính xác là một số, nó sẽ thất bại1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
09Ngoại lệ duy nhất là khoảng trắng ở đầu hoặc cuối chuỗi, vì chúng bị bỏ qua
Nhưng trong cuộc sống thực, chúng ta thường có các giá trị theo đơn vị, như
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
003 hoặc 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
004 trong CSS. Ngoài ra, ở nhiều quốc gia, ký hiệu tiền tệ đi sau số tiền, vì vậy chúng tôi có 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
005 và muốn trích xuất một giá trị số từ đóĐó là những gì
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
63 và 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
007 dành choHọ “đọc” một số từ một chuỗi cho đến khi họ không thể. Trong trường hợp có lỗi, số đã thu thập được trả về. Hàm
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
63 trả về một số nguyên, trong khi hàm 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
007 sẽ trả về một số dấu phẩy động1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
0Có những tình huống khi
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
010 sẽ trở lại let billion = 1_000_000_000;
56. Nó xảy ra khi không có chữ số nào có thể đọc được1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
1Đối số thứ hai của
0121e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
Hàm
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
013 có tham số thứ hai tùy chọn. Nó chỉ định cơ sở của hệ thống số, vì vậy, 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
63 cũng có thể phân tích các chuỗi số hex, số nhị phân, v.v.1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
2Các hàm toán học khác
JavaScript có một đối tượng Math tích hợp chứa một thư viện nhỏ các hàm và hằng số toán học
Một vài ví dụ
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
015Trả về một số ngẫu nhiên từ 0 đến 1 [không bao gồm 1]
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
31e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
016 và 1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
017Trả về giá trị lớn nhất và nhỏ nhất từ số lượng đối số tùy ý
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
41e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
018Trả về
let billion = 1_000_000_000;
24 được nâng lên lũy thừa đã cho1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
5Có nhiều hàm và hằng số hơn trong đối tượng
1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000
020, bao gồm lượng giác, mà bạn có thể tìm thấy trong tài liệu dành cho đối tượng Math