Home-theater-designers
Node.js అనేది Chrome యొక్క v8 ఇంజిన్‌పై నిర్మించిన ఓపెన్-సోర్స్ JavaScript రన్‌టైమ్, ఇది బ్రౌజర్ వెలుపల JavaScript కోడ్‌ని అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.
దీని ఈవెంట్ మోడల్, ఎకోసిస్టమ్ మరియు వేగం Node.jsని సర్వర్ సైడ్ అప్లికేషన్‌ల కోసం మోస్ట్ వాంటెడ్ మరియు ఉపయోగించిన రన్‌టైమ్‌లలో ఒకటిగా చేసింది.
విండోస్ మీడియా ప్లేయర్ 12 డౌన్‌లోడ్ 64 బిట్
చాలా Node.js API సర్వర్‌లు ఎక్స్‌ప్రెస్ లేదా మరొక ఫ్రేమ్‌వర్క్‌ను ఉపయోగిస్తాయి. అయితే, మీరు కొన్ని దశల్లో ఫ్రేమ్‌వర్క్ లేకుండా సాధారణ Node.js APIని కూడా సృష్టించవచ్చు.
రోజు యొక్క వీడియోను తయారు చేయండి
దశ 1: మీ అభివృద్ధి వాతావరణాన్ని సెటప్ చేయడం
ప్రాజెక్ట్ డైరెక్టరీని సృష్టించండి మరియు cd అమలు చేయడం ద్వారా దానిలోకి:
mkdir nodejs-api
cd nodejs-api
తరువాత, ప్రారంభించండి npm అమలు చేయడం ద్వారా మీ ప్రాజెక్ట్‌లో:
npm init -y
ఈ CRUD API MongoDB, NoSQL డేటాబేస్ మరియు దాని ప్రసిద్ధ ODM, ముంగూస్ వినియోగాన్ని కలిగి ఉంటుంది.
ఇన్‌స్టాల్ చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి ముంగిస :
npm install mongoose
తరువాత, aని సృష్టించండి server.js మీ ప్రాజెక్ట్ యొక్క రూట్ డైరెక్టరీలో ఫైల్ చేయండి మరియు సర్వర్‌ని సృష్టించడానికి దిగువ కోడ్ బ్లాక్‌ను జోడించండి:
const http = require("http");
const server = http.createServer((req, res) => {});
server.listen(3000, () => {
console.log(`Server is running`);
});
ఈ కోడ్ బ్లాక్ http మాడ్యూల్, కోర్ Node.js మాడ్యూల్‌ని దిగుమతి చేస్తుంది. HTTP ద్వారా డేటాను బదిలీ చేయడానికి http మాడ్యూల్ Node.jsని అనుమతిస్తుంది. ఈ మాడ్యూల్ సర్వర్‌ని సృష్టించడానికి అవసరమైన పద్ధతులను కలిగి ఉంది.
తరువాత, ఇది http మాడ్యూల్‌ని పిలుస్తుంది సృష్టించు సర్వర్ సర్వర్ యొక్క ఉదాహరణను సృష్టించి మరియు తిరిగి ఇచ్చే పద్ధతి. ది సృష్టించు సర్వర్ పద్ధతి అభ్యర్థన మరియు ప్రతిస్పందన వస్తువుతో కాల్‌బ్యాక్ ఫంక్షన్‌ను పారామీటర్‌లుగా తీసుకుంటుంది.
తరువాత, కోడ్ కాల్ చేస్తుంది వినండి తిరిగి వచ్చిన సర్వర్ ఉదాహరణలో పద్ధతి. ఇది అందించిన పోర్ట్‌లో ట్రాఫిక్‌ను వినడం ప్రారంభించేందుకు సర్వర్‌ని అనుమతిస్తుంది. ది వినండి పద్ధతి విజయవంతం అయినప్పుడు కాల్‌బ్యాక్-రెండో ఆర్గ్యుమెంట్-ను తొలగిస్తుంది.
చివరగా, పేరుతో రెండు డైరెక్టరీలను సృష్టించండి మార్గాలు మరియు నమూనాలు మీ ప్రాజెక్ట్ యొక్క రూట్ డైరెక్టరీలో. ది మార్గాలు ఫోల్డర్ మీ API కోసం రూటింగ్ లాజిక్‌ను కలిగి ఉంటుంది మోడల్ డేటాబేస్కు సంబంధించిన ప్రతిదీ కలిగి ఉంటుంది.
దశ 2: మీ అప్లికేషన్‌ను డేటాబేస్కు కనెక్ట్ చేస్తోంది
లో server.js , దిగుమతి ముంగిస :
const mongoose = require("mongoose");
కాల్ చేయండి కనెక్ట్ చేయండి న పద్ధతి ముంగిస మరియు మీ MongoDB URIని వాదనగా పాస్ చేయండి:
mongoose.connect("MongoDB_URI")
దశ 3: API మోడల్‌ని సృష్టిస్తోంది
సాధారణ బ్లాగ్ అప్లికేషన్ కోసం CRUD APIని సృష్టించండి. మీలో నమూనాలు ఫోల్డర్, సృష్టించు a blogModel.js ఫైల్ చేసి, మీ ఫైల్‌కి క్రింది కోడ్‌ను జోడించండి:
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);
పైన ఉన్న కోడ్ బ్లాక్ రెండు లక్షణాలతో ముంగూస్ మోడల్‌ను సృష్టిస్తుంది మరియు వాటిని MongoDB డేటాబేస్కు మ్యాప్ చేస్తుంది.
ఈ మోడల్‌లోని రెండు లక్షణాలు a స్ట్రింగ్ తో టైప్ చేయండి అవసరం సెట్ నిజం . రిక్వెస్ట్ బాడీలో ప్రాపర్టీలు ఏవీ లేకుంటే దానితో పాటు ఎర్రర్ మెసేజ్‌లు ప్రదర్శించబడతాయి.
చివరి పంక్తికి కాల్ చేయడం ద్వారా ముంగూస్ మోడల్‌ను సృష్టిస్తుంది మరియు ఎగుమతి చేస్తుంది మోడల్ న పద్ధతి ముంగిస. మోడల్ పేరును పాస్ చేయండి ( బ్లాగు ) మొదటి వాదనగా మరియు స్కీమాగా ( బ్లాగ్ షెడ్యూల్ ) రెండవ వాదనగా.
దశ 4: మీ అప్లికేషన్‌లో రూటింగ్‌ని అమలు చేయడం
సహాయం లేకుండా ఎక్స్‌ప్రెస్ వంటి ఫ్రేమ్‌వర్క్‌లు , మీరు మీ APIకి చేసిన ప్రతి అభ్యర్థనను నిర్వహించడానికి లాజిక్‌ను మాన్యువల్‌గా సృష్టించాలి.
ముందుగా, aని సృష్టించండి blogRoutes.js మీలోని ఫైల్ మార్గాలు ఫోల్డర్, ఆపై బ్లాగ్ మోడల్‌ను దిగుమతి చేయండి:
const Blog = require("../models/blogModel");
తరువాత, అసమకాలికతను సృష్టించండి రూటర్ ఫంక్షన్, పాస్ req మరియు res పారామీటర్‌లుగా, మరియు ఫంక్షన్‌ను ఎగుమతి చేయండి:
const router = async function (req, res) {};
module.exports = router;
ఈ ఫంక్షన్ మీ అన్ని రూటింగ్ లాజిక్‌లను కలిగి ఉంటుంది.
తర్వాత, మీరు రూటింగ్ లాజిక్ మార్గాన్ని రూట్ ద్వారా అమలు చేస్తారు.
మార్గాలను పొందండి
దిగువ కోడ్ బ్లాక్‌ని మీకు జోడించండి రూటర్ అమలు చేయడానికి ఫంక్షన్ పొందండి చేసిన అభ్యర్థనల కోసం రూట్ హ్యాండ్లర్ /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));
}
పైన కోడ్ బ్లాక్ తనిఖీ చేస్తుంది url మరియు పద్ధతి అభ్యర్థన వస్తువు యొక్క లక్షణాలు. ఇది డేటాబేస్ నుండి అన్ని బ్లాగులను దీని ద్వారా పొందుతుంది కనుగొనండి ముంగిస నమూనాపై పద్ధతి ( బ్లాగు )
తరువాత, ఇది కాల్ చేస్తుంది వ్రాస్తాము న పద్ధతి res , ప్రతిస్పందన వస్తువు. ఈ పద్ధతి మూడు వాదనలు ఇచ్చిన ప్రతిస్పందన హెడర్‌ను పంపుతుంది: స్థితి కోడ్, ఐచ్ఛిక స్థితి సందేశం మరియు శీర్షికలు. ది 200 స్థితి కోడ్ విజయవంతమైన ప్రతిస్పందనను సూచిస్తుంది మరియు ఈ API కాల్ కోసం కంటెంట్-రకం సెట్ చేయబడింది అప్లికేషన్/json .
చివరగా, కాల్ చేయడం ద్వారా సర్వర్ హ్యాంగ్ అవ్వకుండా చూసుకోవడానికి అభ్యర్థనను మూసివేయండి ముగింపు న పద్ధతి res . అనే పిలుపు JSON.stringify మారుస్తుంది బ్లాగులు JSON స్ట్రింగ్‌కు ఆబ్జెక్ట్ చేయండి మరియు దానిని పాస్ చేయండి ముగింపు పద్ధతి దానిని ప్రతిస్పందన శరీరంగా అందిస్తుంది.
దిగువ కోడ్ బ్లాక్‌ని మీకు జోడించండి రూటర్ అమలు చేయడానికి ఫంక్షన్ పొందండి ఒకే వనరు కోసం రూట్ హ్యాండ్లర్:
// 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 }));
}
}
ఈ కోడ్ ఉపయోగిస్తుంది మ్యాచ్ రీజెక్స్ ఎక్స్‌ప్రెషన్‌ను ఆర్గ్యుమెంట్‌గా తీసుకునే పద్ధతి, url ఫార్మాట్‌తో సరిపోలుతుందో లేదో తనిఖీ చేయడానికి: /api/blogs/<సంఖ్య> .
తరువాత, సంగ్రహించండి id నుండి ఆస్తి url దాని కాల్ చేయడం ద్వారా స్ట్రింగ్ విడిపోయింది పద్ధతి. ఈ పద్ధతి ఒక నమూనాను వాదనగా తీసుకుంటుంది ( / ), నమూనా ఆధారంగా స్ట్రింగ్‌ను విభజించి, శ్రేణిని అందిస్తుంది. ఆ శ్రేణి యొక్క మూడవ మూలకం id .
చివరగా, మ్యాచింగ్‌తో పత్రాన్ని తిరిగి పొందండి id మీ డేటాబేస్ నుండి. అది ఉనికిలో ఉంటే, పంపండి a ప్రతిస్పందన కోడ్ 200 , అభ్యర్థనను మూసివేసి, తిరిగి పొందిన బ్లాగును పంపండి. అది ఉనికిలో లేకుంటే, లోపాన్ని విసిరి, క్యాచ్ బ్లాక్‌లో ప్రతిస్పందనగా పంపండి.
పోస్ట్ మార్గం
అమలు చేయడానికి మీ రూటర్ ఫంక్షన్‌కు దిగువ కోడ్ బ్లాక్‌ని జోడించండి పోస్ట్ రూట్ హ్యాండ్లర్:
// 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);
}
}
అభ్యర్థన వస్తువు అమలు చేస్తుంది Node.js రీడబుల్ స్ట్రీమ్ ఇంటర్ఫేస్. ఈ ప్రవాహం a సమాచారం మరియు ఒక ముగింపు రిక్వెస్ట్ బాడీ నుండి మీకు డేటాకు యాక్సెస్ ఇచ్చే ఈవెంట్.
ఈ కోడ్ డేటా ఈవెంట్‌ను వింటుంది మరియు దానిని స్ట్రింగ్‌గా మార్చడం ద్వారా మరియు దానిని సంగ్రహించడం ద్వారా నిర్వహిస్తుంది శరీరం వేరియబుల్. లో ముగింపు ఈవెంట్ హ్యాండ్లర్, ఇది ఒక సృష్టిస్తుంది బ్లాగు పార్స్డ్ బాడీ స్ట్రింగ్‌తో ఉదాహరణ. ఇది కొత్త బ్లాగును సేవ్ చేస్తుంది, స్థితి కోడ్ మరియు కంటెంట్ హెడర్‌ను పంపుతుంది మరియు అభ్యర్థనను మూసివేస్తుంది.
మార్గం ఉంచండి
అమలు చేయడానికి మీ రూటర్ ఫంక్షన్‌కు దిగువ కోడ్ బ్లాక్‌ని జోడించండి పెట్టండి రూట్ హ్యాండ్లర్:
పదంలోని రెండవ పేజీని ఎలా తొలగించాలి
// 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 అభ్యర్థన హ్యాండ్లర్ దాదాపు ఒకేలా ఉంటుంది పోస్ట్ అభ్యర్థన హ్యాండ్లర్, ఇది సంగ్రహిస్తుంది తప్ప id నుండి ఆస్తి url సంబంధిత బ్లాగును నవీకరించడానికి.
మార్గాన్ని తొలగించండి
మీ రౌటర్ ఫంక్షన్‌ను అమలు చేయడానికి దిగువ కోడ్ బ్లాక్‌ని జోడించండి తొలగించు రూట్ హ్యాండ్లర్:
// 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 }));
}
}
ఈ కోడ్ బ్లాక్‌ని సంగ్రహిస్తుంది id నుండి url , మ్యాచింగ్‌తో పత్రాన్ని తొలగిస్తుంది id , స్థితి కోడ్ మరియు శీర్షికలను పంపుతుంది మరియు అభ్యర్థనను మూసివేస్తుంది.
చివరగా, దిగుమతి రూటర్ మీలో server.js ఫైల్ చేసి మీ కాల్ చేయండి రూటర్ ఫంక్షన్, పాస్ req మరియు res వాదనలుగా:
const router = require("./routes/blogRoutes");
const server = http.createServer((req, res) => {
router(req, res);
});
ఇది మీ సర్వర్‌ని అడ్డగించడానికి మరియు అభ్యర్థనలను సముచితంగా నిర్వహించడానికి అనుమతిస్తుంది.
మీరు పూర్తి చేసిన ప్రాజెక్ట్‌ను ఇందులో కనుగొనవచ్చు GitHub రిపోజిటరీ .
Node.js ఫ్రేమ్‌వర్క్‌ని ఉపయోగించడం
చేతితో వెబ్ APIని సృష్టించడం సాధ్యమే అయినప్పటికీ, ఇది చాలా కష్టమైన పని. మీరు చాలా ఎడ్జ్ కేసులను కవర్ చేసారని మరియు మీ కోడ్ బగ్ రహితంగా ఉందని నిర్ధారించుకోవాలి.
సంవత్సరాలుగా, డెవలపర్లు దీన్ని మరింత సులభతరం చేయడానికి ExpressJS, NestJS, Fastify మొదలైన ఫ్రేమ్‌వర్క్‌లను రూపొందించారు.