Làm cách nào để kiểm tra giá trị là số nguyên trong JavaScript?

Tạo số nguyên ngẫu nhiên trong lập trình là một nhiệm vụ tương đối phổ biến. Khi bạn đã biết cách thực hiện thì sẽ rất nhanh chóng và dễ dàng… chỉ cần một dòng mã. Trong hướng dẫn nhanh này, chúng tôi sẽ chỉ cho bạn cách. Chúng tôi sẽ xây dựng mã để đảm bảo bạn hiểu ý nghĩa của từng phần

Để trợ giúp về ngữ cảnh, giả sử chúng ta muốn tạo một số nguyên ngẫu nhiên lớn hơn hoặc bằng 1 và nhỏ hơn hoặc bằng 20. Chúng tôi muốn lưu trữ số dưới dạng một biến được gọi là số

Bước 1. tạo một số ngẫu nhiên

JavaScript có một phương pháp đơn giản để tạo một số ngẫu nhiên. "Tuyệt vời. Điều này sẽ được dễ dàng sau đó. " bạn có thể nghĩ. Mặc dù bạn hơi đúng (rốt cuộc đó chỉ là một dòng duy nhất mà chúng tôi đang xây dựng), nhưng nó cũng không đơn giản như vậy. Số ngẫu nhiên được trả về sẽ lớn hơn hoặc bằng 0 và nhỏ hơn 1. Không tuyệt vời khi chúng tôi đang cố gắng tạo một số nguyên từ 1 đến 20. Đó là nơi chúng ta phải bắt đầu mặc dù

const number = Math.random();

“Toán học” là một Đối tượng do JavaScript cung cấp cho chúng ta. Nó có một số Phương thức tích hợp sẵn mà chúng ta có thể sử dụng. Một trong những phương pháp là ngẫu nhiên(). Vì một phương thức về cơ bản là một loại hàm, theo sau nó là dấu ngoặc đơn

Những gì dòng trên đang nói là,

“Tạo cho tôi một biến có tên là số và biến giá trị của nó thành một số ngẫu nhiên trong khoảng từ 0 (bao gồm) đến 1 (không bao gồm). ”

Bước 2. nhân với 20

Điều đầu tiên chúng ta cần làm là tăng kích thước của số ngẫu nhiên. Để làm như vậy, chúng tôi nhân nó với số cao nhất mà chúng tôi muốn đạt được. Trong ví dụ của chúng tôi, chúng tôi muốn số lượng tối đa của chúng tôi là 20 vì vậy đó là những gì chúng tôi sẽ nhân với. Điều đó có nghĩa là lần lặp tiếp theo của dòng mã của chúng tôi là

const number = Math.random()*20;

Những gì dòng trên đang nói là,

“Hãy tạo cho tôi một biến có tên là số. Tính toán giá trị của nó cho tôi bằng cách lấy một số ngẫu nhiên trong khoảng từ 0 (bao gồm) đến 1 (không bao gồm) và nhân số đó với 20. ”

Khi chúng tôi làm điều đó, chúng tôi đang tạo một số ngẫu nhiên trong khoảng từ 0 (bao gồm) đến 20 (độc quyền). Số ngẫu nhiên đó có thể sẽ có một số lượng lớn các chữ số thập phân sau nó. Trong khi chúng ta tiến gần hơn đến mục tiêu cuối cùng của mình, chúng ta vẫn còn một chút việc phải làm

Bước 3. loại bỏ các chữ số thập phân

Số (số) ngẫu nhiên của chúng tôi hiện có thể được xác định như sau

0 <= số < 20 với bất kỳ số chữ số thập phân nào

Tuy nhiên điều đó là chưa đủ vì mục tiêu cuối cùng của chúng tôi là

1 <= số <= 20 không có chữ số thập phân

Xóa các chữ số thập phân không quá phức tạp vì một lần nữa, JavaScript đã hỗ trợ chúng tôi bằng các công cụ tích hợp của nó

const number = Math.trunc(Math.random()*20);

Cũng như các phương trình trong toán học, JavaScript sẽ tính giá trị của số bằng cách thực hiện phép tính trong ngoặc trước rồi mới thực hiện phần tiếp theo

Vậy Toán. random()*20 sẽ được tính trước. Toán học. trunc() sau đó sẽ được thực hiện trên số kết quả. Như với Bước 1, Math là đối tượng và trong trường hợp này, trunc() là phương thức.  

Những gì dòng trên đang nói là,

“Hãy tạo cho tôi một biến có tên là số. Tính toán giá trị của nó cho tôi bằng cách tạo một số ngẫu nhiên trong khoảng từ 0 (bao gồm) đến 20 (không bao gồm) rồi cắt ngắn nó để xóa các dấu thập phân. ”

