Home-theater-designers
Node.js és un temps d'execució JavaScript de codi obert basat en el motor v8 de Chrome que us permet executar codi JavaScript fora d'un navegador.
El seu model d'esdeveniments, ecosistema i velocitat han fet de Node.js un dels temps d'execució més desitjats i utilitzats per a aplicacions del costat del servidor.
La majoria dels servidors d'API Node.js utilitzen Express o un altre marc. Tanmateix, també podeu crear una API Node.js senzilla sense marc en només uns quants passos.
MAKEUSEO VÍDEO DEL DIA
Pas 1: Configura el teu entorn de desenvolupament
Creeu un directori de projectes i cd en ella executant:
mkdir nodejs-api
cd nodejs-api
A continuació, inicialitzeu npm al vostre projecte executant:
les tecles de fletxa no funcionen en Excel
npm init -y
Aquesta API CRUD comptarà amb l'ús de MongoDB, una base de dades NoSQL i el seu popular ODM, mangosta.
Executeu la següent comanda per instal·lar mangosta :
npm install mongoose
A continuació, creeu un server.js fitxer al directori arrel del vostre projecte i afegiu el bloc de codi següent per crear un servidor:
const http = require("http");
const server = http.createServer((req, res) => {});
server.listen(3000, () => {
console.log(`Server is running`);
});
Aquest bloc de codi importa el mòdul http, un mòdul bàsic de Node.js. El mòdul http permet a Node.js transferir dades mitjançant HTTP. Aquest mòdul conté els mètodes necessaris per crear un servidor.
A continuació, crida al mòdul http createServer mètode que crea i retorna una instància d'un servidor. El createServer El mètode pren una funció de devolució de trucada amb un objecte de sol·licitud i resposta com a paràmetres.
A continuació, el codi crida a escolta mètode a la instància del servidor retornada. Això permet que el servidor comenci a escoltar el trànsit al port donat. El escolta El mètode dispara una devolució de trucada (el segon argument) quan té èxit.
Finalment, creeu dos directoris anomenats rutes i models al directori arrel del vostre projecte. El rutes La carpeta contindrà la lògica d'encaminament de la vostra API, mentre que model contindrà tot allò relacionat amb la base de dades.
Pas 2: connecteu la vostra aplicació a una base de dades
En server.js , importació mangosta :
const mongoose = require("mongoose");
Truqueu al connectar mètode activat mangosta i passeu el vostre URI de MongoDB com a argument:
mongoose.connect("MongoDB_URI")
Pas 3: Creació d'un model d'API
Creeu una API CRUD per a una aplicació de bloc senzilla. En el teu models carpeta, creeu una blogModel.js fitxer i afegiu el codi següent al vostre fitxer:
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);
El bloc de codi anterior crea un model de mangosta amb dues propietats i les assigna a una base de dades MongoDB.
hi ha hagut un problema en restablir el Windows 10 del vostre PC
Les dues propietats d'aquest model tenen a Corda escriviu amb requerit ajustat a veritat . Els missatges d'error que s'acompanyen es mostraran si el cos de la sol·licitud no conté cap de les propietats.
La línia final crea i exporta un model de mangosta cridant al model mètode activat mangosta. Passeu el nom del model ( Bloc ) com a primer argument i esquema ( Horari del blog ) com a segon argument.
Pas 4: implementació de l'encaminament a la vostra aplicació
Sense l'ajuda de marcs com Express , haureu de crear manualment la lògica per gestionar cada sol·licitud feta a la vostra API.
Primer, creeu un blogRoutes.js fitxer al vostre rutes carpeta i, a continuació, importeu el model de bloc:
const Blog = require("../models/blogModel");
A continuació, creeu un asincrònic encaminador funció, passar requeriment i res com a paràmetres i exporteu la funció:
const router = async function (req, res) {};
module.exports = router;
Aquesta funció contindrà tota la vostra lògica d'encaminament.
A continuació, implementareu la ruta lògica d'encaminament per ruta.
OBTENIR rutes
Afegiu el bloc de codi següent al vostre encaminador funció per implementar la ACONSEGUIR gestor de rutes per a les sol·licituds realitzades a /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));
}
El bloc de codi anterior comprova el url i mètode propietats de l'objecte de sol·licitud. A continuació, obté tots els blocs de la base de dades mitjançant el trobar mètode en el model de mangosta ( Bloc ).
A continuació, anomena el Escriure Cap mètode activat res , l'objecte de resposta. Aquest mètode envia una capçalera de resposta amb tres arguments: un codi d'estat, un missatge d'estat opcional i capçaleres. El 200 el codi d'estat representa una resposta correcta i el tipus de contingut per a aquesta trucada d'API està establert a aplicació/json .
Finalment, tanqueu la sol·licitud per assegurar-vos que el servidor no es pengi trucant a final mètode activat res . La crida a JSON.stringify converteix el blocs objecte a una cadena JSON i passar-ho a final El mètode el retorna com a cos de resposta.
Afegiu el bloc de codi següent al vostre encaminador funció per implementar la ACONSEGUIR gestor de rutes per a un sol recurs:
// 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 }));
}
}
Aquest codi utilitza el partit mètode, que pren una expressió regex com a argument, per comprovar si l'URL coincideix amb el format: /api/blogs/
A continuació, extreu el id propietat de la url cadena cridant la seva dividit mètode. Aquest mètode pren un patró com a argument ( / ), divideix la cadena segons el patró i retorna una matriu. El tercer element d'aquesta matriu és el id .
Finalment, recupera el document amb la coincidència id de la vostra base de dades. Si existeix, envieu un codi de resposta de 200 , tanqueu la sol·licitud i envieu el bloc recuperat. Si no existeix, llenceu un error i envieu-lo com a resposta al bloc catch.
Ruta POST
Afegiu el bloc de codi següent a la funció de l'encaminador per implementar el PUBLICACIÓ gestor de rutes:
// 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);
}
}
L'objecte de sol·licitud implementa el Node.js ReadableStream interfície. Aquest corrent emet a dades i un final esdeveniment que us permeti accedir a les dades de l'òrgan de la sol·licitud.
Aquest codi escolta l'esdeveniment de dades i el gestiona convertint-lo en una cadena i concatenant-lo al cos variable. En el final gestor d'esdeveniments, crea un Bloc instància amb la cadena del cos analitzat. A continuació, desa el nou bloc, envia el codi d'estat i la capçalera del contingut i tanca la sol·licitud.
Ruta PUT
Afegiu el bloc de codi següent a la funció de l'encaminador per implementar el POSAR gestor de rutes:
aplicacions de text a veu per a Android
// 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);
}
}
El gestor de sol·licituds PUT és gairebé idèntic al PUBLICACIÓ gestor de peticions, tret que extreu el fitxer id propietat de la url per actualitzar el bloc corresponent.
ELIMINAR Ruta
Afegiu el bloc de codi següent a la funció de l'encaminador per implementar el vostre ELIMINAR gestor de rutes:
// 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 }));
}
}
Aquest bloc de codi extreu el id des del url , elimina el document amb la coincidència id , envia el codi d'estat i les capçaleres i tanca la sol·licitud.
Finalment, importar encaminador en el teu server.js arxiva i truca al teu encaminador funció, passant requeriment i res com a arguments:
const router = require("./routes/blogRoutes");
const server = http.createServer((req, res) => {
router(req, res);
});
Això permet al vostre servidor interceptar i gestionar les peticions de manera adequada.
Podeu trobar el projecte acabat en aquest Repositori GitHub .
Ús d'un marc Node.js
Tot i que és possible crear una API web a mà, pot ser una tasca difícil. Haureu d'assegurar-vos que heu cobert molts casos extrems i que el vostre codi sigui millor que estigui lliure d'errors.
Al llarg dels anys, els desenvolupadors han creat marcs com ExpressJS, NestJS, Fastify, etc., per fer-ho molt més fàcil.