Rokasgrāmata iesācējiem par RESTful API vietnē Node.js

REST (pārstāvības stāvokļa pārsūtīšanas) API — dažreiz saukta par RESTful AP — ir API, kas izmanto HTTP pieprasījumus, lai piekļūtu resursiem un tos izmantotu.

Šie resursi bieži tiek attēloti JSON formātā, lai gan dažkārt tiek izmantots XML, teksta un HTML formāts. REST API ir kļuvušas par standarta veidu lietojumprogrammām datu apmaiņai tīklā, izmantojot HTTP metodes, piemēram, GET, PUT, POST un DELETE. Tie atvieglo resursu izveidi, lasīšanu, atjaunināšanu un dzēšanu, ko parasti dēvē par CRUD operācijām.

Šajā rokasgrāmatā ir aprakstīts, kā jūs varat izmantot Node. JS, lai izveidotu vienkāršu CRUD Restful API.

Kas jums jāievēro

Pārliecinieties, vai jūsu vietējā datorā ir instalēts Node.js. Skrien mezgls -v lai pārbaudītu, vai Node. JS ir instalēts. Šai komandai jāatgriež versijas numurs.

Saistīts: Kā instalēt Node.js operētājsistēmā Windows

Jums vajadzētu būt arī jūsu iecienītākajam eksemplāram teksta redaktors (piemēram, VS kods).

Projekta iestatīšana

Izveidojiet mapi savai lietojumprogrammai un dodieties uz to. Inicializējiet terminālī un tikko izveidotajā direktorijā

pack.json skrienot npm init.

$ npm init -y 

The pack.json palīdzēs jums instalēt un pārvaldīt npm pakotnes. The -y karodziņš izveido failu package.json, izmantojot noklusējuma opcijas, jums nav jāiestata atsevišķa informācija. Jūsu termināļa izvadei vajadzētu izskatīties šādi. Ņemiet vērā, ka nosaukums būs atšķirīgs atkarībā no tā, kādu nosaukumu esat norādījis savai mapei.

Uzstādiet serveri

Lai izveidotu serveri, vispirms instalējiet Express.js un Nodemon. Express.js ir mezgls. Js ietvars, kas tika izstrādāts, lai atvieglotu tīmekļa lietojumprogrammu un API izstrādi. Jūs to izmantosit, lai konfigurēt serveri un API galapunkti. Nodemon, no otras puses, ir izstrādes rīks, kas restartēs jūsu serveri, kad mainīsies jūsu lietojumprogrammas kods.

Lai instalētu, palaidiet šo komandu izteikt un mezgls:

npm es izteiktu mezglu 

Pēc tam, lai izveidotu serveri, izveidojiet failu un izsauciet to serveris.js pēc tam pievienojiet šādu kodu.

// Pieprasīt ekspress
const izteikt = prasīt ("izteikt");
// Inicializēt ekspress
const app = express();
const PORT = 8080;
// parsēt JSON
app.use (express.json());
// parsēt URL kodētos datus
app.use (express.urlencoded({paplašināts: true }));
// izveidot serveri
app.listen (PORT, () => {
console.log(`Serveris darbojas portā ${PORT}`);
});

Iepriekš minētajā kodā pieprasiet izteikt savu serveris.js failu un inicializējiet to. Pēc tam konfigurējiet Express, lai parsētu JSON un URL kodētos datus. Visbeidzot, izveidojiet serveri, izmantojot klausies () metode no Express.

Saistīts: Kas ir Express.js un kāpēc to vajadzētu izmantot?

Darba sākšana: izveidojiet masīvu lietotāja datu glabāšanai

Vienkāršības labad jūs neizmantosit datu bāzi, bet gan vienkāršu lietotāju masīvu. Failā app.js pievienojiet tālāk norādīto kodu aiz rindas, kas parsē URL kodētos datus.

const lietotāji = [{
 id: 1,
 vārds: "Jane Doe",
 vecums: "22",
 },
 {
 id: 2,
 vārds: "Džons Dū",
 vecums: "31",
}];

Saistīts: Kā izveidot datu bāzi un kolekciju MongoDB

Kā iestatīt maršrutus programmā Express.js

