Home-theater-designers
Node.js er en open source JavaScript-runtime bygget på chromes v8-motor, der giver dig mulighed for at køre JavaScript-kode uden for en browser.
Dens hændelsesmodel, økosystem og hastighed har gjort Node.js til en af de mest eftersøgte og brugte kørselstider til applikationer på serversiden.
De fleste Node.js API-servere bruger Express eller et andet framework. Du kan dog også oprette et simpelt Node.js API uden et framework med blot et par trin.
MAKEUSE AF DAGENS VIDEO
Trin 1: Opsætning af dit udviklingsmiljø
Opret en projektmappe og cd ind i det ved at køre:
mkdir nodejs-api
cd nodejs-api
Dernæst initialiser npm i dit projekt ved at køre:
npm init -y
Denne CRUD API vil indeholde brugen af MongoDB, en NoSQL-database, og dens populære ODM, mongoose.
Kør følgende kommando for at installere mangust :
npm install mongoose
Opret derefter en server.js fil i dit projekts rodmappe, og tilføj kodeblokken nedenfor for at oprette en server:
const http = require("http");
const server = http.createServer((req, res) => {});
server.listen(3000, () => {
console.log(`Server is running`);
});
Denne kodeblok importerer http-modulet, et kerne-Node.js-modul. http-modulet tillader Node.js at overføre data over HTTP. Dette modul indeholder de metoder, der kræves for at oprette en server.
Dernæst kalder det http-modulet opretteServer metode, som opretter og returnerer en forekomst af en server. Det opretteServer metoden tager en tilbagekaldsfunktion med et anmodnings- og svarobjekt som parametre.
Dernæst kalder koden for Lyt metode på den returnerede serverforekomst. Dette gør det muligt for serveren at begynde at lytte efter trafik på den givne port. Det Lyt metoden affyrer et tilbagekald - det andet argument - når det lykkes.
Til sidst skal du oprette to navngivne mapper ruter og modeller i dit projekts rodmappe. Det ruter mappen vil indeholde routinglogikken for din API, mens model vil indeholde alt relateret til databasen.
Trin 2: Tilslutning af din applikation til en database
I server.js , import mangust :
er linkedin -præmie værd for jobsøgende
const mongoose = require("mongoose");
Ring til Opret forbindelse metode på mangust og send din MongoDB URI som et argument:
mongoose.connect("MongoDB_URI")
Trin 3: Oprettelse af en API-model
Opret en CRUD API til en simpel blogapplikation. I din modeller mappe, skal du oprette en blogModel.js fil og tilføj følgende kode til 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);
Kodeblokken ovenfor opretter en mongoose-model med to egenskaber og knytter dem til en MongoDB-database.
Begge egenskaber i denne model har en Snor skriv med påkrævet indstillet til rigtigt . De medfølgende fejlmeddelelser vises, hvis en anmodningstekst ikke indeholder nogen af egenskaberne.
Den sidste linje opretter og eksporterer en mangustmodel ved at kalde model metode på mangust. Send modelnavnet ( Blog ) som det første argument og et skema ( blogskema ) som det andet argument.
Trin 4: Implementering af routing i din applikation
Uden hjælp af rammer som Express , bliver du nødt til manuelt at oprette logikken for at håndtere hver anmodning til din API.
Først skal du oprette en blogRoutes.js fil i din ruter mappe, og importer derefter blogmodellen:
const Blog = require("../models/blogModel");
Opret derefter en asynkron router funktion, bestå req og res som parametre, og eksporter funktionen:
const router = async function (req, res) {};
module.exports = router;
Denne funktion vil indeholde al din routinglogik.
Dernæst skal du implementere routinglogikken rute for rute.
GET ruter
Tilføj kodeblokken nedenfor til din router funktion til at implementere FÅ rutebehandler for anmodninger til /api/blogs :
// 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));
}
Kodeblokken ovenfor kontrollerer url og metode egenskaber for anmodningsobjektet. Den henter derefter alle blogs fra databasen via finde metode på mongoose modellen ( Blog ).
Dernæst kalder det skrivehoved metode på res , svarobjektet. Denne metode sender en svaroverskrift givet tre argumenter: en statuskode, en valgfri statusmeddelelse og overskrifter. Det 200 statuskoden repræsenterer et vellykket svar, og indholdstypen for dette API-kald er indstillet til applikation/json .
Luk endelig anmodningen for at sikre, at serveren ikke hænger ved at ringe til ende metode på res . Opkaldet til JSON.stringify konverterer blogs gøre indsigelse mod en JSON-streng og sende den til ende metoden returnerer det som svarlegemet.
Tilføj kodeblokken nedenfor til din router funktion til at implementere FÅ rutehandler for en enkelt ressource:
// 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 }));
}
}
Denne kode bruger match metode, der tager et regex-udtryk ind som et argument, for at kontrollere, om url'en matcher formatet: /api/blogs/
Udtræk derefter id ejendom fra url streng ved at kalde dens dele metode. Denne metode tager et mønster som et argument ( / ), opdeler strengen baseret på mønsteret og returnerer en matrix. Det tredje element i dette array er id .
Til sidst skal du hente dokumentet med matchningen id fra din database. Hvis den findes, så send en svarkode på 200 , luk anmodningen, og send den hentede blog. Hvis det ikke eksisterer, smid en fejl og send det som et svar i catch-blokken.
POST rute
Tilføj kodeblokken nedenfor til din routerfunktion for at implementere STOLPE rutehandler:
// 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);
}
}
Anmodningsobjektet implementerer Node.js ReadableStream interface. Denne strøm udsender en data og en ende begivenhed, som giver dig adgang til data fra anmodningsorganet.
Denne kode lytter efter datahændelsen og håndterer den ved at konvertere den til en streng og sammenkæde den til legeme variabel. I den ende hændelseshandler, det skaber en Blog instans med den parsede kropsstreng. Den gemmer derefter den nye blog, sender statuskoden og indholdsoverskriften og lukker anmodningen.
PUT rute
Tilføj kodeblokken nedenfor til din routerfunktion for at implementere SÆTTE rutehandler:
// 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-anmodningshåndteringen er næsten identisk med STOLPE anmodningshandler, bortset fra at den udtrækker id ejendom fra url at opdatere den relevante blog.
SLET rute
Tilføj kodeblokken nedenfor til din routerfunktion for at implementere din SLET rutehandler:
// 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 }));
}
}
Denne kodeblok uddrager id fra url , sletter dokumentet med matchningen id , sender statuskoden og overskrifterne og lukker anmodningen.
Til sidst importerer router i din server.js fil og ring til din router funktion, bestået req og res som argumenter:
const router = require("./routes/blogRoutes");
const server = http.createServer((req, res) => {
router(req, res);
});
Dette giver din server mulighed for at opsnappe og håndtere anmodninger korrekt.
Du kan finde det færdige projekt i denne GitHub-depot .
Brug af en Node.js Framework
Selvom det er muligt at oprette en web-API i hånden, kan det være en vanskelig opgave. Du skal sikre dig, at du har dækket masser af edge-sager, og din kode må hellere være fejlfri.
Gennem årene har udviklere bygget rammer som ExpressJS, NestJS, Fastify osv., for at gøre det meget nemmere.