Het HTTP-object gebruiken in Node.js

De HTTP-module binnen onze applicaties geschreven in Node.js Ze helpen ons een deel van de functionaliteit te bouwen om onze servers tot leven te laten komen, maar dit is niet het exclusieve gebruik dat we aan deze module kunnen geven.
De ware kracht van HTTP wordt gezien wanneer we uw object gebruiken om de verschillende verzoeken te verwerken of verzoek die uit onze applicatie kan komen, hiermee kunnen wij de gegevens verwerken die afkomstig zijn van NA via formulieren of verzoeken van klanten RUST UIT.
Handleiding vereistenOm de oefeningen die in deze tutorial worden voorgesteld uit te voeren, moeten we een functionele installatie hebben van: Node.js in ons systeem en hebben toegangsrechten. Het is ook belangrijk om toegang te hebben tot een rich text-editor om de voorbeelden te coderen, we kunnen alles gebruiken waar we ons prettig bij voelen, maar vanwege het gebruiksgemak raden we aan Sublieme tekst of Kladblok ++ die ook add-ons voor de syntaxis hebben JavaScript Y HTML.
Gegevensverwerking NA stelt ons in staat om gegevens uit formulieren te halen, hiermee kunnen we gegevens verwerken die afkomstig zijn van gebruikersinteracties met onze applicaties, waardoor we bedrijfslogica kunnen implementeren om deze gegevens te verwerken.
De meest directe manier waarop we de gegevens moeten verwerken NA het is door HTTP-object, door directe interactie met de methode maakServer () we kunnen het type methode van het verzoek identificeren, ofwel: NA of KRIJGEN en zelfs NEERZETTEN Y VERWIJDEREN.
Als we waarnemers zijn, zien we dat dit ons op een bepaalde manier aan het denken zet over onze toepassingen RUSTIG, dat wil zeggen, we kunnen ermee communiceren via verschillende clients en niet noodzakelijk met formulieren HTMLDat is echter een onderwerp dat verder gaat dan deze tutorial.
Het eerste dat we zullen doen, is een klein formulier maken waarmee we de gegevens van onze applicatie in de browser kunnen vastleggen, hiervoor gaan we een bestand maken met de naam formulier.html in de map of map van onze applicatie.
Dit laatste wordt niet aanbevolen in een productieomgeving, dus we zullen het alleen als referentie nemen om te kunnen demonstreren hoe het systeem werkt. HTTP-object. De code van ons formulier is als volgt:

Zoals we kunnen zien, geven we eenvoudigweg aan ons formulier aan dat het de methode moet gebruiken NA, we hebben een paar tekstvelden en tot slot een knop indienen om onze gegevens naar de server te sturen.
Nu moeten we de server maken Node.js dat zal ons helpen om de gegevens van het formulier te verzamelen, hier moeten we rekening houden met twee mogelijkheden, de eerste is wanneer we toegang krijgen tot het pad van onze applicatie, dit zal de methode gebruiken KRIJGEN en dit is waar we onze vorm moeten laten zien.
De tweede mogelijkheid is wanneer de formuliergegevens worden verzonden en hiervoor moeten we de methode valideren NA dat is het doel van de oefening. Om het formulier weer te geven, moeten we een synchrone component maken die ons bestand leest formulier.html en serveer het in de bijbehorende route, hiervoor kunnen we vertrouwen op de methode leesFileSync van de module fs.
In het volgende deel moeten we ervoor zorgen dat onze server de gegevens aankan NA, hiervoor gaan we gewoon laten zien wat we in de console ontvangen met de methode console.log (), op deze manier kunnen we bevestigen dat alles naar behoren werkt, laten we de eerste code eens bekijken om te bereiken wat we willen:

 var http = vereisen ('http'); var querystring = vereisen ('querystring'); var util = vereisen ('util'); var form = vereisen ('fs'). readFileSync ('form.html'); http .createServer (functie (verzoek, antwoord) {if (request.method === "POST") {var dataPost = ''; request.on ('data', functie (chunk) {dataPost + = chunk;}). on ('end', function () {var dataPostObject = querystring.parse (dataPost); console.log ('Gebruiker heeft gegevens verzonden: \ n', dataPost); response.end ('U hebt gegevens verzonden: \ n '+ util.inspect (dataPostObject));});} if (request.method === "GET") {response.writeHead (200, {' Content-Type ':' text / html '}); response.end ( formulier);}}). luister (8082);

Om alles zo leesbaar mogelijk te maken, zijn de modules extra ingebouwd querystring Y Bruikbaar, met hen kunnen we de informatie die van de server komt verwerken en zo manipuleren om deze af te drukken.
Laten we eens kijken hoe ons formulier er in eerste instantie uit zou moeten zien wanneer we onze applicatie starten en de browser openen op het hoofdpad van het project:

VERGROTEN

We gaan nu wat gegevens invoeren in de tekstvelden die we in ons formulier zien en klikken op de verzendknop, dit zal ons een scherm presenteren met de verzonden gegevens en het zal de console naar ons afdrukken. verzoek gewoon, dat wil zeggen, zoals het wordt ontvangen door onze applicatie:

We hebben toen gezien dat het heel gemakkelijk was om de formuliergegevens te verwerken, in ieder geval om ze opnieuw te tonen.
Hoewel het vorige voorbeeld correct werkt, heeft het enkele zwakke punten dat als de toepassing in productie zou gaan, dit ons meer hoofdpijn zou kunnen bezorgen, bijvoorbeeld wat er gebeurt als het ons meer gegevens stuurt dan het geheugen van onze server kan ondersteunen, uiteraard onze hele structuur zou instorten. Als we gegevens ontvangen van: NA leeg, in de huidige staat van onze applicatie zou het mislukken en zouden we een foutmelding krijgen waardoor onze service zou crashen en niet meer zou werken.
Om deze gebreken te corrigeren, moeten we eenvoudig enkele zeer eenvoudige validaties opnemen. Allereerst gaan we een variabele opnemen die ons zal helpen de ontvangen gegevens te beperken tot een maximum van 2 MBDit kan ons een beetje zekerheid geven dat het systeem, in ieder geval met weinig gebruikers, niet kan crashen. Dan zullen we dat evalueren zodat ons verzoek NA worden verwerkt op HTTP-object die het bevat kan niet leeg zijn, dus we zorgen ervoor dat er geen directe storingen in onze server zijn. Laten we eens kijken naar de bovenstaande code met de juiste aanpassingen:

 var http = vereisen ('http'); var querystring = vereisen ('querystring'); var util = vereisen ('util'); var form = vereisen ('fs'). readFileSync ('form.html'); var maxData = 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 ('De ingevoerde gegevens overschrijden onze capaciteit');}}). on ('end', function () {if (! PostData) {response.end (); return;} var ObjectPostData = querystring.parse (PostData); console.log ('De gebruiker heeft de gegevens verzonden: \ n', PostData); response.end ( 'Je hebt de gegevens verzonden: \ n' + util.inspect (datosPostObjeto));});} if (request.method === "GET") {response.writeHead (200, {'Content-Type': ' tekst / html '}); response.end (formulier);}}). luister (8082);

Als we gegevens ontvangen die groter zijn dan 2 MB, schrijven we gewoon een header HTTP 413 om het geval aan te geven en we vernietigen de ontvangen gegevens onmiddellijk om onze server niet onnodig te belasten.
In het geval dat we lege gegevens ontvangen van: NA, gaan we gewoon door met onze uitvoering om te voorkomen dat de service onverwacht sterft.
Een ander gebruik dat we aan de methode kunnen geven NA van HTTP is om bestanden te kunnen ontvangen, hiervoor moeten we een aanvulling in ons systeem installeren en het is het formidabele pakket om dit doel in de console te bereiken Node.js we gaan de volgende code uitvoeren:

 npm installeer [email protected]

Dit zou als volgt moeten zijn:

Volgende handeling gaan we onze . aanpassen formulier.html met de volgende code:

Wat we eigenlijk deden, was de kop van het formulier aanpassen, zodat onze server weet dat het meer dan alleen tekst gaat ontvangen, en we hebben ook de tekstvelden gewijzigd in bestanden. Eindelijk gaan we ons bestand wijzigen server.js en we zullen de volgende code plaatsen:

 var http = vereisen ('http'); var formidable = vereisen ('formidable'); var form = vereisen ('fs'). readFileSync ('form.html'); http.createServer (functie (verzoek, antwoord) { if (request.method === "POST") {var inkomende = nieuwe formidable.IncomingForm (); inkomende.uploadDir = 'bestanden'; inkomende.on ('bestand', functie (veld, bestand) {if (! bestand .size) {return;} response.write (bestand.naam + 'ontvangen \ n');}) on ('end', function () {response.end ('Alle bestanden zijn ontvangen');}); inkomende.parse (verzoek);} if (request.method === "GET") {response.writeHead (200, {'Content-Type': 'text / html'}); response.end (formulier); } }) luister (8082);

We zien hoe de module formidabel is degene die ons helpt bij het verwerken van het uploaden van bestanden, dit zal ze opslaan in een map met de naam verslagen, waarvoor de doelmap moet beschikken over schrijfrechten om te werken Node.js.
Met deze laatste hebben we onze tutorial afgerond, zoals we zagen hebben we meerdere opties waarmee we de verzoeken kunnen verwerken NA het object gebruiken HTTP op onze server Node.js, naast alle voordelen die het toevoegt aan onze ontwikkelingen.