Ném lỗi nodejs

Nếu bạn đã từng viết bất kỳ chương trình nào khác ngoài chương trình "Xin chào thế giới", có lẽ bạn đã quen thuộc với khái niệm lỗi trong lập trình. Chúng là lỗi trong mã của bạn, thường được gọi là "lỗi", khiến chương trình bị lỗi hoặc hoạt động không mong muốn. Không giống như một số ngôn ngữ, chẳng hạn như Go và Rust, nơi bạn buộc phải tương tác với các lỗi tiềm ẩn trong từng bước, bạn có thể vượt qua mà không cần có chiến lược xử lý lỗi nhất quán trong JavaScript và Node. js

Tuy nhiên, nó không nhất thiết phải theo cách này, bởi vì Node. js có thể khá đơn giản khi bạn đã quen thuộc với các mẫu được sử dụng để tạo, phân phối và xử lý các lỗi tiềm ẩn. Bài viết này nhằm mục đích giới thiệu cho bạn các mẫu này để bạn có thể làm cho chương trình của mình mạnh mẽ hơn bằng cách đảm bảo rằng bạn sẽ phát hiện ra các lỗi tiềm ẩn và xử lý chúng một cách thích hợp trước khi triển khai ứng dụng của mình vào sản xuất

Lỗi trong Node là gì. js

Một lỗi trong nút. js là bất kỳ phiên bản nào của đối tượng

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function (err, result) {}

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Khi bạn có một đối tượng

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Làm thế nào để cung cấp lỗi

Cách thích hợp để gửi lỗi từ hàm JavaScript khác nhau tùy thuộc vào việc hàm thực hiện hoạt động đồng bộ hay không đồng bộ. Trong phần này, tôi sẽ trình bày chi tiết bốn mẫu phổ biến để gửi lỗi từ một chức năng trong Nút. ứng dụng js

1. ngoại lệ

Cách phổ biến nhất để các chức năng gửi lỗi là ném chúng. Khi bạn đưa ra một lỗi, nó sẽ trở thành một ngoại lệ và cần được xử lý ở đâu đó trong ngăn xếp bằng cách sử dụng khối

function (err, result) {}

function (err, result) {}

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Để sử dụng mẫu này trong các chức năng của bạn, tất cả những gì bạn cần làm là thêm từ khóa

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

2. Gọi lại lỗi đầu tiên

Do tính chất không đồng bộ của nó, Node. js sử dụng nhiều chức năng gọi lại để xử lý lỗi của nó. Một hàm gọi lại được truyền dưới dạng đối số cho một hàm khác và được thực thi khi hàm đó hoàn thành công việc của nó. Nếu bạn đã viết mã JavaScript trong một khoảng thời gian bất kỳ, bạn có thể biết rằng mẫu gọi lại được sử dụng nhiều trong mã JavaScript

Nút. js sử dụng quy ước gọi lại lỗi đầu tiên trong hầu hết các phương thức không đồng bộ của nó để đảm bảo rằng các lỗi được kiểm tra đúng cách trước khi sử dụng kết quả của một thao tác. Hàm gọi lại này thường là đối số cuối cùng của hàm khởi tạo thao tác không đồng bộ và được gọi một lần khi xảy ra lỗi hoặc có kết quả từ thao tác. Chữ ký của nó được hiển thị dưới đây

________số 8

