Lassen Sie uns über die Codierung im Node.js-Puffer sprechen

Dieser Artikel führt Sie durch die Codierung in Node.js Buffer. Ich hoffe, er wird Ihnen helfen!

Die kleinste Einheit eines Computers ist ein Bit, also 0 und 1, die hohen und niedrigen Pegeln der Hardware entsprechen. Da jedoch nur ein Bit zu wenig Informationen darstellt, werden 8 Bits als ein Byte angegeben. Danach werden verschiedene Informationen wie Zahlen und Zeichenfolgen auf Basis von Bytes gespeichert. [Empfohlenes Lernen: „nodejs-Tutorial“] Wie speichere ich

Zeichen? Es basiert auf der Kodierung. Wenn dann ein Rendern erforderlich ist, wird die Schriftartenbibliothek entsprechend der entsprechenden Kodierung überprüft und anschließend werden die Grafiken der entsprechenden Zeichen gerendert.

Zeichensatz

Der früheste Zeichensatz (Zeichensatz) ist der ASCII-Code, der aus ABC 123 und weiteren 128 Zeichen besteht, da der Computer erstmals in den Vereinigten Staaten erfunden wurde. Später entwickelte Europa auch eine Reihe von Zeichensatzstandards namens ISO, und später entwickelte China auch eine Reihe von Zeichensatzstandards namens GBK.

Die Internationale Organisation für Normung war der Meinung, dass nicht jeder von uns einen anderen Code haben könne, da sonst derselbe Code in verschiedenen Zeichensätzen unterschiedliche Bedeutungen hätte. Deshalb haben wir eine Unicode-Codierung vorgeschlagen, die die meisten Codes der Welt einschließt, sodass jedes Zeichen eine hat ein einzigartiger Code.

Aber ASCII-Code erfordert nur 1 Byte zum Speichern, während GBK 2 Bytes erfordert und einige Zeichensätze 3 Bytes erfordern usw. Einige benötigen nur ein Byte zum Speichern, aber 2 Bytes sind eine ziemliche Platzverschwendung. Es gibt also verschiedene Kodierungsschemata wie utf-8, utf-16, utf-24 usw.

utf-8, utf-16 und utf-24 sind alles Unicode-Kodierungen, aber die spezifischen Implementierungspläne sind unterschiedlich.

UTF-8 Um Platz zu sparen, wurde eine Speicherlösung mit variabler Länge von 1 bis 6 Bytes entwickelt. UTF-16 ist auf 2 Bytes festgelegt und UTF-24 ist auf 4 Bytes festgelegt.

Schließlich wird UTF-8 häufig verwendet, da es am wenigsten Platz beansprucht.

Pufferkodierung von Node.js

Jede Sprache unterstützt die Kodierung und Dekodierung von Zeichensätzen, und Node.js macht dasselbe.

Buffer kann zum Speichern von Binärdaten in Node.js verwendet werden. Beim Konvertieren von Binärdaten in eine Zeichenfolge müssen Sie den Zeichensatz from, byteLength, lastIndexOf und andere Methoden angeben, die die Angabe der Codierung unterstützen:

Spezifische Unterstützung Die Codierungen umfassen:

utf8, ucs2, utf16le, latin1, ascii, base64, hex

Einige Schüler finden möglicherweise: base64 und hex sind keine Zeichensätze. Warum erscheinen sie hier?

Ja, zusätzlich zu Zeichensätzen umfassen Byte-zu-Zeichen-Codierungsschemata auch Base64 für die Konvertierung in Klartextzeichen und Hex für die Konvertierung in Hexadezimalzeichen.

Aus diesem Grund nennt Node.js es Codierung statt Zeichensatz, da es sich bei den unterstützten Codierungs- und Decodierungsschemata nicht nur um Zeichensätze handelt.

Wenn keine Kodierung angegeben ist, ist die Standardeinstellung utf8.

const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');

console.log(buf.toString());// hello world

Quellcode kodieren

Ich habe den Node.js-Quellcode zur Kodierung durchgesehen:

Dieser Abschnitt implementiert die Kodierung: https://github.com/nodejs/node/blob/master/lib/ buffer.js #L587-L726

Sie können sehen, dass jede Codierung die APIs „Encoding“, „EncodingVal“, „ByteLength“, „Write“, „Slice“ und „IndexOf“ implementiert. Da diese APIs unterschiedliche Codierungsschemata verwenden, liefern sie unterschiedliche Ergebnisse die eingehende Kodierung, die eine polymorphe Idee ist.

