Hướng dẫn is nan false in javascript? - nan có sai trong javascript không?

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.

Giá trị ban đầu của NaN không phải là một số-giống như giá trị của

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

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ư

  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
  

  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)
• Hoạt động toán học trong đó kết quả không phải là một số thực (ví dụ:

  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
  

  9)
• Mẫu không xác định (ví dụ:

  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]
  

  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)
• 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ụ:

  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]
  

  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à 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ệ

  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]
  

  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)

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à

  isNaN("hello world"); // true
  Number.isNaN("hello world"); // false
  

  1.
• NaN so sánh không đồng đều (thông qua NaN2, NaN3, === và NaN5) 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 NaN9 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à NaN9: Cái trước sẽ trả về

isNaN("hello world"); // true
Number.isNaN("hello world"); // false

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 NaN9:

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 == false4, null == false5) không thể tìm thấy NaN, trong khi những cái tìm giá trị (null == false7) 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ũ null1 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ề null7 mà không kiểm tra giá trị của cơ sở.

Xem thêm