Ghid pentru gestionarea excepțiilor în Express

Introducere

Excepțiile și erorile sunt obligate să apară în timp ce utilizatorii interacționează cu orice aplicație, este la latitudinea inginerilor de software să aleagă un mijloc de a gestiona orice eroare care ar putea apărea - cu bună știință sau fără să știe. Drept urmare, dezvoltatorii backend care creează API-uri cu Express se trezesc să lucreze pentru a se asigura că construiesc un API util, eficient și utilizabil. Ceea ce este de cea mai mare importanță este să gestionați erorile astfel încât să construiți un sistem robust, deoarece acest lucru ajută la reducerea timpului de dezvoltare, erorile directe, problemele de productivitate și determină succesul sau scalabilitatea dezvoltării software.

Trebuie să înregistrați mesajul de eroare, să suprimați eroarea, să notificați utilizatorii despre eroare sau să scrieți cod pentru a gestiona erorile? Nu te mai mira.

În acest ghid, vom învăța cum să construim o bază de cod robustă de gestionare a erorilor pentru aplicațiile Express, care va ajuta la detectarea erorilor aplicației și la acțiunile optime pentru a recupera orice aplicație de la eșuarea grațioasă în timpul rulării.

Ce este gestionarea erorilor?

În dezvoltarea de software, există două tipuri diferite de excepții: operațional și programatic.

• Eșecuri operaționale pot apărea în timpul rulării și pentru a preveni terminarea bruscă a aplicației, trebuie să gestionăm cu grație aceste excepții prin metode eficiente de gestionare a erorilor.
• Excepțiile programatice sunt aruncate manual de un programator, atunci când apare o stare excepțională.

Puteți considera excepțiile operaționale drept excepții „neașteptate, dar prevăzute” (cum ar fi accesarea unui index în afara limitelor), iar excepțiile programatice ca excepții „așteptate și prevăzute” (cum ar fi o excepție de formatare a numărului).

Gestionarea excepțiilor este procedura utilizată pentru a găsi și remedia defecte în cadrul unui program. Gestionarea erorilor trimite mesaje care includ tipul de eroare care a avut loc și stiva în care s-a produs eroarea.

În Express, gestionarea excepțiilor se referă la modul în care Express se pregătește să capteze și să proceseze excepțiile sincrone și asincrone. Lucrul bun despre gestionarea excepțiilor în Express este că, în calitate de dezvoltator, nu trebuie să vă scrieți propriile gestionări de excepții; Express vine cu un handler implicit de excepții. Managerul de excepții ajută la identificarea erorilor și la raportarea acestora către utilizator. De asemenea, oferă diverse strategii de remediere și le implementează pentru a atenua excepțiile.

În timp ce acestea pot părea o mulțime de lucruri care trec sub capotă, gestionarea excepțiilor în Express nu încetinește procesul general al unui program și nici nu întrerupe execuția acestuia.

Înțelegerea gestionării excepțiilor în Express

Cu gestionarea implicită a erorilor care vine cu Express, avem în mâinile noastre un set de funcții middleware care ajută la identificarea automată a erorilor în gestionatorii de rute. În curând, vom crea un proiect pentru a pune în practică teoria despre cum să returnăm erorile corecte într-o aplicație Express și cum să nu scurgem informații sensibile.

Definirea funcției middleware în Express

Funcțiile middleware de tratare a erorilor sunt definite astfel încât să accepte un Error obiect ca prim parametru de intrare, urmat de parametrii impliciti ai oricărei alte funcții middleware: request, response, și next. next() funcția trece peste tot middleware-ul curent la următorul handler de erori pentru router.

Configurarea gestionării erorilor în Express

Rulați următoarea comandă în terminal pentru a crea o aplicație Node și Express:

$ mkdir error-handling-express

În folderul nou creat, să inițializam un nou proiect Node:

$ cd error-handling-express && npm init -y

Aceasta creează un package.json fișier în folderul nostru.

Pentru a crea un server Express în aplicația noastră Node, trebuie să instalăm express pachet, dotenv pentru încărcarea automată a variabilelor de mediu în .env fișier în process.env obiect, și nodemon pentru repornirea aplicației nod dacă o modificare a fișierului este notă în director.

$ npm install express dotenv nodemon

Apoi, creați un app.js fișier în folderul de proiect care va servi drept fișier index pentru aplicație.

