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 Các 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
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ố, vì vậy nó chính xác là 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ố 0let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
Nó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ưlet mcs = 1e-6; // five zeroes to the left from 1
Nếu chúng ta đếm các 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 đã cho// -3 divides by 1 with 3 zeroes
1e-3 === 1 / 1000; // 0.001
// -6 divides by 1 with 6 zeroes
1.23e-6 === 1.23 / 1000000; // 0.00000123
// an example with a bigger number
1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
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.
let mcs = 1e-6; // five zeroes to the left from 1
0 và sau đó là sốVí dụ
alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
Cá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 các tiền tố
let mcs = 1e-6; // five zeroes to the left from 1
1 và let mcs = 1e-6; // five zeroes to the left from 1
2let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
Chỉ 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
let mcs = 1e-6; // five zeroes to the left from 1
3 [mà chúng ta sẽ thấy ở phần sau của chương này]Phương thức
let mcs = 1e-6; // five zeroes to the left from 1
4 trả về một chuỗi biểu diễn của let mcs = 1e-6; // five zeroes to the left from 1
5 trong hệ thống số với giá trị đã cho là let mcs = 1e-6; // five zeroes to the left from 1
6Ví dụ
let num = 255;
alert[ num.toString[16] ]; // ff
alert[ num.toString[2] ]; // 11111111
let mcs = 1e-6; // five zeroes to the left from 1
6 có thể thay đổi từ let mcs = 1e-6; // five zeroes to the left from 1
8 đến let mcs = 1e-6; // five zeroes to the left from 1
9. Theo mặc định, đó là // -3 divides by 1 with 3 zeroes
1e-3 === 1 / 1000; // 0.001
// -6 divides by 1 with 6 zeroes
1.23e-6 === 1.23 / 1000000; // 0.00000123
// an example with a bigger number
1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
0Cá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à
1 hoặc// -3 divides by 1 with 3 zeroes 1e-3 === 1 / 1000; // 0.001 // -6 divides by 1 with 6 zeroes 1.23e-6 === 1.23 / 1000000; // 0.00000123 // an example with a bigger number 1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
2// -3 divides by 1 with 3 zeroes 1e-3 === 1 / 1000; // 0.001 // -6 divides by 1 with 6 zeroes 1.23e-6 === 1.23 / 1000000; // 0.00000123 // an example with a bigger number 1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
base=2 chủ yếu để gỡ lỗi các hoạt động theo bit, các chữ số có thể là
3 hoặc// -3 divides by 1 with 3 zeroes 1e-3 === 1 / 1000; // 0.001 // -6 divides by 1 with 6 zeroes 1.23e-6 === 1.23 / 1000000; // 0.00000123 // an example with a bigger number 1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
5let mсs = 0.000001;
base=36 là giá trị lớn nhất, các chữ số có thể là
1 hoặc// -3 divides by 1 with 3 zeroes 1e-3 === 1 / 1000; // 0.001 // -6 divides by 1 with 6 zeroes 1.23e-6 === 1.23 / 1000000; // 0.00000123 // an example with a bigger number 1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
6. 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 hài hước nhưng hữu ích đối với// -3 divides by 1 with 3 zeroes 1e-3 === 1 / 1000; // 0.001 // -6 divides by 1 with 6 zeroes 1.23e-6 === 1.23 / 1000000; // 0.00000123 // an example with a bigger number 1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
9 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, chẳng hạn để 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ốlet mcs = 1e-6; // five zeroes to the left from 1
9let mcs = 1e-6; // five zeroes to the left from 1
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
// -3 divides by 1 with 3 zeroes
1e-3 === 1 / 1000; // 0.001
// -6 divides by 1 with 6 zeroes
1.23e-6 === 1.23 / 1000000; // 0.00000123
// an example with a bigger number
1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
9 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ư alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
0 trong ví dụ trên, thì chúng ta cần đặt hai dấu chấm alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
1 sau nóNếu chúng ta đặt một dấu chấm.
alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
2, 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
alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
3Mộ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
alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
4Vòng xuống. alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
5 trở thành alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
6 và alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
7 trở thành alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
8. alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
9Làm tròn. alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
5 trở thành let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
1 và alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
7 trở thành let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
3. let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
4Làm tròn đến số nguyên gần nhất. alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
5 trở thành alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
6, let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
7 trở thành let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
1, trường hợp giữa. let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
9 làm tròn lên tới let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
1 nữa. let num = 255;
alert[ num.toString[16] ]; // ff
alert[ num.toString[2] ]; // 11111111
1 [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. alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
5 trở thành alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
6, alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
7 trở thành let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
3Đây là bảng để tóm tắt sự khác biệt giữa chúng
alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
4alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
9let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
4let num = 255;
alert[ num.toString[16] ]; // ff
alert[ num.toString[2] ]; // 11111111
1alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
5alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
6let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
1alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
6alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
6let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
7alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
6let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
1let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
1alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
6alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
7alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
8let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
3let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
3let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
3let billion = 1_000_000_000;
15alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
8let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
3alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
8let a = 0b11111111; // binary form of 255
let b = 0o377; // octal form of 255
alert[ a == b ]; // true, the same number 255 at both sides
3Cá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ả
2let billion = 1_000_000_000;
Điều này làm tròn lên hoặc xuống đến giá trị gần nhất, tương tự như
4let a = 0b11111111; // binary form of 255 let b = 0o377; // octal form of 255 alert[ a == b ]; // true, the same number 255 at both sides
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;
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 một phân số vô tận let billion = 1_000_000_000;
43Vì vậy, phép chia cho lũy thừa
// -3 divides by 1 with 3 zeroes
1e-3 === 1 / 1000; // 0.001
// -6 divides by 1 with 6 zeroes
1.23e-6 === 1.23 / 1000000; // 0.00000123
// an example with a bigger number
1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
0 được đảm bảo hoạt động tốt trong hệ thập phân, nhưng phép chia cho alert[ 0xff ]; // 255
alert[ 0xFF ]; // 255 [the same, case doesn't matter]
6 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 let mcs = 1e-6; // five zeroes to the left from 1
8 được đảm bảo đú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ốlet billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
0Chú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
let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
1Vì 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
let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
2Đ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.
// -3 divides by 1 with 3 zeroes
1e-3 === 1 / 1000; // 0.001
// -6 divides by 1 with 6 zeroes
1.23e-6 === 1.23 / 1000000; // 0.00000123
// an example with a bigger number
1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
3 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.
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;
56let billion = 1_000_000_000;
3let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
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;
4let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
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;
5let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
Đô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ônglet billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
6Xin lưu ý rằng một chuỗi trống hoặc chỉ có khoảng trắng được coi là
// -3 divides by 1 with 3 zeroes
1e-3 === 1 / 1000; // 0.001
// -6 divides by 1 with 6 zeroes
1.23e-6 === 1.23 / 1000000; // 0.00000123
// an example with a bigger number
1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
3 trong tất cả các hàm số bao gồm let billion = 1_000_000_000;
65
68 và let billion = 1_000_000_000;
69let billion = 1_000_000_000;
Số. isNaN và số. Các phương thức isFinite là các 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;
7let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
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;
8let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
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ị
3 và// -3 divides by 1 with 3 zeroes 1e-3 === 1 / 1000; // 0.001 // -6 divides by 1 with 6 zeroes 1.23e-6 === 1.23 / 1000000; // 0.00000123 // an example with a bigger number 1234e-2 === 1234 / 100; // 12.34, decimal point moves 2 times
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ố có một bit dấu có thể khác ngay cả khi tất cả các bit khác là số 0let billion = 1_000_000_000;
Trong tất cả các trường hợp khác,
let billion = 1_000_000_000;
97 giống như let billion = 1_000_000_000;
98Chú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ộ]Chuyển đổi số bằng cách sử dụng dấu cộng
let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
01 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ạilet billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
9Ngoạ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ư
let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
03 hoặc let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
04 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ó let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
05 và muốn trích xuất một giá trị số từ đóĐó là những gì mà
let mcs = 1e-6; // five zeroes to the left from 1
3 và let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
07 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
let mcs = 1e-6; // five zeroes to the left from 1
3 trả về một số nguyên, trong khi hàm let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
07 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
let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
10 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
12let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
Hàm
let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
13 có tham số thứ hai tùy chọn. Nó chỉ định cơ sở của hệ thống số, vì vậy, let mcs = 1e-6; // five zeroes to the left from 1
3 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
2JavaScript 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ụ
let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
15Trả 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
3let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
16 và let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
17Trả 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
4let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
18Trả về
let billion = 1_000_000_000;
24 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
let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes
alert[ 7.3e9 ]; // 7.3 billions [same as 7300000000 or 7_300_000_000]
20, 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