Phương pháp nào chuyển đổi đầu vào thành giá trị số trong JavaScript?

Question

Javascript cung cấp nhiều phương thức tích hợp để chuyển đổi giá trị chuỗi thành số. Khái niệm đằng sau việc chuyển đổi chuỗi thành số là chuyển đổi kiểu trong Javascript. Các phương thức khác nhau do Javascript cung cấp chỉ có thể được sử dụng để chuyển đổi chuỗi thành số nếu các ký tự chuỗi có thể chuyển đổi thành số, nếu không, giá trị NaN sẽ được hiển thị

Nội dung chính Show

Phạm vi của Điều
Giới thiệu
Làm cách nào để chuyển đổi chuỗi thành số trong JavaScript?
Các cách tiếp cận đối với chuỗi thành số Javascript
Sử dụng hàm parseInt()
Cái nào chuyển đổi thành giá trị số trong JavaScript *?
Lệnh nào trong JavaScript được sử dụng để chuyển đổi giá trị chuỗi thành giá trị số?
Phương thức nào được sử dụng để chuyển đổi một số trong chuỗi thành số nguyên trong JavaScript?
Làm cách nào để chuyển đổi từ chuỗi thành số trong JavaScript?

Phạm vi của Điều

Trong bài này chúng ta sẽ tìm hiểu

Cách chuyển đổi chuỗi thành số đầu vào javascript trong Javascript
Các chức năng khác nhau để chuyển đổi chuỗi thành số javascript
Cách dùng toán tử chuyển chuỗi thành số javascript
Các ràng buộc trong việc chuyển đổi chuỗi thành số javascript

Giới thiệu

Trong lập trình, chúng ta thường gặp các tình huống phải thực hiện một tập hợp các thao tác trên các loại dữ liệu khác nhau. Thông thường trong những trường hợp như vậy, kiểu dữ liệu của các bộ dữ liệu này cần phải giống nhau

Ví dụ
Giả sử chúng tôi đã tạo một trang web máy tính tỷ lệ phần trăm lấy số điểm đã ghi và tổng số điểm làm đầu vào rồi chia chúng, rồi nhân kết quả với 100

Bây giờ, giả sử giá trị đầu vào là một chuỗi, do đó không thể thực hiện phép chia giữa số điểm đã ghi và tổng số điểm. Vì vậy, làm thế nào để chúng ta tính toán tỷ lệ phần trăm?

Nếu chúng ta cần trích xuất các đầu vào ở dạng số. Javascript cung cấp tính năng chuyển đổi đầu vào chuỗi thành giá trị số. Do đó, các điểm được ghi và tổng số điểm có thể được chuyển đổi thành các giá trị số trước khi thực hiện các phép toán số học trên chúng.

Làm cách nào để chuyển đổi chuỗi thành số trong JavaScript?

Javascript cung cấp nhiều phương thức tích hợp cũng như cung cấp hỗ trợ toán tử để chuyển đổi chuỗi thành số trong Javascript. Ý tưởng chính đằng sau điều này là chuyển đổi kiểu trong Javascript

Trong Javascript, chuyển đổi kiểu là quá trình chuyển đổi dữ liệu từ kiểu này sang kiểu khác

Ví dụ


let num1 = '10'
let num2 = '2'

let num3 = num1 / num2

console.log(typeof num3)
đầu ra
Một số phương thức phổ biến do JavaScript cung cấp để chuyển đổi một chuỗi thành một số nguyên thủy làL parseInt(), parseFloat(), Math. sàn (), Toán. ceil(), Toán tử một ngôi / Nhân với 1

Các cách tiếp cận đối với chuỗi thành số Javascript

Trong phần này, chúng ta sẽ thảo luận về các phương pháp khác nhau để chuyển đổi một chuỗi thành một số trong Javascript. Sau đây là một số cách tiếp cận để chuyển đổi một chuỗi thành một số trong Javascript

Sử dụng hàm parseInt()

Một chuỗi trong chương trình Javascript cũng có thể được chuyển đổi thành số bằng lệnh Math. hàm round(). Toán học. Hàm round() lấy chuỗi và làm tròn giá trị có trong chuỗi thành số nguyên gần nhất. Toán học. hàm round() dùng để làm tròn số đến 2 chữ số thập phân trong JavaScript

