Home-theater-designers
Node.js to środowisko uruchomieniowe JavaScript o otwartym kodzie źródłowym, zbudowane na silniku v8 chrome, który umożliwia uruchamianie kodu JavaScript poza przeglądarką.
Jego model zdarzeń, ekosystem i szybkość sprawiły, że Node.js jest jednym z najbardziej pożądanych i używanych środowisk wykonawczych dla aplikacji po stronie serwera.
Większość serwerów Node.js API używa Express lub innego frameworka. Możesz jednak również stworzyć proste API Node.js bez frameworka w zaledwie kilku krokach.
MAKEUSEOF WIDEO DNIA
Krok 1: Konfiguracja środowiska programistycznego
Utwórz katalog projektu i płyta CD do niego, uruchamiając:
mkdir nodejs-api
cd nodejs-api
Następnie zainicjuj npm w swoim projekcie, uruchamiając:
npm init -y
Ten interfejs API CRUD będzie wykorzystywał MongoDB, bazę danych NoSQL i jej popularny ODM, mangusta.
Uruchom następujące polecenie, aby zainstalować mangusta :
npm install mongoose
Następnie utwórz serwer.js plik w katalogu głównym projektu i dodaj poniższy blok kodu, aby utworzyć serwer:
const http = require("http");
const server = http.createServer((req, res) => {});
server.listen(3000, () => {
console.log(`Server is running`);
});
Ten blok kodu importuje moduł http, podstawowy moduł Node.js. Moduł http umożliwia Node.js przesyłanie danych przez HTTP. Ten moduł zawiera metody wymagane do utworzenia serwera.
Następnie wywołuje moduł http utwórzSerwer metoda, która tworzy i zwraca instancję serwera. The utwórzSerwer Metoda przyjmuje funkcję zwrotną z obiektem żądania i odpowiedzi jako parametry.
Następnie kod wywołuje słuchać metody na zwróconej instancji serwera. Pozwala to serwerowi na rozpoczęcie nasłuchiwania ruchu na danym porcie. The słuchać metoda uruchamia wywołanie zwrotne — drugi argument — gdy się powiedzie.
Na koniec utwórz dwa katalogi o nazwie trasy oraz modele w katalogu głównym projektu. The trasy folder będzie zawierał logikę routingu dla twojego API, podczas gdy Model będzie zawierać wszystko, co dotyczy bazy danych.
jak sprawdzić iPhone'a pod kątem wirusa
Krok 2: Łączenie aplikacji z bazą danych
W serwer.js , import mangusta :
const mongoose = require("mongoose");
Zadzwoń do łączyć metoda włączona mangusta i przekaż swój URI MongoDB jako argument:
mongoose.connect("MongoDB_URI")
Krok 3: Tworzenie modelu API
Utwórz CRUD API dla prostej aplikacji blogowej. W Twoim modele folder, utwórz blogModel.js plik i dodaj następujący kod do swojego pliku:
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);
Powyższy blok kodu tworzy model mangusty z dwiema właściwościami i mapuje je do bazy danych MongoDB.
Obie właściwości w tym modelu mają Strunowy wpisz z wymagany Ustawić PRAWDA . Towarzyszące komunikaty o błędach zostaną wyświetlone, jeśli treść żądania nie zawiera żadnej z właściwości.
Ostatnia linia tworzy i eksportuje model mangusty, wywołując Model metoda włączona mangusta. Podaj nazwę modelu ( Blog ) jako pierwszy argument i schemat ( blogSchedule ) jako drugi argument.
Krok 4: Implementacja routingu w Twojej aplikacji
Bez pomocy frameworki takie jak Express , musisz ręcznie utworzyć logikę do obsługi każdego żądania wysłanego do Twojego interfejsu API.
Najpierw utwórz blogRoutes.js plik w twoim trasy folderu, a następnie zaimportuj model bloga:
const Blog = require("../models/blogModel");
Następnie utwórz asynchroniczny router funkcja, pass wymagane oraz res jako parametry i wyeksportuj funkcję:
const router = async function (req, res) {};
module.exports = router;
Ta funkcja zawiera całą logikę routingu.
Następnie zaimplementujesz trasę logiki routingu według trasy.
POBIERZ Trasy
Dodaj poniższy blok kodu do swojego router funkcja do realizacji DOSTAWAĆ obsługa tras dla próśb skierowanych do /api/blogi :
// 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));
}
Powyższy blok kodu sprawdza adres URL oraz metoda właściwości obiektu żądania. Następnie pobiera wszystkie blogi z bazy danych za pomocą odnaleźć metoda na modelu mangusty ( Blog ).
Następnie nazywa Napisz Głowę metoda włączona res , obiekt odpowiedzi. Ta metoda wysyła nagłówek odpowiedzi z trzema argumentami: kodem stanu, opcjonalnym komunikatem o stanie i nagłówkami. The 200 kod stanu reprezentuje pomyślną odpowiedź, a typ zawartości dla tego wywołania interfejsu API jest ustawiony na aplikacja/json .
Na koniec zamknij żądanie, aby upewnić się, że serwer nie zawiesi się, wywołując koniec metoda włączona res . Wezwanie do JSON.stringify konwertuje blogi obiekt do ciągu JSON i przekazanie go do koniec Metoda zwraca ją jako treść odpowiedzi.
Dodaj poniższy blok kodu do swojego router funkcja do realizacji DOSTAWAĆ procedura obsługi tras dla pojedynczego zasobu:
// 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 }));
}
}
Ten kod używa mecz metoda, która jako argument przyjmuje wyrażenie regularne, aby sprawdzić, czy adres URL jest zgodny z formatem: /api/blogs/
Następnie wyodrębnij ID nieruchomość z adres URL ciąg, wywołując jego rozdzielać metoda. Ta metoda przyjmuje wzorzec jako argument ( / ), dzieli ciąg na podstawie wzorca i zwraca tablicę. Trzecim elementem tej tablicy jest ID .
Na koniec pobierz dokument z pasującym ID z Twojej bazy danych. Jeśli istnieje, wyślij kod odpowiedzi 200 , zamknij żądanie i wyślij pobrany blog. Jeśli nie istnieje, zgłoś błąd i wyślij go jako odpowiedź w bloku catch.
POST Trasa
Dodaj poniższy blok kodu do funkcji routera, aby zaimplementować POCZTA obsługa trasy:
// 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);
}
}
Obiekt żądania implementuje Node.js ReadableStream interfejs. Ten strumień emituje a dane i koniec zdarzenie, które daje dostęp do danych z treści żądania.
Ten kod nasłuchuje zdarzenia danych i obsługuje je, konwertując je na ciąg i łącząc je z ciało zmienny. w koniec obsługa zdarzeń, tworzy Blog wystąpienie z przeanalizowanym ciągiem treści. Następnie zapisuje nowego bloga, wysyła kod stanu i nagłówek treści oraz zamyka żądanie.
Trasa PUT
Dodaj poniższy blok kodu do funkcji routera, aby zaimplementować POŁOŻYĆ obsługa trasy:
// 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);
}
}
Program obsługi żądań PUT jest prawie identyczny z POCZTA obsługi żądań, z wyjątkiem tego, że wyodrębnia ID nieruchomość z adres URL aby zaktualizować odpowiedni blog.
USUŃ trasę
Dodaj poniższy blok kodu do funkcji routera, aby zaimplementować swój KASOWAĆ obsługa trasy:
// 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 }));
}
}
Ten blok kodu wyodrębnia ID od adres URL , usuwa dokument z pasującym ID , wysyła kod stanu i nagłówki oraz zamyka żądanie.
Wreszcie, importuj router w Twoim serwer.js złóż plik i zadzwoń router funkcja, przekazywanie wymagane oraz res jako argumenty:
const router = require("./routes/blogRoutes");
const server = http.createServer((req, res) => {
router(req, res);
});
Dzięki temu serwer może odpowiednio przechwytywać i obsługiwać żądania.
W tym miejscu możesz znaleźć ukończony projekt Repozytorium GitHub .
Korzystanie z frameworka Node.js
Chociaż możliwe jest ręczne utworzenie internetowego interfejsu API, może to być trudne zadanie. Musisz upewnić się, że omówiłeś wiele przypadków brzegowych, a Twój kod powinien być wolny od błędów.
Przez lata programiści budowali frameworki, takie jak ExpressJS, NestJS, Fastify itp., aby to znacznie ułatwić.