Node.js הוא זמן ריצה של JavaScript בקוד פתוח המבוסס על מנוע v8 של כרום המאפשר לך להריץ קוד JavaScript מחוץ לדפדפן.

מודל האירועים, המערכת האקולוגית והמהירות שלו הפכו את Node.js לאחד מזמני הריצה המבוקשים והמשומשים ביותר עבור יישומים בצד השרת.

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

שלב 1: הגדרת סביבת הפיתוח שלך

צור ספריית פרויקט ו CD לתוך זה על ידי הפעלת:

mkdir nodejs-api
CD nodejs-api

לאחר מכן, אתחול npm בפרויקט שלך על ידי הפעלת:

npm init -y

API זה של CRUD יכלול שימוש ב- MongoDB, מסד נתונים NoSQL, וב-ODM הפופולרי שלו, נמייה.

הפעל את הפקודה הבאה להתקנה נְמִיָה:

npm להתקין נְמִיָה

לאחר מכן, צור א server.js קובץ בספריית השורש של הפרויקט שלך והוסף את בלוק הקוד למטה כדי ליצור שרת:

const http = לִדרוֹשׁ("http");
const server = http.createServer((req, res) => {});
server.listen (3000, () => {
לְנַחֵם.עֵץ(`השרת פועל`);
});

בלוק קוד זה מייבא את מודול http, מודול ליבה של Node.js. מודול http מאפשר ל-Node.js להעביר נתונים דרך HTTP. מודול זה מכיל את השיטות הנדרשות ליצירת שרת.

instagram viewer

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

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

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

שלב 2: חיבור האפליקציה שלך למסד נתונים

ב server.js, ייבוא נְמִיָה:

const נמיה = לִדרוֹשׁ("נְמִיָה");

תתקשר ל לְחַבֵּר שיטה על נְמִיָה והעבר את ה-URI של MongoDB כטיעון:

mongoose.connect("MongoDB_URI")

שלב 3: יצירת מודל API

צור API של CRUD עבור יישום בלוג פשוט. אצלך דגמים תיקיה, צור א blogModel.js קובץ והוסף את הקוד הבא לקובץ שלך:

const נמיה = לִדרוֹשׁ("נְמִיָה");
const blogSchema = נמייה. סכֵימָה({
 כותרת: {
 סוּג: חוּט,
 נדרש: [נכון, "לבלוג חייבת להיות כותרת"],
 },
 גוף: {
 סוּג: חוּט,
 נדרש: [נכון, "לבלוג חייב להיות גוף"],
 },
});
מודול.יצוא = mongoose.model("בלוג", blogSchema);

בלוק הקוד שלמעלה יוצר מודל נמייה עם שני מאפיינים וממפה אותם למסד נתונים של MongoDB.

לשני המאפיינים במודל זה יש א חוּט הקלד עם נדרש מכוון ל נָכוֹן. הודעות השגיאה הנלוות יוצגו אם גוף הבקשה אינו מכיל אף אחד מהמאפיינים.

השורה האחרונה יוצרת ומייצאת מודל נמייה על ידי קריאה ל- דֶגֶם שיטה על נְמִיָה. תעביר את שם הדגם (בלוג) כארגומנט הראשון וסכימה (blogSchema) כטיעון השני.

שלב 4: הטמעת ניתוב באפליקציה שלך

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

ראשית, צור א blogRoutes.js קובץ שלך מסלולים תיקייה, ולאחר מכן ייבא את מודל הבלוג:

const בלוג = לִדרוֹשׁ("../models/blogModel");

לאחר מכן, צור אסינכרוני נתב לתפקד, לעבור req ו מילואים כפרמטרים, וייצא את הפונקציה:

const נתב = אסינכרוןפוּנקצִיָה (דרישה, מילואים) {};
מודול.יצוא = נתב;

פונקציה זו תכיל את כל היגיון הניתוב שלך.

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

מסלולי GET

הוסף את בלוק הקוד שלהלן לשלך נתב פונקציה ליישם את לקבל מטפל במסלול לבקשות שנשלחו אל /api/blogs:

// קבל: /api/בלוגים
if (req.url "/api/blogs"&& req.method "לקבל") {
// קבל את כל הבלוגים
const בלוגים = לְהַמתִין Blog.find();
// מַעֲרֶכֶת ה סטָטוּס קוד ותוֹכֶן-סוּג
 res.writeHead (200, { "סוג תוכן": "application/json" });
// לשלוח נתונים
מילואים.סוֹף(JSON.stringify(בלוגים));
}

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

לאחר מכן, הוא קורא ל- לכתוב ראש שיטה על מילואים, אובייקט התגובה. שיטה זו שולחת כותרת תגובה בהינתן שלושה ארגומנטים: קוד סטטוס, הודעת מצב אופציונלית וכותרות. ה 200 קוד סטטוס מייצג תגובה מוצלחת וסוג התוכן עבור קריאת ה-API הזו מוגדר ל application/json.

לבסוף, סגור את הבקשה כדי לוודא שהשרת לא נתקע על ידי קריאה ל- סוֹף שיטה על מילואים. הקריאה ל JSON.stringify ממיר את בלוגים מתנגד למחרוזת JSON ומעביר אותה ל- סוֹף השיטה מחזירה אותו כגוף התגובה.

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

// קבל: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.method "לקבל") {
לְנַסוֹת {
// לחלץ מזהה מכתובת האתר
 const id = req.url.split("/")[3];
// קבל בלוג מ-DB
const בלוג = לְהַמתִין Blog.findById (מזהה);
if (בלוג) {
 res.writeHead (200, { "סוג תוכן": "application/json" });
מילואים.סוֹף(JSON.stringify(בלוג));
 } אַחֵר {
לזרוקחָדָשׁשְׁגִיאָה("בלוג לא קיים");
 }
 } לתפוס (שגיאה) {
 res.writeHead (404, { "סוג תוכן": "application/json" });
מילואים.סוֹף(JSON.stringify({ הוֹדָעָה: שגיאה }));
 }
}

