One place for hosting & domains

      Verwenden von Puffern in Node.js.


      Der Autor hat den COVID-19 Relief Fund dazu ausgewählt, eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Ein Puffer ist ein Speicherplatz (normalerweise RAM), in dem Binärdaten gespeichert werden. In Node.js können wir mit der integrierten Puffer-Klasse auf diese Speicherbereiche zugreifen. Puffer speichern eine Folge von Ganzzahlen, ähnlich einem Array in JavaScript. Im Gegensatz zu Arrays können Sie die Größe eines Puffers nach seiner Erstellung nicht mehr ändern.

      Möglicherweise haben Sie implizit Puffer verwendet, wenn Sie bereits Node.js-Code geschrieben haben. Wenn Sie beispielsweise mit fs.readFile() aus einer Datei lesen, sind die an den Rückruf oder das Versprechen zurückgegebenen Daten ein Pufferobjekt. Wenn HTTP-Anforderungen in Node.js gestellt werden, geben sie außerdem Datenströme zurück, die vorübergehend in einem internen Puffer gespeichert sind, wenn der Client den Stream nicht auf einmal verarbeiten kann.

      Puffer sind nützlich, wenn Sie mit Binärdaten interagieren, normalerweise auf niedrigeren Netzwerkebenen. Sie bieten Ihnen auch die Möglichkeit, feinkörnige Datenmanipulationen in Node.js durchzuführen.

      In diesem Tutorial verwenden Sie Node.js REPL, um verschiedene Beispiele für Puffer durchzugehen, z. B. das Erstellen von Puffern, das Lesen aus Puffern, das Schreiben in und das Kopieren aus Puffern sowie die Verwendung von Puffern zum Konvertieren zwischen binären und codierten Daten. Am Ende des Tutorials haben Sie gelernt, wie Sie mit der Puffer-Klasse mit Binärdaten arbeiten.

      Voraussetzungen

      Schritt 1 — Erstellen eines Puffers

      Dieser erste Schritt zeigt Ihnen die beiden wichtigsten Möglichkeiten zum Erstellen eines Pufferobjekts in Node.js.

      Um zu entscheiden, welche Methode verwendet werden soll, müssen Sie die folgende Frage beantworten: Möchten Sie einen neuen Puffer erstellen oder einen Puffer aus vorhandenen Daten extrahieren? Wenn Sie Daten im Speicher speichern möchten, die Sie noch nicht empfangen haben, sollten Sie einen neuen Puffer erstellen. In Node.js verwenden wir dazu die Funktion alloc() der Puffer-Klasse.

      Öffnen wir die Node.js REPL, um uns selbst davon zu überzeugen. Geben Sie in Ihrem Terminal den Befehl node ein:

      Sie sehen, dass die Eingabeaufforderung mit > beginnt.

      Die Funktion alloc() verwendet die Größe des Puffers als erstes und einziges erforderliches Argument. Die Größe ist eine Ganzzahl, die angibt, wie viele Speicherbytes das Pufferobjekt verwendet. Wenn wir beispielsweise einen Puffer mit einer Größe von 1 KB (Kilobyte) erstellen möchten, der 1024 Byte entspricht, geben Sie dies in die Konsole ein:

      • const firstBuf = Buffer.alloc(1024);

      Um einen neuen Puffer zu erstellen, haben wir die global verfügbare Puffer-Klasse verwendet, die über die Methode alloc() verfügt. Durch die Angabe von 1024 als Argument für alloc() haben wir einen Puffer mit einer Größe von 1 KB erstellt.

      Wenn Sie einen Puffer mit alloc() initialisieren, wird der Puffer standardmäßig mit binären Nullen als Platzhalter für festgelegte Datenmengen gefüllt. Wir können dennoch den Standardwert ändern, wenn wir möchten. Wenn wir einen neuen Puffer mit Einsen anstelle von Nullen erstellen möchten, setzen wir den zweiten Parameter der Funktion alloc()fill.

      Erstellen Sie in Ihrem Terminal an der REPL-Eingabeaufforderung einen neuen Puffer, der mit Einsen gefüllt ist:

      • const filledBuf = Buffer.alloc(1024, 1);

      Wir haben gerade ein neues Pufferobjekt erstellt, das auf einen Speicherplatz im Speicher verweist, in dem 1 KB Einsen gespeichert sind. Obwohl wir eine Ganzzahl eingegeben haben, sind alle in einem Puffer gespeicherten Daten Binärdaten.

      Binärdaten können in vielen verschiedenen Formaten vorliegen. Betrachten wir beispielsweise eine Binärsequenz, die ein Datenbyte darstellt: 01110110. Wenn diese Binärsequenz eine Zeichenfolge in Englisch unter Verwendung des ASCII-Codierungsstandards darstellen würde, wäre dies der Buchstabe v. Wenn unser Computer jedoch ein Bild verarbeitet, könnte diese Binärsequenz Informationen über die Farbe eines Pixels enthalten.

      Der Computer kann sie unterschiedlich verarbeiten, da die Bytes unterschiedlich codiert sind. Die Bytecodierung ist das Format des Bytes. Ein Puffer in Node.js verwendet standardmäßig das UTF-8-Codierungsschema, wenn er mit Zeichenfolgendaten initialisiert wird. Ein Byte in UTF-8 repräsentiert eine Zahl, einen Buchstaben (in Englisch und in anderen Sprachen) oder ein Symbol. UTF-8 ist eine Obermenge von ASCII, dem amerikanischen Standardcode für den Informationsaustausch. ASCII kann Bytes mit englischen Groß- und Kleinbuchstaben, den Zahlen 0-9 und einigen anderen Symbolen wie dem Ausrufezeichen (!) codieren oder mit dem kaufmännischen Und-Zeichen (&).

      Wenn wir ein Programm schreiben würden, das nur mit ASCII-Zeichen arbeiten könnte, könnten wir die von unserem Puffer verwendete Codierung mit dem dritten Argument der Funktion alloc() ändern – der Codierung.

      Erstellen wir einen neuen Puffer, der fünf Byte lang ist und nur ASCII-Zeichen speichert:

      • const asciiBuf = Buffer.alloc(5, 'a', 'ascii');

      Der Puffer wird mit fünf Bytes des Zeichens a unter Verwendung der ASCII-Darstellung initialisiert.

      Hinweis: Node.js unterstützt standardmäßig die folgenden Zeichencodierungen:

      • ASCII, dargestellt als ascii
      • UTF-8, dargestellt als utf-8 oder utf8
      • UTF-16, dargestellt als utf-16le oder utf16le
      • UCS-2, dargestellt als ucs-2 oder ucs2
      • Base64, dargestellt als base64
      • Hexadezimal, dargestellt als hex
      • ISO/IEC 8859-1, dargestellt als latin1 oder binär

      Alle diese Werte können in Pufferklassenfunktionen verwendet werden, die einen Codierungsparameter akzeptieren. Daher sind diese Werte alle für die Methode alloc() gültig.

      Bisher haben wir mit der Funktion alloc() neue Puffer erstellt. Manchmal möchten wir jedoch einen Puffer aus bereits vorhandenen Daten erstellen, z. B. einer Zeichenfolge oder einer Anordnung.

      Um einen Puffer aus bereits vorhandenen Daten zu erstellen, verwenden wir die Methode from(). Wir können diese Funktion verwenden, um Puffer zu erstellen aus:

      • Eine Anordnung von Ganzzahlen: die ganzzahligen Werte können zwischen 0 und 255 liegen.
      • Ein ArrayBuffer: Dies ist ein JavaScript-Objekt, das eine festgesetzte Länge von Bytes speichert.
      • Eine Zeichenfolge.
      • Ein weiterer Puffer.
      • Andere JavaScript-Objekte mit einer Symbol.toPrimitive-Eigenschaft. Diese Eigenschaft teilt JavaScript mit, wie das Objekt in einen primitiven Datentyp konvertiert werden soll: Boolescher Wert, Nullwert, undefiniert, Zahl, Zeichenfolge oder Symbol. Weitere Informationen zu Symbolen finden Sie in der JavaScript-Dokumentation von Mozilla.

      Sehen wir uns an, wie wir einen Puffer aus einer Zeichenfolge erstellen können. Geben Sie in der Node.js Folgendes ein:

      • const stringBuf = Buffer.from('My name is Paul');

      Wir haben jetzt ein Pufferobjekt aus der Zeichenfolge My name is Paul​​​ erstellt. Erstellen wir einen neuen Puffer aus einem anderen Puffer, den wir zuvor erstellt haben:

      • const asciiCopy = Buffer.from(asciiBuf);

      Wir haben jetzt einen neuen Puffer asciiCopy erstellt, der dieselben Daten wie asciiBuf enthält.

      Nachdem wir die Erstellung von Puffern erlebt haben, können wir uns mit Beispielen zum Lesen ihrer Daten befassen.

      Schritt 2 – Lesen aus einem Puffer

      Es gibt viele Möglichkeiten, auf Daten in einem Puffer zuzugreifen. Wir können auf ein einzelnes Byte in einem Puffer zugreifen oder den gesamten Inhalt extrahieren.

      Um auf ein Byte eines Puffers zuzugreifen, übergeben wir den Index oder die Position des gewünschten Bytes. Puffer speichern Daten sequentiell wie Arrays. Sie indizieren ihre Daten auch wie Arrays, beginnend bei 0. Wir können die Array-Notation für das Pufferobjekt verwenden, um ein einzelnes Byte zu erhalten.

      Sehen wir uns an, wie dies aussieht, indem Sie einen Puffer aus einer Zeichenfolge in der REPL erstellen:

      • const hiBuf = Buffer.from('Hi!');

      Lesen wir nun das erste Byte des Puffers:

      Wenn Sie ENTER drücken, zeigt die REPL Folgendes:

      Output

      72

      Die Ganzzahl 72 entspricht der UTF-8-Darstellung für den Buchstaben H.

      Hinweis: Die Werte für Bytes können Zahlen zwischen 0 und 255 sein. Ein Byte ist eine Folge von 8 Bits. Ein Bit ist binär und kann daher nur einen von zwei Werten haben: 0 oder 1. Wenn wir eine Folge von 8 Bits und zwei mögliche Werte pro Bit haben, haben wir maximal 2⁸ mögliche Werte für ein Byte. Das führt zu einer maximalen Größe von 256 Werten. Da wir ab Null zählen, bedeutet dies, dass unsere höchste Zahl 255 ist.

      Machen wir dasselbe für das zweite Byte. Geben Sie Folgendes in die REPL ein:

      Die REPL gibt 105 zurück, was den Kleinbuchstaben i darstellt.

      Wir erhalten schließlich das dritte Zeichen:

      In der REPL wird 33 angezeigt, was ! entspricht.

      Versuchen wir, ein Byte aus einem ungültigen Index abzurufen:

      Die REPL wird Folgendes ausgeben:

      Output

      undefined

      Dies ist genau so, als hätten wir versucht, auf ein Element in einer Anordnung mit einem falschen Index zuzugreifen.

      Nachdem wir nun gesehen haben, wie einzelne Bytes eines Puffers gelesen werden, sehen wir uns unsere Optionen zum gleichzeitigen Abrufen aller in einem Puffer gespeicherten Daten an. Das Pufferobjekt wird mit den Methoden toString() und toJSON() bereitgestellt, die den gesamten Inhalt eines Puffers in zwei verschiedenen Formaten zurückgeben.

      Wie der Name schon sagt, konvertiert die toString()-Methode die Bytes des Puffers in eine Zeichenfolge und gibt sie an den Benutzer zurück. Wenn wir diese Methode auf hiBuf verwenden, erhalten wir die Zeichenfolge Hi!. Versuchen wir es!

      Geben Sie in der Eingabeaufforderung Folgendes ein:

      Die REPL wird Folgendes ausgeben:

      Output

      'Hi!'

      Dieser Puffer wurde aus einer Zeichenfolge erstellt. Sehen wir uns an, was passiert, wenn wir toString() in einem Puffer verwenden, der nicht aus Zeichenfolgendaten hergestellt wurde.

      Erstellen wir einen neuen, leeren Puffer, der 10 Bytes groß ist:

      • const tenZeroes = Buffer.alloc(10);

      Verwenden wir nun die toString()-Methode:

      Wir sehen das folgende Ergebnis:

      'u0000u0000u0000u0000u0000u0000u0000u0000u0000u0000'
      

      Die Zeichenfolge u0000 ist das Unicode-Zeichen für NULL. Sie entspricht der Zahl 0. Wenn die Daten des Puffers nicht als Zeichenfolge codiert sind, gibt die Methode toString() die UTF-8-Codierung der Bytes zurück.

      toString() verfügt über einen optionalen Parameter, die Codierung. Mit diesem Parameter können wir die Codierung der zurückgegebenen Pufferdaten ändern.

      Wenn Sie beispielsweise die hexadezimale Codierung für hiBuf wünschen, geben Sie bei der Eingabeaufforderung Folgendes ein:

      Diese Aussage wird folgendermaßen bewertet:

      Output

      '486921'

      486921 ist die hexadezimale Darstellung für die Bytes, die die Zeichenfolge Hi! darstellen. Wenn Benutzer in Node.js die Codierung von Daten von einem Formular in ein anderes konvertieren möchten, legen sie die Zeichenfolge normalerweise in einen Puffer und rufen toString() mit der gewünschten Codierung auf.

      Die toJSON()-Methode verhält sich anders. Unabhängig davon, ob der Puffer aus einer Zeichenfolge erstellt wurde oder nicht, werden die Daten immer als ganzzahlige Darstellung des Bytes zurückgegeben.

      Lassen Sie uns die Puffer hiBuf und tenZeroes erneut verwenden, um die Verwendung von toJSON() zu üben. Geben Sie bei der Eingabeaufforderung Folgendes ein:

      Die REPL wird Folgendes ausgeben:

      Output

      { type: 'Buffer', data: [ 72, 105, 33 ] }

      Das JSON-Objekt verfügt über eine type-Eigenschaft, die immer Puffer ist. Auf diese Weise können Programme diese JSON-Objekte von anderen JSON-Objekten unterscheiden.

      Die Daten-Eigenschaft enthält eine Anordnung der ganzzahligen Darstellung der Bytes. Möglicherweise haben Sie bemerkt, dass 72, 105 und 33 den Werten entsprechen, die wir beim einzelnen Abrufen der Bytes erhalten haben.

      Versuchen wir die toJSON()-Methode mit tenZeroes:

      In der REPL sehen Sie Folgendes:

      Output

      { type: 'Buffer', data: [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] }

      Der Typ ist der gleiche wie zuvor angegeben. Die Daten sind jedoch jetzt eine Anordnung mit zehn Nullen.

      Nachdem wir uns nun mit den wichtigsten Möglichkeiten zum Lesen aus einem Puffer befasst haben, schauen wir uns an, wie wir den Inhalt eines Puffers ändern.

      Schritt 3 — Modifizieren eines Puffers

      Es gibt viele Möglichkeiten, um ein bestehendes Pufferobjekt zu ändern. Ähnlich wie beim Lesen können wir Pufferbytes mithilfe der Array-Syntax einzeln ändern. Wir können auch neue Inhalte in einen Puffer schreiben und die vorhandenen Daten ersetzen.

      Lassen Sie uns zunächst untersuchen, wie wir einzelne Bytes eines Puffers ändern können. Erinnern Sie sich an unsere Puffervariable hiBuf, die den String Hi! enthält. Lassen Sie uns jedes Byte so ändern, dass es stattdessen Hey enthält.

      Versuchen wir in der REPL zunächst, das zweite Element von hiBuf auf e zu setzen:

      Lassen Sie uns diesen Puffer nun als Zeichenfolge betrachten, um zu bestätigen, dass die richtigen Daten gespeichert werden. Rufen Sie anschließend die toString()-Methode auf:

      Sie wird bewertet als:

      Output

      'Hu0000!'

      Wir haben diese seltsame Ausgabe erhalten, weil der Puffer nur einen ganzzahligen Wert akzeptieren kann. Wir können ihn nicht dem Buchstaben e zuordnen; vielmehr müssen wir ihm die Zahl zuweisen, deren binäres Äquivalent e darstellt:

      Wenn wir nun die toString()-Methode aufrufen:

      In der REPL erhalten wir diese Ausgabe:

      Output

      'He!'

      Um das letzte Zeichen im Puffer zu ändern, müssen wir das dritte Element auf die Ganzzahl setzen, die dem Byte für y entspricht:

      Lassen Sie uns dies noch einmal mit der toString()-Methode bestätigen:

      Ihre REPL zeigt:

      Output

      'Hey'

      Wenn wir versuchen, ein Byte zu schreiben, das außerhalb des Bereichs des Puffers liegt, wird es ignoriert und der Inhalt des Puffers ändert sich nicht. Versuchen wir beispielsweise, das nicht vorhandene vierte Element des Puffers auf o zu setzen:

      Wir können bestätigen, dass der Puffer mit der toString()-Methode unverändert bleibt:

      Die Ausgabe ist immer noch:

      Output

      'Hey'

      Wenn wir den Inhalt des gesamten Puffers ändern möchten, können wir die write()-Methode verwenden. Die write()-Methode akzeptiert eine Zeichenfolge, die den Inhalt eines Puffers ersetzt.

      Verwenden wir die write()-Methode, um den Inhalt von hiBuf wieder zu Hi! zu ändern. Geben Sie in Ihrer Node.js-Shell bei der Eingabeaufforderung den folgenden Befehl ein:

      Die write()-Methode hat 3 in der REPL zurückgegeben. Dies liegt daran, dass drei Datenbytes geschrieben wurden. Jeder Buchstabe hat eine Byte-Größe, da dieser Puffer eine UTF-8-Codierung verwendet, bei der für jedes Zeichen ein Byte verwendet wird. Wenn der Puffer eine UTF-16-Codierung verwendet hätte, die mindestens zwei Bytes pro Zeichen enthält, hätte die Funktion write() 6 zurückgegeben.

      Überprüfen Sie nun den Inhalt des Puffers mit toString():

      Die REPL wird Folgendes ausgeben:

      Output

      'Hi!'

      Dies ist schneller, als jedes Element byteweise ändern zu müssen.

      Wenn Sie versuchen, mehr Bytes als die Größe eines Puffers zu schreiben, akzeptiert das Pufferobjekt nur, welche Bytes passen. Erstellen wir zur Veranschaulichung einen Puffer, in dem drei Bytes gespeichert sind:

      • const petBuf = Buffer.alloc(3);

      Versuchen wir nun, Cats darauf zu schreiben:

      Wenn der Aufruf von write() ausgewertet wird, gibt die REPL 3 zurück und zeigt an, dass nur drei Bytes in den Puffer geschrieben wurden. Bestätigen Sie nun, dass der Puffer die ersten drei Bytes enthält:

      Die REPL gibt Folgendes aus:

      Output

      'Cat'

      Die Funktion write() fügt die Bytes in sequentieller Reihenfolge hinzu, sodass nur die ersten drei Bytes in den Puffer gestellt wurden.

      Im Gegensatz dazu erstellen wir einen Puffer, der vier Bytes speichert:

      • const petBuf2 = Buffer.alloc(4);

      Schreiben Sie den gleichen Inhalt darauf:

      Fügen Sie dann einige neue Inhalte hinzu, die weniger Platz beanspruchen als der ursprüngliche Inhalt:

      Da Puffer nacheinander ab 0 schreiben, wenn wir den Inhalt des Puffers drucken:

      Wir würden begrüßt werden mit:

      Output

      'Hits'

      Die ersten beiden Zeichen werden überschrieben, der Rest des Puffers bleibt jedoch unberührt.

      Manchmal befinden sich die Daten, die wir in unserem bereits vorhandenen Puffer haben möchten, nicht in einer Zeichenfolge, sondern in einem anderen Pufferobjekt. In diesen Fällen können wir die copy()-Funktion verwenden, um zu ändern, was unser Puffer speichert.

      Erstellen wir zwei neue Puffer:

      • const wordsBuf = Buffer.from('Banana Nananana');
      • const catchphraseBuf = Buffer.from('Not sure Turtle!');

      Die Puffer wordsBuf und catchphraseBuf enthalten beide Zeichenfolgendaten. Wir möchten catchphraseBuf so ändern, dass es Nananana Turtle! speichert statt Not sure Turtle!​​​. Wir werden copy() verwenden, um Nananana von wordsBuf zu catchphraseBuf zu bekommen.

      Um Daten von einem Puffer in den anderen zu kopieren, verwenden wir die copy()-Methode für den Puffer, der die Informationsquelle darstellt. Da wordsBuf die zu kopierenden Zeichenfolgendaten enthält, müssen wir diese wie folgt kopieren:

      • wordsBuf.copy(catchphraseBuf);

      Der Zielparameter ist in diesem Fall der catchphraseBuf-Puffer.

      Wenn wir das in die REPL eingeben, gibt es 15 zurück, was anzeigt, dass 15 Bytes geschrieben wurden. Die Zeichenfolge Nananana verwendet nur 8 Datenbytes, sodass wir sofort wissen, dass unsere Kopie nicht wie beabsichtigt verlaufen ist. Verwenden Sie die toString()-Methode, um den Inhalt von catchphraseBuf anzuzeigen:

      • catchphraseBuf.toString();

      Die REPL gibt Folgendes aus:

      Output

      'Banana Nananana!'

      Standardmäßig hat copy() den gesamten Inhalt von wordsBuf übernommen und in catchphraseBuf abgelegt. Wir müssen selektiver für unser Ziel sein und nur Nananana kopieren. Lassen Sie uns den ursprünglichen Inhalt von catchphraseBuf neu schreiben, bevor wir fortfahren:

      • catchphraseBuf.write('Not sure Turtle!');

      Die Funktion copy() verfügt über einige weitere Parameter, mit denen wir anpassen können, welche Daten in den anderen Puffer kopiert werden. Hier ist eine Liste aller Parameter dieser Funktion:

      • target – Dies ist der einzige erforderliche Parameter von copy(). Wie wir aus unserer vorherigen Verwendung gesehen haben, ist dies der Puffer, in den wir kopieren möchten.
      • targetStart – Dies ist der Index der Bytes im Zielpuffer, in den mit dem Kopieren begonnen werden soll. Standardmäßig ist es 0, d. h. es werden Daten kopiert, die am Anfang des Puffers beginnen.
      • sourceStart – Dies ist der Index der Bytes im Quellpuffer, aus denen kopiert werden soll.
      • sourceEnd – Dies ist der Index der Bytes im Quellpuffer, in den das Kopieren beendet werden soll. Standardmäßig ist es die Länge des Puffers.

      Um Nananana aus wordsBuf in catchphraseBuf zu kopieren, sollte unser Ziel catchphraseBuf wie zuvor sein. Der targetStart wäre 0, da Nananana am Anfang von catchphraseBuf erscheinen soll. Der sourceStart sollte 7 sein, da dies der Index ist, in dem Nananana in wordsBuf beginnt. Das sourceEnd würde weiterhin die Länge der Puffer sein.

      Kopieren Sie bei der REPL-Eingabeaufforderung den Inhalt von wordsBuf folgendermaßen:

      • wordsBuf.copy(catchphraseBuf, 0, 7, wordsBuf.length);

      Die REPL bestätigt, dass 8 Bytes geschrieben wurden. Beachten Sie, wie wordsBuf.length als Wert für den Parameter sourceEnd verwendet wird. Wie bei Arrays gibt uns die Eigenschaft length die Größe des Puffers an.

      Nun sehen wir uns den Inhalt von catchphraseBuf an:

      • catchphraseBuf.toString();

      Die REPL gibt Folgendes aus:

      Output

      'Nananana Turtle!'

      Erfolg! Wir konnten die Daten von catchphraseBuf ändern, indem wir den Inhalt von wordsBuf kopiert haben.

      Sie können die Node.js REPL beenden, wenn Sie dies möchten. Beachten Sie, dass alle erstellten Variablen nicht mehr verfügbar sind, wenn Sie Folgendes tun:

      Zusammenfassung

      In diesem Tutorial haben Sie gelernt, dass Puffer Zuordnungen fester Länge im Speicher sind, in denen Binärdaten gespeichert werden. Sie haben zuerst Puffer erstellt, indem Sie ihre Größe im Speicher definiert und sie mit bereits vorhandenen Daten initialisiert haben. Anschließend lasen Sie Daten aus einem Puffer, indem Sie die einzelnen Bytes untersucht und die Methoden toString() und toJSON() verwendet haben. Schließlich haben Sie die von einem Puffer gespeicherten Daten geändert, indem Sie die einzelnen Bytes geändert und die Methoden write() und copy() verwendet haben.

      Puffer geben Ihnen einen guten Einblick, wie Binärdaten von Node.js manipuliert werden. Jetzt, da Sie mit Puffern interagieren können, können Sie die verschiedenen Auswirkungen der Zeichenkodierung auf die Speicherung von Daten beobachten. Sie können beispielsweise Puffer aus Zeichenfolgendaten erstellen, die keine UTF-8- oder ASCII-Codierung aufweisen, und deren Größenunterschied beobachten. Sie können auch einen Puffer mit UTF-8 und toString() verwenden, um ihn in andere Codierungsschemata zu konvertieren.

      Informationen zu Puffern in Node.js finden Sie in der Node.js-Dokumentation zum Puffer-Objekt. Wenn Sie Node.js weiter lernen möchten, können Sie zur Codieren in Node-Reihe zurückkehren oder Programmierprojekte und -einstellungen auf unserer Node-Themenseite durchsuchen.



      Source link