Số chữ số JavaScript

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

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Vì 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

let 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

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Tuy 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;

let mсs = 0.000001;

Trong 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;

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Nói cách khác,

let mсs = 0.000001;

let mсs = 0.000001;

1e3 === 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;

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Nếu chúng ta đếm số 0 trong

let mсs = 0.000001;

let mсs = 0.000001;

Nói cách khác, một số âm sau

let mсs = 0.000001;

let billion = 1000000000;

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

Ví dụ

let billion = 1000000000;

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 tiền tố

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

let billion = 1000000000;

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

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Phương thức

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Ví dụ

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

let billion = 1000000000;

Cá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à

  let billion = 1000000000;

  01 hoặc

  let billion = 1000000000;

  02

• cơ sở = 2 chủ yếu để gỡ lỗi các hoạt động theo bit, các chữ số có thể là

  let billion = 1000000000;

  03 hoặc

  let mсs = 0.000001;

  5

• base=36 là giá trị lớn nhất, các chữ số có thể là

  let billion = 1000000000;

  01 hoặc

  let 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 cho

  1e3 === 1 * 1000; // e3 means *1000
  1.23e6 === 1.23 * 1000000; // e6 means *1000000

  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

  69

  let billion = 1_000_000_000;

  0

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;

let billion = 1000000000;

let billion = 1000000000;

Nếu chúng ta đặt một dấu chấm.

let billion = 1000000000;

Cũng có thể viết

let billion = 1000000000;

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;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Đây là bảng để tóm tắt sự khác biệt giữa chúng

let billion = 1000000000;

let billion = 1000000000;

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1_000_000_000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

let billion = 1000000000;

Cá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;

Chẳng hạn, chúng tôi có

let billion = 1_000_000_000;

let billion = 1_000_000_000;

Có hai cách để làm như vậy

1. 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

   let billion = 1_000_000_000;

   23, gọi hàm làm tròn rồi chia lại

   let billion = 1_000_000_000;

   1

2. Phương thức toFixed(n) làm tròn số thành

   let billion = 1_000_000_000;

   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;

   2

   Điều này làm tròn lên hoặc xuống giá trị gần nhất, tương tự như

   let billion = 1000000000;

   54

   let billion = 1_000_000_000;

   3

   Xin lưu ý rằng kết quả của

   let billion = 1_000_000_000;

   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ối

   let billion = 1_000_000_000;

   4

   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

   let billion = 1_000_000_000;

   27, e. g viết

   let billion = 1_000_000_000;

   28

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;

let billion = 1_000_000_000;

Đ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;

Đúng vậy, nếu chúng ta kiểm tra xem tổng của

let billion = 1_000_000_000;

let billion = 1_000_000_000;

let billion = 1_000_000_000;

let billion = 1_000_000_000;

Lạ lùng. Vậy thì nó là gì nếu không phải là

let billion = 1_000_000_000;

let billion = 1_000_000_000;

ô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;

let billion = 1_000_000_000;

let billion = 1_000_000_000;

Như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;

let billion = 1_000_000_000;

let billion = 1_000_000_000;

let billion = 1_000_000_000;

let billion = 1_000_000_000;

Vì vậy, phép chia cho lũy thừa

let billion = 1000000000;

let billion = 1000000000;

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

let billion = 1_000_000_000;

Khô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;

Và 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;

let billion = 1_000_000_000;

Khô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;

Xin lưu ý rằng

let billion = 1_000_000_000;

let billion = 1_000_000_000;

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Chú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

Vì 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

Đ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ố 0.

let billion = 1000000000;

let billion = 1_000_000_000;

Đó 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?

• let billion = 1_000_000_000;

  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ào

• let billion = 1_000_000_000;

  56 đại diện cho một lỗi

Chúng thuộc loại

let billion = 1_000_000_000;

• let billion = 1_000_000_000;

  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ông

  1e3 === 1 * 1000; // e3 means *1000
  1.23e6 === 1.23 * 1000000; // e6 means *1000000

  03

  Nhưng chúng ta có cần chức năng này không? . Giá trị

  let billion = 1_000_000_000;

  56 là duy nhất ở chỗ nó không bằng bất cứ thứ gì, kể cả chính nó

  1e3 === 1 * 1000; // e3 means *1000
  1.23e6 === 1.23 * 1000000; // e6 means *1000000

  04

• let billion = 1_000_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;

  64

  1e3 === 1 * 1000; // e3 means *1000
  1.23e6 === 1.23 * 1000000; // e6 means *1000000

  05

Đôi khi,

let billion = 1_000_000_000;

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Xin lưu ý rằng một chuỗi trống hoặc chỉ có khoảng trắng được coi là

let billion = 1000000000;

let billion = 1_000_000_000;

let billion = 1_000_000_000;

let 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;

let billion = 1_000_000_000;

let billion = 1_000_000_000;

• let billion = 1_000_000_000;

  73 trả về

  let billion = 1_000_000_000;

  63 nếu đối số thuộc loại

  let 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;

  33

  1e3 === 1 * 1000; // e3 means *1000
  1.23e6 === 1.23 * 1000000; // e6 means *1000000

  07

• let billion = 1_000_000_000;

  78 trả về

  let billion = 1_000_000_000;

  63 nếu đối số thuộc loại

  let 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;

  33

  1e3 === 1 * 1000; // e3 means *1000
  1.23e6 === 1.23 * 1000000; // e6 means *1000000

  08

Theo một cách nào đó,

let billion = 1_000_000_000;

let billion = 1_000_000_000;

let billion = 1_000_000_000;

let billion = 1_000_000_000;

let billion = 1_000_000_000;

let billion = 1_000_000_000;

So sánh với

let 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;

let billion = 1_000_000_000;

1. Nó hoạt động với

   let billion = 1_000_000_000;

   56.

   let billion = 1_000_000_000;

   93, đó là một điều tốt
2. Các giá trị

   let billion = 1000000000;

   03 và

   let billion = 1_000_000_000;

   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ố 0

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;

let billion = 1_000_000_000;

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

let billion = 1_000_000_000;

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Ngoạ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

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Đó là những gì

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Họ “đọ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

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Có những tình huống khi

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

let billion = 1_000_000_000;

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Đối số thứ hai của

1e3 === 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

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

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

Trả 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

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Trả 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

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Trả về

let billion = 1_000_000_000;

1e3 === 1 * 1000; // e3 means *1000
1.23e6 === 1.23 * 1000000; // e6 means *1000000

Có 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

Làm cách nào để đếm số chữ số trong JavaScript?

JavaScript có thể xử lý bao nhiêu chữ số?

1e6 trong JavaScript là gì?

Làm cách nào để lấy tổng các chữ số trong JavaScript?