Đối số đầu tiên được dành riêng cho đối tượng lỗi. Nếu xảy ra lỗi trong quá trình thực hiện thao tác không đồng bộ, nó sẽ có sẵn thông qua đối số

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Như bạn có thể thấy, phương thức

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Nói chung, các phương thức sử dụng mẫu gọi lại này để phân phối lỗi không thể biết mức độ quan trọng của lỗi mà chúng tạo ra đối với ứng dụng của bạn. Nó có thể nghiêm trọng hoặc tầm thường. Thay vì tự quyết định, lỗi gửi lên cho bạn xử lý. Điều quan trọng là phải kiểm soát luồng nội dung của hàm gọi lại bằng cách luôn kiểm tra lỗi trước khi thử truy cập kết quả của thao tác. Bỏ qua lỗi là không an toàn và bạn không nên tin vào nội dung của

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Nếu bạn muốn sử dụng mẫu gọi lại lỗi đầu tiên này trong các hàm không đồng bộ của riêng mình, tất cả những gì bạn cần làm là chấp nhận một hàm làm đối số cuối cùng và gọi nó theo cách được hiển thị bên dưới

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Bất kỳ người gọi nào của hàm

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Bạn không phải trực tiếp xử lý lỗi trong chức năng gọi lại. Bạn có thể đưa nó lên ngăn xếp bằng cách chuyển nó tới một lệnh gọi lại khác, nhưng đảm bảo không ném ngoại lệ từ bên trong hàm vì nó sẽ không bị bắt, ngay cả khi bạn bao quanh mã trong khối

function (err, result) {}

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

3. lời hứa từ chối

Lời hứa là cách hiện đại để thực hiện các hoạt động không đồng bộ trong Node. js và hiện nay thường được ưa thích hơn so với gọi lại vì cách tiếp cận này có luồng tốt hơn phù hợp với cách chúng tôi phân tích chương trình, đặc biệt là với mẫu

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Biến

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Bạn cũng có thể sử dụng API được quảng cáo trong chức năng

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Bạn có thể sử dụng các lời hứa trong các chức năng không đồng bộ của mình bằng cách trả về một lời hứa từ hàm và đặt mã chức năng vào lời gọi lại lời hứa. Nếu có lỗi,

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

4. trình phát sự kiện

Một mẫu khác có thể được sử dụng khi xử lý các hoạt động không đồng bộ chạy dài có thể tạo ra nhiều lỗi hoặc kết quả là trả về một EventEmitter từ hàm và phát ra một sự kiện cho cả trường hợp thành công và thất bại. Một ví dụ về mã này được hiển thị dưới đây

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Hàm

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Đây là cách bạn có thể nghe và phản ứng với từng sự kiện được phát ra từ hàm

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Như bạn có thể thấy từ hình trên, chức năng gọi lại cho từng trình xử lý sự kiện được thực thi độc lập ngay khi sự kiện được phát ra. Sự kiện

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Mở rộng đối tượng lỗi

Việc sử dụng các lớp lỗi có sẵn hoặc một thể hiện chung của đối tượng

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Các lớp lỗi tùy chỉnh mở rộng đối tượng

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function (err, result) {}

function (err, result) {}

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Đây là cách mở rộng đối tượng

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Lớp

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Từ khóa

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Các loại lỗi

Sẽ rất hữu ích khi phân biệt giữa các loại lỗi khác nhau có thể xảy ra trong một Nút. ứng dụng js. Nói chung, các lỗi có thể được chia thành hai loại chính. lỗi lập trình viên và các vấn đề vận hành. Đối số xấu hoặc không chính xác cho một chức năng là một ví dụ về loại sự cố đầu tiên, trong khi các lỗi tạm thời khi xử lý các API bên ngoài chắc chắn thuộc loại thứ hai

1. lỗi vận hành

Lỗi vận hành chủ yếu là lỗi dự kiến ​​có thể xảy ra trong quá trình thực thi ứng dụng. Chúng không nhất thiết là lỗi nhưng là những tình huống bên ngoài có thể làm gián đoạn quá trình thực thi chương trình. Trong những trường hợp như vậy, toàn bộ tác động của lỗi có thể được hiểu và xử lý một cách thích hợp. Một số ví dụ về lỗi vận hành trong Node. js bao gồm những điều sau đây

• Yêu cầu API không thành công vì lý do nào đó (e. g. , máy chủ ngừng hoạt động hoặc vượt quá giới hạn tốc độ)
• Kết nối cơ sở dữ liệu bị mất, có thể do kết nối mạng bị lỗi
• Hệ điều hành không thể thực hiện yêu cầu của bạn để mở tệp hoặc ghi vào tệp
• Người dùng gửi thông tin nhập không hợp lệ đến máy chủ, chẳng hạn như số điện thoại hoặc địa chỉ email không hợp lệ