קוד זה משתמש ב- התאמה שיטה, שמקבלת ביטוי רגולרי כארגומנט, כדי לבדוק אם כתובת האתר תואמת לפורמט: /api/blogs/.

לאחר מכן, חלץ את תְעוּדַת זֶהוּת רכוש מה כתובת אתר מחרוזת על ידי קריאה שלה לְפַצֵל שיטה. שיטה זו לוקחת דפוס כארגומנט (/), מפצל את המחרוזת על סמך התבנית, ומחזיר מערך. האלמנט השלישי של המערך הזה הוא ה תְעוּדַת זֶהוּת.

לבסוף, אחזר את המסמך עם ההתאמה תְעוּדַת זֶהוּת ממסד הנתונים שלך. אם זה קיים, שלח א קוד תגובה של 200, סגור את הבקשה ושלח את הבלוג שאוחזר. אם זה לא קיים, זרוק שגיאה ושלח אותה כתגובה בבלוק ה-catch.

מסלול POST

הוסף את בלוק הקוד למטה לפונקציית הנתב שלך כדי ליישם את הודעה מטפל במסלול:

// פוסט: /api/blogs/
if (req.url "/api/blogs"&& req.method "הודעה") {
לְנַסוֹת {
 תן גוף = "";
// האזן לאירוע נתונים
 req.on("נתונים", (נתח) => {
 body += chunk.toString();
 });


// תקשיב ל סוֹףמִקרֶה
 req.on("סוֹף", אסינכרון () => {
// צור בלוג
תן בלוג = חָדָשׁ בלוג(JSON.parse (גוף));
// שמור ב-DB
לְהַמתִין blog.save();
 res.writeHead (200, { "סוג תוכן": "application/json" });
מילואים.סוֹף(JSON.stringify(בלוג));
 });
 } לתפוס (שגיאה) {
לְנַחֵם.log (שגיאה);
 }
}

אובייקט הבקשה מיישם את Node.js ReadableStream מִמְשָׁק. זרם זה פולט א נתונים ו סוֹף אירוע שנותן לך גישה לנתונים מגוף הבקשה.

קוד זה מאזין לאירוע הנתונים ומטפל בו על ידי המרתו למחרוזת ושישורו ל- גוּף מִשְׁתַנֶה. בתוך ה סוֹף מטפל באירועים, הוא יוצר א בלוג מופע עם מחרוזת הגוף המנותחת. לאחר מכן הוא שומר את הבלוג החדש, שולח את קוד הסטטוס וכותרת התוכן וסוגר את הבקשה.

מסלול PUT

הוסף את בלוק הקוד למטה לפונקציית הנתב שלך כדי ליישם את לָשִׂים מטפל במסלול:

// PUT: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.method "לָשִׂים") {
לְנַסוֹת {
// לחלץ מזהה מכתובת האתר
 const id = req.url.split("/")[3];
 תן גוף = "";
req.on("נתונים", (נתח) => {
 body += chunk.toString();
 });
 req.on("סוֹף", אסינכרון () => {
 // מצא ו עדכוןמסמך
תן updatedBlog = לְהַמתִין Blog.findByIdAndUpdate (מזהה, JSON.parse (גוף), {
חָדָשׁ: נָכוֹן,
 });
res.writeHead (200, { "סוג תוכן": "application/json" });
מילואים.סוֹף(JSON.stringify(בלוג מעודכן));
 });
 } לתפוס (שגיאה) {
לְנַחֵם.log (שגיאה);
 }
}

המטפל בבקשת PUT כמעט זהה ל- הודעה מטפל בקשות, אלא שהוא מחלץ את תְעוּדַת זֶהוּת רכוש מה כתובת אתר לעדכון הבלוג הרלוונטי.

מחק מסלול

הוסף את בלוק הקוד למטה לפונקציית הנתב שלך כדי ליישם את שלך לִמְחוֹק מטפל במסלול:

// לִמְחוֹק: /api/blogs/:תְעוּדַת זֶהוּת
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.method "לִמְחוֹק") {
לְנַסוֹת {
 const id = req.url.split("/")[3];
// לִמְחוֹק בלוג מ DB
לְהַמתִין Blog.findByIdAndDelete (מזהה);
 res.writeHead (200, { "סוג תוכן": "application/json" });
 res.end (JSON.stringify({ הודעה: "הבלוג נמחק בהצלחה" }));
 } לתפוס (שגיאה) {
 res.writeHead (404, { "סוג תוכן": "application/json" });
מילואים.סוֹף(JSON.stringify({ הוֹדָעָה: שגיאה }));
 }
}

בלוק קוד זה מחלץ את תְעוּדַת זֶהוּת מ ה כתובת אתר, מוחק את המסמך עם ההתאמה תְעוּדַת זֶהוּת, שולח את קוד המצב והכותרות וסוגר את הבקשה.

לבסוף, ייבוא נתב אצלך server.js להגיש ולהתקשר שלך נתב תפקוד, עובר req ו מילואים בתור טיעונים:

const נתב = לִדרוֹשׁ(./routes/blogRoutes");
const server = http.createServer((req, res) => {
 נתב (req, res);
});

זה מאפשר לשרת שלך ליירט ולטפל בבקשות כראוי.

אתה יכול למצוא את הפרויקט שהושלם בזה מאגר GitHub.

שימוש במסגרת Node.js

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

במהלך השנים, מפתחים בנו מסגרות כמו ExpressJS, NestJS, Fastify וכו', כדי להקל בהרבה.