Utilisation de l'objet HTTP dans Node.js

Le module HTTP dans nos applications écrites en Node.js Ils nous aident à construire une partie des fonctionnalités pour donner vie à nos serveurs, cependant ce n'est pas l'usage exclusif que nous pouvons donner à ce module.
Le vrai pouvoir de HTTP est visible lorsque nous utilisons votre objet pour traiter les différentes demandes ou demande qui peuvent provenir de notre application, avec cela nous pouvons traiter les données qui proviennent de PUBLIER via des formulaires ou des demandes clients DU REPOS.
Exigences du didacticielPour réaliser les exercices proposés dans ce tutoriel nous devons disposer d'une installation fonctionnelle de Node.js dans notre système et avoir les autorisations pour y accéder. Il est également important de pouvoir avoir accès à un éditeur de texte riche pour coder les exemples, nous pouvons utiliser ce avec quoi nous nous sentons à l'aise, cependant, pour sa facilité d'utilisation, nous recommandons Texte sublime ou alors Bloc-notes ++ qui ont également des add-ons pour la syntaxe JavaScript Oui HTML.
Traitement de l'information PUBLIER nous permet d'acquérir des données à partir de formulaires, ce qui nous permet de gérer les données provenant des interactions des utilisateurs avec nos applications, nous permettant ainsi de mettre en œuvre une logique métier pour traiter ces données.
La manière la plus directe dont nous disposons pour traiter les données PUBLIER c'est à travers Objet HTTP, par interaction directe avec la méthode createServer () nous pouvons identifier le type de méthode de la requête, soit PUBLIER ou alors AVOIR et même METTRE Oui EFFACER.
Si nous sommes des observateurs, nous voyons que cela nous fait penser à nos applications d'une manière Reposant, c'est-à-dire que nous pouvons communiquer avec lui via différents clients et pas nécessairement avec des formulaires HTMLCependant, c'est un sujet qui va au-delà de ce tutoriel.
La première chose que nous allons faire est de créer un petit formulaire qui va nous permettre de capturer les données de notre application dans le navigateur, pour cela nous allons créer un fichier appelé formulaire.html dans le répertoire ou dossier de notre application.
Ce dernier n'est pas recommandé dans un environnement de production donc nous le prendrons uniquement comme référence pour pouvoir démontrer le fonctionnement du système. Objet HTTP. Le code de notre formulaire sera le suivant :

Comme on peut le voir, nous indiquons simplement à notre formulaire qu'il doit utiliser la méthode PUBLIER, nous avons quelques champs de texte, et enfin un bouton nous faire parvenir pour envoyer nos données au serveur.
Maintenant, nous devons créer le serveur Node.js qui nous aidera à collecter les données du formulaire, ici nous devons prendre en compte deux possibilités, la première est lorsque nous accédons au chemin de notre application, cela utilisera la méthode AVOIR et c'est là que nous devons montrer notre forme.
La deuxième possibilité est quand les données du formulaire sont envoyées et pour cela il faut valider la méthode PUBLIER qui est le but de l'exercice. Pour que nous puissions afficher le formulaire, nous devons créer un composant synchrone qui lit notre fichier formulaire.html et le servir dans la route correspondante, pour cela nous pouvons compter sur la méthode readFileSync du module fs.
Dans la partie suivante, nous devons faire en sorte que notre serveur puisse gérer les données PUBLIER, pour cela nous allons simplement montrer ce que nous recevons dans la console avec la méthode console.log(), de cette façon, nous pouvons confirmer que tout fonctionne correctement, voyons le code initial pour obtenir ce que nous voulons :

 var http = require ('http'); var querystring = require ('querystring'); var util = require ('util'); var form = require ('fs'). readFileSync ('form.html'); http .createServer (function (request, response) {if (request.method === "POST") {var dataPost = ''; request.on ('data', function (chunk) {dataPost + = chunk;}). on ('end', function () {var dataPostObject = querystring.parse (dataPost); console.log ('User sent data: \ n', dataPost); response.end ('Vous avez envoyé des données : \ n '+ util.inspect (dataPostObject));});} if (request.method === "GET") {response.writeHead (200, {' Content-Type ':' text / html '}); réponse. end ( forme);}}) écouter (8082);

Pour que tout soit le plus lisible possible, les modules ont été en plus intégrés chaîne de requête Oui Utile, avec eux nous pouvons traiter les informations qui viennent du serveur et ainsi pouvoir les manipuler pour les imprimer.
Voyons à quoi devrait ressembler initialement notre formulaire lorsque nous démarrons notre application et ouvrons le navigateur à la racine du projet :

AGRANDIR

