Home-theater-designers
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.
MAKEUSE AV DAGENS VIDEO
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:
const buf = Buffer.alloc(8);
console.log(buf);
// output: <Buffer 00 00 00 00 00 00 00 00>
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:
hur man får handelskort på steam
const buf_filled = Buffer.alloc(8, 5);
console.log(buf_filled);
// output: <Buffer 05 05 05 05 05 05 05 05>
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:
const buf = Buffer.alloc(8);
buf.write("v", "utf-8");
console.log(buf)
// output: <Buffer 76 00 00 00 00 00 00 00>
buf.write("va","utf-8");
console.log(buf)
// output: <Buffer 76 61 00 00 00 00 00 00>
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:
anledningar till att sociala medier är dåliga
// String
const stringBuf = Buffer.from('string')
console.log(stringBuf)
// output: <Buffer 73 74 72 69 6e 67>
// Array
const arrayBuf = Buffer.from([97, 114, 114, 97, 121], 'hex')
console.log(arrayBuf);
// output: <Buffer 61 72 72 61 79>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:
const myBuf = Buffer.from('Mine');
console.log(MyBuf[1]);
// output: 105
console.log(MyBuf[3]);
// output: 101
console.log(MyBuf[5]);
// output: undefined
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:
const myBuf = Buffer.from('Mine');
console.log(myBuf.toString());
// output: 'Mine'
const numberBuf = Buffer.from([123]);
console.log(numberBuf.toString())
// output: '{'
const emptyBuf = Buffer.alloc(5);
console.log(emptyBuf.toString());
// output: '\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.