Håndtering av buffere i Node.js

JavaScript Det er et språk som har god håndtering av strenger, men fordi det opprinnelig ble designet for å håndtere HTML -dokumenter, er det ikke veldig godt til å håndtere binære data, faktisk har JavaScript ikke en binær datatype som sådan, inneholder bare strukturerte tall eller typer.

Som vi allerede vet Node.js er basert på JavaScript og den kan håndtere tekstprotokoller som HTTP, hvor du også kan bruke denne til å etablere kommunikasjon med databaser, manipulere bilder og til og med håndtere filmanipulering, og på grunn av det vi diskuterte kan det være ganske komplisert å gjøre dette med bare strenger.

Men for å gjøre disse binære manipulasjonsoppgavene mye enklere, Node.js inkluderer en binær bufferimplementering, som lar oss hente og sette byte til en opprettet buffer uten store problemer.

KravFor å utføre øvelsene som er foreslått i denne opplæringen må vi ha en funksjonell installasjon av Node.js i systemet vårt, kan vi ta en titt på denne opplæringen før vi fortsetter å fordype oss i den. Det er også viktig å ha tilgang til en rik tekstredigerer for å kode eksemplene. Vi kan bruke det vi føler oss komfortable med, men for enkel brukervennlighet anbefaler vi Sublim tekst o NotePad ++ som også har plugins for syntaksen JavaScript Y HTML.

Opprettelse av buffer

For å lage en buffer er det like enkelt som å lage en ny forekomst av klassen Buffer(). La oss se hvordan vi lager en enkel buffer basert på en UTF-8-koding som følger:

 var buf = new Buffer ('Hello world!'); console.log (buf);

Vi kommer til å utføre vårt eksempel etter konsoll for å se svaret det gir oss Node.js Når det gjelder opprettelsen av bufferen vår:

Som vi ser om vi skriver ut variabelen vår buff, Svaret er kanskje ikke det vi ventet, men vi må huske at vi lager en forekomst av Buffer og hva denne klassen gjør er å kode innholdet i henhold til spesifikk tegnkoding.

Vi kan også lage en strengbuffer med andre kodinger, som vil være gyldige så lenge vi spesifiserer det samme som det andre argumentet, la oss se:

 var buf2 = ny buffer ('9b38kte610la', 'base64'); console.log (buf2);

Som vi kan se, kan vi spesifisere kodingen uten problemer. La oss deretter se hvilke typer koding som godtas og deres respektive identifikatorer:

ascii - ASCIIDette er standard kodingstype og er begrenset av tegnkodingen med samme navn.
utf8 - UTF -8Dette er en variabel med kodingen som kan representere hvert eksisterende Unicode -tegn, og dette er standardkodingen av bufferen vår hvis den ikke spesifiserer noen.
base64 - Base64Dette er en type koding som brukes til å representere binære data i en type strengformat. ASCII og det brukes hovedsakelig til å legge inn binære data i tekstdokumenter for å sikre at dataene forblir intakte i transporten.
I tillegg, hvis vi ikke har det opprinnelige innholdet for bufferen vår, og vi må lage en, kan vi gjøre det ved å spesifisere kapasiteten, for dette gjør vi det på følgende måte:

 var buf = new Buffer (1024);

Med dette er det vi gjør å lage en 1024-byte buffer for vår fremtidige virksomhet.

Håndtering av byte i bufferen

Etter at vi har opprettet eller mottatt bufferen, kan det være lurt å inspisere den og endre innholdet. For det første, for å få tilgang til byte i den, kan vi bruke parentesene som følger:

 var buf = new Buffer ('her er innholdet i bufferen min'); console.log (buf [10]);

Hvis vi kjører vårt eksempel, får vi den tiende posisjonen til bufferen, vi kan til og med bytte til den niende posisjonen til bufferen og se resultatet, la oss se hvordan den ser ut:

Som vi kan se, får vi tilfeldige byte for posisjonene til bufferen vår, selv om vi trenger å manipulere innholdet i en hvilken som helst posisjon i den, kan vi gjøre noe som følgende:

 var buf = new Buffer ('her er innholdet i min nye buffer'); buf [2] = 110; buf [6] = 180; buf [10] = 90; console.log (buf [2]); console.log (buf [6]); console.log (buf [10]);

La oss se konsollresponsen i vårt eksempel:

Som vi så kunne vi endre innholdet i visse posisjoner i bufferen vår uten store problemer, i tillegg til dette kan vi få størrelsen på bufferen vår med eiendommen lengde som følger:

 var buf = ny buffer (100); console.log (buf.length);

Hvis vi er observatører, kan vi se at responsen til konsollen vår vil være 100, hvor vi etter å ha oppnådd denne verdien kan bruke den til å iterere over bufferen vår og dermed manipulere hver posisjon for å oppnå verdien eller sette en bestemt verdi, La oss se en enkelt eksempel på dette:

 var buf = ny buffer (100); for (var i = 0; i <buf.length; i ++) {buf [i] = i; } console.log (buf);

Det vi gjorde i dette eksemplet var å lage en ny buffer med en kapasitet på 100 byte, og deretter setter vi hver byte med en verdi som starter fra 0 til 99, til slutt skal vi se svaret på konsollen når vi utfører vårt eksempel:

Utvinning av bufferdata

Et annet interessant trekk ved bufferen, når vi har opprettet eller mottatt den, er å kunne trekke ut en del av den. Vi kan "hogge" det for å si det på en eller annen måte og lage en annen mindre buffer med den delen vi har hakket, uten å glemme å spesifisere fra og til hvor vi skal hugge den, la oss se et eksempel for å illustrere det vi har forklart:

 var buffer_complete = ny buffer ("dette er innholdet i bufferen min som vi skal hugge"); var buffer_small = full_buffer.slice (26, 55); console.log (buffer_small.toString ());

Som vi kan se, lager vi først forekomsten av bufferen vår med det opprinnelige innholdet, deretter med funksjonen skive () Vi spesifiserer fra og til hvor vi skal hente innholdet, vi tilordner det vi får til en ny variabel, og til slutt dekoder vi innholdet for å kunne visualisere innholdet i den andre bufferen, la oss se svaret etter konsoll når vi utfører eksempel:

Det er viktig å nevne at når vi kutter en ny buffer, bruker vi ikke nytt systemminne, denne nye bufferen bruker farens minne siden den bare refererer til den, men med en annen begynnelse og slutt. Dette kan forårsake noen problemer hvis vi ikke er forsiktige siden vi jobber med den samme bufferen, for dette anbefaler vi å jobbe med metoden kopiere for å unngå problemene, som vi vil se nedenfor.

Kopierer en buffer

Som vi nevnte, når vi kutter en buffer kan vi få noen problemer hvis ikke vi er forsiktige, men for dette har vi metoden kopiere, som lar oss kopiere innholdet i en buffer til en ny buffer, ved å bruke en ny forekomst og en ny minneplass, la oss se:

 var buffer1 = ny buffer ("Innholdsbuffer nummer 1, innhold som skal kopieres"); var buffer2 = ny buffer (20); var startobj = 0; var startSource = 26; var sourceEnd = 50; buffer1.copy (buffer2, startobj, startSource, endSource); console.log (buffer2.toString ());

Som vi kan se, lager vi to forskjellige buffere, der den første vil ha innholdet og den andre bare vil ha størrelsen, vi angir begynnelsen for vår andre buffer, og på samme måte angir vi begynnelsen og slutten for ny buffer som vi vil kopiere, la oss se svaret på konsollen når du kjører eksemplet:

Dekoding av en buffer

Som vi så i tidligere eksempler, kunne vi skrive ut det originale innholdet i bufferen vår ved å bruke metoden toString (), dette er det som kalles dekoding av bufferen, der som forekomsten av klassen Buffer() hvis vi ikke spesifiserer noe, dekoder vi det som standard til UTF-8.

Vi kan til og med gjøre en transkoding av en streng UTF-8 til base64 For å nevne ett tilfelle, la oss se:

 var stringutf8 = 'min nye streng'; var buf = new Buffer (stringutf8); var base64string = buf.toString ('base64') console.log (base64string);

Til slutt skal vi se hvordan vi har omkodet vår originale streng:

Med dette fullfører vi denne opplæringen der vi lærte måtene å håndtere binære data på Node.js takk til klassen Buffer, som lar oss manipulere den fra lesing, skriving, skaffe små biter av den, kopiere den til nye forekomster og til og med omdanne denne bufferen til nye typer koding for manipulering i programmene våre.