Hàm

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1 phân tích cú pháp một đối số chuỗi và trả về một số nguyên của cơ số đã chỉ định (cơ số trong các hệ thống số toán học)

parseInt(string)
parseInt(string, radix)

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

2

Một chuỗi bắt đầu bằng một số nguyên. Khoảng trắng hàng đầu trong đối số này bị bỏ qua

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

3 Tùy chọn

Một số nguyên giữa

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

4 và

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

5 đại diện cho cơ số (cơ số trong hệ thống số toán học) của

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

2. Nó được chuyển đổi thành ; . Nếu

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

8 hoặc không được cung cấp, cơ số sẽ được suy ra dựa trên giá trị của

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

2. Hãy cẩn thận — điều này KHÔNG phải lúc nào cũng được mặc định là

parseInt("Hello", 8); // Not a number at all
parseInt("546", 2); // Digits other than 0 or 1 are invalid for binary radix

0. Phần giải thích chi tiết hơn điều gì sẽ xảy ra khi không cung cấp

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

3

Một số nguyên được phân tích cú pháp từ

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

2 đã cho hoặc

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

7 khi

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

3 dưới dạng số nguyên 32 bit nhỏ hơn

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

4 hoặc lớn hơn

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

5 hoặc

ký tự không phải khoảng trắng đầu tiên không thể được chuyển đổi thành một số

Ghi chú. JavaScript không có sự phân biệt "số dấu phẩy động" và "số nguyên" ở cấp độ ngôn ngữ.

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1 và

parseInt("Hello", 8); // Not a number at all
parseInt("546", 2); // Digits other than 0 or 1 are invalid for binary radix

8 chỉ khác nhau về hành vi phân tích cú pháp, nhưng không nhất thiết là giá trị trả về của chúng. Ví dụ:

parseInt("Hello", 8); // Not a number at all
parseInt("546", 2); // Digits other than 0 or 1 are invalid for binary radix

9 và

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

0 sẽ trả về cùng một giá trị. một

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

1 42

Hàm

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

2 , phân tích cú pháp chuỗi đó, sau đó trả về một số nguyên hoặc

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

7

Nếu không phải là

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

7, giá trị trả về sẽ là số nguyên là đối số đầu tiên được lấy làm số trong

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

3 đã chỉ định. (Ví dụ:

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

3 của

parseInt("Hello", 8); // Not a number at all
parseInt("546", 2); // Digits other than 0 or 1 are invalid for binary radix

0 chuyển đổi từ số thập phân,

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

8 chuyển đổi từ bát phân,

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

9 từ thập lục phân, v.v. )

Đối số

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

3 là. Nếu nó không được cung cấp hoặc nếu giá trị trở thành 0,

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

7 hoặc

parseInt("0e0", 16);

2 (

parseInt("0e0", 16);

3 bị ép buộc thành

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

7), JavaScript sẽ giả định như sau

Nếu dữ liệu đầu vào

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

2, với khoảng trắng ở đầu và các dấu có thể có

parseInt("0e0", 16);

6/

parseInt("0e0", 16);

7 bị xóa, bắt đầu bằng

parseInt("0e0", 16);

8 hoặc

parseInt("0e0", 16);

9 (số 0, theo sau là chữ thường hoặc chữ hoa X), thì

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

3 được coi là

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

9 và phần còn lại của chuỗi được phân tích cú pháp dưới dạng thập lục phân

Nếu đầu vào

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

2 bắt đầu bằng bất kỳ giá trị nào khác, thì cơ số là

parseInt("Hello", 8); // Not a number at all
parseInt("546", 2); // Digits other than 0 or 1 are invalid for binary radix

0 (thập phân)

Ghi chú. Các tiền tố khác như

parseInt("900719925474099267n");
// 900719925474099300

4, hợp lệ trong , được coi là chữ số bình thường trước

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1.

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1 cũng không coi các chuỗi bắt đầu bằng ký tự

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

8 là giá trị bát phân. Tiền tố duy nhất mà

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1 nhận ra là

parseInt("0e0", 16);

8 hoặc

parseInt("0e0", 16);

