Parlons de l'encodage dans Node.js Buffer

Cet article vous guidera à travers l'encodage dans Node.js Buffer J'espère qu'il vous sera utile !

La plus petite unité d'un ordinateur est un bit, c'est-à-dire 0 et 1, qui correspondent aux niveaux haut et bas du matériel. Cependant, un seul bit représente trop peu d'informations, donc 8 bits sont spécifiés comme un octet. Après cela, diverses informations telles que des nombres et des chaînes sont stockées en fonction des octets. [Apprentissage recommandé : "tutoriel Nodejs"] Comment stocker les

personnages ? Cela repose sur l'encodage. Différents caractères correspondent à différents encodages. Ensuite, lorsque le rendu est nécessaire, la bibliothèque de polices est vérifiée en fonction de l'encodage correspondant, puis les graphiques des caractères correspondants sont rendus.

Jeu de caractères

Le premier jeu de caractères (jeu de caractères) est le code ASCII, qui est abc ABC 123 et 128 autres caractères, car l'ordinateur a été inventé pour la première fois aux États-Unis. Plus tard, l’Europe a également développé un ensemble de normes de jeux de caractères appelé ISO, et plus tard la Chine a également développé un ensemble de normes de jeux de caractères appelé GBK.

L'Organisation internationale de normalisation a estimé que nous ne pouvions pas avoir chacun un code différent, sinon le même code aurait des significations différentes dans différents jeux de caractères. Nous avons donc proposé le codage Unicode pour inclure la plupart des codes du monde, afin que chaque caractère ait un code unique.

Mais le code ASCII ne nécessite que 1 octet pour être stocké, tandis que GBK nécessite 2 octets, et certains jeux de caractères nécessitent 3 octets, etc. Certains n'ont besoin que d'un octet pour stocker mais 2 octets sont stockés. Il existe donc différents schémas de codage tels que utf-8, utf-16, utf-24, etc.

utf-8, utf-16 et utf-24 sont tous des encodages Unicode, mais les plans de mise en œuvre spécifiques sont différents.

UTF-8 Afin de gagner de la place, une solution de stockage de longueur variable de 1 à 6 octets est conçue. UTF-16 est fixé à 2 octets et UTF-24 est fixé à 4 octets.

Enfin, UTF-8 est largement utilisé car il prend le moins de place.

Encodage tampon de Node.js

Chaque langue prend en charge l'encodage et le décodage des jeux de caractères, et Node.js fait de même.

Buffer peut être utilisé pour stocker des données binaires dans Node.js. Lors de la conversion de données binaires en chaîne, vous devez spécifier le jeu de caractères from, byteLength, lastIndexOf et d'autres méthodes prenant en charge la spécification de l'encodage :

Support spécifique Les encodages. incluent :

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

Certains étudiants peuvent trouver : base64 et hex ne sont pas des jeux de caractères, pourquoi apparaissent-ils ici ?

Oui, en plus des jeux de caractères, les schémas de codage octet en caractère incluent également base64 pour la conversion en caractères de texte brut et hex pour la conversion en hexadécimal.

C'est pourquoi Node.js l'appelle encodage au lieu de jeu de caractères, car les schémas d'encodage et de décodage pris en charge ne sont pas de simples jeux de caractères.

Si l'encodage n'est pas spécifié, la valeur par défaut est utf8.

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

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

code source d'encodage

J'ai parcouru le code source de Node.js sur l'encodage :

Cette section implémente l'encodage : https://github.com/nodejs/node/blob/master/lib/ buffer.js #L587-L726

Vous pouvez voir que chaque encodage implémente les API encoding, encodingVal, byteLength, write, slice, indexOf. Étant donné que ces API utilisent des schémas d'encodage différents, elles auront des résultats différents, Node js renverra différents objets en fonction. l'encodage entrant, qui est une idée polymorphe.

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;
  }
}

Résumé

La plus petite unité pour stocker des données dans un ordinateur est le bit, mais la plus petite unité pour stocker des informations est l'octet. Sur la base de la relation de mappage entre l'encodage et les caractères, divers jeux de caractères sont implémentés, notamment ascii et iso. , gbk, etc. , et l'Organisation internationale de normalisation a proposé l'unicode pour inclure tous les caractères. Il existe plusieurs solutions d'implémentation Unicode : utf-8, utf-16 et utf-24. Elles utilisent différents nombres d'octets pour stocker les caractères. Parmi eux, utf-8 est de longueur variable et possède le plus petit volume de stockage, il est donc largement utilisé.

Node.js stocke les données binaires via Buffer, et lors de leur conversion en chaîne, vous devez spécifier un schéma de codage qui inclut non seulement des jeux de caractères (charset), mais prend également en charge les schémas hexadécimaux et base64, notamment :

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

Nous avons examiné le code source de codage de Node.js et avons constaté que chaque schéma de codage implémenterait une série d'API, ce qui est une idée polymorphe.

L'encodage est un concept fréquemment rencontré lors de l'apprentissage de Node.js, et l'encodage de Node.js n'inclut pas seulement le jeu de caractères. J'espère que cet article pourra aider tout le monde à comprendre l'encodage et les jeux de caractères.

Pour plus de connaissances sur la programmation, veuillez visiter : Introduction à la programmation ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!