Node.js er en åpen kildekode JavaScript-runtime bygget på chromes v8-motor som lar deg kjøre JavaScript-kode utenfor en nettleser.

Dens hendelsesmodell, økosystem og hastighet har gjort Node.js til en av de mest ettertraktede og brukte kjøretidene for applikasjoner på serversiden.

De fleste Node.js API-servere bruker Express eller et annet rammeverk. Du kan imidlertid også lage en enkel Node.js API uten rammeverk på bare noen få trinn.

Trinn 1: Sette opp utviklingsmiljøet ditt

Lag en prosjektkatalog og cd inn i den ved å kjøre:

mkdir nodejs-api
cd nodejs-api

Deretter initialiser npm i prosjektet ditt ved å kjøre:

npm init -y

Denne CRUD API vil inneholde bruk av MongoDB, en NoSQL-database, og dens populære ODM, mongoose.

Kjør følgende kommando for å installere mangust:

npm installere mangust

Deretter oppretter du en server.js fil i prosjektets rotkatalog og legg til kodeblokken nedenfor for å lage en server:

konst http = krever("http");
konst server = http.createServer((req, res) => {});

server.listen (3000, () => {
konsoll.Logg(`Tjeneren kjører`);
});

instagram viewer

Denne kodeblokken importerer http-modulen, en kjerne Node.js-modul. http-modulen lar Node.js overføre data over HTTP. Denne modulen inneholder metodene som kreves for å lage en server.

Deretter kaller den http-modulen oppretteServer metode som oppretter og returnerer en forekomst av en server. De oppretteServer metoden tar en tilbakeringingsfunksjon med et forespørsel- og svarobjekt som parametere.

Deretter kaller koden lytte metode på den returnerte serverforekomsten. Dette gjør at serveren kan begynne å lytte etter trafikk på den gitte porten. De lytte metoden avfyrer en tilbakeringing – det andre argumentet – når den lykkes.

Til slutt oppretter du to navngitte kataloger ruter og modeller i prosjektets rotkatalog. De ruter mappen vil inneholde rutinglogikken for API-en din, mens modell vil inneholde alt relatert til databasen.

Trinn 2: Koble applikasjonen din til en database

I server.js, importere mangust:

konst mangust = krever("mangus");

Ring koble metode på mangust og send MongoDB URI som et argument:

mongoose.connect("MongoDB_URI")

Trinn 3: Opprette en API-modell

Lag et CRUD API for en enkel bloggapplikasjon. I din modeller mappe, opprette en blogModel.js fil og legg til følgende kode i filen din:

konst mangust = krever("mangus");
konst blogSchema = mangust. Skjema({
tittel: {
type: String,
påkrevd: [true, "Bloggen må ha en tittel"],
},
kropp: {
type: String,
påkrevd: [true, "Bloggen må ha en kropp"],
},
});
modul.eksport = mongoose.model("Blogg", blogSchema);

Kodeblokken ovenfor lager en mongoose-modell med to egenskaper og tilordner dem til en MongoDB-database.

Begge egenskapene i denne modellen har en String skriv med nødvendig satt til ekte. De medfølgende feilmeldingene vil vises hvis en forespørselstekst ikke inneholder noen av egenskapene.

Den siste linjen oppretter og eksporterer en mangustmodell ved å kalle modell metode på mangust. Send modellnavnet (Blogg) som det første argumentet og et skjema (bloggskjema) som det andre argumentet.

Trinn 4: Implementering av ruting i applikasjonen din

Uten hjelp av rammeverk som Express, må du manuelt opprette logikken for å håndtere hver forespørsel til API-en din.

Lag først en blogRoutes.js fil i din ruter mappen, og importer deretter bloggmodellen:

konst Blogg = krever("../models/blogModel");

Deretter oppretter du en asynkron ruter funksjon, pass rekv og res som parametere, og eksporter funksjonen:

konst ruter = asynkronfunksjon (krav, res) {};
modul.eksport = ruter;

Denne funksjonen vil inneholde all din rutinglogikk.

Deretter skal du implementere rutinglogikken rute for rute.

GET ruter

Legg til kodeblokken nedenfor til din ruter funksjon for å implementere rutebehandler for forespørsler til /api/blogs:

// FÅ: /api/blogger
if (req.url "/api/blogs"&& req.metode "") {
// få alle blogger
konst blogger = avvente Blog.finn();

// sett de status kode oginnhold-type
res.writeHead (200, { "Innholdstype": "applikasjon/json" });

// send data
res.slutt(JSON.stringify(blogger));
}

Kodeblokken ovenfor kontrollerer url og metode egenskapene til forespørselsobjektet. Den henter deretter alle blogger fra databasen via finne metode på mongoose modellen (Blogg).

Deretter kaller den skrivehode metode på res, svarobjektet. Denne metoden sender en svaroverskrift gitt tre argumenter: en statuskode, en valgfri statusmelding og overskrifter. De 200 statuskoden representerer et vellykket svar og innholdstypen for dette API-kallet er satt til applikasjon/json.

Til slutt lukker du forespørselen for å sikre at serveren ikke henger ved å ringe slutt metode på res. Oppfordringen til JSON.stringify konverterer blogger objekt til en JSON-streng og sende den til slutt metoden returnerer den som svarteksten.

