מדריך לטיפול בחריגים באקספרס

מבוא

חריגים ושגיאות צפויים להתרחש בזמן שמשתמשים מקיימים אינטראקציה עם כל אפליקציה, מהנדסי התוכנה הם אלה שיבחרו אמצעי לטפל בכל שגיאה שעלולה להתעורר - ביודעין או שלא ביודעין. כתוצאה מכך, מפתחי backend שבונים ממשקי API עם Express מוצאים את עצמם עובדים כדי להבטיח שהם בונים API שימושי, יעיל ושמיש. מה שהכי חשוב הוא לטפל בשגיאות בצורה כזו שתבנה מערכת חזקה מכיוון שזה עוזר להפחית את זמן הפיתוח, שגיאות מוחלטות, בעיות פרודוקטיביות וקובע את ההצלחה או המדרגיות של פיתוח תוכנה.

האם עליך לרשום את הודעת השגיאה, לדכא את השגיאה, להודיע ​​למשתמשים על השגיאה או לכתוב קוד כדי לטפל בשגיאות? לא תוהה יותר.

במדריך זה, נלמד כיצד לבנות בסיס קוד חזק לטיפול בשגיאות עבור יישומי אקספרס, שיסייע באיתור שגיאות יישומים ונקיטת פעולות אופטימליות כדי לשחזר כל יישום מכשל בחן במהלך זמן הריצה.

מהו טיפול בשגיאות?

בפיתוח תוכנה, ישנם שני סוגים שונים של חריגים: מבצעי ו פרוגרמטית.

• כשלים תפעוליים עלולים להופיע במהלך זמן הריצה, ועל מנת למנוע מהאפליקציה להיסגר באופן פתאומי, עלינו לטפל בחריגים אלה בחן באמצעות שיטות טיפול יעילות בשגיאות.
• חריגים פרוגרמטיים נזרקים ידנית על ידי מתכנת, כאשר מתעורר מצב חריג.

אתה יכול לחשוב על חריגים תפעוליים כעל חריגים "בלתי צפויים, אך צפויים" (כגון גישה לאינדקס מחוץ לתחום), ועל חריגים פרוגרמטיים כעל חריגים "צפויים וצפויים" (כגון חריג עיצוב מספר).

טיפול בחריגים הוא ההליך המשמש לאיתור ותיקון פגמים בתוך תוכנית. טיפול בשגיאות שולח הודעות הכוללות את סוג השגיאה שהתרחשה ואת המחסנית שבה קרתה השגיאה.

ב-Express, טיפול בחריגים מתייחס לאופן שבו Express מגדיר את עצמו לתפוס ולעבד חריגים סינכרוניים וא-סינכרוניים. הדבר הטוב בטיפול בחריגים ב-Express הוא שכמפתח, אינך צריך לכתוב מטפלי חריגים משלך; Express מגיע עם מטפל חריגים המוגדר כברירת מחדל. המטפל בחריגים מסייע בזיהוי שגיאות ובדיווח עליהן למשתמש. הוא גם מספק אסטרטגיות מתקנות שונות ומיישם אותן כדי לצמצם חריגים.

למרות שאלו עשויים להיראות כמו הרבה דברים שעוברים מתחת למכסה המנוע, הטיפול בחריגים ב-Express אינו מאט את התהליך הכולל של תוכנית או משהה את הביצוע שלה.

הבנת טיפול בחריגים ב-Express

עם מטפל השגיאות המוגדר כברירת מחדל שמגיע עם Express, יש לנו בידינו קבוצה של פונקציות תווך שעוזרות לתפוס שגיאות במטפלי מסלול באופן אוטומטי. בקרוב, ניצור פרויקט ליישם תיאוריה כיצד להחזיר שגיאות מתאימות באפליקציית Express וכיצד לא להדליף מידע רגיש.

הגדרת פונקציית תווך ב-Express

פונקציות התווך לטיפול בשגיאות מוגדרות בצורה כזו שהן מקבלות Error אובייקט כפרמטר הקלט הראשון, ואחריו פרמטרי ברירת המחדל של כל פונקציית תווך אחרת: request, response, ו next. ה next() הפונקציה מדלגת על כל תוכנת האמצע הנוכחית למטפל השגיאות הבא עבור הנתב.

הגדרת טיפול בשגיאות ב-Express

הפעל את הפקודה הבאה בטרמינל שלך כדי ליצור אפליקציית Node ו-Express:

$ mkdir error-handling-express

בתיקייה החדשה שנוצרה, בואו נאתחל פרויקט Node חדש:

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

זה יוצר א package.json קובץ בתיקייה שלנו.

כדי ליצור שרת אקספרס באפליקציית ה-Node שלנו, עלינו להתקין את express חבילה, dotenv לטעינה אוטומטית של משתני סביבה לתוך .env קובץ לתוך process.env אובייקט, וכן nodemon להפעלה מחדש של אפליקציית הצומת אם צוין שינוי בקובץ בספריה.

$ npm install express dotenv nodemon

לאחר מכן, צור app.js קובץ בתיקיית הפרויקט שתשמש כקובץ האינדקס של האפליקציה.

כעת, לאחר שהתקנו את כל התלות הנדרשת עבור אפליקציית Express שלנו, עלינו להגדיר את הסקריפט לקריאת האפליקציה ב- package.json קוֹבֶץ. כדי להשיג זאת, ה package.json קובץ, כך שה scripts האובייקט הוא כמו שמוצג להלן:

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

לחלופין, אתה יכול לדלג על השימוש nodemon, ולהשתמש node app.js במקום.

הקמת שרת אקספרס

כדי להגדיר את השרת, עלינו לייבא תחילה את החבילות השונות אל app.js. ניצור גם א .env קובץ בספריית הפרויקט - לאחסון כל משתני הסביבה עבור היישום:

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

PORT=4000 

הגדרנו את מספר היציאה עבור האפליקציה ב .env, אשר נטען ונקרא על ידי dotenv, וניתן לגשת אליהם מאוחר יותר.

אתחול שרת האקספרס

