Home-theater-designers
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.
MAKEUSE AV DAGENS VIDEO
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 :
hemknappen fungerar inte iphone 7
npm install mongoose
Skapa sedan en server.js fil i ditt projekts rotkatalog och lägg till kodblocket nedan för att skapa en server:
const http = require("http");
const server = http.createServer((req, res) => {});
server.listen(3000, () => {
console.log(`Server is running`);
});
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 :
const mongoose = require("mongoose");
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:
const mongoose = require("mongoose");
const blogSchema = mongoose.Schema({
title: {
type: String,
required: [true, "Blog must have a title"],
},
body: {
type: String,
required: [true, "Blog must have a body"],
},
});
module.exports = mongoose.model("Blog", 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 ( bloggschema ) som det andra argumentet.
Steg 4: Implementera routing i din applikation
Utan hjälp av ramar som Express må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:
const Blog = require("../models/blogModel");
Skapa sedan en asynkron router funktion, pass req och res som parametrar och exportera funktionen:
const router = async function (req, res) {};
module.exports = 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/bloggar :
// GET: /api/blogs
if (req.url === "/api/blogs" && req.method === "GET") {
// get all blogs
const blogs = await Blog.find();
// set the status code and content-type
res.writeHead(200, { "Content-Type": "application/json" });
// send data
res.end(JSON.stringify(blogs));
}
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:
// GET: /api/blogs/:id
if (req.url.match(/\/api\/blogs\/([0-9]+)/) && req.method === "GET") {
try {
// extract id from url
const id = req.url.split("/")[3];
// get blog from DB
const blog = await Blog.findById(id);
if (blog) {
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify(blog));
} else {
throw new Error("Blog does not exist");
}
} catch (error) {
res.writeHead(404, { "Content-Type": "application/json" });
res.end(JSON.stringify({ message: error }));
}
}
Denna kod använder match metod, som tar in ett regexuttryck som ett argument, för att kontrollera om webbadressen matchar formatet: /api/blogs/
Därefter, extrahera 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/blogs/
if (req.url === "/api/blogs" && req.method === "POST") {
try {
let body = "";
// Listen for data event
req.on("data", (chunk) => {
body += chunk.toString();
});
// Listen for end event
req.on("end", async () => {
// Create Blog
let blog = new Blog(JSON.parse(body));
// Save to DB
await blog.save();
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify(blog));
});
} catch (error) {
console.log(error);
}
}
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.method === "PUT") {
try {
// extract id from url
const id = req.url.split("/")[3];
let body = "";
req.on("data", (chunk) => {
body += chunk.toString();
});
req.on("end", async () => {
// Find and update document
let updatedBlog = await Blog.findByIdAndUpdate(id, JSON.parse(body), {
new: true,
});
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify(updatedBlog));
});
} catch (error) {
console.log(error);
}
}
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:
// DELETE: /api/blogs/:id
if (req.url.match(/\/api\/blogs\/([0-9]+)/) && req.method === "DELETE") {
try {
const id = req.url.split("/")[3];
// Delete blog from DB
await Blog.findByIdAndDelete(id);
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify({ message: "Blog deleted successfully" }));
} catch (error) {
res.writeHead(404, { "Content-Type": "application/json" });
res.end(JSON.stringify({ message: error }));
}
}
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:
const router = require("./routes/blogRoutes");
const 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.