Acum că am instalat toate dependențele necesare pentru aplicația noastră Express, trebuie să setăm scriptul pentru citirea aplicației în package.json fişier. Pentru a realiza asta, package.json fișier, astfel încât scripts obiectul este așa cum se arată mai jos:

"scripts": {
    "start": "nodemon app.js"
},

Alternativ, puteți sări peste utilizare nodemon, si foloseste node app.js in schimb.

Configurarea unui server Express

Pentru a configura serverul, trebuie mai întâi să importam diferitele pachete în app.js. Vom crea, de asemenea, un .env fișier în directorul proiectului – pentru a stoca toate variabilele de mediu pentru aplicație:

const express = require('express')
require('dotenv').config

PORT=4000 

Am definit numărul portului pentru aplicație în .env, care este încărcat și citit de dotenv, și poate fi accesat ulterior.

Inițializarea Express Server

Acum, trebuie să inițializam serverul Express și să facem aplicația noastră să asculte numărul portului aplicației, împreună cu o solicitare către o rută de testare - /test. Să actualizăm app.js, sub declarațiile de import:

const app = express();
const port = process.env.PORT || 4000;

app.get("/test", async (req, res) => {
    return res.status(200).json({ success: true });
});

app.listen(port, () => {
    console.log(`Server is running at port ${port}`);
});

De aici încolo, vom învăța cum să gestionăm diverse cazuri de utilizare ale erorilor operaționale care pot fi întâlnite, în Express.

Gestionarea erorilor negăsit în Express

Să presupunem că trebuie să preluați toți utilizatorii dintr-o bază de date de utilizatori, puteți gestiona eficient un scenariu potențial de eroare în care nu există date în baza de date, prin împachetarea logicii într-un try/catch bloc – în speranța de a detecta orice eroare care s-ar putea proiecta în catch bloc:

const getUser = () => undefined;

app.get("/get-user", async (req, res) => {
	try {
		const user = getUser();
		if (!user) {
			throw new Error('User not found');
		}
	} catch (error) {
	    
		console.log(error); 
		
		res.status(400).send(error.message) 
	}
	return res.status(200).json({
		success: true
	});
});

Rezultă:

User not found

Acum, când se face această solicitare (puteți testa folosind Postman) și nu există niciun utilizator în baza de date, clientul primește un mesaj de eroare care spune „Utilizatorul nu a fost găsit”. De asemenea, veți observa că eroarea este înregistrată și în consolă.

Optimizarea gestionării erorilor cu middleware pentru gestionarea erorilor

Putem optimiza dezvoltarea prin crearea unui middleware de gestionare a erorilor care ar veni la sfârșitul tuturor rutelor definite, astfel încât, dacă o eroare este aruncată pe una dintre rute, Express va arunca automat o privire la următorul middleware și va continua să coboare pe listă. până ajunge la manipulatorul de erori. Managerul de erori va procesa eroarea și, de asemenea, va trimite înapoi un răspuns clientului.

Pentru a începe, creați un folder numit middleware în directorul proiectului și în acest folder, creați un fișier numit errorHandler.js care definește gestionarea erorilor:

const errorHandler = (error, req, res, next) => {
    
    console.log(error); 
    
    res.status(400).send(error.message); 
}
module.exports = errorHandler;

În funcția noastră de middleware, am făcut Express conștient că aceasta nu este o funcție de bază de middleware, ci un handler de erori, adăugând error parametrul înaintea celor 3 parametri de bază.

Acum, vom folosi gestionarea erorilor din demonstrația noastră app.js și gestionați eroarea inițială de preluare a utilizatorilor cu middleware-ul de gestionare a erorilor, așa cum se arată mai jos:

const getUser = () => undefined;

app.get("/get-user", async (req, res, next) => {
	try {
		const user = getUser();
		if (!user) {
			throw new Error("User not found");
		}
	} catch (error) {
		return next(error);
	}
});

app.use(errorHandler);

Ne putem optimiza codul și mai mult, creând o retragere în jurul try/catch logică. Putem realiza acest lucru prin crearea unui nou folder în directorul de proiect numit utils, și în el, creați un fișier numit tryCatch.js.

Pentru a abstractiza try-catch logică – putem defini o funcție care acceptă o altă funcție (cunoscută sub numele de controlor) ca parametru și returnează un async funcție care va deține a try/catch pentru orice controlor primit.

Dacă apare o eroare în controler, aceasta este prinsă în catch bloc și următoarea funcție se numește:

const tryCatch = (controller) => async (req, res, next) => {
	try {
		await controller(req, res);
	} catch (error) {
		return next(error);
	}
};
module.exports = tryCatch;

Cu try/catch abstractizare, ne putem refactoriza codul pentru a-l face mai succint, omitând try-catch clauza în mod explicit atunci când preia utilizatorii în app.js:

const getUser = () => undefined;

app.get(
	"/get-user",
	tryCatch(async (req, res) => {
		const user = getUser();
		if (!user) {
			throw new Error("User not found");
		}
		res.status(400).send(error.message);
	})
);

Am abstras cu succes logica try-catch și codul nostru încă funcționează ca înainte.

Gestionarea erorilor de validare în Express

Pentru această demonstrație, vom crea o rută nouă în aplicația noastră Express pentru autentificare – pentru a valida un ID de utilizator la conectare. Mai întâi, vom instala joi pachet, pentru a ajuta la crearea unei scheme, cu care putem aplica cerințele:

$ npm i joi

Apoi, creați o schemă care este a Joi.object cu userId care trebuie să fie un număr și este obligatoriu – ceea ce înseamnă că cererea trebuie să corespundă unui obiect cu un ID de utilizator pe acesta.

Putem folosi validate() metoda din obiectul schema pentru a valida fiecare intrare în raport cu schema:

const schema = Joi.object({
	userId: Joi.number().required(),
});

app.post(
	"/login",
	tryCatch(async (req, res) => {
		const {error, value} = schema.validate({});
		if (error) throw error;
	})
);

Dacă un obiect gol este trecut în validate() metoda, eroarea va fi tratată cu grație, iar mesajul de eroare va fi trimis clientului:

Pe consolă, avem și acces la a details matrice care include diverse detalii despre eroare care ar putea fi comunicate utilizatorului dacă este necesar.

Pentru a gestiona în mod specific erorile de validare în așa fel încât să treacă detaliile de eroare adecvate pentru fiecare eroare de validare, middleware-ul de gestionare a erorilor poate fi refactorizat:

const errorHandler = (error, req, res, next) => {
	console.log(error); 

	if (error.name === "ValidationError") {
		return res.status(400).send({
			type: "ValidationError",
			details: error.details,
		});
	}

	res.status(400).send(error.message); 
};

module.exports = errorHandler;

cu errorHandler.js acum personalizat, când facem aceeași cerere cu un obiect gol trecut la validate() metodă:

Acum avem acces la un obiect personalizat care returnează mesajele într-un mod mai lizibil/prietenos. În acest fel, suntem capabili să trimitem și să gestionăm diferite tipuri de erori în funcție de tipul de eroare care vine.

Concluzie

În acest ghid, am analizat fiecare aspect al gestionării erorilor Express.js, inclusiv modul în care codul sincron și asincron este gestionat în mod implicit, cum să vă creați propriile clase de eroare, cum să scrieți funcții de middleware personalizate de tratare a erorilor și să furnizați next în calitate de manipulator final al capturii

Ca în cazul tuturor sarcinilor existente, există și cele mai bune practici în timpul dezvoltării, care includ gestionarea eficientă a erorilor, iar astăzi am învățat cum putem gestiona erorile într-o aplicație Express într-un mod robust.

Gestionarea corectă a erorilor nu înseamnă doar reducerea timpului de dezvoltare prin găsirea cu ușurință a erorilor și erorilor, ci și dezvoltarea unei baze de cod robuste pentru aplicații la scară largă. În acest ghid, am văzut cum să configurați middleware pentru gestionarea erorilor operaționale. Alte modalități de a îmbunătăți gestionarea erorilor includ: netrimiterea de urme de stivă, oprirea proceselor cu grație pentru a gestiona excepțiile neprinse, furnizarea de mesaje de eroare adecvate, trimiterea de jurnale de eroare și configurarea unei clase care extinde Error clasă.

Sper că exemplele pe care le-am folosit în acest tutorial v-au fost plăcute. Am acoperit diverse scenarii pe care le-ați putea întâlni atunci când scrieți o aplicație Express pentru utilizare în lumea reală despre gestionarea erorilor. Vă rog, spuneți-mi dacă am omis ceva. Ne va ajuta și mă va ajuta să învăț mai multe. O zi buna si multumesc pentru lectura.

Puteți consulta tot codul sursă folosit în articolul despre Github.

Resurse suplimentare