Lai veiktu darbības ar datiem, ir jāiestata maršrutēšana. Maršruti noteiks, kā jūsu lietojumprogramma atbildēs uz pieprasījumiem, kas veikti konkrētam galapunktam. Katram maršrutam ir HTTP metode, URL un apstrādātāja funkcija, kas apstrādā HTTP pieprasījumu un atbildi. Lai iestatītu maršrutus, pievienojiet savam serveris.js failu pēc jūsu lietotājiem masīvs.

app.post('/create', (req, res) => {
 // Izveidot lietotāju
});
app.get('/users', (req, res) => {
 // Izgūst visus lietotājus
});
app.get('/lietotājs/:lietotāja ID', (req, res) => {
 // Atgriež lietotāju pēc ID
});
app.put('/lietotājs/:lietotāja ID', (req, res) => {
 // Atjaunināt lietotāju pēc ID
});
app.delete('/delete/:userID', (req, res) => {
 // Dzēst lietotāju pēc ID
});
app.delete('/users', (req, res) => {
 // Dzēst visus lietotājus
});

Kā veikt CRUD darbības mezglā. Js

Jums ir jāizveido funkcijas, kas manipulēs ar lietotāja datiem un atgriezīs atbildi atbilstoši saskaņotajam maršrutam. Šīs funkcijas izveidos, lasīs, atjauninās un dzēsīs lietotāja datus.

Saistīts: Kā veikt CRUD operācijas MongoDB

Kā izveidot jaunu lietotāju

Lai izveidotu jaunu lietotāju, jums būs nepieciešams:

• Pārbaudiet, vai pieprasījuma pamatteksts ir tukšs — ja tā ir, nosūtiet kļūdas atbildi.
• Izņemiet lietotāja datus no pieprasījuma struktūras.
• Apstipriniet lietotāja datus.
• Nosūtiet lietotāja datus uz masīvu.

Ņemiet vērā, ka jūs izmantojat masīvu tikai vienkāršības labad. Reālā gadījumā jūs mijiedarbotos ar datu bāzi.

Rediģējiet savu POST maršrutu, kā norādīts tālāk.

app.post("/create", (req, res) => {
// Pārbaudiet, vai pieprasījuma pamatteksts ir tukšs
if (!Object.keys (req.body).length) {
 atgriezt res.status (400).json({
 ziņojums: "Pieprasījuma pamatteksts nevar būt tukšs",
 });
}
// Izmantojiet objektu iznīcināšanu, lai iegūtu vārdu un vecumu
const {vārds, vecums} = req.body;
if (!vārds || !vecums) {
 res.status (400).json({
 ziņojums: "Pārliecinieties, ka esat nosūtījis gan vārdu, gan vecumu",
 });
}
const newUser = {
 id: users.length + 1,
 vārds,
 vecums,
};
mēģināt {
 users.push (newUser);
 res.status (201).json({
 ziņojums: "Jauns lietotājs ir veiksmīgi izveidots",
 });
} nozveja (kļūda) {
 res.status (500).json({
 ziņojums: "Neizdevās izveidot lietotāju",
 });
}
});

Kā lasīt lietotājus

Lai izgūtu visus lietotājus, atbildē atgrieziet lietotāju masīvu.

app.get("/lietotāji", (req, res) => {
 mēģināt {
 res.status (200).json({
 lietotājiem
 });
 } nozveja (kļūda) {
 res.status (500).json({
 ziņojums: "Neizdevās izgūt visus lietotājus",
 });
 }
});

Ja pārbaudāt šo maršrutu, izmantojot pastnieku, atbildes pamattekstā jāsaņem lietotāju masīvs.

Lai izgūtu tikai vienu lietotāju:

• Iegūstiet lietotāja ID no URL parametra.
• Izmantot atrast () lai noteiktu, kādus konkrētus lietotāja datus jūs pieprasāt.
• Atsūtiet lietotāju atbildē.