Legg til kodeblokken nedenfor til din ruter funksjon for å implementere rutebehandler for en enkelt ressurs:

// FÅ: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.metode "") {
prøve {
// trekke ut id fra url
const id = req.url.split("/")[3];

// få blogg fra DB
konst blogg = avvente Blog.findById (id);

if (blogg) {
res.writeHead (200, { "Innholdstype": "applikasjon/json" });
res.slutt(JSON.stringify(blogg));
} ellers {
kastenyFeil("Blogg finnes ikke");
}
} å fange (feil) {
res.writeHead (404, { "Innholdstype": "applikasjon/json" });
res.slutt(JSON.stringify({ beskjed: feil }));
}
}

Denne koden bruker kamp metode, som tar inn et regulært uttrykk som et argument, for å sjekke om nettadressen samsvarer med formatet: /api/blogs/.

Trekk deretter ut id eiendom fra url streng ved å kalle dens dele metode. Denne metoden tar et mønster som et argument (/), deler strengen basert på mønsteret, og returnerer en matrise. Det tredje elementet i denne matrisen er id.

Til slutt henter du dokumentet med matchingen id fra databasen din. Hvis den finnes, send en svarkode på 200, lukk forespørselen og send den hentede bloggen. Hvis den ikke eksisterer, kast en feil og send den som et svar i catch-blokken.

POST-rute

Legg til kodeblokken nedenfor til ruterfunksjonen din for å implementere POST rutebehandler:

// POST: /api/blogs/
if (req.url "/api/blogs"&& req.metode "POST") {
prøve {
la kroppen = "";

// Lytt etter datahendelse
req.on("data", (klump) => {
body += chunk.toString();
});

// Lytt etter sluttbegivenhet
req.on("slutt", asynkron () => {
// Lag blogg
la blogg = ny Blogg(JSON.parse (kropp));

// Lagre til DB
avvente blog.save();
res.writeHead (200, { "Innholdstype": "applikasjon/json" });
res.slutt(JSON.stringify(blogg));
});
} å fange (feil) {
konsoll.log (feil);
}
}

Forespørselsobjektet implementerer Node.js ReadableStream grensesnitt. Denne strømmen avgir en data og en slutt hendelse som gir deg tilgang til data fra forespørselsorganet.

Denne koden lytter etter datahendelsen og håndterer den ved å konvertere den til en streng og sette den sammen til kropp variabel. I slutt hendelsesbehandler, skaper den en Blogg forekomst med den analyserte brødtekststrengen. Den lagrer deretter den nye bloggen, sender statuskoden og innholdsoverskriften og lukker forespørselen.

PUT Rute

Legg til kodeblokken nedenfor til ruterfunksjonen din for å implementere SETTE rutebehandler:

// PUT: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.metode "SETTE") {
prøve {
// trekke ut id fra url
const id = req.url.split("/")[3];
la kroppen = "";

req.on("data", (klump) => {
body += chunk.toString();
});
req.on("slutt", asynkron () => {
// Finn og Oppdaterdokument
la oppdatert blogg = avvente Blog.findByIdAndUpdate (id, JSON.parse (body), {
ny: ekte,
});

res.writeHead (200, { "Innholdstype": "applikasjon/json" });
res.slutt(JSON.stringify(oppdatert blogg));
});
} å fange (feil) {
konsoll.log (feil);
}
}

PUT-forespørselsbehandleren er nesten identisk med POST forespørselsbehandler, bortsett fra at den trekker ut id eiendom fra url for å oppdatere den aktuelle bloggen.

SLETT rute

Legg til kodeblokken nedenfor til ruterfunksjonen din for å implementere din SLETT rutebehandler:

// SLETT: /api/blogger/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.metode "SLETT") {
prøve {
const id = req.url.split("/")[3];

// Slett blogg fra DB
avvente Blog.findByIdAndDelete (id);
res.writeHead (200, { "Innholdstype": "applikasjon/json" });
res.end (JSON.stringify({ melding: "Bloggen ble slettet" }));
} å fange (feil) {
res.writeHead (404, { "Innholdstype": "applikasjon/json" });
res.slutt(JSON.stringify({ beskjed: feil }));
}
}

Denne kodeblokken trekker ut id fra url, sletter dokumentet med samsvarende id, sender statuskoden og overskriftene og lukker forespørselen.

Til slutt, import ruter i din server.js fil og ring din ruter funksjon, bestått rekv og res som argumenter:

konst ruter = krever("./routes/blogRoutes");

konst server = http.createServer((req, res) => {
ruter (req, res);
});

Dette lar serveren din fange opp og håndtere forespørsler på riktig måte.

Du finner det ferdige prosjektet i denne GitHub-depot.

Bruke et Node.js-rammeverk

Selv om det er mulig å lage et web-API for hånd, kan det være en vanskelig oppgave. Du må sørge for at du har dekket mange kantsaker, og at koden din bør være feilfri.

Gjennom årene har utviklere bygget rammeverk som ExpressJS, NestJS, Fastify, etc., for å gjøre det mye enklere.