En buffer er en spesifikk plassering i råminnet. Den fungerer som en midlertidig lagringsplass for overflødig binær data som prosesseringsenheten ikke kan akseptere i det aktuelle øyeblikket.
Node.js inkluderer en bufferklasse. Den kan håndtere binære data når den administrerer TCP-strømmer (Transfer Control Protocol) og lese-skriveoperasjoner på et filsystem.
Lær hvordan du oppretter, leser og endrer innholdet i en buffer.
Opprette en buffer
For å lage en buffer i Node.js, bruker du alloc() eller fra() metoder. De alloc() metoden oppretter en ny buffer, og spesifiserer størrelsen under opprettelsen som den første og eneste nødvendige parameteren. Det er nyttig når du ikke har noen data å lagre på tidspunktet for bufferoppretting.
Spesifiser parameteren bufferstørrelse i byte når du oppretter en buffer med alloc() metode. For eksempel:
konst buf = Buffer.alloc(8);
konsoll.log (buff);
// utgang:
Buffer-klassen legger automatisk til nuller som plassholderverdier for nye data når du oppretter dem med alloc() metode.
Bufferklassen uttrykker hver 0-verdi som 00, ved hjelp av heksadesimalt format. I dette eksemplet inneholder den totalt åtte verdier.
For å initialisere bufferen med forskjellige plassholderverdier, ta et sekund fylle parameter:
konst buff_filled = Buffer.alloc(8, 5);
konsoll.log (buff_filled);
// utgang:
Dette objektet siterer en del i minnet som lagrer 8 byte av verdien 05. Merk at selv om du bestod et tall som fylle parameter, buffere lagrer bare data i binær.
Etter å ha allokert minne til bufferen, skriv data ved å ringe til skrive() metode:
konst buf = Buffer.alloc(8);buf.write("v", "utf-8");
konsoll.log (buff)
// utgang:
buf.write("va","utf-8");
konsoll.log (buff)
// utgang:
De skrive() metoden bruker tegnkoding for å konvertere den første parameteren ved å bruke utf-8 og skriver deretter strengen til bufferen. Å legge til et andre tegn i strengen vil fylle opp den andre byten.
For å trekke ut data fra eksisterende datatyper som strenger eller matriser, bruk fra() metode. Denne metoden lager buffere fra strenger og matriser.
For eksempel:
// String
konst stringBuf = Buffer.from('streng')
konsoll.log (stringBuf)
// utgang:
// Array
konst arrayBuf = Buffer.from([97, 114, 114, 97, 121], 'hex')
konsoll.log (arrayBuf);
// utgang:
De fra() metoden tar inndata som sin første parameter, beregner antall byte den trenger for å kode dataene, og sender deretter resultatet til bufferen. Ved å angi et annet kodingsformat som den andre parameteren, kan du overstyre standardkodingen (UTF-8).
Sende tall til fra() metoden vil resultere i en feil.
Leser en buffer
Selv om buffere ligner på arrays, kan de ikke endre størrelse og kan håndteres binære datadata takket være innebygde metoder.
Buffer-klassen lar oss lese individuelle byte av dataene ved hjelp av JavaScripts firkant-syntaks.
For eksempel:
konst minBuf = Buffer.fra('Min');
konsoll.Logg(MyBuf[1]);
// utgang: 105konsoll.Logg(MyBuf[3]);
// utgang: 101
konsoll.Logg(MyBuf[5]);
// utgang: udefinert
Kodeblokken ovenfor bruker den firkantede parentessyntaksen for å oppnå verdiene til den første og tredje byten i deres desimalrepresentasjon. Forsøk på å få en ugyldig byte vil resultere i en udefinert feil.
For å få tilgang til alle dataene, kommer Buffer-klassen med metoder tilJSON() og toString(), som henter innholdet i to forskjellige formater.
De toString() metoden sender ut en streng som bufferinnholdet:
konst minBuf = Buffer.fra('Min');
konsoll.Logg(myBuf.toString());
// utgang: 'Min'konst nummerBuf = Buffer.fra([123]);
konsoll.Logg(nummerBuf.toString())
// utgang: '{'
konst emptyBuf = Buffer.alloc(5);
konsoll.Logg(tommeBuf.toString());
// utgang: '\\x00\\x00\\x00\\x00\\x00'
Det første anropet initialiserer bufferen med verdien "Min”, som kallet til toString replikerer. Det andre eksemplet bruker en single-int array for initialisering, som har en strengrepresentasjon som "{" karakter. I det siste tilfellet, en buffer med fem nullverdier returnerer strengen "\x00\x00\x00\x00\x00”. Snoren \x00 er den heksadesimale representasjonen av null.
De toString() metoden gir alltid resultatet i strengformat, uansett hvilken type data du initialiserer bufferen med.
De .toJSON() metoden returnerer desimalrepresentasjonen av bufferdataene, uavhengig av dataene du brukte til å initialisere bufferen.
For eksempel:
konst minBuf = Buffer.fra('Min');
konsoll.Logg(myBuf.toJSON());
// utgang: { type: 'Buffer', data: [ 77, 105, 110, 101 ] }
JSON-utgangen har en type eiendom med en verdi på Buffer for å angi opprinnelsen. Dataegenskapen lagrer en rekke desimaler som representerer den opprinnelige byte-matrisen.
Endre en buffer
I likhet med å få tilgang til de individuelle bytene til en buffer, kan du også endre individuelle byte av innholdet til en buffer ved å bruke den firkantede syntaksen.
Når du bruker hakeparentessyntaksen til å endre et individuelt innhold, kan du bare tilordne desimalrepresentasjonen av verdien.
For eksempel:
myBuf[0] = 70
konsoll.Logg(myBuf.toString())
// utgang: 'Fin'
Fordi buffere er binære data, kan du ikke gi en spesifikk del av en buffer en streng. Hvis du prøver å sette en individuell byte til en streng, vil Buffer oversette den til et nulltegn.
For eksempel:
minBuf[0] = 'F';
konsoll.Logg(myBuf.toString());
// utgang: '\\x00ine'Alternativt kan du endre hele innholdet i en buffer ved å bruke skrive() metode.
Vurder å sette inn en indeks utenfor bufferens lengde. I stedet for å returnere en feil, ignorerer Buffer den ugyldige indeksen og holder det opprinnelige bufferinnholdet intakt.
Prøv for eksempel å sette det femte elementet til myBuf til r via sin desimalrepresentasjon av 114:
minBuf[4] = 114;
konsoll.Logg(myBuf.toString());
// utgang: 'Min'
Legg merke til at toString() metoden returnerer samme verdi 'Min'.
Siden du ikke kan endre størrelsen på en buffer, vil forsøk på å skrive mer data enn én kan holde, føre til at de ekstra dataene forkastes. For eksempel:
konst buf1 = Buffer.alloc(5)
buf1.write('Antall');
konsoll.Logg(buf1.toString())
// utgang: 'numbe'
Bruker toString() metode for å bekrefte bufferdataene, returnerer den "numbe" heller enn 'Antall'. Som er det innsatte argumentet i skrive() metode.
Buffere skriver på en seriell måte som begynner på indeks null. De skrive() metoden legger til bytes i en buffer, og overskriver tidligere data.
For eksempel:
konst buf2 = Buffer.alloc(6);buf2.write('medlem');
konsoll.Logg(buff2.toString())
// utgang: 'medlem'
buf2.write('hei');
konsoll.Logg(buff2.toString());
// utgang: 'himber'
Koden ovenfor oppretter en seks-byte buffer og legger til strengen "medlem" til det ved hjelp av skrive() metode.
Den oppdaterer deretter bufferen med nytt innhold som tar opp mindre minneplass enn det tidligere innholdet.
Dette resulterer i opprettelsen av en ny streng med de to første bytene overskrevet og de resterende bytene uendret.
Mange APIer og datastrukturer bruker buffere
Nå vet du hvordan du lager en buffer, skriver til en, leser innholdet og endrer den med de riktige metodene.
Det er flere andre metoder tilgjengelig for å arbeide med Node.js Buffer-klassen.
Du bør kjenne til disse metodene og forstå buffere for å forstå hvordan ulike konsepter som strømmer og filsystemer fungerer.