Những tình huống này không phát sinh do lỗi trong mã ứng dụng, nhưng chúng phải được xử lý chính xác. Nếu không, chúng có thể gây ra nhiều vấn đề nghiêm trọng hơn

2. lỗi lập trình viên

Lỗi lập trình viên là những lỗi trong logic hoặc cú pháp của chương trình mà chỉ có thể sửa được bằng cách thay đổi mã nguồn. Các loại lỗi này không thể xử lý được vì theo định nghĩa, chúng là lỗi trong chương trình. Một số ví dụ về lỗi lập trình bao gồm

• Lỗi cú pháp, chẳng hạn như không thể đóng dấu ngoặc nhọn
• Nhập lỗi khi bạn cố làm điều gì đó bất hợp pháp, chẳng hạn như thực hiện các thao tác trên toán hạng của các loại không khớp
• Tham số không hợp lệ khi gọi hàm
• Lỗi tham chiếu khi bạn viết sai tên biến, hàm hoặc thuộc tính
• Cố gắng truy cập một vị trí ngoài phần cuối của một mảng
• Không xử lý được lỗi vận hành

Xử lý lỗi vận hành

Các lỗi vận hành hầu hết có thể dự đoán được, vì vậy chúng phải được dự đoán và giải thích trong quá trình phát triển. Về cơ bản, việc xử lý các loại lỗi này liên quan đến việc xem xét liệu một hoạt động có thể bị lỗi hay không, tại sao nó có thể bị lỗi và điều gì sẽ xảy ra nếu nó xảy ra. Hãy xem xét một số chiến lược để xử lý các lỗi vận hành trong Node. js

1. Báo lỗi up stack

Trong nhiều trường hợp, hành động thích hợp là dừng luồng thực thi của chương trình, dọn dẹp mọi quy trình chưa hoàn thành và báo cáo lỗi lên ngăn xếp để có thể xử lý thích hợp. Đây thường là cách chính xác để giải quyết lỗi khi chức năng xảy ra lỗi nằm ở phía dưới ngăn xếp khiến nó không có đủ thông tin để xử lý lỗi trực tiếp. Báo cáo lỗi có thể được thực hiện thông qua bất kỳ phương pháp gửi lỗi nào được thảo luận trước đó trong bài viết này

2. Thử lại thao tác

Các yêu cầu mạng đối với các dịch vụ bên ngoài đôi khi có thể không thành công, ngay cả khi yêu cầu đó hoàn toàn hợp lệ. Điều này có thể là do lỗi tạm thời, có thể xảy ra nếu có lỗi mạng hoặc quá tải máy chủ. Những vấn đề như vậy thường là tạm thời, vì vậy, thay vì báo cáo lỗi ngay lập tức, bạn có thể thử lại yêu cầu một vài lần cho đến khi thành công hoặc cho đến khi đạt đến số lần thử lại tối đa. Việc xem xét đầu tiên là xác định xem có thích hợp để thử lại yêu cầu hay không. Ví dụ: nếu mã trạng thái HTTP phản hồi ban đầu là 500, 503 hoặc 429, bạn nên thử lại yêu cầu sau một khoảng thời gian ngắn.

Bạn có thể kiểm tra xem tiêu đề HTTP Thử lại sau khi có trong phản hồi hay không. Tiêu đề này cho biết lượng thời gian chờ đợi chính xác trước khi đưa ra yêu cầu tiếp theo. Nếu tiêu đề

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

3. Gửi lỗi cho khách hàng

Khi xử lý thông tin đầu vào bên ngoài từ người dùng, nên cho rằng thông tin đầu vào không hợp lệ theo mặc định. Do đó, điều đầu tiên cần làm trước khi bắt đầu bất kỳ quy trình nào là xác thực đầu vào và báo cáo bất kỳ sai sót nào cho người dùng kịp thời để có thể sửa chữa và gửi lại. Khi cung cấp lỗi máy khách, hãy đảm bảo bao gồm tất cả thông tin mà máy khách cần để tạo thông báo lỗi có ý nghĩa đối với người dùng