app.get("/lietotāji/:lietotāja ID", (req, res) => {
 const id = parseInt (req.params.userID);
 console.log (id);
 mēģināt {
 let user = users.find((user) => user.id id);
 if (!lietotājs) {
 atgriezt res.status (404).json({
 ziņojums: "Lietotājs nav atrasts",
 });
 }
 res.status (200).json({
 lietotājs,
 });
 } nozveja (kļūda) {
 res.status (500).json({
 ziņojums: "Neizdevās izgūt lietotāju",
 });
 }
});

Kā atjaunināt lietotājus

Lai atjauninātu lietotāju:

• Izgūstiet lietotāja ID no URL.
• Izmantot atrast () lai pārbaudītu, vai lietotājs pastāv.
• Izmantot indexOf() lai iegūtu atsauces lietotāja indeksu.
• Izmantojiet indeksu, lai rediģētu lietotāja datus ar datiem, kas nosūtīti caur pieprasījuma pamattekstu.

app.put("/lietotāji/:lietotāja ID", (req, res) => {
 mēģināt {
 const id = parseInt (req.params.userID);
 let user = users.find((user) => user.id id);
 if (!lietotājs) {
 atgriezt res.status (404).json({
 ziņojums: "Lietotājs nav atrasts",
 });
 }
 const userIDX = lietotāji.indexOf (lietotājs);
 lietotāji[lietotāja IDX].nosaukums = req.body.name || lietotāji[lietotājaIDX].nosaukums;
 lietotāji[lietotāja IDX].age = req.body.age || lietotāji[lietotājaIDX].vecums;
 res.status (200).json({
 ziņojums: "Lietotājs ir veiksmīgi atjaunināts",
 lietotājs,
 });
 } nozveja (kļūda) {
 res.status (500).json({
 ziņojums: "Neizdevās izgūt lietotāju",
 });
 }
});

Kā izdzēst lietotājus

Varat izvēlēties dzēst vienu vai visus lietotājus.

Lai dzēstu vienu lietotāju:

• Izgūstiet lietotāja ID no URL
• Izmantot atrast () lai pārbaudītu, vai lietotājs pastāv
• Izmantot atrastIndekss() lai iegūtu atsauces lietotāja indeksu.
• Izmantot salaist () lai dzēstu lietotāju šajā rādītājā.

app.delete("/lietotāji/:lietotāja ID", (req, res) => {
 mēģināt {
 const id = req.params.userID;
 let userIDX = lietotāji.atrastIndex((lietotājs) => user.id id);
 if (!userIDX) {
 res.status (404).json({
 ziņojums: "Lietotājs nav atrasts",
 });
 }
 users.splice (userIDX, 1);
 res.status (200).json({
 ziņojums: "Lietotājs ir veiksmīgi izdzēsts",
 lietotāji,
 });
 } nozveja (kļūda) {
 res.status (500).json({
 ziņojums: "Neizdevās izdzēst lietotāju",
 });
 }
});

Lai dzēstu visus lietotājus, savienojiet visu masīvu.

app.delete("/lietotāji", (req, res) => {
 mēģināt {
 users.splice (0, users.length);
 res.status (200).json({
 ziņojums: "Visi lietotāji ir veiksmīgi izdzēsti",
 lietotāji,
 });
 } nozveja (kļūda) {
 res.status (500).json({
 ziņojums: "Neizdevās izdzēst lietotājus",
 x,
 });
 }
});

Uzziniet vairāk par RESTful API

Šajā apmācībā ir apskatīts, kā mezglā izveidot pamata RESTful API. JS. Jūs esat iemācījušies izveidot Express serveri, iestatīt maršrutus un visbeidzot izveidot apdarinātāja funkcijas, kas mijiedarbojas ar jūsu datiem, izmantojot HTTP pieprasījumus/atbildes.

Tomēr ir dažas būtiskas tēmas, kuras šeit nav aplūkotas un kuras jums vajadzētu izpētīt tālāk, tostarp to, kā savienot lietojumprogrammu ar tādu datu bāzi kā MongoDB un kā nodrošināt maršrutus.

Kā MongoDB datu bāze var labāk organizēt jūsu datus

MongoDB (no "humongous") ir uz dokumentiem orientēta vairāku platformu datubāze, ko izmanto kā alternatīvu MySQL. Bet ko tas nozīmē?

Lasiet Tālāk

Par autoru