Node.js è un runtime JavaScript open source basato sul motore v8 di Chrome che ti consente di eseguire codice JavaScript al di fuori di un browser.
Il suo modello di eventi, l'ecosistema e la velocità hanno reso Node.js uno dei runtime più ricercati e utilizzati per le applicazioni lato server.
La maggior parte dei server API Node.js utilizza Express o un altro framework. Tuttavia, puoi anche creare una semplice API Node.js senza un framework in pochi passaggi.
Passaggio 1: configurazione dell'ambiente di sviluppo
Creare una directory di progetto e CD in esso eseguendo:
mkdir nodejs-api
CD nodejs-api
Quindi, inizializza npm nel tuo progetto eseguendo:
npm init -y
Questa API CRUD includerà l'uso di MongoDB, un database NoSQL, e il suo popolare ODM, mongoose.
Esegui il comando seguente per installare mangusta:
npm installare mangusta
Quindi, crea un server.js file nella directory principale del tuo progetto e aggiungi il blocco di codice di seguito per creare un server:
cost http = richiedere("http");
cost server = http.createServer((req, res) => {});
server.ascolta (3000, () => {
consolle.tronco d'albero(`Il server è in esecuzione`);
});
Questo blocco di codice importa il modulo http, un modulo principale di Node.js. Il modulo http consente a Node.js di trasferire dati su HTTP. Questo modulo contiene i metodi necessari per creare un server.
Successivamente, chiama i moduli http createServer metodo che crea e restituisce un'istanza di un server. Il createServer accetta una funzione di callback con una richiesta e un oggetto di risposta come parametri.
Successivamente, il codice chiama il ascoltare metodo sull'istanza del server restituita. Ciò consente al server di iniziare ad ascoltare il traffico sulla porta specificata. Il ascoltare il metodo attiva una richiamata, il secondo argomento, quando ha esito positivo.
Infine, crea due directory denominate itinerari e Modelli nella directory principale del tuo progetto. Il itinerari cartella conterrà la logica di routing per la tua API, while modello conterrà tutto ciò che riguarda il database.
Passaggio 2: collegare l'applicazione a un database
In server.js, importare mangusta:
cost mangusta = richiedere("mangusta");
Chiama il Collegare metodo attivo mangusta e passa il tuo URI MongoDB come argomento:
mangusta.connect("MongoDB_URI")
Passaggio 3: creazione di un modello API
Crea un'API CRUD per una semplice applicazione blog. Nel tuo Modelli cartella, creare un blogModel.js file e aggiungi il seguente codice al tuo file:
cost mangusta = richiedere("mangusta");
cost blogSchema = mangusta. Schema({
titolo: {
genere: Corda,
richiesto: [vero, "Il blog deve avere un titolo"],
},
corpo: {
genere: Corda,
richiesto: [vero, "Il blog deve avere un corpo"],
},
});
modulo.esportazioni = mongoose.model("Blog", blogSchema);
Il blocco di codice sopra crea un modello mongoose con due proprietà e le mappa su un database MongoDB.
Entrambe le proprietà in questo modello hanno a Corda digita con necessario impostato VERO. I messaggi di errore associati verranno visualizzati se il corpo di una richiesta non contiene nessuna delle proprietà.
La riga finale crea ed esporta un modello di mangusta chiamando il file modello metodo attivo mangusta. Passa il nome del modello (Blog) come primo argomento e uno schema (blogSchema) come secondo argomento.
Passaggio 4: implementazione del routing nella tua applicazione
Senza l'aiuto di framework come Express, dovrai creare manualmente la logica per gestire ogni richiesta effettuata alla tua API.
Innanzitutto, crea un blogRoutes.js file nel tuo itinerari cartella, quindi importa il modello di blog:
cost Blog = richiedere("../models/blogModel");
Quindi, crea un asincrono router funzione, passare richiesto e ris come parametri ed esportare la funzione:
cost router = asincronofunzione (req, ris) {};
modulo.esportazioni = router;
Questa funzione conterrà tutta la tua logica di routing.
Successivamente, implementerai la logica di routing route by route.
OTTIENI Percorsi
Aggiungi il blocco di codice qui sotto al tuo router funzione per implementare il OTTENERE route handler per le richieste fatte a /api/blogs:
// OTTIENI: /api/blogs
se (URL richiesto "/api/blogs"&& metodo.req "OTTENERE") {
// ottieni tutti i blog
cost blog = aspettare Blog.find();// impostare il stato codice econtenuto-genere
res.writeHead (200, { "Tipo di contenuto": "applicazione/json" });
// invia i dati
ris.fine(JSON.stringere(blog));
}
Il blocco di codice sopra controlla il URL e metodo proprietà dell'oggetto della richiesta. Quindi recupera tutti i blog dal database tramite il file trova metodo sul modello della mangusta (Blog).
Successivamente, chiama il scrivi Head metodo attivo ris, l'oggetto risposta. Questo metodo invia un'intestazione di risposta con tre argomenti: un codice di stato, un messaggio di stato facoltativo e intestazioni. Il 200 il codice di stato rappresenta una risposta riuscita e il tipo di contenuto per questa chiamata API è impostato su applicazione/json.
Infine, chiudi la richiesta per assicurarti che il server non si blocchi chiamando il fine metodo attivo ris. La chiamata a JSON.stringify converte il blog oggetto a una stringa JSON e passandolo a fine il metodo lo restituisce come corpo della risposta.
Aggiungi il blocco di codice qui sotto al tuo router funzione per implementare il OTTENERE gestore di route per una singola risorsa:
// OTTIENI: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && metodo.req "OTTENERE") {
Tentativo {
// estrai l'id dall'URL
const id = req.url.split("/")[3];// ottenere blog da DB
cost blog = aspettare Blog.findById (id);
se (blog) {
res.writeHead (200, { "Tipo di contenuto": "applicazione/json" });
ris.fine(JSON.stringere(blog));
} altro {
gettarenuovoErrore("Il blog non esiste");
}
} presa (errore) {
res.writeHead (404, { "Tipo di contenuto": "applicazione/json" });
ris.fine(JSON.stringere({ Messaggio: errore }));
}
}
Questo codice usa il incontro metodo, che accetta un'espressione regolare come argomento, per verificare se l'URL corrisponde al formato: /api/blogs/.
Quindi, estrai il id proprietà dal URL stringa chiamandola diviso metodo. Questo metodo accetta un modello come argomento (/), divide la stringa in base al modello e restituisce una matrice. Il terzo elemento di quell'array è il id.
Infine, recupera il documento con la corrispondenza id dal tuo database. Se esiste, inviare a codice di risposta 200, chiudi la richiesta e invia il blog recuperato. Se non esiste, genera un errore e invialo come risposta nel blocco catch.
Percorso POST
Aggiungi il blocco di codice qui sotto alla funzione del tuo router per implementare il INVIARE gestore del percorso:
// POST: /api/blog/
se (URL richiesto "/api/blogs"&& metodo.req "INVIARE") {
Tentativo {
lascia che il corpo = "";// Ascolta l'evento dati
rich.on("dati", (pezzo) => {
corpo += chunk.toString();
});// Ascolta fineevento
rich.on("fine", asincrono () => {
// Crea blog
permettere blog = nuovo Blog(JSON.analisi (corpo));
// Salva su DB
aspettare blog.save();
res.writeHead (200, { "Tipo di contenuto": "applicazione/json" });
ris.fine(JSON.stringere(blog));
});
} presa (errore) {
consolle.log (errore);
}
}
L'oggetto richiesta implementa il Node.js ReadableStream interfaccia. Questo flusso emette a dati e un fine evento che ti dà accesso ai dati dell'organismo di richiesta.
Questo codice ascolta l'evento di dati e lo gestisce convertendolo in una stringa e concatenandolo a corpo variabile. Nel fine gestore di eventi, crea a Blog istanza con la stringa del corpo analizzata. Quindi salva il nuovo blog, invia il codice di stato e l'intestazione del contenuto e chiude la richiesta.
PUT Percorso
Aggiungi il blocco di codice qui sotto alla funzione del tuo router per implementare il METTERE gestore del percorso:
// PUT: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && metodo.req "METTERE") {
Tentativo {
// estrai l'id dall'URL
const id = req.url.split("/")[3];
lascia che il corpo = "";rich.on("dati", (pezzo) => {
corpo += chunk.toString();
});
rich.on("fine", asincrono () => {
// Trova e aggiornaredocumento
permettere blog aggiornato = aspettare Blog.findByIdAndUpdate (id, JSON.analisi (corpo), {
nuovo: VERO,
});
res.writeHead (200, { "Tipo di contenuto": "applicazione/json" });
ris.fine(JSON.stringere(blog aggiornato));
});
} presa (errore) {
consolle.log (errore);
}
}
Il gestore delle richieste PUT è quasi identico a INVIARE gestore della richiesta, tranne per il fatto che estrae il file id proprietà dal URL per aggiornare il relativo blog.
CANCELLA Percorso
Aggiungi il blocco di codice di seguito alla funzione del tuo router per implementare il tuo ELIMINA gestore del percorso:
// ELIMINA: /api/blog/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && metodo.req "ELIMINA") {
Tentativo {
const id = req.url.split("/")[3];
// Elimina blog da DB
aspettare Blog.findByIdAndDelete (id);
res.writeHead (200, { "Tipo di contenuto": "applicazione/json" });
res.end (JSON.stringify({ messaggio: "Blog eliminato con successo" }));
} presa (errore) {
res.writeHead (404, { "Tipo di contenuto": "applicazione/json" });
ris.fine(JSON.stringere({ Messaggio: errore }));
}
}
Questo blocco di codice estrae il file id dal URL, elimina il documento con la corrispondenza id, invia il codice di stato e le intestazioni e chiude la richiesta.
Infine, importa router nel tuo server.js file e chiama il tuo router funzione, passaggio richiesto e ris come argomenti:
cost router = richiedere("./routes/blogRoutes");
cost server = http.createServer((req, res) => {
router (richiesto, res);
});
Ciò consente al tuo server di intercettare e gestire le richieste in modo appropriato.
Puoi trovare il progetto completato in questo Archivio GitHub.
Utilizzo di un framework Node.js
Anche se è possibile creare manualmente un'API Web, può essere un compito difficile. Dovrai assicurarti di aver coperto molti casi limite e che il tuo codice dovrebbe essere privo di bug.
Nel corso degli anni, gli sviluppatori hanno creato framework come ExpressJS, NestJS, Fastify, ecc., per renderlo molto più semplice.