4. hủy bỏ chương trình

Trong trường hợp lỗi hệ thống không thể khôi phục, cách hành động hợp lý duy nhất là ghi lại lỗi và chấm dứt chương trình ngay lập tức. Bạn thậm chí có thể không tắt được máy chủ nếu không thể khôi phục ngoại lệ ở lớp JavaScript. Tại thời điểm đó, một quản trị viên hệ thống có thể được yêu cầu xem xét sự cố và khắc phục sự cố trước khi chương trình có thể bắt đầu lại

Ngăn ngừa lỗi lập trình viên

Do bản chất của chúng, các lỗi lập trình viên không thể xử lý được; . Tuy nhiên, có một vài điều bạn có thể làm để giảm đáng kể tần suất chúng xuất hiện trong ứng dụng của bạn

1. Áp dụng TypeScript

TypeScript là một siêu bộ JavaScript được gõ mạnh. Mục tiêu thiết kế chính của nó là xác định tĩnh các cấu trúc có khả năng bị lỗi mà không có bất kỳ hình phạt nào trong thời gian chạy. Bằng cách áp dụng TypeScript trong dự án của bạn (với các tùy chọn trình biên dịch nghiêm ngặt nhất có thể), bạn có thể loại bỏ toàn bộ lớp lỗi lập trình viên tại thời điểm biên dịch. Ví dụ: sau khi tiến hành phân tích hậu kỳ các lỗi, người ta ước tính rằng 38% lỗi trong cơ sở mã của Airbnb có thể ngăn chặn được bằng TypeScript

Khi bạn di chuyển toàn bộ dự án của mình sang TypeScript, các lỗi như "

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

2. Xác định hành vi cho các tham số xấu

Nhiều lỗi lập trình viên do truyền tham số xấu. Những điều này có thể không chỉ do các lỗi rõ ràng, chẳng hạn như chuyển một chuỗi thay vì một số, mà còn do các lỗi tinh vi, chẳng hạn như khi một đối số hàm thuộc loại chính xác nhưng nằm ngoài phạm vi mà hàm có thể xử lý. Khi chương trình đang chạy và chức năng được gọi theo cách đó, nó có thể bị lỗi âm thầm và tạo ra một giá trị sai, chẳng hạn như

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Bạn có thể xử lý các tham số xấu bằng cách xác định hành vi của chúng bằng cách đưa ra lỗi hoặc trả về một giá trị đặc biệt, chẳng hạn như

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

3. kiểm thử tự động

Về bản chất, ngôn ngữ JavaScript không làm được gì nhiều để giúp bạn tìm ra lỗi trong logic của chương trình, vì vậy bạn phải chạy chương trình để xác định xem nó có hoạt động như mong đợi hay không. Sự hiện diện của bộ kiểm tra tự động giúp bạn có nhiều khả năng phát hiện và sửa các lỗi lập trình viên khác nhau, đặc biệt là lỗi logic. Chúng cũng hữu ích trong việc xác định cách một hàm xử lý các giá trị không điển hình. Sử dụng khung kiểm tra, chẳng hạn như Jest hoặc Mocha, là một cách hay để bắt đầu kiểm tra đơn vị Node của bạn. ứng dụng js

Các ngoại lệ chưa được phát hiện và các từ chối lời hứa chưa được xử lý

Các ngoại lệ chưa được xử lý và từ chối lời hứa chưa được xử lý là do lỗi của lập trình viên do không bắt được ngoại lệ bị ném và từ chối lời hứa, tương ứng. Sự kiện

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Tuy nhiên, đây là cách sử dụng sai sự kiện này vì sự hiện diện của một ngoại lệ chưa được phát hiện cho biết ứng dụng đang ở trạng thái không xác định. Do đó, việc cố gắng tiếp tục bình thường mà không khôi phục lỗi được coi là không an toàn và có thể dẫn đến các sự cố khác, chẳng hạn như rò rỉ bộ nhớ và ổ cắm treo. Việc sử dụng hợp lý trình xử lý

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Tương tự, sự kiện

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Bạn phải luôn chạy các máy chủ của mình bằng trình quản lý quy trình sẽ tự động khởi động lại chúng trong trường hợp xảy ra sự cố. Một cái phổ biến là PM2, nhưng bạn cũng có

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Báo cáo lỗi tập trung

