Hầu hết các ngôn ngữ lập trình đều có một số loại dữ liệu số, nhưng JavaScript chỉ có một
Tất cả các số đang và được lưu trữ dưới dạng gấp đôi
Xem thêm'. Javascript - Số nguyên
Tờ khai
var myVariable = 10;
var myVariable = +10;
var myVariable = Number[10];
tối đa
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Number.MAX_SAFE_INTEGER // 2^53 - 1
Number.MIN_SAFE_INTEGER // [-[2^53 - 1]].
Number.MAX_VALUE; // 2^1024
Number.MIN_VALUE; // 0
Giá trị lớn hơn được biểu thị dưới dạng Infinity
số nguyên
var myNumber = 0.1 + 0.2
console.log["myNumber is not 0.3 but " + myNumber]
ép buộc
rõ ràng
Để chuyển đổi giá trị thành số một cách rõ ràng, bạn có thể sử dụng
Thí dụ
Thêm + trước chuỗi “3” biến nó thành một số
console.log[typeof[+"3"]]
ngầm định
Các toán tử số học -, *, / và % đều cố gắng ép buộc các đối số của chúng thành các số trước khi thực hiện phép tính của chúng
Toán tử + phức tạp hơn, bởi vì nó bị quá tải để thực hiện phép cộng số hoặc nối chuỗi, tùy thuộc vào loại đối số của nó
Cưỡng chế im lặng cũng có thể che giấu lỗi vì nó sẽ ngăn ngừa lỗi hoặc lỗi trong phép tính số học
Giá trị
Giá trị biếnSố Giá trịnull0true1false0Chuỗi không phải sốNaNEChuỗi rỗng0Chuỗi sốSố được đại diệnĐối tượng không có giá trị Thuộc tínhNaNĐối tượng có thuộc tính valueOfGiá trị trả về của hàm valueOfMảng trống0Mảng không rỗng0Mảng không rỗng với một giá trị sốSố đầu tiênMảng không trống có nhiều hơn một giá trịNaNundefinedNaNNaNNaNfunctionNaN
Khi bạn đang lập trình, bạn sẽ thường xuyên cần chuyển đổi giữa các loại dữ liệu. Ví dụ: bạn có thể cần chuyển đổi một chuỗi thành một số
Khả năng chuyển đổi loại dữ liệu này sang loại dữ liệu khác giúp bạn linh hoạt hơn khi làm việc với thông tin
JavaScript có các phương thức tích hợp khác nhau để chuyển đổi hoặc truyền chuỗi thành số
Trong bài viết này, bạn sẽ tìm hiểu một số phương thức JavaScript tích hợp có sẵn để chuyển đổi chuỗi thành số, cùng với phần giới thiệu [hoặc bồi dưỡng. ] đến kiến thức cơ bản về cách chuỗi và số hoạt động trong JavaScript
Đây là những gì chúng tôi sẽ đề cập
- Chuỗi trong JavaScript là gì?
- Một số trong JavaScript là gì?
- Làm cách nào để kiểm tra kiểu dữ liệu của một giá trị trong JavaScript?
- Cách chuyển đổi chuỗi thành số bằng hàm
4// integer let num = 47; // float let num = 47.32; // exponential - to represent large numbers let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700 // exponential - to represent small numbers let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77 // binary let num = 0b1111; // stands for 15 // octal let num = 023; // stands for 19 // hexadecimal let num = 0xFF; // stands for 255 - Cách chuyển đổi chuỗi thành số bằng hàm
5// integer let num = 47; // float let num = 47.32; // exponential - to represent large numbers let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700 // exponential - to represent small numbers let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77 // binary let num = 0b1111; // stands for 15 // octal let num = 023; // stands for 19 // hexadecimal let num = 0xFF; // stands for 255 - Cách chuyển đổi chuỗi thành số bằng hàm
6// integer let num = 47; // float let num = 47.32; // exponential - to represent large numbers let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700 // exponential - to represent small numbers let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77 // binary let num = 0b1111; // stands for 15 // octal let num = 023; // stands for 19 // hexadecimal let num = 0xFF; // stands for 255 - Cách chuyển đổi chuỗi thành số bằng hàm
7// integer let num = 47; // float let num = 47.32; // exponential - to represent large numbers let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700 // exponential - to represent small numbers let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77 // binary let num = 0b1111; // stands for 15 // octal let num = 023; // stands for 19 // hexadecimal let num = 0xFF; // stands for 255 - Cách chuyển đổi một chuỗi thành một số bằng cách nhân và chia cho ________ 68
- Cách chuyển đổi một chuỗi thành một số bằng cách sử dụng toán tử
9 Đơn nguyên// integer let num = 47; // float let num = 47.32; // exponential - to represent large numbers let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700 // exponential - to represent small numbers let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77 // binary let num = 0b1111; // stands for 15 // octal let num = 023; // stands for 19 // hexadecimal let num = 0xFF; // stands for 255
Chuỗi trong JavaScript là gì?
Chuỗi là một cách giao tiếp hiệu quả thông qua văn bản, chẳng hạn như lưu trữ và thao tác văn bản. Chúng là một trong những kiểu dữ liệu cơ bản nhất trong tất cả các ngôn ngữ lập trình
Chuỗi trong JavaScript là một kiểu dữ liệu nguyên thủy. Điều này có nghĩa là chúng được tích hợp vào ngôn ngữ theo mặc định
Một chuỗi là một chuỗi có thứ tự gồm 0 hoặc nhiều giá trị ký tự. Cụ thể, đó là một chuỗi gồm một hoặc nhiều ký tự có thể là chữ cái, số hoặc ký hiệu [chẳng hạn như dấu chấm câu]
Nói chung, bạn có thể biết liệu một giá trị dữ liệu có phải là một chuỗi hay không nếu nó được đặt trong dấu ngoặc kép, chẳng hạn như dấu ngoặc đơn hoặc dấu ngoặc kép
Cụ thể, có ba cách bạn có thể tạo một chuỗi trong JavaScript
- Bằng cách sử dụng dấu nháy đơn
- Bằng cách sử dụng dấu ngoặc kép
- Bằng cách sử dụng backticks
Đây là cách tạo một chuỗi bằng dấu nháy đơn
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Đây là cách tạo một chuỗi bằng cách sử dụng dấu ngoặc kép
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Và đây là cách tạo chuỗi bằng backticks
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Cách cuối cùng để tạo chuỗi trong JavaScript còn được gọi là mẫu chữ
Số trong JavaScript là gì?
Các số cho phép bạn biểu diễn các giá trị số và thực hiện các phép toán và phép tính
Các số trong JavaScript là một kiểu dữ liệu nguyên thủy – giống như các chuỗi
Không giống như các ngôn ngữ lập trình khác, bạn không cần chỉ định loại số bạn muốn tạo. Ví dụ: bạn không cần đề cập đến số sẽ là số nguyên hay số float
Trong JavaScript, có một số loại số khác nhau [cả dương và âm] được tích hợp trong ngôn ngữ
- số nguyên. Số nguyên là một giá trị số không bao gồm phần thập phân - hay còn gọi là số tròn chục hay số nguyên
- phao nổi. Số float là một số có phần thập phân và ít nhất một số sau dấu thập phân
- Số mũ là những số có thể là số nguyên hoặc số thực và được theo sau bởi một ____150.
50 biểu thị phép nhân một số vớilet MAX_INT = 4294967295; // Math.pow[2,32] - 1;
52 được nâng lên một lũy thừa cho trướclet MAX_INT = 4294967295; // Math.pow[2,32] - 1; - Số nhị phân [còn được gọi là cơ số 2]. Nhị phân là một hệ thống số bao gồm chỉ có hai số.
53 vàlet MAX_INT = 4294967295; // Math.pow[2,32] - 1;
8. Nó sử dụng 8 bit để biểu diễn một byte. Số bắt đầu bằng// integer let num = 47; // float let num = 47.32; // exponential - to represent large numbers let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700 // exponential - to represent small numbers let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77 // binary let num = 0b1111; // stands for 15 // octal let num = 023; // stands for 19 // hexadecimal let num = 0xFF; // stands for 255
53 theo sau làlet MAX_INT = 4294967295; // Math.pow[2,32] - 1;
56 theo sau là số 8 bitlet MAX_INT = 4294967295; // Math.pow[2,32] - 1; - Số bát phân [còn được gọi là cơ số 8]. Một số bát phân bắt đầu bằng một
53 theo sau là các chữ số bát phân nằm trong khoảng từlet MAX_INT = 4294967295; // Math.pow[2,32] - 1;
58let MAX_INT = 4294967295; // Math.pow[2,32] - 1; - Số thập lục phân [còn được gọi là cơ số 16]. Một số thập lục phân bắt đầu bằng một
53 theo sau bởi một trong hailet MAX_INT = 4294967295; // Math.pow[2,32] - 1;
50 hoặcNumber.MAX_SAFE_INTEGER // 2^53 - 1 Number.MIN_SAFE_INTEGER // [-[2^53 - 1]].
51. Sau đó, có thể có sự kết hợp của các chữ số thập lục phân từNumber.MAX_SAFE_INTEGER // 2^53 - 1 Number.MIN_SAFE_INTEGER // [-[2^53 - 1]].
52 và các chữ cái từNumber.MAX_SAFE_INTEGER // 2^53 - 1 Number.MIN_SAFE_INTEGER // [-[2^53 - 1]].
53 [hoặcNumber.MAX_SAFE_INTEGER // 2^53 - 1 Number.MIN_SAFE_INTEGER // [-[2^53 - 1]].
54]. Các chữ cáiNumber.MAX_SAFE_INTEGER // 2^53 - 1 Number.MIN_SAFE_INTEGER // [-[2^53 - 1]].
53 được liên kết với các giá trịNumber.MAX_SAFE_INTEGER // 2^53 - 1 Number.MIN_SAFE_INTEGER // [-[2^53 - 1]].
56Number.MAX_SAFE_INTEGER // 2^53 - 1 Number.MIN_SAFE_INTEGER // [-[2^53 - 1]].
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Một điều cần lưu ý là các số không được bao quanh bởi dấu ngoặc kép - điều đó sẽ tự động biến chúng thành một chuỗi
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Làm cách nào để kiểm tra loại dữ liệu của một giá trị trong JavaScript?
Để tránh mắc lỗi và kiểm tra kỹ loại dữ liệu của một giá trị trong JavaScript, hãy sử dụng toán tử
Number.MAX_SAFE_INTEGER // 2^53 - 1
Number.MIN_SAFE_INTEGER // [-[2^53 - 1]].
Trước đó tôi đã đề cập rằng các số được đặt trong dấu ngoặc kép là các chuỗi
Bạn có thể tự kiểm tra điều đó bằng cách làm như sau
Number.MAX_SAFE_INTEGER // 2^53 - 1
Number.MIN_SAFE_INTEGER // [-[2^53 - 1]].
Cách chuyển đổi một chuỗi thành một số bằng hàm // integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
4
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Cú pháp chung cho hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Number.MAX_VALUE; // 2^1024
Number.MIN_VALUE; // 0
Hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Chuỗi là giá trị cần chuyển thành số
Cơ số chỉ định hệ thống số toán học mà bạn muốn sử dụng và cơ số của số sẽ được trả về – cho dù số đó sẽ là cơ số 2 [hoặc nhị phân], cơ số 8 [hoặc bát phân], cơ số 10 [thập phân] hay cơ số
Nếu cơ số không được bao gồm, thì nó là
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
var myNumber = 0.1 + 0.2
console.log["myNumber is not 0.3 but " + myNumber]
Nếu chuỗi chứa chữ cái và số thì sao?
var myNumber = 0.1 + 0.2
console.log["myNumber is not 0.3 but " + myNumber]
Khi
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Một điều cần lưu ý là nếu chuỗi không bắt đầu bằng một số, thì thay vào đó, _________ 383 [viết tắt của ________ 384] sẽ được trả về
var myNumber = 0.1 + 0.2
console.log["myNumber is not 0.3 but " + myNumber]
Hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Number.MAX_VALUE; // 2^1024
Number.MIN_VALUE; // 0
Nếu bạn có một chuỗi chứa dấu phẩy thì sao?
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Nếu trường hợp này xảy ra và bạn muốn thực hiện chuyển đổi theo nghĩa đen, tốt nhất nên sử dụng hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Cách chuyển đổi một chuỗi thành một số bằng hàm // integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
5
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Cú pháp chung cho hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Cú pháp và hành vi của hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Sử dụng hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Lấy ví dụ tương tự từ phần trước, đây là cách bạn sẽ viết lại nó bằng cách sử dụng
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Cũng giống như
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Và cũng giống như
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Number.MAX_VALUE; // 2^1024
Number.MIN_VALUE; // 0
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Cách chuyển đổi một chuỗi thành một số bằng hàm // integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
6
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Cú pháp chung cho hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Sự khác biệt giữa hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Hãy lấy ví dụ sau mà bạn đã thấy trước đó sử dụng
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Ngay khi
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Đây là cách ví dụ tương tự hoạt động với hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Vì
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Number.MAX_VALUE; // 2^1024
Number.MIN_VALUE; // 0
Hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Một điều khác cần lưu ý là hàm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Cách chuyển đổi một chuỗi thành một số bằng hàm // integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
7
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Đối tượng
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
var myNumber = 0.1 + 0.2
console.log["myNumber is not 0.3 but " + myNumber]
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Một điều cần lưu ý và ghi nhớ khi sử dụng các phương thức Toán học để chuyển đổi kiểu là khi bạn đang làm việc với số float, chúng sẽ biến chúng thành một số nguyên và số float sẽ mất phần thập phân của nó
Các phương thức sẽ chuyển đổi chuỗi thành số nguyên gần nhất tương đương
Hàm
var myNumber = 0.1 + 0.2
console.log["myNumber is not 0.3 but " + myNumber]
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Nếu giá trị của
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Nếu chuỗi chứa các ký tự không phải là số, ________ 469 trả về ________ 383
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Hàm
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Nếu chuỗi chứa các ký tự không phải là số, ________ 1300 trả về ________ 383. Cách thức hoạt động của hàm này là nó cố gắng chuyển đổi toàn bộ chuỗi thành một số và sau đó đánh giá kết quả, nghĩa là chuỗi phải là một chuỗi hợp lệ để nó hoạt động
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Hàm
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Tương tự như các ví dụ trước, hàm
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Number.MAX_VALUE; // 2^1024
Number.MIN_VALUE; // 0
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Cách chuyển đổi một chuỗi thành một số bằng cách nhân và chia cho // integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
8
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Nhân với
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Và nếu bạn muốn thực hiện chuyển đổi kiểu trên số float, nhân với
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Nếu chuỗi chứa các ký tự không phải là số, nó sẽ trả về ________ 383
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Cách chuyển đổi chuỗi thành số nguyên này cũng hoạt động với việc chia chuỗi cho
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Tại thời điểm này, điều đáng nói là điều gì sẽ xảy ra khi bạn cố gắng thêm
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Trong ví dụ trên,
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
let MAX_INT = 4294967295; // Math.pow[2,32] - 1;
Cách chuyển đổi một chuỗi thành một số bằng cách sử dụng toán tử // integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
9 một ngôi
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Sử dụng toán tử
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Bạn đặt toán tử cộng,
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
hoặc một cái phao
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Tương tự như các cách khác mà bạn đã thấy để chuyển đổi một chuỗi thành một số, toàn bộ chuỗi chỉ được chứa các ký tự số để toán tử một ngôi ________ 69 hoạt động. Nếu chuỗi không đại diện cho một số, thì nó sẽ trả về
Number.MAX_VALUE; // 2^1024
Number.MIN_VALUE; // 0
// integer
let num = 47;
// float
let num = 47.32;
// exponential - to represent large numbers
let num = 477e2; // equal to multiplying 477 to 10 to the power of 2 [or 100] which results in 47700
// exponential - to represent small numbers
let num = 477e-2; // equal to dividing 477 to 10 to the power of 2 [or 100] which results in 4.77
// binary
let num = 0b1111; // stands for 15
// octal
let num = 023; // stands for 19
// hexadecimal
let num = 0xFF; // stands for 255
Sự kết luận
Và bạn có nó rồi đấy. Bây giờ bạn đã biết một số cách để chuyển đổi chuỗi thành số trong JavaScript
Để tìm hiểu thêm về JavaScript, hãy đến với Chứng nhận cấu trúc dữ liệu và thuật toán JavaScript của freeCodeCamp
Đó là một chương trình giảng dạy miễn phí, được cân nhắc kỹ lưỡng và có cấu trúc, nơi bạn sẽ học một cách tương tác. Cuối cùng, bạn cũng sẽ xây dựng 5 dự án để nhận chứng chỉ và củng cố kiến thức của mình
Cảm ơn vì đã đọc
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
QUẢNG CÁO
Học một cái gì đó mới mỗi ngày và viết về nó
Nếu bài viết này hữu ích, hãy tweet nó
Học cách viết mã miễn phí. Chương trình giảng dạy nguồn mở của freeCodeCamp đã giúp hơn 40.000 người có việc làm với tư cách là nhà phát triển. Bắt đầu
Làm cách nào để chuyển đổi Double thành int trong JavaScript?
Làm cách nào để chuyển đổi double thành int? .
lớp công khai DoubleToIntExample2{
public static void main[String args[]]{
Nhân đôi d=mới Nhân đôi[10. 5];
int tôi = d. intValue[];
Hệ thống. ngoài. println[i];
Double có thể biến thành int không?
Sử dụng toán học. round[] chấp nhận giá trị kép và chuyển đổi nó thành giá trị dài gần nhất bằng cách thêm 0. 5 thành giá trị và cắt bớt các dấu thập phân của nó. Sau đó, giá trị dài có thể được chuyển đổi thành int bằng cách sử dụng kiểu chữ
Làm cách nào để chuyển đổi số thành int trong JavaScript?
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 thành giá trị số nguyên . Hàm này trả về một số nguyên cơ số được chỉ định trong đối số thứ hai của hàm parseInt[].
Làm cách nào để chuyển đổi số thập phân thành int trong JavaScript?
vòng[], Toán. các phương thức trunc[] được sử dụng để chuyển đổi số float thành số nguyên . Tất cả các phương thức này đều lấy dấu phẩy động làm đầu vào và trả về một số nguyên. Ngoài ra, các phương thức parseInt[], bitwise Or operation và toFixed[] được sử dụng để loại bỏ số thập phân của các số thực.