Home-theater-designers
Node.js est un runtime JavaScript open source construit sur le moteur v8 de chrome qui vous permet d'exécuter du code JavaScript en dehors d'un navigateur.
Son modèle d'événement, son écosystème et sa vitesse ont fait de Node.js l'un des runtimes les plus recherchés et les plus utilisés pour les applications côté serveur.
comment obtenir de nouveaux emojis android
La plupart des serveurs d'API Node.js utilisent Express ou un autre framework. Cependant, vous pouvez également créer une simple API Node.js sans framework en quelques étapes seulement.
UTILISEZ LA VIDÉO DU JOUR
Étape 1 : Configuration de votre environnement de développement
Créez un répertoire de projet et CD en exécutant:
mkdir nodejs-api
cd nodejs-api
Ensuite, initialisez npm dans votre projet en exécutant :
npm init -y
Cette API CRUD comportera l'utilisation de MongoDB, une base de données NoSQL, et son ODM populaire, la mangouste.
Exécutez la commande suivante pour installer mangouste :
npm install mongoose
Ensuite, créez un serveur.js dans le répertoire racine de votre projet et ajoutez le bloc de code ci-dessous pour créer un serveur :
const http = require("http");
const server = http.createServer((req, res) => {});
server.listen(3000, () => {
console.log(`Server is running`);
});
Ce bloc de code importe le module http, un module Node.js principal. Le module http permet à Node.js de transférer des données via HTTP. Ce module contient les méthodes nécessaires pour créer un serveur.
Ensuite, il appelle le module http créer un serveur méthode qui crée et retourne une instance d'un serveur. La créer un serveur La méthode prend une fonction de rappel avec un objet de requête et de réponse comme paramètres.
Ensuite, le code appelle le Ecoutez méthode sur l'instance de serveur renvoyée. Cela permet au serveur de commencer à écouter le trafic sur le port donné. La Ecoutez La méthode déclenche un rappel (le deuxième argument) lorsqu'elle réussit.
Enfin, créez deux répertoires nommés itinéraires et des modèles dans le répertoire racine de votre projet. La itinéraires dossier contiendra la logique de routage de votre API, tandis que maquette contiendra tout ce qui concerne la base de données.
Étape 2 : Connecter votre application à une base de données
Dans serveur.js , importer mangouste :
const mongoose = require("mongoose");
Appeler le relier méthode sur mangouste et passez votre URI MongoDB en argument :
mongoose.connect("MongoDB_URI")
Étape 3 : Créer un modèle d'API
Créez une API CRUD pour une simple application de blog. Dans ton des modèles dossier, créez un blogModel.js fichier et ajoutez le code suivant à votre fichier :
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);
Le bloc de code ci-dessus crée un modèle de mangouste avec deux propriétés et les mappe à une base de données MongoDB.
Les deux propriétés de ce modèle ont une Chaîne de caractères taper avec obligatoire mis à vrai . Les messages d'erreur qui l'accompagnent s'afficheront si un corps de demande ne contient aucune des propriétés.
La dernière ligne crée et exporte un modèle de mangouste en appelant le maquette méthode sur mangouste. Passez le nom du modèle ( Blog ) comme premier argument et un schéma ( blogCalendrier ) comme deuxième argument.
Étape 4 : Implémenter le routage dans votre application
Sans l'aide de frameworks comme Express , vous devrez créer manuellement la logique pour gérer chaque requête adressée à votre API.
Tout d'abord, créez un blogRoutes.js fichier dans votre itinéraires dossier, puis importez le modèle de blog :
const Blog = require("../models/blogModel");
Ensuite, créez un asynchrone routeur fonction, passer demande et résolution en tant que paramètres, et exportez la fonction :
const router = async function (req, res) {};
module.exports = router;
Cette fonction contiendra toute votre logique de routage.
Ensuite, vous implémenterez la logique de routage route par route.
OBTENIR des itinéraires
Ajoutez le bloc de code ci-dessous à votre routeur fonction de mettre en œuvre le OBTENIR gestionnaire de route pour les requêtes adressées à /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));
}
Le bloc de code ci-dessus vérifie le URL et méthode propriétés de l'objet de requête. Il récupère ensuite tous les blogs de la base de données via le trouver méthode sur le modèle de la mangouste ( Blog ).
Ensuite, il appelle le tête d'écriture méthode sur résolution , l'objet de réponse. Cette méthode envoie un en-tête de réponse avec trois arguments : un code d'état, un message d'état facultatif et des en-têtes. La 200 le code d'état représente une réponse réussie et le type de contenu pour cet appel d'API est défini sur application/json .
Enfin, fermez la requête pour vous assurer que le serveur ne se bloque pas en appelant le fin méthode sur résolution . L'appel à JSON.stringify convertit le blogs objet à une chaîne JSON et en le transmettant au fin La méthode le renvoie comme corps de réponse.
Ajoutez le bloc de code ci-dessous à votre routeur fonction de mettre en œuvre le OBTENIR gestionnaire de route pour une seule ressource :
// 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 }));
}
}
Ce code utilise le match méthode, qui prend une expression regex comme argument, pour vérifier si l'url correspond au format : /api/blogs/
Ensuite, extrayez le identifiant propriété de la URL chaîne en appelant son diviser méthode. Cette méthode prend un motif comme argument ( / ), divise la chaîne en fonction du modèle et renvoie un tableau. Le troisième élément de ce tableau est le identifiant .
Enfin, récupérez le document avec la correspondance identifiant de votre base de données. S'il existe, envoyez un code de réponse de 200 , fermez la demande et envoyez le blog récupéré. S'il n'existe pas, lancez une erreur et envoyez-la comme réponse dans le bloc catch.
Acheminement POST
Ajoutez le bloc de code ci-dessous à votre fonction de routeur pour implémenter le PUBLIER gestionnaire d'itinéraire :
// 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'objet de requête implémente la Node.js ReadableStream interface. Ce flux émet un Les données Et un fin événement qui vous donne accès aux données du corps de la requête.
Ce code écoute l'événement de données et le gère en le convertissant en une chaîne et en le concaténant avec le corps variable. Dans le fin gestionnaire d'événements, il crée un Blog instance avec la chaîne de corps analysée. Il enregistre ensuite le nouveau blog, envoie le code d'état et l'en-tête de contenu, puis ferme la demande.
METTRE l'itinéraire
Ajoutez le bloc de code ci-dessous à votre fonction de routeur pour implémenter le METTRE gestionnaire d'itinéraire :
// 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);
}
}
Le gestionnaire de requêtes PUT est presque identique au PUBLIER gestionnaire de requêtes, sauf qu'il extrait le identifiant propriété de la URL pour mettre à jour le blog concerné.
SUPPRIMER l'itinéraire
Ajoutez le bloc de code ci-dessous à votre fonction de routeur pour implémenter votre EFFACER gestionnaire d'itinéraire :
// 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 }));
}
}
Ce bloc de code extrait le identifiant du URL , supprime le document avec la correspondance identifiant , envoie le code d'état et les en-têtes, puis ferme la demande.
Enfin, importez routeur dans ton serveur.js déposer et appeler votre routeur fonction, passage demande et résolution comme argument :
comment fonctionne le système de classement Overwatch
const router = require("./routes/blogRoutes");
const server = http.createServer((req, res) => {
router(req, res);
});
Cela permet à votre serveur d'intercepter et de gérer les demandes de manière appropriée.
Vous pouvez trouver le projet terminé dans ce Référentiel GitHub .
Utilisation d'un framework Node.js
Même s'il est possible de créer une API Web à la main, cela peut être une tâche difficile. Vous devrez vous assurer que vous avez couvert de nombreux cas extrêmes et que votre code a intérêt à être exempt de bogues.
Au fil des ans, les développeurs ont construit des frameworks comme ExpressJS, NestJS, Fastify, etc., pour le rendre beaucoup plus facile.