9 cho các giá trị thập lục phân — mọi thứ khác được phân tích cú pháp dưới dạng giá trị thập phân nếu thiếu

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

3

Nếu cơ số là

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

9, thì

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1 cho phép chuỗi được tùy ý thêm tiền tố bởi

parseInt("0e0", 16);

8 hoặc

parseInt("0e0", 16);

9 sau ký tự dấu tùy chọn (

parseInt("0e0", 16);

6/

parseInt("0e0", 16);

7)

Nếu giá trị cơ số (bắt buộc nếu cần) không nằm trong phạm vi [2, 36] (bao gồm)

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

2 trả về

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

7

Đối với các cơ số trên

parseInt("Hello", 8); // Not a number at all
parseInt("546", 2); // Digits other than 0 or 1 are invalid for binary radix

0, các chữ cái trong bảng chữ cái tiếng Anh biểu thị các chữ số lớn hơn

parseInt("123_456"); // 123

1. Ví dụ: đối với các số thập lục phân (cơ sở ____21_______9), ____62_______3 đến ____62_______4 được sử dụng. Các chữ cái không phân biệt chữ hoa chữ thường

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

2 hiểu chính xác hai biển báo.

parseInt("0e0", 16);

6 cho tích cực và

parseInt("0e0", 16);

7 cho tiêu cực. Nó được thực hiện như một bước đầu tiên trong phân tích cú pháp sau khi khoảng trắng bị xóa. Nếu không tìm thấy dấu hiệu nào, thuật toán chuyển sang bước tiếp theo;

Nếu

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

2 gặp một ký tự không phải là một số trong

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

3 đã chỉ định, nó sẽ bỏ qua nó và tất cả các ký tự tiếp theo và trả về giá trị số nguyên được phân tích cú pháp cho đến thời điểm đó. Ví dụ: mặc dù về mặt kỹ thuật,

parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36
parseInt(undefined, 36); // 86464843759093: The string "undefined" is 86464843759093 in base 36

0 mã hóa một số nguyên (và sẽ được phân tích cú pháp chính xác thành số nguyên

parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36
parseInt(undefined, 36); // 86464843759093: The string "undefined" is 86464843759093 in base 36

1 bởi

parseInt("Hello", 8); // Not a number at all
parseInt("546", 2); // Digits other than 0 or 1 are invalid for binary radix

8), nhưng

parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36
parseInt(undefined, 36); // 86464843759093: The string "undefined" is 86464843759093 in base 36

3 trả về

parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36
parseInt(undefined, 36); // 86464843759093: The string "undefined" is 86464843759093 in base 36

4, vì

parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36
parseInt(undefined, 36); // 86464843759093: The string "undefined" is 86464843759093 in base 36

5 không phải là một số hợp lệ trong cơ số 10. Vì

parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36
parseInt(undefined, 36); // 86464843759093: The string "undefined" is 86464843759093 in base 36

6 cũng không phải là số nên giá trị trả về sẽ luôn là số nguyên

Nếu ký tự đầu tiên không thể được chuyển đổi thành một số với cơ số đang được sử dụng, thì

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

2 trả về

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

7. Khoảng trắng hàng đầu được cho phép

Đối với mục đích số học, giá trị

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

7 không phải là một số trong bất kỳ cơ số nào. Bạn có thể gọi hàm

parseInt(15.99, 10); // 15
parseInt(-15.1, 10); // -15

0 để xác định xem kết quả của

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

2 có phải là

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

7 hay không. Nếu

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

7 được chuyển sang phép toán số học, kết quả phép toán cũng sẽ là

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

7

Bởi vì các số lớn sử dụng ký tự

parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36
parseInt(undefined, 36); // 86464843759093: The string "undefined" is 86464843759093 in base 36

5 trong biểu diễn chuỗi của chúng (e. g.

parseInt(15.99, 10); // 15
parseInt(-15.1, 10); // -15

6 cho 6. 022 × 1023), sử dụng

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

2 để cắt bớt các số sẽ tạo ra kết quả không mong muốn khi sử dụng trên các số rất lớn hoặc rất nhỏ.

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

2 không nên được sử dụng để thay thế cho

parseInt(15.99, 10); // 15
parseInt(-15.1, 10); // -15

9