Không có chiến lược xử lý lỗi nào hoàn chỉnh nếu không có chiến lược ghi nhật ký mạnh mẽ cho ứng dụng đang chạy của bạn. Khi xảy ra lỗi, điều quan trọng là tìm hiểu lý do tại sao nó xảy ra bằng cách ghi lại càng nhiều thông tin càng tốt về sự cố. Tập trung các nhật ký này giúp bạn dễ dàng có được khả năng hiển thị đầy đủ vào ứng dụng của mình. Bạn sẽ có thể sắp xếp và lọc các lỗi của mình, xem các sự cố hàng đầu và đăng ký nhận thông báo để nhận thông báo về các lỗi mới

Honeybadger cung cấp mọi thứ bạn cần để theo dõi các lỗi xảy ra trong ứng dụng sản xuất của bạn. Thực hiện theo các bước bên dưới để tích hợp nó vào Node của bạn. ứng dụng js

1. Cài đặt gói

Sử dụng

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

2. Nhập thư viện

Nhập thư viện và định cấu hình thư viện bằng khóa API của bạn để bắt đầu báo cáo lỗi

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

3. Báo lỗi

Bạn có thể báo lỗi bằng cách gọi phương thức

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Để biết thêm thông tin về cách Honeybadger tích hợp với Node. js, xem tài liệu đầy đủ hoặc xem Node mẫu. ứng dụng js/Express trên GitHub

Tóm lược

Lớp

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Lỗi vận hành là không thể tránh khỏi và phải được tính đến trong bất kỳ chương trình chính xác nào. Hầu hết thời gian, chiến lược sửa lỗi có thể phục hồi nên được sử dụng để chương trình có thể tiếp tục chạy trơn tru. Tuy nhiên, nếu lỗi đủ nghiêm trọng, có thể thích hợp để chấm dứt chương trình và khởi động lại nó. Cố gắng tắt một cách duyên dáng nếu những tình huống như vậy phát sinh để chương trình có thể khởi động lại ở trạng thái sạch sẽ

Lỗi lập trình viên không thể được xử lý hoặc phục hồi, nhưng chúng có thể được giảm thiểu bằng bộ kiểm tra tự động và công cụ gõ tĩnh. Khi viết một hàm, hãy xác định hành vi cho các tham số xấu và hành động thích hợp sau khi phát hiện. Cho phép chương trình gặp sự cố nếu phát hiện thấy

function (err, result) {}

function square(num) {
  if (typeof num !== 'number') {
    throw new TypeError(`Expected number but got: ${typeof num}`);
  }

  return num * num;
}

try {
  square('8');
} catch (err) {
  console.log(err.message); // Expected number but got: string
}

Sử dụng dịch vụ theo dõi lỗi, chẳng hạn như Honeybadger, để nắm bắt và phân tích lỗi của bạn. Điều này có thể giúp bạn cải thiện đáng kể tốc độ gỡ lỗi và giải quyết

Phần kết luận

Xử lý lỗi thích hợp là một yêu cầu không thể thương lượng nếu bạn đang muốn viết phần mềm tốt và đáng tin cậy. Bằng cách sử dụng các kỹ thuật được mô tả trong bài viết này, bạn sẽ thành công trong việc thực hiện điều đó

Làm cách nào để đưa ra lỗi với mã trong nút js?

Làm cách nào để xử lý lỗi trong nodejs?

Làm cách nào để đưa ra lỗi 500 trong JavaScript?

Làm cách nào để loại bỏ lỗi 404 trong JavaScript?