En buffert är en specifik plats i råminnet. Den fungerar som ett tillfälligt lagringsutrymme för överflödig binär data som bearbetningsenheten inte kan acceptera i just det ögonblicket.
Node.js innehåller en buffertklass. Den kan hantera binära data vid hantering av TCP-strömmar (Transfer Control Protocol) och läs-skrivoperationer på ett filsystem.
Lär dig hur du skapar, läser och ändrar innehållet i en buffert.
Skapa en buffert
För att skapa en buffert i Node.js använder du alloc() eller från() metoder. De alloc() metoden skapar en ny buffert, och anger dess storlek under skapandet som den första och enda nödvändiga parametern. Det är användbart när du inte har några data att lagra när bufferten skapas.
Ange parametern buffertstorlek i byte när du skapar en buffert med alloc() metod. Till exempel:
konst buf = Buffer.alloc(8);
trösta.log (buff);
// output:
Bufferklassen lägger automatiskt till nollor som platshållarvärden för ny data när du skapar den med alloc() metod.
Buffertklassen uttrycker varje 0-värde som 00, med hexadecimalt format. I det här exemplet innehåller den totalt åtta värden.
För att initiera bufferten med olika platshållarvärden, passera en sekund fylla parameter:
konst buff_filled = Buffer.alloc(8, 5);
trösta.log (buff_filled);
// output:
Detta objekt citerar en del i minnet som lagrar 8 byte av värdet 05. Observera att även om du klarade ett nummer som fylla parameter, buffertar lagrar endast data binärt.
Efter att ha allokerat minne till bufferten, skriv data genom att anropa skriva() metod:
konst buf = Buffer.alloc(8);buf.write("v", "utf-8");
trösta.log (buff)
// output:
buf.write("va","utf-8");
trösta.log (buff)
// output:
De skriva() metoden använder teckenkodning för att konvertera den första parametern med hjälp av utf-8 och skriver sedan strängen till bufferten. Om du lägger till ett andra tecken i strängen fylls den andra byten.
För att extrahera data från befintliga datatyper som strängar eller arrayer, använd från() metod. Denna metod skapar buffertar från strängar och arrayer.
Till exempel:
// Sträng
konst stringBuf = Buffer.from('sträng')
trösta.log (stringBuf)
// output:
// Array
konst arrayBuf = Buffer.from([97, 114, 114, 97, 121], "hex")
trösta.log (arrayBuf);
// output:
De från() metoden tar indata som sin första parameter, beräknar antalet byte den behöver för att koda data och skickar sedan resultatet till bufferten. Genom att ange ett annat kodningsformat som den andra parametern kan du åsidosätta standardkodningen (UTF-8).
Skickar nummer till från() metod kommer att resultera i ett fel.
Läser en buffert
Även om buffertar liknar arrayer kan de inte ändras i storlek och kan hanteras binära datordata tack vare inbyggda metoder.
Bufferklassen låter oss läsa enskilda byte av dess data med hjälp av JavaScripts syntax för hakparenteser.
Till exempel:
konst myBuf = Buffer.from('Mina');
trösta.logga(MyBuf[1]);
// utgång: 105trösta.logga(MyBuf[3]);
// utgång: 101
trösta.logga(MyBuf[5]);
// output: odefinierad
Kodblocket ovan använder hakparentessyntaxen för att erhålla värdena för den första och tredje byten i deras decimalrepresentation. Ett försök att få en ogiltig byte kommer att resultera i en odefinierad fel.
För att komma åt alla dess data kommer Buffer-klassen med metoder tillJSON() och att stränga(), som hämtar innehållet i två olika format.
De att stränga() metod matar ut en sträng som buffertinnehållet:
konst myBuf = Buffer.from('Mina');
trösta.logga(myBuf.att stränga());
// output: 'Min'konst nummerBuf = Buffer.from([123]);
trösta.logga(nummerBuf.att stränga())
// output: '{'
konst emptyBuf = Buffer.alloc(5);
trösta.logga(emptyBuf.att stränga());
// utdata: '\\x00\\x00\\x00\\x00\\x00'
Det första samtalet initierar bufferten med värdet "Mina”, som anropet till toString replikerar. Det andra exemplet använder en single-int array för initiering, som har en strängrepresentation som "{" karaktär. I det sista fallet en buffert med fem nollvärden returnerar strängen "\x00\x00\x00\x00\x00”. Tråden \x00 är den hexadecimala representationen av null.
De att stränga() metoden matar alltid ut resultatet i strängformat, oavsett vilken typ av data du initierar bufferten med.
De .toJSON() metod returnerar decimalrepresentationen av buffertdata, oavsett vilken data du använde för att initiera bufferten.
Till exempel:
konst myBuf = Buffer.from('Mina');
trösta.logga(myBuf.toJSON());
// utdata: { typ: 'Buffert', data: [ 77, 105, 110, 101 ] }
JSON-utgången har en typ fastighet med ett värde av Buffert för att ange dess ursprung. Dess dataegenskap lagrar en array av decimaler som representerar den ursprungliga byte-arrayen.
Ändra en buffert
På samma sätt som att komma åt de enskilda byten i en buffert, kan du också modifiera enskilda byte av en bufferts innehåll med hjälp av hakparentessyntaxen.
När du använder hakparentessyntaxen för att ändra ett enskilt innehåll kan du bara tilldela decimalrepresentationen av värdet.
Till exempel:
myBuf[0] = 70
trösta.logga(myBuf.att stränga())
// output: 'Fin'
Eftersom buffertar är binära data kan du inte ge en specifik del av en buffert en sträng. Om du försöker ställa in en enskild byte till en sträng, kommer Buffer att översätta den till ett nolltecken.
Till exempel:
myBuf[0] = 'F';
trösta.logga(myBuf.att stränga());
// output: '\\x00ine'Alternativt kan du ändra hela innehållet i en buffert med hjälp av skriva() metod.
Överväg att infoga ett index utanför buffertens längd. I stället för att returnera ett fel ignorerar Buffer det ogiltiga indexet och behåller det ursprungliga buffertinnehållet intakt.
Försök till exempel att ställa in det femte elementet av myBuf till r via dess decimalrepresentation av 114:
myBuf[4] = 114;
trösta.logga(myBuf.att stränga());
// output: 'Min'
Lägg märke till att att stränga() metod returnerar samma värde 'Mina'.
Eftersom du inte kan ändra storlek på en buffert, kommer det att kassera extra data om du försöker skriva mer data än en kan hålla. Till exempel:
konst buf1 = Buffer.alloc(5)
buf1.write('siffra');
trösta.logga(buf1.att stränga())
// output: 'numbe'
Använda att stränga() metod för att bekräfta buffertdata, returnerar den "numbe" hellre än 'siffra'. Vilket är det infogade argumentet inuti skriva() metod.
Buffertar skriver på ett seriellt sätt som börjar vid index noll. De skriva() metod lägger seriellt till bytes till en buffert, och skriver över eventuella tidigare data.
Till exempel:
konst buf2 = Buffer.alloc(6);buf2.write('medlem');
trösta.logga(buff2.att stränga())
// output: 'medlem'
buf2.write('Hej');
trösta.logga(buff2.att stränga());
// output: 'himber'
Koden ovan skapar en sex-byte buffert och lägger till strängen "medlem" till det med hjälp av skriva() metod.
Den uppdaterar sedan bufferten med nytt innehåll som tar mindre minnesutrymme än det tidigare innehållet.
Detta resulterar i skapandet av en ny sträng med de första två byten skrivna över och de återstående byten lämnas oförändrade.
Många API: er och datastrukturer använder buffertar
Nu vet du hur man skapar en buffert, skriver till en, läser dess innehåll och modifierar den med lämpliga metoder.
Det finns flera andra metoder tillgängliga för att arbeta med klassen Node.js Buffer.
Du bör känna till dessa metoder och förstå buffertar för att förstå hur olika koncept som strömmar och filsystem fungerar.
