Home-theater-designers
Node.js என்பது Chrome இன் v8 இன்ஜினில் கட்டமைக்கப்பட்ட திறந்த மூல JavaScript இயக்க நேரமாகும், இது உலாவிக்கு வெளியே JavaScript குறியீட்டை இயக்க அனுமதிக்கிறது.
அதன் நிகழ்வு மாதிரி, சுற்றுச்சூழல் அமைப்பு மற்றும் வேகம் ஆகியவை Node.js ஐ சர்வர்-சைட் பயன்பாடுகளுக்கு மிகவும் விரும்பப்படும் மற்றும் பயன்படுத்தப்படும் இயக்க நேரங்களாக மாற்றியுள்ளன.
பெரும்பாலான Node.js API சேவையகங்கள் எக்ஸ்பிரஸ் அல்லது வேறு கட்டமைப்பைப் பயன்படுத்துகின்றன. இருப்பினும், நீங்கள் ஒரு சில படிகளில் கட்டமைப்பின்றி ஒரு எளிய Node.js API ஐ உருவாக்கலாம்.
அன்றைய வீடியோவை உருவாக்கவும்
படி 1: உங்கள் மேம்பாட்டு சூழலை அமைத்தல்
திட்ட அடைவை உருவாக்கவும் மற்றும் சிடி ஓடுவதன் மூலம் அதில்:
mkdir nodejs-api
cd nodejs-api
அடுத்து, துவக்கவும் npm இயங்குவதன் மூலம் உங்கள் திட்டத்தில்:
npm init -y
இந்த CRUD API ஆனது NoSQL தரவுத்தளமான MongoDB மற்றும் அதன் பிரபலமான ODM, முங்கூஸ் ஆகியவற்றின் பயன்பாட்டைக் கொண்டிருக்கும்.
நிறுவ பின்வரும் கட்டளையை இயக்கவும் முங்கூஸ் :
npm install mongoose
அடுத்து, ஒரு உருவாக்கவும் server.js உங்கள் திட்டத்தின் ரூட் கோப்பகத்தில் கோப்பு மற்றும் சேவையகத்தை உருவாக்க கீழே உள்ள குறியீட்டு தொகுதியைச் சேர்க்கவும்:
const http = require("http");
const server = http.createServer((req, res) => {});
server.listen(3000, () => {
console.log(`Server is running`);
});
இந்த குறியீடு தொகுதி http தொகுதி, ஒரு கோர் Node.js தொகுதியை இறக்குமதி செய்கிறது. http தொகுதி Node.js ஐ HTTP மூலம் தரவை மாற்ற அனுமதிக்கிறது. இந்த தொகுதி ஒரு சேவையகத்தை உருவாக்க தேவையான முறைகளைக் கொண்டுள்ளது.
அடுத்து, இது 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 தரவுத்தளத்திற்கு வரைபடமாக்குகிறது.
இந்த மாதிரியில் உள்ள இரண்டு பண்புகளும் ஏ லேசான கயிறு உடன் தட்டச்சு செய்யவும் தேவை தயாராதல் உண்மை . கோரிக்கை அமைப்பில் எந்த பண்புகளும் இல்லை என்றால் அதனுடன் இருக்கும் பிழை செய்திகள் காண்பிக்கப்படும்.
இறுதி வரியை அழைப்பதன் மூலம் ஒரு முங்கூஸ் மாதிரியை உருவாக்கி ஏற்றுமதி செய்கிறது மாதிரி மீது முறை முங்கூஸ். மாதிரி பெயரை அனுப்பவும் ( வலைப்பதிவு ) முதல் வாதம் மற்றும் ஒரு திட்டமாக ( வலைப்பதிவு அட்டவணை ) இரண்டாவது வாதமாக.
படி 4: உங்கள் பயன்பாட்டில் ரூட்டிங் செயல்படுத்துதல்
உதவியின்றி எக்ஸ்பிரஸ் போன்ற கட்டமைப்புகள் , உங்கள் API க்கு செய்யப்படும் ஒவ்வொரு கோரிக்கையையும் கையாள நீங்கள் கைமுறையாக தர்க்கத்தை உருவாக்க வேண்டும்.
முதலில், ஒரு உருவாக்கவும் blogRoutes.js உங்கள் கோப்பு பாதைகள் கோப்புறை, பின்னர் வலைப்பதிவு மாதிரியை இறக்குமதி செய்யவும்:
const Blog = require("../models/blogModel");
அடுத்து, ஒத்திசைவற்ற ஒன்றை உருவாக்கவும் திசைவி செயல்பாடு, பாஸ் தேவை மற்றும் ரெஸ் அளவுருக்களாக, செயல்பாட்டை ஏற்றுமதி செய்யவும்:
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 மற்றும் முறை கோரிக்கை பொருளின் பண்புகள். அது பின்னர் அனைத்து வலைப்பதிவுகளையும் தரவுத்தளத்தில் இருந்து பெறுகிறது கண்டுபிடிக்க முங்கூஸ் மாதிரியில் முறை ( வலைப்பதிவு )
அடுத்து, அது அழைக்கிறது எழுது தலை மீது முறை ரெஸ் , பதில் பொருள். இந்த முறை மூன்று வாதங்கள் கொடுக்கப்பட்ட பதில் தலைப்பை அனுப்புகிறது: ஒரு நிலை குறியீடு, ஒரு விருப்ப நிலை செய்தி மற்றும் தலைப்புகள். தி 200 நிலைக் குறியீடு வெற்றிகரமான பதிலைக் குறிக்கிறது மற்றும் இந்த API அழைப்பிற்கான உள்ளடக்க வகை அமைக்கப்பட்டுள்ளது விண்ணப்பம்/json .
இறுதியாக, அழைப்பதன் மூலம் சேவையகம் செயலிழக்கவில்லை என்பதை உறுதிப்படுத்த கோரிக்கையை மூடவும் முடிவு மீது முறை ரெஸ் . என்ற அழைப்பு 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/
அடுத்து, பிரித்தெடுக்கவும் ஐடி இருந்து சொத்து url அதை அழைப்பதன் மூலம் சரம் பிளவு முறை. இந்த முறை ஒரு வடிவத்தை வாதமாக எடுக்கிறது ( / ), வடிவத்தின் அடிப்படையில் சரத்தைப் பிரித்து, வரிசையை வழங்கும். அந்த வரிசையின் மூன்றாவது உறுப்பு ஐடி .
இறுதியாக, பொருத்தத்துடன் ஆவணத்தை மீட்டெடுக்கவும் ஐடி உங்கள் தரவுத்தளத்திலிருந்து. அது இருந்தால், அனுப்பவும் பதில் குறியீடு 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 பாதை கையாளுபவர்:
// 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 கோரிக்கை ஹேண்ட்லர் கிட்டத்தட்ட ஒரே மாதிரியாக உள்ளது அஞ்சல் கோரிக்கை கையாளுபவர், அது பிரித்தெடுக்கிறது தவிர ஐடி இருந்து சொத்து 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 }));
}
}
இந்த குறியீடு தொகுதி பிரித்தெடுக்கிறது ஐடி இருந்து url , பொருத்தத்துடன் ஆவணத்தை நீக்குகிறது ஐடி , நிலைக் குறியீடு மற்றும் தலைப்புகளை அனுப்புகிறது மற்றும் கோரிக்கையை மூடுகிறது.
ஆப்பிள் வாட்ச் தொடர் 6 அலுமினியம் vs எஃகு
இறுதியாக, இறக்குமதி திசைவி உங்கள் server.js கோப்பு மற்றும் உங்கள் அழைப்பு திசைவி செயல்பாடு, கடந்து தேவை மற்றும் ரெஸ் வாதங்களாக:
const router = require("./routes/blogRoutes");
const server = http.createServer((req, res) => {
router(req, res);
});
இது உங்கள் சேவையகத்தை இடைமறித்து கோரிக்கைகளை சரியான முறையில் கையாள அனுமதிக்கிறது.
முடிக்கப்பட்ட திட்டத்தை இதில் காணலாம் கிட்ஹப் களஞ்சியம் .
Node.js கட்டமைப்பைப் பயன்படுத்துதல்
கையால் வலை API ஐ உருவாக்குவது சாத்தியம் என்றாலும், அது கடினமான பணியாக இருக்கலாம். நீங்கள் பல எட்ஜ் கேஸ்களை உள்ளடக்கியிருப்பதை உறுதிசெய்ய வேண்டும், மேலும் உங்கள் குறியீடு பிழைகள் இல்லாமல் இருப்பது நல்லது.
பல ஆண்டுகளாக, டெவலப்பர்கள் எக்ஸ்பிரஸ்ஜேஎஸ், நெஸ்ட்ஜேஎஸ், ஃபாஸ்டிஃபை போன்ற கட்டமைப்புகளை மிகவும் எளிதாக்குவதற்கு உருவாக்கியுள்ளனர்.