Để chuyển đổi một số thành chuỗi ký tự của nó trong một cơ số cụ thể, hãy sử dụng

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

00

Bởi vì

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1 trả về một số, nó có thể bị mất độ chính xác nếu số nguyên được biểu thị bằng chuỗi nằm ngoài phạm vi an toàn. Hàm

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

02 hỗ trợ phân tích cú pháp các số nguyên có độ dài tùy ý một cách chính xác, bằng cách trả về một giá trị

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

03

Tất cả các ví dụ sau đều trả về

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

04

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

Tất cả các ví dụ sau đều trả về

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

7

parseInt("Hello", 8); // Not a number at all
parseInt("546", 2); // Digits other than 0 or 1 are invalid for binary radix

Tất cả các ví dụ sau đều trả về

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

06

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

Ví dụ sau trả về

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

07

parseInt("0e0", 16);

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1 không xử lý các giá trị

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

03. Nó dừng ở ký tự

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

10 và coi chuỗi trước đó là một số nguyên bình thường, có thể mất độ chính xác

parseInt("900719925474099267n");
// 900719925474099300

Thay vào đó, bạn nên chuyển chuỗi tới hàm

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

02, không có ký tự

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

10 ở cuối

BigInt("900719925474099267");
// 900719925474099267n

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

2 không hoạt động với

parseInt("123_456"); // 123

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1 có thể có kết quả thú vị khi làm việc trên các chuỗi không kết hợp với cơ số cao;

parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36
parseInt(undefined, 36); // 86464843759093: The string "undefined" is 86464843759093 in base 36

Nói chung, không nên sử dụng

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1 trên các chuỗi không phải chuỗi, đặc biệt là sử dụng nó thay thế cho

parseInt(15.99, 10); // 15
parseInt(-15.1, 10); // -15

9. Nó có thể hoạt động trên số lượng nhỏ

parseInt(15.99, 10); // 15
parseInt(-15.1, 10); // -15

Tuy nhiên, nó chỉ hoạt động vì biểu diễn chuỗi của các số này sử dụng ký hiệu phân số cơ bản (

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

18,

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

19), trong đó

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1 dừng ở dấu thập phân. Các số lớn hơn hoặc bằng 1e+21 hoặc nhỏ hơn hoặc bằng 1e-7 sử dụng ký hiệu hàm mũ (

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

21,

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

22) trong biểu diễn chuỗi của chúng và

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1 sẽ dừng ở ký tự

parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36
parseInt(undefined, 36); // 86464843759093: The string "undefined" is 86464843759093 in base 36

5 hoặc dấu thập phân, luôn xuất hiện sau chữ số đầu tiên. Điều này có nghĩa là đối với số lớn và số nhỏ,

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // but `parseInt('015', 8)` will return 13
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

1 sẽ trả về số nguyên có một chữ số

Cái nào chuyển đổi thành giá trị số trong JavaScript *?

Phương thức toàn cục Number() chuyển đổi một biến (hoặc một giá trị) thành một số. Một chuỗi số (như "3. 14") chuyển đổi thành một số (như 3. 14). Một chuỗi rỗng (như "") chuyển đổi thành 0. Một chuỗi không phải là số (như "John") chuyển đổi thành NaN (Không phải là số).

Lệnh nào trong JavaScript được sử dụng để chuyển đổi giá trị chuỗi thành giá trị số?

Trong JavaScript, hàm parseInt() (hoặc một phương thức) được sử dụng để chuyển đổi tham số hoặc giá trị chuỗi được truyền vào thành một giá trị số nguyên. Hàm này trả về một số nguyên của cơ số được chỉ định trong đối số thứ hai của hàm parseInt()

Phương thức nào được sử dụng để chuyển đổi một số trong chuỗi thành số nguyên trong JavaScript?

Số. parseInt() phân tích cú pháp một chuỗi và trả về một số nguyên.

Làm cách nào để chuyển đổi từ chuỗi thành số trong JavaScript?

Một chuỗi trong chương trình Javascript có thể được chuyển đổi thành một số bằng cách sử dụng hàm parseFloat(). Hàm parseFloat trong Javascript lấy một chuỗi và chuyển đổi nó thành giá trị thập phân

programming javascript