Dòng này sẽ tạo ra một số nguyên (một số nguyên) trong khoảng từ 0 (đã bao gồm) đến 19 (đã bao gồm). gần đó

Bước 4. tăng phạm vi lên 1

Đây có lẽ là bước dễ nhất trong quá trình xây dựng dòng mã của chúng tôi. Thậm chí có thể một số mà một số bạn có thể đã có thể tự mình tìm ra. Đừng lo lắng nếu bạn chưa từng… đã có rất nhiều điều cần tiếp thu và có thể là những điều mới để bạn xem và học hỏi. Thực tế là bạn đã vượt qua giai đoạn này của hướng dẫn có nghĩa là bạn đang làm tất cả những điều phù hợp để trở thành Nhà phát triển JavaScript tuyệt vời

Bước trước đã cho chúng tôi một số nguyên từ 0 đến 19. Chúng tôi cần đó là 1 và 20, vì vậy chúng tôi chỉ cần thêm 1 như bên dưới

const number = Math.trunc(Math.random()*20) + 1;

Những gì dòng trên đang nói là,

“Hãy tạo cho tôi một biến có tên là số. Tính toán giá trị của nó cho tôi bằng cách tạo một số nguyên ngẫu nhiên trong khoảng từ 0 (đã bao gồm) đến 19 (đã bao gồm) rồi thêm 1 vào số ngẫu nhiên đó. ”

Số ngẫu nhiên thấp nhất được tạo trước khi thêm 1 sẽ là 0, có nghĩa là số thấp nhất của chúng tôi sẽ là 1. Số ngẫu nhiên cao nhất trước khi thêm 1 là 19, có nghĩa là số cao nhất của chúng tôi sẽ là 20. Chúng tôi sẽ không có bất kỳ chữ số thập phân nào vì vậy chúng tôi đã hoàn tất

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

________số 8_______

Ở đâ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;

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

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;

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;

let mсs = 0.000001;

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

let mсs = 0.000001;

// -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

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

let mcs = 1e-6; // five zeroes to the left from 1

let mcs = 1e-6; // five zeroes to the left from 1

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

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

Phương thức

let mcs = 1e-6; // five zeroes to the left from 1

let mcs = 1e-6; // five zeroes to the left from 1

let mcs = 1e-6; // five zeroes to the left from 1

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

let mcs = 1e-6; // five zeroes to the left from 1

let mcs = 1e-6; // five zeroes to the left from 1

// -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

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à

  // -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

  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

• base=2 chủ yếu để gỡ lỗi các hoạt động theo bit, các chữ số có thể 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 hoặc

  let mсs = 0.000001;

  5

• base=36 là giá trị lớn nhất, các chữ số có thể 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

  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 buồn cười nhưng hữu ích cho

  let mcs = 1e-6; // five zeroes to the left from 1

  9 là khi chúng ta cần biến một mã định danh 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ố _______20_______9

  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

// -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

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

Cũng có thể viết

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

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

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

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

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

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

let num = 255;

alert( num.toString(16) );  // ff
alert( num.toString(2) );   // 11111111

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

Đâ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)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

let num = 255;

alert( num.toString(16) );  // ff
alert( num.toString(2) );   // 11111111

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

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

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

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

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

let billion = 1_000_000_000;

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

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

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 đến giá trị gần nhất, tương tự 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

   4

   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 các 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

// -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

alert( 0xff ); // 255
alert( 0xFF ); // 255 (the same, case doesn't matter)

let mcs = 1e-6; // five zeroes to the left from 1

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;

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

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

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

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

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

Đ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

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

  let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes
  
  alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

  3

  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ó

  let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes
  
  alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

  4

• 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

  let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes
  
  alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

  5

Đôi khi,

let billion = 1_000_000_000;

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

Xin 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

let billion = 1_000_000_000;

let billion = 1_000_000_000;

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

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

  let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes
  
  alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

  7

• 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

  let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes
  
  alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

  8

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ị

   // -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 khác nhau.

   let billion = 1_000_000_000;

   96, về mặt kỹ thuật thì đú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 đều là số 0

Trong tất cả các trường hợp khác,

let billion = 1_000_000_000;

let billion = 1_000_000_000;

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

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

let billion = 1_000_000_000;

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

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ư

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

Đó là những gì mà

let mcs = 1e-6; // five zeroes to the left from 1

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

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

let mcs = 1e-6; // five zeroes to the left from 1

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

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

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

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

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

let mcs = 1e-6; // five zeroes to the left from 1

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ụ

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

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

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

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

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

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

let billion = 1e9;  // 1 billion, literally: 1 and 9 zeroes

alert( 7.3e9 );  // 7.3 billions (same as 7300000000 or 7_300_000_000)

Làm cách nào để kiểm tra toàn bộ số trong js?

Làm cách nào để kiểm tra xem thứ gì đó có phải là số nguyên JavaScript không?