Hantering av buffertar i Node.js

JavaScript Det är ett språk som har en bra hantering av strängar, men eftersom det ursprungligen var utformat för att hantera HTML -dokument, är det inte särskilt bra på att hantera binära data, faktiskt har JavaScript inte en binär datatyp som sådan, innehåller bara strukturerade nummer eller typer.

Som vi redan vet Node.js är baserad på JavaScript och det kan hantera textprotokoll som HTTP, där du också kan använda detta för att upprätta kommunikation med databaser, manipulera bilder och till och med hantera filmanipulation och på grund av det vi diskuterade kan det vara ganska komplicerat att göra detta med bara strängar.

Men för att göra dessa binära manipulationsuppgif.webpter mycket enklare, Node.js innehåller en binär buffertimplementering, som gör att vi kan få och ställa in byte för en skapad buffert utan större problem.

KravFör att utföra de övningar som föreslås i denna handledning måste vi ha en funktionell installation av Node.js i vårt system kan vi ta en titt på denna handledning innan vi fortsätter att fördjupa oss i den. Det är också viktigt att kunna ha tillgång till en rich text -editor för att koda exemplen, vi kan använda vad vi än känner oss bekväma med, men för enkel användning rekommenderar vi Sublim text o NotePad ++ som också har plugins för syntaxen JavaScript Y HTML.

Buffertskapande

För att skapa en buffert är det lika enkelt som att göra en ny instans av klassen Buffert(). Låt oss se hur vi skapar en enkel buffert baserad på en UTF-8-kodning enligt följande:

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

Vi kommer att utföra vårt exempel med konsol för att se svaret som det ger oss Node.js Angående skapandet av vår buffert:

Som vi ser om vi skriver ut vår variabel vältränad, svaret kanske inte är vad vi förväntade oss, men vi måste komma ihåg att vi skapar en instans av Buffert och vad den här klassen gör är att koda dess innehåll enligt specifik teckenkodning.

Vi kan också skapa en strängbuffert med andra kodningar, som är giltiga så länge vi anger samma som det andra argumentet, låt oss se:

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

Som vi kan se kan vi ange kodningen utan problem, låt oss sedan se vilka typer av kodning som accepteras och deras respektive identifierare:

ascii - ASCIIDetta är standardkodningstypen och begränsas av teckenkodningen med samma namn.
utf8 - UTF -8Detta är en variabel med kodningen som kan representera varje befintligt Unicode -tecken och detta är standardkodningen för vår buffert om den inte anger någon.
base64 - Base64Detta är en typ av kodning som används för att representera binära data i en typ av strängformat. ASCII och det används mestadels för att bädda in binära data i textdokument för att säkerställa att data förblir intakta vid transporten.
Dessutom, om vi inte har det ursprungliga innehållet för vår buffert och vi behöver skapa en, kan vi göra det genom att ange dess kapacitet, för detta gör vi det på följande sätt:

 var buf = new Buffer (1024);

Med detta är det vi gör att skapa en 1024-byte buffert för vår framtida verksamhet.

Hantering av byte i bufferten

När vi har skapat eller tagit emot bufferten kanske vi vill inspektera den och ändra dess innehåll. För det första, för att komma åt byte i det, kan vi använda parenteserna enligt följande:

 var buf = new Buffer ('här är innehållet i min buffert'); console.log (buf [10]);

Om vi ​​kör vårt exempel får vi buffertens tionde position, vi kan till och med byta till buffertens nionde position och se resultatet, låt oss se hur det ser ut:

Som vi kan se får vi slumpmässiga byte för positionerna i vår buffert, även om vi behöver manipulera innehållet i någon position i den kan vi göra något liknande följande:

 var buf = new Buffer ('här är innehållet i min nya buffert'); buf [2] = 110; buf [6] = 180; buf [10] = 90; console.log (buf [2]); console.log (buf [6]); console.log (buf [10]);

Låt oss se konsolsvaret i vårt exempel:

Som vi såg kunde vi ändra innehållet i vissa positioner i vår buffert utan större problem, utöver detta kan vi få storleken på vår buffert med egenskapen längd som följer:

 var buf = new Buffer (100); console.log (buf.length);

Om vi ​​är observatörer kan vi se att svaret på vår konsol kommer att vara 100, där vi efter det här värdet kan använda det för att iterera över vår buffert och därmed manipulera varje position för att få dess värde eller ställa in ett specifikt värde, Låt oss se en enkelt exempel på detta:

 var buf = new Buffer (100); för (var i = 0; i <buf.length; i ++) {buf [i] = i; } console.log (buf);

Det vi gjorde i det här exemplet var att skapa en ny buffert med en kapacitet på 100 byte och sedan ställer vi in ​​varje byte med ett värde från 0 till 99, låt oss slutligen se konsolens svar när vi kör vårt exempel:

Extrahering av buffertdata

En annan intressant egenskap hos bufferten, när vi väl har skapat eller tagit emot den, är att kunna extrahera en del av den. Vi kan "hugga" det för att säga det på något sätt och skapa en annan mindre buffert med den delen som vi har hackat, utan att glömma att ange från och till var vi ska hugga det, låt oss se ett exempel för att illustrera vad vi har förklarat:

 var buffer_complete = new Buffer ("detta är innehållet i min buffert som vi ska hugga"); var buffer_small = full_buffer.slice (26, 55); console.log (buffer_small.toString ());

Som vi kan se skapar vi först instansen av vår buffert med det ursprungliga innehållet, sedan med funktionen skiva () Vi specificerar från och till var vi ska hämta innehållet, vi tilldelar det vi får till en ny variabel och slutligen avkodar vi innehållet för att kunna visualisera innehållet i vår andra buffert, låt oss se svaret från konsolen när vi kör exempel:

Det är viktigt att nämna att när vi skär av en ny buffert använder vi inte nytt systemminne, den här nya bufferten använder faderns minne eftersom den bara hänvisar till den men med en annan början och slut. Detta kan orsaka vissa problem om vi inte är försiktiga eftersom vi arbetar med samma buffert, för detta rekommenderar vi att du arbetar med metoden kopiera för att undvika problemen, som vi kommer att se nedan.

Kopierar en buffert

Som vi nämnde, när vi skär en buffert kan vi få några problem om inte vi är försiktiga, men för detta har vi metoden kopiera, vilket gör att vi kan kopiera innehållet i en buffert till en ny buffert, med hjälp av en ny instans och ett nytt minnesutrymme, låt oss se:

 var buffer1 = new Buffer ("Content buffer number 1, content to copy"); var buffer2 = ny buffert (20); var startobj = 0; var startSource = 26; var sourceEnd = 50; buffer1.copy (buffer2, startobj, startSource, endSource); console.log (buffer2.toString ());

Som vi kan se skapar vi två olika buffertar, där den första har innehållet och den andra bara har storleken, vi anger början för vår andra buffert, och på samma sätt anger vi början och slutet för ny buffert som vi kommer att kopiera, låt oss se konsolens svar när exemplet körs:

Avkodning av en buffert

Som vi såg i tidigare exempel kunde vi skriva ut det ursprungliga innehållet i vår buffert med hjälp av metoden att stränga (), detta är vad som kallas avkodning av bufferten, där som förekomsten av klassen Buffert() om vi inte anger något, avkodar vi det som standard UTF-8.

Vi kan till och med göra en omkodning av en sträng UTF-8 till bas64 för att nämna ett fall, låt oss se:

 var stringutf8 = 'min nya sträng'; var buf = new Buffer (stringutf8); var base64string = buf.toString ('base64') console.log (base64string);

Låt oss slutligen se hur vi har omkodat vår ursprungliga sträng:

Med detta avslutar vi denna handledning där vi lärde oss sätten att hantera binär data i Node.js tack till klassen Buffert, vilket gör att vi kan manipulera den från dess läsning, skrivning, få små bitar av den, kopiera den till nya instanser och till och med omvandla den bufferten till nya typer av kodning för dess manipulation i våra program.