node.js est basé sur le moteur v8 de Chrome pour exécuter du code js , nous pouvons donc nous débarrasser de l'environnement du navigateur et exécuter du code js directement dans la console, comme le hello world suivant hello world code
console.log('hello world'); Vous pouvez l'exécuter directement en utilisant node dans la console
Le module http intégré de node.js fournit des fonctionnalités de service http de base. Sur la base de http createServer CommonJS , nous pouvons utiliser require pour importer le module http à utiliser. module qui nous permet de créer un http Le serveur reçoit une fonction de rappel en paramètre. Cette fonction de rappel reçoit deux paramètres - request et response .
request comprend toutes les informations demandées par le client, telles que url , header de la requête, la méthode de la requête et. corps de la requête.Laresponse est principalement utilisée pour renvoyer des informations.Le client encapsule certaines opérations liées au corps de la réponse.Par exemple, la méthode response.writeHead nous permet de personnaliser les informations d'en-tête et le code d'état du corps de retour. le corps de la réponse, nous appelons response.end() . Vous pouvez envoyer le corps de la réponse au client. L'utilisation de la fonction createServer crée uniquement un objet Server pour nous, mais ne lui permet pas d'écouter. Méthode listen de server à écouter. Nous pouvons en fait commencer à exécuter
listen en tant que serveur. Le premier paramètre est le numéro de port d'écoute, le deuxième paramètre est l' ip de l'hôte lié et le troisième paramètre est une fonction de rappel qui sera. appelé de manière asynchrone par le module http . Lorsqu'une erreur est rencontrée, elle peut être L'exception levée est obtenue à partir du premier paramètre de la fonction de rappel. Nous pouvons choisir de gérer l'exception pour rendre notre serveur plus robuste. en utilisant le module http pour créer un serveur simple.
const { createServer } = require('http' );
const HÔTE = 'localhost';
const PORT = '8080';
const serveur = createServer((req, resp) => {
// le premier paramètre est le code d'état qu'il renvoie
// et le deuxième paramètre est l'information d'en-tête de réponse
resp.writeHead(200, { 'Content-Type' : 'text/plain' });
console.log('le serveur fonctionne...');
// appelle la méthode de fin pour indiquer au serveur que la demande a été satisfaite
resp.end('bonjour serveur http nodejs');
});
server.listen(PORT, HOST, (erreur) => {
si (erreur) {
console.log('Quelque chose ne va pas : ', erreur);
retour;
}
console.log(`le serveur écoute sur http://${HOST}:${PORT} ...`);
}); Vous pouvez directement essayer de l'exécuter avec node et créer votre propre serveur ! Une fois le serveur exécuté, le navigateur peut accéder au serveur en accédant à http://localhost:8080
Vous pouvez également utiliser nodemon pour l'exécuter, de sorte que lorsque notre code change, nous n'ayons pas besoin de terminer manuellement le programme et de réexécuter
npm i -g nodemon.
Il est recommandé de l'installer globalement afin que vous puissiez l'utiliser directement. sans utiliser npx nodemon C'est également très simple, remplacez simplement la commande node par la commande nodemon
nodemon http-server.js.
. Lorsque nous avons utilisé les objets createServer et resp plus tôt, nous n'avons pu voir aucune invite de syntaxe. Nous devons suivre la documentation officielle node pour le vérifier à tout moment. C'est un peu gênant, mais cela n'a pas d'importance. peut utiliser .d.ts nous aide à fournir la fonction d'invite de syntaxe. Notez que nous n'utilisons pas ts pour le développement, mais utilisons uniquement sa fonction d'invite de syntaxe
npm init -y@types/node -- pnpm i @types/node -Djsconfig.json dans le répertoire du projet, excluez node_modules , il n'est pas nécessaire de le vérifier{ "compilerOptions": {
"checkJs": vrai
},
"exclure": ["node_modules", "**/node_modules/*"]
} Je me demande si vous avez découvert qu'il y a réellement une erreur dans le code ci-dessus ? checkJs peut nous aider à vérifier les erreurs de type. Vous pouvez choisir de l'activer en fonction de vos besoins. Après avoir activé la vérification, il nous avertira immédiatement de l'incompatibilité des types de paramètres.
À ce stade, passez la souris sur la méthode listen et vous pourrez voir la signature de la méthode.
Comme vous pouvez le voir, le paramètre port d'origine doit être de type number , mais lorsque nous l'avons défini, il était de type string , il ne correspond donc pas. Remplacez-le simplement par 8080 de number et vous pouvez directement consulter la documentation api correspondante. sans ouvrir le node officiel . Il m'a fallu beaucoup de temps pour trouver le document et le vérifier.
.Notre simple http server n'a renvoyé qu'une seule phrase, est-il donc possible de renvoyer plusieurs phrases ? Cela nécessite d'utiliser la méthode write de l'objet resp . end ne peut renvoyer le contenu qu'une seule fois. Au lieu de cela, nous pouvons écrire le end dans le corps de la write plusieurs fois. transmettez tous les paramètres. Laissez-le seulement remplir la fonction d'envoi du corps de réponse
const { createServer } = require("http");
const HÔTE = "localhost" ;
constPORT = 8080 ;
const serveur = createServer((req, resp) => {
resp.writeHead(200, { "Content-Type": "text/plain" });
console.log("le serveur fonctionne...");
// écris quelques phrases de lorem
resp.write("Lorem ipsum dolor sit amet consectetur adipisicing elit.n");
resp.write("Omnis eligendi aperiam delectus?n");
resp.write("Aut, quam quo!n");
resp.end();
});
server.listen(PORT, HOST, (erreur) => {
si (erreur) {
console.log("Quelque chose ne va pas : ", erreur);
retour;
}
console.log(`le serveur écoute sur http://${HOST}:${PORT} ...`);
}); Cette fois, nous avons écrit trois phrases, et l'effet devient maintenant celui-ci.
nous pouvons non seulement renvoyer une chaîne au navigateur, mais également lire directement le contenu du fichier html et le renvoyer au navigateur en conséquence. Cela nécessite l'utilisation d'un autre module intégré de Node.js -. fs , qui Le module fournit la fonction d'opération de fichier. Vous pouvez utiliser fs.readFile pour lire des fichiers de manière asynchrone, mais il ne renverra pas d'objet promise , nous devons donc transmettre un rappel pour gérer l'opération après avoir lu le fichier. peut également utiliser fs.readFileSync pour bloquer la lecture de fichiers de manière synchrone, nous choisissons ici la lecture asynchrone
const { createServer } = require("http");
const fs = require("fs");
const HÔTE = "localhost" ;
const PORT = 8080;const serveur = createServer((req, resp) => {
// change le type MIME de text/plain en text/html
resp.writeHead(200, { "Content-Type": "text/html" });
// lit le contenu du fichier html
fs.readFile("index.html", (erreur, données) => {
si (erreur) {
console.erreur(
"une erreur s'est produite lors de la lecture du contenu du fichier html : ",
se tromper
); jetez une erreur ;
}
console.log("opération réussie!");
resp.write(data);
resp.end();
});
});
server.listen(PORT, HOST, (erreur) => {
si (erreur) {
console.log("Quelque chose ne va pas : ", erreur);
retour;
}
console.log(`le serveur écoute sur http://${HOST}:${PORT} ...`);
}); Le résultat actuel est le suivant :
Renvoyez html avec succès Remarque : Ici, vous devez modifier **Content-Type** de l'en-tête de réponse en **text/html** pour informer le navigateur que nous renvoyons le contenu du fichier **html** . Si vous utilisez toujours **text/plain** est renvoyé, le navigateur n'analysera pas le contenu renvoyé, même s'il est conforme à la syntaxe **html** , il ne sera pas analysé, tout comme ce qui suit :
Lorsque nous devons écrire un serveur back-end qui est uniquement responsable du renvoi des données d'interface, nous devons renvoyer le contenu au format json . Je pense que vous êtes intelligent et savez comment le gérer :
MIME sur application/jsonresp.write , la chaîne json est transmise. Vous pouvez utiliser JSON.stringify pour traiter l'objet et renvoyerconst { createServer } = require("http");
const HÔTE = "localhost" ;
constPORT = 8080 ;
const serveur = createServer((req, resp) => {
// change le type MIME en application/json
resp.writeHead(200, { "Content-Type": "application/json" });
// crée une donnée json en utilisant un objet
const jsonDataObj = {
code: 0,
message : "succès",
données: {
nom : "pâte à modeler",
âge : 20 ans,
hobby : "coder",
},
} ;
resp.write(JSON.stringify(jsonDataObj));
resp.end();
});
server.listen(PORT, HOST, (erreur) => {
si (erreur) {
console.log("Quelque chose ne va pas : ", erreur);
retour;
}
console.log(`le serveur écoute sur http://${HOST}:${PORT} ...`);
}); Les résultats sont les suivants :
L'idée de renvoyer des fichiers PDF est similaire à celle du renvoi de fichiers html auparavant. Il s'agit à la fois d'un processus de définition du type MIME de l'en-tête de réponse, de lecture du fichier et de renvoi du contenu du fichier. quelque chose de différent. Notre idée est de le faire pendant que le serveur est en cours d'exécution. Pour générer un fichier pdf et le renvoyer, vous devez changer MIME en application/pdf Pour générer un fichier pdf , vous devez utiliser une bibliothèque - pdfkit
pnpm et pdfkit.
Tout d'abord, nous écrivons une fonction pour créer un fichier pdf , car la création d'un fichier pdf nécessite également d'effectuer quelques opérations d'écriture, nous ne savons pas quand elle sera terminée, mais notre demande doit attendre que pdf soit créé avant de pouvoir pouvoir le faire. obtenir une réponse, nous devons donc la rendre asynchrone et renvoyer une promise
/**
* @description Créer un fichier pdf */const createPdf = () => {
renvoyer une nouvelle promesse ((résoudre, rejeter) => {
if (!fs.existsSync("exemple.pdf")) {
// crée un objet PDFDocument
const doc = nouveau PDFDocument();
// crée un flux d'écriture en redirigeant le contenu pdf.
doc.pipe(fs.createWriteStream("exemple.pdf"));
// ajoute du contenu au document pdf
doc.fontSize(16).text("Bonjour PDF", 100, 100);
// termine l'opération de génération du fichier PDF.
doc.end();
}
résoudre("succès");
});
}; L'opération de pipeline est utilisée ici pour transférer le contenu de PDFDocument vers le flux d'écriture nouvellement créé via le pipeline. Lorsque l'opération est terminée, nous informons le monde extérieur par resovle que le fichier pdf a été créé, puis appelons
const. server dans le code du serveur. = createServer(async (req, resp) => {
// change le type MIME en application/pdf
resp.writeHead(200, { "Content-Type": "application/pdf" });
// crée un fichier pdf
attendre createPdf();
// lit le fichier pdf créé
fs.readFile("exemple.pdf", (erreur, données) => {
si (erreur) {
console.erreur(
"une erreur s'est produite lors de la lecture du contenu du fichier pdf : ",
se tromper
);
jeter l'erreur;
}
console.log("opération réussie!");
resp.end(données);
});
});
server.listen(PORT, HOST, (erreur) => {
si (erreur) {
console.log("Quelque chose ne va pas : ", erreur);
retour;
}
console.log(`le serveur écoute sur http://${HOST}:${PORT} ...`);
}); Le navigateur peut désormais lire le fichier pdf créé.
est toujours la même. Lisez un fichier audio, puis envoyez-le à l'objet resp via un pipeline et renvoyez-le
const { createServer } = require("http");
const {stat, createReadStream } = require("fs");
const HÔTE = "localhost" ;
constPORT = 8080 ;
const serveur = createServer((req, resp) => {
// change le type MIME en audio/mpe
resp.writeHead(200, { "Content-Type": "audio/mp3" });
const mp3FileName = "audio.mp3";
stat(mp3FileName, (err, stats) => {
si (stats.isFile()) {
const rs = createReadStream(mp3FileName);
// redirige le flux de lecture vers resp
rs.pipe(resp);
} autre {
resp.end("le fichier mp3 n'existe pas");
}
});
});
server.listen(PORT, HOST, (erreur) => {
si (erreur) {
console.log("Quelque chose ne va pas : ", erreur);
retour;
}
console.log(`le serveur écoute sur http://${HOST}:${PORT} ...`);
}); L'effet est le suivant
Après ouverture, il existe une interface pour la lecture audio. Il s'agit de l'affichage des fichiers audio fournis par chrome . Lorsque vous ouvrez la console, vous constaterez que des fichiers audio sont renvoyés.
Remarque : Après avoir transmis le flux du fichier audio à **resp** via le tube , il n'est pas nécessaire d'appeler **resp.end()** , car cela fermera la réponse entière et entraînera la suppression du fichier audio. indisponible.
Le traitement des fichiers vidéo et des fichiers audio est le même, sauf que MIME doit être modifié en video/mp4 . Tout le reste est le même
const { createServer } = require("http");
const {stat, createReadStream } = require("fs");
const HÔTE = "localhost" ;
constPORT = 8080 ;
const serveur = createServer((req, resp) => {
// change le type MIME en audio/mpe
resp.writeHead(200, { "Content-Type": "audio/mp4" });
const mp4FileName = "vidéo.mp4";
stat(mp4FileName, (err, stats) => {
si (stats.isFile()) {
const rs = createReadStream(mp4FileName);
// redirige le flux de lecture vers resp
rs.pipe(resp);
} autre {
resp.end("le fichier mp4 n'existe pas");
}
});
});
server.listen(PORT, HOST, (erreur) => {
si (erreur) {
console.log("Quelque chose ne va pas : ", erreur);
retour;
}
console.log(`le serveur écoute sur http://${HOST}:${PORT} ...`);
});
nous avons appris :
Node pour créer un serveur httpjsJSONhtmlpdf .Bien que le contenu soit simple, il l'est toujours. J'espère que vous pourrez le suivre et l'essayer. Ne pensez pas que c'est facile de le regarder simplement parce que vous le regardez. Cela ne veut pas dire que vous le savez. Vous ne découvrirez vos propres problèmes qu'après l'avoir réellement mis en œuvre.