כעת, עלינו לאתחל את שרת האקספרס ולגרום לאפליקציה שלנו להאזין למספר יציאת האפליקציה, יחד עם בקשה למסלול בדיקה - /test. בואו נעדכן app.js, מתחת להצהרות הייבוא:

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}`);
});

מכאן ואילך נלמד כיצד לטפל במקרים שונים של שימוש בטעויות תפעוליות שניתן להיתקל בהן, באקספרס.

טיפול בשגיאות לא נמצא ב-Express

נניח שאתה צריך להביא את כל המשתמשים ממסד נתונים של משתמשים, אתה יכול לטפל ביעילות בתרחיש שגיאה פוטנציאלי שבו לא קיימים נתונים במסד הנתונים, על ידי גלישת ההיגיון לתוך try/catch בלוק - בתקווה לתפוס כל שגיאה שעלולה להקרין ב- catch בלוק:

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
	});
});

זו התוצאה:

User not found

כעת, כאשר הבקשה הזו מתבצעת (תוכל לבדוק באמצעות Postman) ואין משתמש במסד הנתונים, הלקוח מקבל הודעת שגיאה האומרת "User not found". כמו כן, תבחין שהשגיאה נרשמה גם בקונסולה.

אופטימיזציה של טיפול בשגיאות עם תוכנת אמצעית למטפל בשגיאות

נוכל לייעל את הפיתוח על ידי יצירת תוכנת תווך למטפל שגיאות שתגיע בסוף כל המסלולים המוגדרים, כך שאם נזרקת שגיאה באחד המסלולים, Express יבדוק אוטומטית את התווך הבא ותמשיך לרדת ברשימה עד שהוא מגיע למטפל השגיאות. מטפל השגיאות יעבד את השגיאה וגם ישלח חזרה תגובה ללקוח.

כדי להתחיל, צור תיקיה בשם middleware בספריית הפרויקט, ובתיקיה זו, צור קובץ בשם errorHandler.js שמגדיר את מטפל השגיאות:

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

בפונקציית תוכנת התווך שלנו, הכרנו את Express לכך שזו אינה פונקציית תוכנה בסיסית, אלא מטפל בשגיאות, על ידי הוספת error פרמטר לפני 3 הפרמטרים הבסיסיים.

כעת, נשתמש במטפל השגיאות בהדגמה שלנו app.js ולטפל בשגיאה הראשונית של שליפת משתמשים עם תוכנת התווך של מטפל השגיאות, כמו שמוצג להלן:

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);

אנחנו יכולים לייעל את הקוד שלנו אפילו יותר, על ידי יצירת אבסטרקציה סביב ה try/catch הִגָיוֹן. נוכל להשיג זאת על ידי יצירת תיקיה חדשה בספריית הפרויקט שנקראת utils, ובו, צור קובץ בשם tryCatch.js.

כדי להפשט את try-catch לוגיקה - אנו יכולים להגדיר פונקציה שמקבלת פונקציה אחרת (הידועה בשם בקר) כפרמטר שלו, ומחזיר את an async פונקציה שתחזיק א try/catch עבור כל בקר שהתקבל.

אם מתרחשת שגיאה בבקר, היא נתפסת ב- catch בלוק והפונקציה הבאה נקראת:

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

עם try/catch בהפשטה, נוכל לשנות את הקוד שלנו כדי להפוך אותו לתמצית יותר על ידי דילוג על try-catch סעיף מפורש בעת שליפת משתמשים ב- 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);
	})
);

הפשטנו בהצלחה את ההיגיון של ה-Try-catch והקוד שלנו עדיין עובד כפי שעבד בעבר.

טיפול בשגיאות אימות ב-Express

עבור הדגמה זו, ניצור מסלול חדש באפליקציית האקספרס שלנו לכניסה - כדי לאמת מזהה משתמש בעת הכניסה. ראשית, נתקין את joi חבילה, כדי לעזור ביצירת סכימה, שבאמצעותה נוכל לאכוף דרישות:

$ npm i joi

לאחר מכן, צור סכימה שהיא א Joi.object עם userId שחייב להיות מספר ונדרש - כלומר הבקשה חייבת להתאים לאובייקט עם מזהה משתמש עליו.

אנו יכולים להשתמש ב- validate() שיטה באובייקט הסכימה כדי לאמת כל קלט מול הסכימה:

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

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

אם חפץ ריק מועבר לתוך validate() שיטה, השגיאה תטופל בחן, והודעת השגיאה תישלח ללקוח:

בקונסולה, אנו מקבלים גם גישה ל-a details מערך הכולל פרטים שונים על השגיאה שניתן להעביר למשתמש במידת הצורך.

כדי לטפל באופן ספציפי בשגיאות אימות באופן שיעביר את פרטי השגיאה המתאים לכל שגיאת אימות, ניתן לשנות את התווך של מטפל השגיאות:

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;

עם errorHandler.js כעת מותאם אישית, כאשר אנו מבצעים את אותה בקשה עם אובייקט ריק המועבר ל- validate() שיטה:

כעת יש לנו גישה לאובייקט מותאם אישית שמחזיר הודעות בצורה קריאה/ידידותית יותר. בדרך זו, אנו מסוגלים לשלוח ולטפל בסוגים שונים של שגיאות בהתבסס על סוג השגיאה הנכנסת.

סיכום

במדריך זה, עברנו על כל היבט של טיפול בשגיאות של Express.js, כולל אופן הטיפול בקוד סינכרוני וא-סינכרוני כברירת מחדל, כיצד ליצור מחלקות שגיאה משלך, כיצד לכתוב פונקציות מותאמות אישית לטיפול בשגיאות ולספק next בתור המטפל הסופי בתפיסה

כמו בכל משימה בחוץ, יש גם שיטות עבודה מומלצות במהלך הפיתוח הכוללות טיפול יעיל בשגיאות, והיום למדנו איך אנחנו יכולים לטפל בשגיאות באפליקציית Express בצורה חזקה.

טיפול נכון בשגיאות פירושו לא רק להפחית את זמן הפיתוח על ידי איתור באגים ושגיאות בקלות, אלא גם פיתוח בסיס קוד חזק עבור יישומים בקנה מידה גדול. במדריך זה, ראינו כיצד להגדיר תוכנת ביניים לטיפול בשגיאות תפעול. כמה דרכים אחרות לשיפור הטיפול בשגיאות כוללות: אי שליחת עקבות מחסנית, עצירת תהליכים בחן כדי לטפל בחריגים שלא נתפסו, אספקת הודעות שגיאה מתאימות, שליחת יומני שגיאה והגדרת מחלקה שמרחיבה את Error מעמד.

אני מקווה שהדוגמאות שהשתמשתי בהן במדריך זה היו מהנות עבורך. כיסיתי תרחישים שונים שאתה עלול להיתקל בהם בעת כתיבת יישום Express לשימוש בעולם האמיתי על ניהול שגיאות. בבקשה, ספר לי אם יש משהו שפספסתי. זה יועיל לנו ויעזור לי ללמוד יותר. יום טוב ותודה שקראתם.

אתה יכול לעיין בכל קוד המקור המשמש במאמר על GitHub.

משאבים נוספים