Node.js är en JavaScript-runtime med öppen källkod byggd på chromes v8-motor som låter dig köra JavaScript-kod utanför en webbläsare.
Dess händelsemodell, ekosystem och hastighet har gjort Node.js till en av de mest eftertraktade och använda körtiderna för applikationer på serversidan.
De flesta Node.js API-servrar använder Express eller annat ramverk. Du kan dock också skapa ett enkelt Node.js API utan ramverk med bara några få steg.
Steg 1: Konfigurera din utvecklingsmiljö
Skapa en projektkatalog och CD in i det genom att köra:
mkdir nodejs-api
CD nodejs-api
Initiera sedan npm i ditt projekt genom att köra:
npm init -y
Detta CRUD API kommer att innehålla användningen av MongoDB, en NoSQL-databas, och dess populära ODM, mongoose.
Kör följande kommando för att installera mungo:
npm Installera mungo
Skapa sedan en server.js fil i ditt projekts rotkatalog och lägg till kodblocket nedan för att skapa en server:
konst http = behöva("http");
konst server = http.createServer((req, res) => {});
server.listen (3000, () => {
trösta.logga(`Server körs`);
});
Detta kodblock importerar http-modulen, en kärnmodul för Node.js. http-modulen tillåter Node.js att överföra data över HTTP. Denna modul innehåller de metoder som krävs för att skapa en server.
Därefter anropar den http-modulen skapaServer metod som skapar och returnerar en instans av en server. De skapaServer metoden tar en återuppringningsfunktion med ett förfrågnings- och svarsobjekt som parametrar.
Därefter anropar koden lyssna metod på den returnerade serverinstansen. Detta gör att servern kan börja lyssna efter trafik på den givna porten. De lyssna metoden avfyrar ett callback – det andra argumentet – när det lyckas.
Slutligen, skapa två namngivna kataloger rutter och modeller i ditt projekts rotkatalog. De rutter mappen kommer att innehålla routningslogiken för ditt API, medan modell kommer att innehålla allt relaterat till databasen.
Steg 2: Anslut din applikation till en databas
I server.js, importera mungo:
konst mangust = behöva("mungo");
Ring ansluta metod på mungo och skicka din MongoDB URI som ett argument:
mongoose.connect("MongoDB_URI")
Steg 3: Skapa en API-modell
Skapa ett CRUD API för en enkel bloggapplikation. I din modeller mapp, skapa en blogModel.js fil och lägg till följande kod till din fil:
konst mangust = behöva("mungo");
konst blogSchema = mangust. Schema({
titel: {
typ: Sträng,
krävs: [sant, "Bloggen måste ha en titel"],
},
body: {
typ: Sträng,
krävs: [sant, "Bloggen måste ha en kropp"],
},
});
modul.export = mongoose.model("Blogg", blogSchema);
Kodblocket ovan skapar en mongoosemodell med två egenskaper och mappar dem till en MongoDB-databas.
Båda fastigheterna i denna modell har en Sträng typ med nödvändig satt till Sann. De medföljande felmeddelandena kommer att visas om en begäran inte innehåller någon av egenskaperna.
Den sista raden skapar och exporterar en mangustmodell genom att anropa modell metod på mungo. Skicka modellnamnet (Blogg) som det första argumentet och ett schema (blogSchema) som det andra argumentet.
Steg 4: Implementera routing i din applikation
Utan hjälp av ramar som Expressmåste du manuellt skapa logiken för att hantera varje begäran som görs till ditt API.
Skapa först en blogRoutes.js fil i din rutter mapp, importera sedan bloggmodellen:
konst Blogg = behöva("../models/blogModel");
Skapa sedan en asynkron router funktion, pass req och res som parametrar och exportera funktionen:
konst router = asynkronfungera (req, res) {};
modul.export = router;
Denna funktion kommer att innehålla all din routinglogik.
Därefter ska du implementera routinglogiken rutt för rutt.
GET rutter
Lägg till kodblocket nedan till din router funktion för att implementera SKAFFA SIG rutthanterare för förfrågningar till /api/blogs:
// HÄMTA: /api/bloggar
if (req.url "/api/blogs"&& req.metod "SKAFFA SIG") {
// få alla bloggar
konst bloggar = vänta Blog.find();// uppsättning de status koda ochinnehåll-typ
res.writeHead (200, { "Innehållstyp": "applikation/json" });
// skicka data
res.slutet(JSON.stringify(bloggar));
}
Kodblocket ovan kontrollerar url och metod egenskaperna för förfrågningsobjektet. Den hämtar sedan alla bloggar från databasen via hitta metod på mongoose modellen (Blogg).
Därefter kallar den skrivhuvud metod på res, svarsobjektet. Denna metod skickar ett svarshuvud med tre argument: en statuskod, ett valfritt statusmeddelande och rubriker. De 200 statuskoden representerar ett lyckat svar och innehållstypen för detta API-anrop är inställd på applikation/json.
Slutligen, stäng begäran för att säkerställa att servern inte hänger sig genom att anropa slutet metod på res. Uppmaningen till JSON.stringify konverterar bloggar invända mot en JSON-sträng och skicka den till slutet metoden returnerar den som svarskroppen.
Lägg till kodblocket nedan till din router funktion för att implementera SKAFFA SIG rutthanterare för en enskild resurs:
// HÄMTA: /api/bloggar/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.metod "SKAFFA SIG") {
Prova {
// extrahera id från url
const id = req.url.split("/")[3];// få blogg från DB
konst blogg = vänta Blog.findById (id);
if (blogg) {
res.writeHead (200, { "Innehållstyp": "applikation/json" });
res.slutet(JSON.stringify(blogg));
} annan {
kastanyFel("Blogg finns inte");
}
} fånga (fel) {
res.writeHead (404, { "Innehållstyp": "applikation/json" });
res.slutet(JSON.stringify({ meddelande: fel }));
}
}
Denna kod använder match metod, som tar in ett regexuttryck som ett argument, för att kontrollera om webbadressen matchar formatet: /api/blogs/.
Extrahera sedan id egendom från url sträng genom att anropa dess dela metod. Denna metod tar ett mönster som ett argument (/), delar upp strängen baserat på mönstret och returnerar en array. Det tredje elementet i den arrayen är id.
Till sist hämtar du dokumentet med matchningen id från din databas. Om det finns, skicka ett svarskod på 200, stäng begäran och skicka den hämtade bloggen. Om det inte finns, skicka ett felmeddelande och skicka det som ett svar i catch-blocket.
POST-rutt
Lägg till kodblocket nedan till din routerfunktion för att implementera POSTA rutthanterare:
// POST: /api/bloggar/
if (req.url "/api/blogs"&& req.metod "POSTA") {
Prova {
låt kroppen = "";// Lyssna efter datahändelse
req.on("data", (bit) => {
body += chunk.toString();
});// Lyssna efter slutethändelse
req.on("slutet", asynkron () => {
// Skapa blogg
låta blogg = ny Blogg(JSON.parse (kropp));
// Spara till DB
vänta blog.save();
res.writeHead (200, { "Innehållstyp": "applikation/json" });
res.slutet(JSON.stringify(blogg));
});
} fånga (fel) {
trösta.log (fel);
}
}
Förfrågningsobjektet implementerar Node.js ReadableStream gränssnitt. Denna ström avger en data och en slutet händelse som ger dig åtkomst till data från begäranden.
Denna kod lyssnar efter datahändelsen och hanterar den genom att konvertera den till en sträng och sammanfoga den till kropp variabel. I den slutet händelsehanterare skapar den en Blogg instans med den analyserade kroppssträngen. Den sparar sedan den nya bloggen, skickar statuskoden och innehållshuvudet och stänger begäran.
PUT rutt
Lägg till kodblocket nedan till din routerfunktion för att implementera SÄTTA rutthanterare:
// PUT: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.metod "SÄTTA") {
Prova {
// extrahera id från url
const id = req.url.split("/")[3];
låt kroppen = "";req.on("data", (bit) => {
body += chunk.toString();
});
req.on("slutet", asynkron () => {
// Hitta och uppdateringdokumentera
låta uppdateradBlogg = vänta Blog.findByIdAndUpdate (id, JSON.parse (kropp), {
ny: Sann,
});
res.writeHead (200, { "Innehållstyp": "applikation/json" });
res.slutet(JSON.stringify(uppdaterad Blogg));
});
} fånga (fel) {
trösta.log (fel);
}
}
PUT-begäranshanteraren är nästan identisk med POSTA begäranhanterare, förutom att den extraherar id egendom från url för att uppdatera relevant blogg.
RADERA rutt
Lägg till kodblocket nedan till din routerfunktion för att implementera din RADERA rutthanterare:
// RADERA: /api/bloggar/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.metod "RADERA") {
Prova {
const id = req.url.split("/")[3];
// Radera blogg från DB
vänta Blog.findByIdAndDelete (id);
res.writeHead (200, { "Innehållstyp": "applikation/json" });
res.end (JSON.stringify({ meddelande: "Bloggen har raderats" }));
} fånga (fel) {
res.writeHead (404, { "Innehållstyp": "applikation/json" });
res.slutet(JSON.stringify({ meddelande: fel }));
}
}
Detta kodblock extraherar id från url, tar bort dokumentet med matchningen id, skickar statuskoden och rubrikerna och stänger begäran.
Till sist, importera router i ditt server.js fil och ring din router funktion, förbigående req och res som argument:
konst router = behöva("./routes/blogRoutes");
konst server = http.createServer((req, res) => {
router (req, res);
});
Detta gör att din server kan fånga upp och hantera förfrågningar på lämpligt sätt.
Du hittar det avslutade projektet i denna GitHub-förråd.
Använda ett Node.js Framework
Även om det är möjligt att skapa ett webb-API för hand, kan det vara en svår uppgift. Du måste se till att du har täckt många kantfall och att din kod borde vara buggfri.
Genom åren har utvecklare byggt ramverk som ExpressJS, NestJS, Fastify, etc., för att göra det mycket enklare.
