JavaScript Numbers - Các chữ số trong JavaScript
JavaScript chỉ có một kiểu số. Các số có thể được viết cùng hoặc không cùng phần thập phân.
ví dụ
var x = 3.14; // A number with decimals
var y = 3; // A number without decimals<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>Numbers can be written with or without decimals:</p>
<p id="demo"></p>
<script>
var x = 3.14;
var y = 3;
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>
</body>
</html>Các chữ số JavaScript luôn là số thực có dấu phẩy động 64-bit(JavaScript Numbers are Always 64-bit Floating Point)
Không như mọi ngôn ngữ lập trình khác, JavaScript không định rõ sự khác biệt giữa các kiểu chữ số, integers, short, long, floating-point etc.
Các số JavaScript luôn được lưu trữ dưới dang dấu phẩu động chính xác kép, theo chuẩn quốc tế IEEE 754.
Định dang này lưu trữ các số tại 64 bits, nơi chữ số (phân số) được lưu trong bits 0 đến 51, số mũ trong bits 52 đến 62, và dấu trong bit 63:
| Giá trị (Cũng được biết giống như phân số/Phần định trị) | Số mũ | Dấu |
|---|---|---|
| 52 bits (0 - 51) | 11 bits (52 - 62) | 1 bit (63) |
Độ chính xác
Các số nguyên(các chữ số không có kí hiệu dấu chấm hoặc số mũ) có thể chính xác lên đến 15 chữ số.
ví dụ
var x = 999999999999999; // x will be 999999999999999
var y = 9999999999999999; // y will be 10000000000000000<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>Integers (numbers without a period or exponent notation) are accurate up to 15 digits:</p>
<p id="demo"></p>
<script>
var x = 999999999999999;
var y = 9999999999999999;
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>
</body>
</html>
Số tối đa của phần thập là 17, nhưng số học dấu phẩy động không lúc nào cũng chính xác 100% :
ví dụ
var x = 0.2 + 0.1; // x will be 0.30000000000000004<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>Floating point arithmetic is not always 100% accurate.</p>
<p id="demo"></p>
<script>
var x = 0.2 + 0.1;
document.getElementById("demo").innerHTML = "0.2 + 0.1 = " + x;
</script>
</body>
</html>
Để giải quyết vấn đề trên, có thể giúp bằng việc nhân và chia:
ví dụ
var x = (0.2 * 10 + 0.1 * 10) / 10; // x will be 0.3<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>Floating point arithmetic is not always 100% accurate:</p>
<p id="demo1"></p>
<p>But it helps to multiply and divide:</p>
<p id="demo2"></p>
<script>
var x = 0.2 + 0.1;
document.getElementById("demo1").innerHTML = "0.2 + 0.1 = " + x;
var y = (0.2*10 + 0.1*10) / 10;
document.getElementById("demo2").innerHTML = "0.2 + 0.1 = " + y;
</script>
</body>
</html>
Cộng thêm các số và các chuỗi
Cảnh báo!!!
JavaScript sử dụng toán tử + cho cả hai việc cộng và nối.
Các số thì cộng. Các chuỗi thì nối.
Nếu bạn công hai số, kết quả sẽ là một số:
ví dụ
var x = 10;
var y = 20;
var z = x + y; // z will be 30 (a number)<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>If you add two numbers, the result will be a number:</p>
<p id="demo"></p>
<script>
var x = 10;
var y = 20;
var z = x + y;
document.getElementById("demo").innerHTML = z;
</script>
</body>
</html>
Nếu bạn cộng hai chuỗi, kết quả sẽ là một chuỗi được nối:
ví dụ
var x = "10";
var y = "20";
var z = x + y; // z will be 1020 (a string)<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>If you add two numeric strings, the result will be a concatenated string:</p>
<p id="demo"></p>
<script>
var x = "10";
var y = "20";
var z = x + y;
document.getElementById("demo").innerHTML = z;
</script>
</body>
Nếu bạn cộng số và chuỗi , kết quả sẽ là một chuỗi nối:
ví dụ
var x = 10;
var y = "20";
var z = x + y; // z will be 1020 (a string)<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>If you add a number and a numeric string, the result will be a concatenated string:</p>
<p id="demo"></p>
<script>
var x = 10;
var y = "20";
var z = x + y;
document.getElementById("demo").innerHTML = z;
</script>
</body>
</html>
Nếu bạn cộng chuỗi mà số, kết quả sẽ là một chuỗi nối:
ví dụ
var x = "10";
var y = 20;
var z = x + y; // z will be 1020 (a string)<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>If you add a numeric string and a number, the result will be a concatenated string:</p>
<p id="demo"></p>
<script>
var x = "10";
var y = 20;
document.getElementById("demo").innerHTML =
"The result is: " + x + y;
</script>
</body>
</html>
Một lỗi thường mắc phải là đoán rằng kết quả sau sẽ là 30:
ví dụ
var x = 10;
var y = 20;
var z = "The result is: " + x + y;<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>A common mistake is to expect this result to be 30:</p>
<p id="demo"></p>
<script>
var x = 10;
var y = 20;
document.getElementById("demo").innerHTML =
"The result is: " + x + y;
</script>
</body>
</html>
Một lỗi thường gặp là đoán rằng kết quả sẽ là 102030:
ví dụ
var x = 10;
var y = 20;
var z = "30";
var result = x + y + z;<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>A common mistake is to expect this result to be 102030:</p>
<p id="demo"></p>
<script>
var x = 10;
var y = 20;
var z = "30";
var result = x + y + z;
document.getElementById("demo").innerHTML = result;
</script>
</body>
</html>
Tip: Các thông dịch viên của JavaScript làm việc từ trái sang phải.
Đầu tiên 10 + 20 được cộng vì x và y đều là số.
Sau đó 30 + "30" được nối với nhau vì z là một chuỗi.
Các chuỗi số
Các chuỗi số JavaScript có thể có nội dung dạng số:
var x = 100; // x is a number
var y = "100"; // y is a stringJavaScript sẽ cố để chuyển đổi các chuỗi thành các số trong tất cả các tính toán chữ số:
Điều này sẽ chạy:
var x = "100";
var y = "10";
var z = x / y; // z will be 10<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>JavaScript will try to convert strings to numbers when dividing:</p>
<p id="demo"></p>
<script>
var x = "100";
var y = "10";
var z = x / y;
document.getElementById("demo").innerHTML = z;
</script>
</body>
</html>
Điều này cũng sẽ hoạt động:
var x = "100";
var y = "10";
var z = x * y; // z will be 1000<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>JavaScript will try to convert strings to numbers when multiplying:</p>
<p id="demo"></p>
<script>
var x = "100";
var y = "10";
var z = x * y;
document.getElementById("demo").innerHTML = z;
</script>
</body>
</html>
Và điều này cũng sẽ chạy:
var x = "100";
var y = "10";
var z = x - y; // z will be 90<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>JavaScript will try to convert strings to numbers when subtracting:</p>
<p id="demo"></p>
<script>
var x = "100";
var y = "10";
var z = x - y;
document.getElementById("demo").innerHTML = z;
</script>
</body>
</html>
Nhưng điều sau sẽ không hoạt động:
var x = "100";
var y = "10";
var z = x + y; // z will not be 110 (It will be 10010)
<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>JavaScript will NOT convert strings to numbers when adding:</p>
<p id="demo"></p>
<script>
var x = "100";
var y = "10";
var z = x + y;
document.getElementById("demo").innerHTML = z;
</script>
</body>
</html>
Tip: Trong ví dụ cuối JavaScript sử dụng toán tử + để nối các chuỗi.
NaN - Không phải một số(NaN - Not a Number)
NaN là một từ riêng của JavaScript chỉ ra rằng số đó không phải là một số hợp lệ.
Cố gắng giải toán với một chuỗi không phải số kết quả sẽ là NaN (không phải số):
ví dụ
var x = 100 / "Apple"; // x will be NaN (Not a Number)<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>A number divided by a non-numeric string becomes NaN (Not a Number):</p>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML = 100 / "Apple";
</script>
</body>
</html>
Tuy nhiên, nếu chuỗi có chứa các giá trị số học, kết quả sẽ là một số:
ví dụ
var x = 100 / "10"; // x will be 10<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>A number divided by a numeric string becomes a number:</p>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML = 100 / "10";
</script>
</body>
</html>
Bạn có thể sử dụng hàm toàn cục JavaScript isNaN() để xem giá trị có phải là một số:
ví dụ
var x = 100 / "Apple";
isNaN(x); // returns true because x is Not a Number<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>You can use the global JavaScript function isNaN() to find out if a value is a number:</p>
<p id="demo"></p>
<script>
var x = 100 / "Apple";
document.getElementById("demo").innerHTML = isNaN(x);
</script>
</body>
</html>
Cẩn thân với NaN.Nếu bạn dùng NaN trong một phép toán, kết quả sẽ cũng là NaN:
ví dụ
var x = NaN;
var y = 5;
var z = x + y; // z will be NaN<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>If you use NaN in a mathematical operation, the result will also be NaN:</p>
<p id="demo"></p>
<script>
var x = NaN;
var y = 5;
document.getElementById("demo").innerHTML = x + y;
</script>
</body>
</html>
Hoặc kết quả có thể là một chuỗi nối:
ví dụ
var x = NaN;
var y = "5";
var z = x + y; // z will be NaN5<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>If you use NaN in a mathematical operation, the result can be a concatenation:</p>
<p id="demo"></p>
<script>
var x = NaN;
var y = "5";
document.getElementById("demo").innerHTML = x + y;
</script>
</body>
</html>
NaN là một số: typeof NaN trả về number:
ví dụ
typeof NaN; // returns "number"<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>The typeof NaN is number:</p>
<p id="demo"></p>
<script>
var x = NaN;
document.getElementById("demo").innerHTML = typeof x;
</script>
</body>
</html>iqVô cực(Infinity)
Infinity (hay-Infinity ) là một giá trị trong JavaScript sẽ trả về nếu bạn tính toán một số vượt số lớn nhất có thể.
ví dụ
var myNumber = 2;
while (myNumber != Infinity) { // Execute until Infinity
myNumber = myNumber * myNumber;
}<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>Infinity is returned if you calculate a number outside the largest possible number:</p>
<p id="demo"></p>
<script>
var myNumber = 2;
var txt = "";
while (myNumber != Infinity) {
myNumber = myNumber * myNumber;
txt = txt + myNumber + "<br>";
}
document.getElementById("demo").innerHTML = txt;
</script>
</body>
</html>
Chia cho 0 (zero) cũng tạo ra Infinity:
ví dụ
var x = 2 / 0; // x will be Infinity
var y = -2 / 0; // y will be -Infinity<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>Division by zero generates Infinity;</p>
<p id="demo"></p>
<script>
var x = 2/0;
var y = -2/0;
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>
</body>
</html>Infinity là một số: typeof Infinity trả về number.
ví dụ
typeof Infinity; // returns "number"<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>Infinity is a number:</p>
<p id="demo"></p>
<script>
var x = Infinity;
document.getElementById("demo").innerHTML = typeof x;
</script>
</body>
</html>
Hệ thập lục phân(Hexadecimal)
JavaScript phiên dịch hằng số như hệ thập lục phân nếu chúng được nối trước bởi 0x.
ví dụ
var x = 0xFF; // x will be 255<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>Numeric constants, preceded by 0x, are interpreted as hexadecimal:</p>
<p id="demo"></p>
<script>
var x = 0xFF;
document.getElementById("demo").innerHTML = "0xFF = " + x;
</script>
</body>
</html>
Tip: Không bao giờ viết một số với bắt đầu bằng 0 (như 07).
Một vài phiên bản JavaScript dịch các số như bát phân nếu chúng được viết bắt dầu bằng không.
Mặc định, các số hiển thị của JavaScript là số thập phân cơ số 10 .
Nhưng bạn có thể dùng phương thức toString() để xuất ra các chữ số có cơ số 2 đến 36.
Hệ thập lục phân là cơ số 16. Hệ thập phân là cơ số 10. Hệ bát phân là cơ số 8. Nhị phân là cơ số 2.
ví dụ
var myNumber = 32;
myNumber.toString(10); // returns 32
myNumber.toString(32); // returns 10
myNumber.toString(16); // returns 20
myNumber.toString(8); // returns 40
myNumber.toString(2); // returns 100000<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>The toString() method can output numbers from base 2 to 36:</p>
<p id="demo"></p>
<script>
var myNumber = 32;
document.getElementById("demo").innerHTML =
"32 = " + "<br>" +
" Decimal " + myNumber.toString(10) + "<br>" +
" Hexadecimal " + myNumber.toString(16) + "<br>" +
" Octal " + myNumber.toString(8) + "<br>" +
" Binary " + myNumber.toString(2);
</script>
</body>
</html>Các chữ số có thể là các đối tượng
Thông thường các chữ số JavaScript là các giá trị nguyên thủy được tạo từ các chữ gốc:
var x = 123;
Nhưng các chữ số có thể được định nghĩa như các đối tượng với từ khóa new:
var y = new Number(123);
ví dụ
var x = 123;
var y = new Number(123);
// typeof x returns number
// typeof y returns object<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>A number can be an object, but there is no need to create a number as an object.</p>
<p id="demo"></p>
<script>
var x = 123;
var y = new Number(123);
document.getElementById("demo").innerHTML = typeof x + "<br>" + typeof y;
</script>
</body>
</html>
Tip: Đừng tạo các đối tượng số. Nó làm chậm tốc độ thực thi.
Từ khóa new phức tạp hóa dòng code. Nó có thể dẫn đến một số kết quả không ngờ:
Khi dùng toán tử == , các chữ số tương đương sẽ bằng nhau:
ví dụ
var x = 500;
var y = new Number(500);
// (x == y) is true because x and y have equal values<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>Never create numbers as objects.</p>
<p>Numbers and objects cannot be safely compared.</p>
<p id="demo"></p>
<script>
var x = 500; // x is a number
var y = new Number(500); // y is an object
document.getElementById("demo").innerHTML = (x==y);
</script>
</body>
</html>
Khi sử dụng toán tử === , các số tương đương sẽ không bằng nhau, vì toán tử === xem xét sự tương đương giữa cả kiểu và giá trị.
ví dụ
var x = 500;
var y = new Number(500);
// (x === y) is false because x and y have different types<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>Never create numbers as objects.</p>
<p>Numbers and objects cannot be safely compared.</p>
<p id="demo"></p>
<script>
var x = 500; // x is a number
var y = new Number(500); // y is an object
document.getElementById("demo").innerHTML = (x===y);
</script>
</body>
</html>
Hoặc tệ hơn nữa. Các đối tượng không thể bị so sánh:
ví dụ
var x = new Number(500);
var y = new Number(500);
// (x == y) is false because objects cannot be compared<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Numbers</h2>
<p>Never create numbers as objects.</p>
<p>JavaScript objects cannot be compared.</p>
<p id="demo"></p>
<script>
var x = new Number(500); // x is an object
var y = new Number(500); // y is an object
document.getElementById("demo").innerHTML = (x==y);
</script>
</body>
</html>
Tip: Ghi chép lại sự khác biệt giữa (x==y) và(x===y).
So sánh hai đối tượng JavaScript sẽ luôn luôn trả về false.
Tags:
Phản hồi từ học viên
5
(Dựa trên đánh giá ngày hôm nay)