Nous allons maintenant entrer des données dans les champs de texte que nous voyons dans notre formulaire et cliquer sur le bouton d'envoi, cela nous présentera un écran avec les données envoyées et nous imprimera la console. demande simple, c'est-à-dire tel qu'il est reçu par notre application :

Nous avons vu alors qu'il était très facile de traiter les données du formulaire, au moins de les montrer à nouveau.
Bien que l'exemple précédent fonctionne correctement, il présente certaines faiblesses selon lesquelles si l'application devait entrer en production, cela pourrait nous causer plus de maux de tête, par exemple, que se passe-t-il si elle nous envoie plus de données que la mémoire de notre serveur ne peut en supporter, évidemment notre toute la structure s'effondrerait. Si nous recevons des données de PUBLIER vide, dans l'état actuel de notre application, cela échouerait et nous obtiendrions une erreur qui ferait planter notre service et cesserait de fonctionner.
Pour corriger ces défauts nous devons simplement incorporer quelques validations très simples, tout d'abord nous allons incorporer une variable qui nous aidera à limiter les données reçues à un maximum de 2 MoCela peut nous donner un peu de sécurité qu'au moins avec peu d'utilisateurs, il ne sera pas possible que le système tombe en panne. Ensuite, nous évaluerons cela afin que notre demande PUBLIER être traité le Objet HTTP qui le contient ne peut pas être vide, nous veillons donc à ce qu'il n'y ait pas de pannes directes sur notre serveur. Regardons le code ci-dessus avec les modifications appropriées :

 var http = require ('http'); var querystring = require ('querystring'); var util = require ('util'); var form = require ('fs'). readFileSync ('form.html'); var maxDonnées = 2 * 1024 * 1024; http.createServer (function (request, response) {if (request.method === "POST") {var dataPost = ''; request.on ('data', function (chunk) {dataPost + = chunk; if ( dataPost.length> maxData) {dataPost = ''; this.destroy (); response.writeHead (413); response.end ('Les données saisies dépassent notre capacité');}}). on ('end', fonction () {if (! PostData) {response.end (); return;} var ObjectPostData = querystring.parse (PostData); console.log ('L'utilisateur a envoyé les données : \ n', PostData); response.end ( 'Vous avez envoyé les données : \ n' + util.inspect (datosPostObjeto));});} if (request.method === "GET") {response.writeHead (200, {'Content-Type' : ' text / html '});response.end (form);}}).écouter (8082);

Si nous recevons des données supérieures à 2 Mo, nous écrivons simplement un en-tête HTTP 413 d'indiquer le cas et nous détruisons immédiatement les données reçues afin de ne pas garder la charge sur notre serveur inutilement.
Dans le cas où nous recevons des données vides de PUBLIER, nous continuons simplement notre exécution en empêchant le service de mourir de manière inattendue.
Une autre utilisation que l'on peut donner à la méthode PUBLIER de HTTP est de pouvoir recevoir des fichiers, pour cela nous devons installer un complément dans notre système et c'est le formidable package, pour atteindre cet objectif dans la console Node.js nous allons exécuter le code suivant :

 npm installer [email protected]

Cela devrait être comme suit :

Prochain acte, nous allons modifier notre formulaire.html avec le code suivant :

Fondamentalement, nous avons modifié l'en-tête du formulaire afin que notre serveur sache qu'il va recevoir quelque chose de plus que du texte, et nous avons également modifié les champs de texte en fichiers. Enfin nous allons modifier notre fichier serveur.js et nous placerons le code suivant :

 var http = require ('http'); var formidable = require ('formidable'); var form = require ('fs'). readFileSync ('form.html'); http.createServer (fonction (requête, réponse) { if (request.method === "POST") {var entrant = nouveau formidable.IncomingForm (); entrant.uploadDir = 'fichiers'; entrant.on ('fichier', fonction (champ, fichier) {if (! fichier .size) {return;} response.write (file.name + 'reçu \ n');}).on ('end', function () {response.end ('Tous les fichiers ont été reçus');}); entrant.parse (request);} if (request.method === "GET") {response.writeHead (200, {'Content-Type': 'text / html'}); response.end (form); } }) écouter (8082);

On voit comment le module formidable est celui qui nous aide à traiter le téléchargement des fichiers, cela les stockera dans un dossier appelé enregistrements, qui, pour que le dossier de destination fonctionne, doit disposer d'une autorisation d'écriture sur Node.js.
Avec ce dernier, nous avons terminé notre tutoriel, comme nous l'avons vu, nous avons plusieurs options avec lesquelles nous pouvons traiter les demandes PUBLIER utiliser l'objet HTTP sur notre serveur Node.js, en plus de tous les avantages qu'elle ajoute à nos développements.