===
so sánh cả loại và giá trị.
Mặc dù NaN
là giả, ===
sẽ không phải là cách để so sánh nó. Một cái gì đó là "giả" nếu nó đánh giá là sai trong biểu thức boolean. Điều đó không giống như bằng [hoặc tương đương] sai.
Ví dụ, null == false
trả về sai, mặc dù null
là sai. Điều này không hoàn toàn trực quan, nhưng đó chỉ là cách JavaScript xử lý các giá trị sai/sai.
isNaN["hello world"]; // true
Number.isNaN["hello world"]; // false
0 và chuỗi trống [""] là những trường hợp đặc biệt trong đó so sánh bình đẳng giá trị so với isNaN["hello world"]; // true
Number.isNaN["hello world"]; // false
1 đánh giá thành isNaN["hello world"]; // true
Number.isNaN["hello world"]; // false
2 [tức là isNaN["hello world"]; // true
Number.isNaN["hello world"]; // false
3 và isNaN["hello world"]; // true
Number.isNaN["hello world"]; // false
4]. Tuy nhiên, isNaN["hello world"]; // true
Number.isNaN["hello world"]; // false
5 và isNaN["hello world"]; // true
Number.isNaN["hello world"]; // false
6 vẫn trả về sai.NaN
đặc biệt ở chỗ nó không có giá trị thực, vì vậy việc so sánh nó với chính nó không trả về đúng. Về cơ bản, NaN
bằng không có gì, thậm chí không NaN
.
Cách duy nhất để so sánh đáng tin cậy một cái gì đó với NAN là sử dụng
isNaN[1n]; // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN[1n]; // false
0.Đến điểm thứ hai của bạn,
isNaN[1n]; // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN[1n]; // false
1 là một biểu thức boolean. isNaN[1n]; // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN[1n]; // false
2 Đầu tiên trải qua sự ép buộc loại cho một boolean [và hãy nhớ rằng, NaN
là sai] và sau đó boolean không isNaN[1n]; // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN[1n]; // false
4 làm cho nó đúng. Khi nó xảy ra, nó bị phủ định gấp đôi, vì vậy isNaN[1n]; // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN[1n]; // false
5 giống như Boolean isNaN["hello world"]; // true
Number.isNaN["hello world"]; // false
1. Tất nhiên isNaN[1n]; // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN[1n]; // false
7, vì vậy biểu thức đánh giá là isNaN["hello world"]; // true
Number.isNaN["hello world"]; // false
2.Thuộc tính toàn cầu Giá trị ban đầu của NaN
là một giá trị đại diện cho số không.NaN
property is a value representing Not-A-Number.Thử nó
Sự mô tả
NaN
là một tài sản của đối tượng toàn cầu. Nói cách khác, nó là một biến trong phạm vi toàn cầu.NaN
không phải là một số-giống như giá trị của
2. Trong các trình duyệt hiện đại, const arr = [2, 4, NaN, 12];
arr.indexOf[NaN]; // -1
arr.includes[NaN]; // true
// Methods accepting a properly defined predicate can always find NaN
arr.findIndex[[n] => Number.isNaN[n]]; // 2
NaN
là một tài sản không thể cấu hình, không có thể đi được. Ngay cả khi điều này không phải là trường hợp, tránh ghi đè nó. Nó là khá hiếm khi sử dụng NaN
trong một chương trình.
Có năm loại hoạt động khác nhau trả về NaN
:
- Chuyển đổi số không thành công [ví dụ: những cái rõ ràng như
6,const arr = [2, 4, NaN, 12]; arr.indexOf[NaN]; // -1 arr.includes[NaN]; // true // Methods accepting a properly defined predicate can always find NaN arr.findIndex[[n] => Number.isNaN[n]]; // 2
7 hoặc những cái ngầm nhưconst arr = [2, 4, NaN, 12]; arr.indexOf[NaN]; // -1 arr.includes[NaN]; // true // Methods accepting a properly defined predicate can always find NaN arr.findIndex[[n] => Number.isNaN[n]]; // 2
8]const arr = [2, 4, NaN, 12]; arr.indexOf[NaN]; // -1 arr.includes[NaN]; // true // Methods accepting a properly defined predicate can always find NaN arr.findIndex[[n] => Number.isNaN[n]]; // 2
- Hoạt động toán học trong đó kết quả không phải là một số thực [ví dụ:
9]const arr = [2, 4, NaN, 12]; arr.indexOf[NaN]; // -1 arr.includes[NaN]; // true // Methods accepting a properly defined predicate can always find NaN arr.findIndex[[n] => Number.isNaN[n]]; // 2
- Mẫu không xác định [ví dụ:
0,const f2b = [x] => new Uint8Array[new Float64Array[[x]].buffer]; const b2f = [x] => new Float64Array[x.buffer][0]; // Get a byte representation of NaN const n = f2b[NaN]; // Change the first bit, which is the sign bit and doesn't matter for NaN n[0] = 1; const nan2 = b2f[n]; console.log[nan2]; // NaN console.log[Object.is[nan2, NaN]]; // true console.log[f2b[NaN]]; // Uint8Array[8] [0, 0, 0, 0, 0, 0, 248, 127] console.log[f2b[nan2]]; // Uint8Array[8] [1, 0, 0, 0, 0, 0, 248, 127]
1,const f2b = [x] => new Uint8Array[new Float64Array[[x]].buffer]; const b2f = [x] => new Float64Array[x.buffer][0]; // Get a byte representation of NaN const n = f2b[NaN]; // Change the first bit, which is the sign bit and doesn't matter for NaN n[0] = 1; const nan2 = b2f[n]; console.log[nan2]; // NaN console.log[Object.is[nan2, NaN]]; // true console.log[f2b[NaN]]; // Uint8Array[8] [0, 0, 0, 0, 0, 0, 248, 127] console.log[f2b[nan2]]; // Uint8Array[8] [1, 0, 0, 0, 0, 0, 248, 127]
2,const f2b = [x] => new Uint8Array[new Float64Array[[x]].buffer]; const b2f = [x] => new Float64Array[x.buffer][0]; // Get a byte representation of NaN const n = f2b[NaN]; // Change the first bit, which is the sign bit and doesn't matter for NaN n[0] = 1; const nan2 = b2f[n]; console.log[nan2]; // NaN console.log[Object.is[nan2, NaN]]; // true console.log[f2b[NaN]]; // Uint8Array[8] [0, 0, 0, 0, 0, 0, 248, 127] console.log[f2b[nan2]]; // Uint8Array[8] [1, 0, 0, 0, 0, 0, 248, 127]
3]const f2b = [x] => new Uint8Array[new Float64Array[[x]].buffer]; const b2f = [x] => new Float64Array[x.buffer][0]; // Get a byte representation of NaN const n = f2b[NaN]; // Change the first bit, which is the sign bit and doesn't matter for NaN n[0] = 1; const nan2 = b2f[n]; console.log[nan2]; // NaN console.log[Object.is[nan2, NaN]]; // true console.log[f2b[NaN]]; // Uint8Array[8] [0, 0, 0, 0, 0, 0, 248, 127] console.log[f2b[nan2]]; // Uint8Array[8] [1, 0, 0, 0, 0, 0, 248, 127]
- Một phương pháp hoặc biểu thức có toán hạng hoặc bị ép buộc
NaN
[ví dụ:
5,const f2b = [x] => new Uint8Array[new Float64Array[[x]].buffer]; const b2f = [x] => new Float64Array[x.buffer][0]; // Get a byte representation of NaN const n = f2b[NaN]; // Change the first bit, which is the sign bit and doesn't matter for NaN n[0] = 1; const nan2 = b2f[n]; console.log[nan2]; // NaN console.log[Object.is[nan2, NaN]]; // true console.log[f2b[NaN]]; // Uint8Array[8] [0, 0, 0, 0, 0, 0, 248, 127] console.log[f2b[nan2]]; // Uint8Array[8] [1, 0, 0, 0, 0, 0, 248, 127]
6] - điều này có nghĩa làconst f2b = [x] => new Uint8Array[new Float64Array[[x]].buffer]; const b2f = [x] => new Float64Array[x.buffer][0]; // Get a byte representation of NaN const n = f2b[NaN]; // Change the first bit, which is the sign bit and doesn't matter for NaN n[0] = 1; const nan2 = b2f[n]; console.log[nan2]; // NaN console.log[Object.is[nan2, NaN]]; // true console.log[f2b[NaN]]; // Uint8Array[8] [0, 0, 0, 0, 0, 0, 248, 127] console.log[f2b[nan2]]; // Uint8Array[8] [1, 0, 0, 0, 0, 0, 248, 127]
NaN
là truyền nhiễm - Các trường hợp khác trong đó giá trị không hợp lệ được biểu diễn dưới dạng một số [ví dụ: ngày không hợp lệ
8,const f2b = [x] => new Uint8Array[new Float64Array[[x]].buffer]; const b2f = [x] => new Float64Array[x.buffer][0]; // Get a byte representation of NaN const n = f2b[NaN]; // Change the first bit, which is the sign bit and doesn't matter for NaN n[0] = 1; const nan2 = b2f[n]; console.log[nan2]; // NaN console.log[Object.is[nan2, NaN]]; // true console.log[f2b[NaN]]; // Uint8Array[8] [0, 0, 0, 0, 0, 0, 248, 127] console.log[f2b[nan2]]; // Uint8Array[8] [1, 0, 0, 0, 0, 0, 248, 127]
9]const f2b = [x] => new Uint8Array[new Float64Array[[x]].buffer]; const b2f = [x] => new Float64Array[x.buffer][0]; // Get a byte representation of NaN const n = f2b[NaN]; // Change the first bit, which is the sign bit and doesn't matter for NaN n[0] = 1; const nan2 = b2f[n]; console.log[nan2]; // NaN console.log[Object.is[nan2, NaN]]; // true console.log[f2b[NaN]]; // Uint8Array[8] [0, 0, 0, 0, 0, 0, 248, 127] console.log[f2b[nan2]]; // Uint8Array[8] [1, 0, 0, 0, 0, 0, 248, 127]
NaN
và các hành vi của nó không được phát minh bởi JavaScript. Ngữ nghĩa của nó trong số học điểm nổi [bao gồm cả ===
1] được chỉ định bởi IEEE 754. ________ 6 Hành vi của
- Nếu
NaN
có liên quan đến hoạt động toán học [nhưng không phải là hoạt động bitwise], kết quả thường làNaN
. [Xem ví dụ ngược bên dưới.] - Khi
NaN
là một trong những toán hạng của bất kỳ so sánh quan hệ nào [===
6,===
7,===
8,===
9], kết quả luôn là
1.isNaN["hello world"]; // true Number.isNaN["hello world"]; // false
NaN
so sánh không đồng đều [thông quaNaN
2,NaN
3,===
vàNaN
5] với bất kỳ giá trị nào khác - bao gồm cả giá trịNaN
khác.
NaN
cũng là một trong những giá trị giả mạo trong JavaScript.
Ví dụ
Thử nghiệm chống lại NAN
Để biết nếu một giá trị là NaN
, hãy sử dụng NaN
9 hoặc ===
0 để xác định rõ nhất liệu một giá trị là NaN
-hoặc, vì NaN
là giá trị duy nhất so sánh không đồng đều với chính nó, bạn có thể thực hiện tự so sánh như ===
3.
NaN === NaN; // false
Number.NaN === NaN; // false
isNaN[NaN]; // true
isNaN[Number.NaN]; // true
Number.isNaN[NaN]; // true
function valueIsNaN[v] {
return v !== v;
}
valueIsNaN[1]; // false
valueIsNaN[NaN]; // true
valueIsNaN[Number.NaN]; // true
Tuy nhiên, xin lưu ý sự khác biệt giữa ===
0 và NaN
9: Cái trước sẽ trả về
isNaN["hello world"]; // true
Number.isNaN["hello world"]; // false
2 nếu giá trị hiện tại Hiện tại NaN
:isNaN["hello world"]; // true
Number.isNaN["hello world"]; // false
Vì lý do tương tự, việc sử dụng giá trị lớn sẽ gây ra lỗi với ===
0 chứ không phải với NaN
9:
isNaN[1n]; // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN[1n]; // false
Ngoài ra, một số phương thức mảng không thể tìm thấy NaN
, trong khi các phương thức khác có thể. Cụ thể, những cái tìm chỉ số [null == false
4, null == false
5] không thể tìm thấy NaN
, trong khi những cái tìm giá trị [null == false
7] có thể:
const arr = [2, 4, NaN, 12];
arr.indexOf[NaN]; // -1
arr.includes[NaN]; // true
// Methods accepting a properly defined predicate can always find NaN
arr.findIndex[[n] => Number.isNaN[n]]; // 2
Để biết thêm thông tin về NaN
và so sánh của nó, xem so sánh và giống nhau bình đẳng.
Giá trị nan khác biệt có thể quan sát được
Có một động lực cho NaN
không đồng đều với chính nó. Có thể tạo ra hai số điểm nổi với các biểu diễn nhị phân khác nhau nhưng cả hai đều là NaN
, bởi vì trong mã hóa IEEE 754, bất kỳ số điểm nổi nào với số mũ null
1 và mantissa khác không là NaN
. Trong JavaScript, bạn có thể thực hiện thao tác cấp độ bit bằng các mảng được đánh máy.
const f2b = [x] => new Uint8Array[new Float64Array[[x]].buffer];
const b2f = [x] => new Float64Array[x.buffer][0];
// Get a byte representation of NaN
const n = f2b[NaN];
// Change the first bit, which is the sign bit and doesn't matter for NaN
n[0] = 1;
const nan2 = b2f[n];
console.log[nan2]; // NaN
console.log[Object.is[nan2, NaN]]; // true
console.log[f2b[NaN]]; // Uint8Array[8] [0, 0, 0, 0, 0, 0, 248, 127]
console.log[f2b[nan2]]; // Uint8Array[8] [1, 0, 0, 0, 0, 0, 248, 127]
Âm thầm thoát khỏi Nan
NaN
tuyên truyền thông qua các hoạt động toán học, do đó, thường đủ để kiểm tra NaN
một lần khi kết thúc tính toán để phát hiện các điều kiện lỗi. Trường hợp duy nhất trong đó NaN
được thoát khỏi âm thầm là khi sử dụng số mũ với số mũ là ____10, ngay lập tức trả về null
7 mà không kiểm tra giá trị của cơ sở.
Thông số kỹ thuật
Thông số kỹ thuật ngôn ngữ Ecmascript # sec-value-properies-of-the-global-expect-nan # sec-value-properties-of-the-global-object-nan |
Tính tương thích của trình duyệt web
Bảng BCD chỉ tải trong trình duyệt