const encodingOps = {
  utf8: {
    encoding: 'utf8',
    encodingVal: encodingsMap.utf8,
    byteLength: byteLengthUtf8,
    write: (buf, string, offset, len) => buf.utf8Write(string, offset, len),
    slice: (buf, start, end) => buf.utf8Slice(start, end),
    indexOf: (buf, val, byteOffset, dir) =>
      indexOfString(buf, val, byteOffset, encodingsMap.utf8, dir)
  },
  ucs2: {
    encoding: 'ucs2',
    encodingVal: encodingsMap.utf16le,
    byteLength: (string) => string.length * 2,
    write: (buf, string, offset, len) => buf.ucs2Write(string, offset, len),
    slice: (buf, start, end) => buf.ucs2Slice(start, end),
    indexOf: (buf, val, byteOffset, dir) =>
      indexOfString(buf, val, byteOffset, encodingsMap.utf16le, dir)
  },
  utf16le: {
    encoding: 'utf16le',
    encodingVal: encodingsMap.utf16le,
    byteLength: (string) => string.length * 2,
    write: (buf, string, offset, len) => buf.ucs2Write(string, offset, len),
    slice: (buf, start, end) => buf.ucs2Slice(start, end),
    indexOf: (buf, val, byteOffset, dir) =>
      indexOfString(buf, val, byteOffset, encodingsMap.utf16le, dir)
  },
  latin1: {
    encoding: 'latin1',
    encodingVal: encodingsMap.latin1,
    byteLength: (string) => string.length,
    write: (buf, string, offset, len) => buf.latin1Write(string, offset, len),
    slice: (buf, start, end) => buf.latin1Slice(start, end),
    indexOf: (buf, val, byteOffset, dir) =>
      indexOfString(buf, val, byteOffset, encodingsMap.latin1, dir)
  },
  ascii: {
    encoding: 'ascii',
    encodingVal: encodingsMap.ascii,
    byteLength: (string) => string.length,
    write: (buf, string, offset, len) => buf.asciiWrite(string, offset, len),
    slice: (buf, start, end) => buf.asciiSlice(start, end),
    indexOf: (buf, val, byteOffset, dir) =>
      indexOfBuffer(buf,
                    fromStringFast(val, encodingOps.ascii),
                    byteOffset,
                    encodingsMap.ascii,
                    dir)
  },
  base64: {
    encoding: 'base64',
    encodingVal: encodingsMap.base64,
    byteLength: (string) => base64ByteLength(string, string.length),
    write: (buf, string, offset, len) => buf.base64Write(string, offset, len),
    slice: (buf, start, end) => buf.base64Slice(start, end),
    indexOf: (buf, val, byteOffset, dir) =>
      indexOfBuffer(buf,
                    fromStringFast(val, encodingOps.base64),
                    byteOffset,
                    encodingsMap.base64,
                    dir)
  },
  hex: {
    encoding: 'hex',
    encodingVal: encodingsMap.hex,
    byteLength: (string) => string.length >>> 1,
    write: (buf, string, offset, len) => buf.hexWrite(string, offset, len),
    slice: (buf, start, end) => buf.hexSlice(start, end),
    indexOf: (buf, val, byteOffset, dir) =>
      indexOfBuffer(buf,
                    fromStringFast(val, encodingOps.hex),
                    byteOffset,
                    encodingsMap.hex,
                    dir)
  }
};
function getEncodingOps(encoding) {
  encoding += '';
  switch (encoding.length) {
    case 4:
      if (encoding === 'utf8') return encodingOps.utf8;
      if (encoding === 'ucs2') return encodingOps.ucs2;
      encoding = StringPrototypeToLowerCase(encoding);
      if (encoding === 'utf8') return encodingOps.utf8;
      if (encoding === 'ucs2') return encodingOps.ucs2;
      break;
    case 5:
      if (encoding === 'utf-8') return encodingOps.utf8;
      if (encoding === 'ascii') return encodingOps.ascii;
      if (encoding === 'ucs-2') return encodingOps.ucs2;
      encoding = StringPrototypeToLowerCase(encoding);
      if (encoding === 'utf-8') return encodingOps.utf8;
      if (encoding === 'ascii') return encodingOps.ascii;
      if (encoding === 'ucs-2') return encodingOps.ucs2;
      break;
    case 7:
      if (encoding === 'utf16le' ||
          StringPrototypeToLowerCase(encoding) === 'utf16le')
        return encodingOps.utf16le;
      break;
    case 8:
      if (encoding === 'utf-16le' ||
          StringPrototypeToLowerCase(encoding) === 'utf-16le')
        return encodingOps.utf16le;
      break;
    case 6:
      if (encoding === 'latin1' || encoding === 'binary')
        return encodingOps.latin1;
      if (encoding === 'base64') return encodingOps.base64;
      encoding = StringPrototypeToLowerCase(encoding);
      if (encoding === 'latin1' || encoding === 'binary')
        return encodingOps.latin1;
      if (encoding === 'base64') return encodingOps.base64;
      break;
    case 3:
      if (encoding === 'hex' || StringPrototypeToLowerCase(encoding) === 'hex')
        return encodingOps.hex;
      break;
  }
}

Zusammenfassung

Die kleinste Einheit zum Speichern von Daten in einem Computer ist Bit, aber die kleinste Einheit zum Speichern von Informationen ist Byte. Basierend auf der Zuordnungsbeziehung zwischen Codierung und Zeichen werden verschiedene Zeichensätze implementiert, einschließlich ASCII und ISO , gbk usw. und die Internationale Organisation für Normung haben Unicode zur Einbeziehung aller Zeichen vorgeschlagen. Es gibt mehrere Unicode-Implementierungslösungen: utf-8, utf-16, utf-24. Sie verwenden unterschiedliche Anzahlen von Bytes zum Speichern von Zeichen. Unter diesen hat utf-8 eine variable Länge und das kleinste Speichervolumen und ist daher weit verbreitet.

Node.js speichert Binärdaten über Buffer, und wenn Sie sie in eine Zeichenfolge konvertieren, müssen Sie ein Codierungsschema angeben. Dieses Codierungsschema umfasst nicht nur Zeichensätze (Zeichensatz), sondern unterstützt auch Hex- und Base64-Schemas, einschließlich:

utf8, ucs2, utf16le, latin1, ascii, base64, hex

Wir haben uns den Node.js-Quellcode der Codierung angesehen und festgestellt, dass jedes Codierungsschema eine Reihe von APIs implementiert, was eine polymorphe Idee ist.

Codierung ist ein Konzept, auf das man beim Erlernen von Node.js häufig stößt. Die Codierung von Node.js umfasst nicht nur Zeichensätze. Ich hoffe, dieser Artikel kann jedem helfen, Codierung und Zeichensätze zu verstehen.

Weitere Kenntnisse zum Thema Programmierung finden Sie unter: Einführung in die Programmierung! !

Das obige ist der detaillierte Inhalt vonLassen Sie uns über die Codierung im Node.js-Puffer sprechen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!