Mari bercakap tentang pengekodan dalam Node.js Buffer

Artikel ini akan membawa anda melalui pengekodan dalam Node.js Penampan saya harap ia akan membantu anda.

Unit terkecil komputer ialah sedikit, iaitu 0 dan 1, yang diwakili oleh tahap tinggi dan rendah pada perkakasan. Walau bagaimanapun, hanya satu bit mewakili maklumat yang terlalu sedikit, jadi 8 bit ditetapkan sebagai satu bait Selepas itu, pelbagai maklumat seperti nombor dan rentetan disimpan berdasarkan bait. [Kajian yang disyorkan: "tutorial nodejs"] Bagaimana untuk menyimpan

aksara? Ia bergantung pada pengekodan aksara yang berbeza sepadan dengan pengekodan yang berbeza Kemudian apabila rendering diperlukan, pustaka fon disemak mengikut pengekodan yang sepadan, dan kemudian grafik aksara yang sepadan diberikan.

Set aksara

Set aksara terawal (set aksara) ialah kod ASCII, iaitu abc ABC 123 dan 128 aksara lain, kerana komputer pertama kali dicipta di Amerika Syarikat . Kemudian, Eropah juga membangunkan satu set piawaian set watak yang dipanggil ISO, dan kemudian China juga membangunkan satu set piawaian yang dipanggil GBK.

Organisasi Antarabangsa untuk Standardisasi merasakan bahawa setiap daripada mereka tidak boleh mempunyai set mereka sendiri, jika tidak, kod yang sama akan mempunyai makna yang berbeza dalam set aksara yang berbeza, jadi mereka mencadangkan pengekodan unikod untuk memasukkan kebanyakan kod dunia, jadi bahawa setiap aksara Hanya pengekodan unik.

Tetapi kod ASCII hanya memerlukan 1 bait untuk disimpan, manakala GBK memerlukan 2 bait, dan beberapa set aksara memerlukan 3 bait, dsb. Ada yang hanya memerlukan satu bait untuk menyimpan tetapi menyimpan 2 Bait, yang merupakan pembaziran ruang . Jadi terdapat skema pengekodan yang berbeza seperti utf-8, utf-16, utf-24 dan sebagainya.

utf-8, utf-16 dan utf-24 semuanya pengekodan unikod, tetapi pelan pelaksanaan khusus adalah berbeza.

UTF-8 Untuk menjimatkan ruang, penyelesaian storan panjang berubah-ubah dari 1 hingga 6 bait direka bentuk. UTF-16 ditetapkan pada 2 bait, dan UTF-24 ditetapkan pada 4 bait.

Akhir sekali, UTF-8 digunakan secara meluas kerana ia menggunakan ruang paling sedikit.

Pengekodan Penampan Node.js

Setiap bahasa menyokong pengekodan dan penyahkodan set aksara, dan Node.js melakukan perkara yang sama.

Buffer boleh digunakan untuk menyimpan data binari dalam Node.js Apabila menukar data binari kepada rentetan, anda perlu menentukan set aksara dari, byteLength, lastIndexOf dan kaedah lain yang menyokong pengekodan:

Pengekodan khusus yang disokong ialah:

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

Sesetengah pelajar mungkin mendapati bahawa: base64 dan hex bukan set aksara Ah, kenapa awak ada di sini?

Ya, sebagai tambahan kepada set aksara, skema pengekodan bait ke aksara juga termasuk base64 untuk menukar kepada aksara teks biasa dan hex untuk menukar kepada perenambelasan.

Inilah sebabnya Node.js memanggilnya pengekodan dan bukannya set charset, kerana skim pengekodan dan penyahkodan yang disokong bukan sekadar set aksara.

Jika pengekodan tidak dinyatakan, lalainya ialah utf8.

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

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

Kod sumber pengekodan

Saya telah melalui kod sumber Node.js tentang pengekodan:

Bahagian ini melaksanakan pengekodan: https:/ /github.com/nodejs/node/blob/master/lib/buffer.js#L587-L726

Anda boleh melihat bahawa setiap pengekodan melaksanakan pengekodan, pengekodanVal, byteLength, tulis, potong, indexApis ini, kerana apis ini menggunakan skema pengekodan yang berbeza, akan mempunyai hasil yang berbeza Node.js akan mengembalikan objek yang berbeza mengikut pengekodan yang masuk. Ini adalah idea polimorfik.

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

Ringkasan

Unit terkecil data yang disimpan dalam komputer ialah bit, tetapi unit terkecil maklumat yang disimpan ialah bait Hubungan pemetaan berdasarkan pengekodan dan aksara ialah Pelbagai set aksara telah dilaksanakan, termasuk ascii, iso, gbk, dsb., dan Pertubuhan Standardisasi Antarabangsa telah mencadangkan unicode untuk memasukkan semua aksara Terdapat beberapa penyelesaian pelaksanaan unikod: utf-8, utf-16, utf -24, dan mereka menggunakan bilangan bait yang berbeza untuk menyimpan aksara. Antaranya, utf-8 adalah panjang berubah-ubah dan mempunyai volum simpanan terkecil, jadi ia digunakan secara meluas.

Node.js menyimpan data binari melalui Buffer, dan apabila menukarnya kepada rentetan, anda perlu menentukan skema pengekodan ini bukan sahaja termasuk set aksara (charset), tetapi juga menyokong skema hex dan base64 , termasuk:

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

Kami melihat kod sumber pengekodan Node.js dan mendapati setiap skim pengekodan akan digunakan untuk melaksanakan satu siri API Ini adalah pemikiran Polimorfik.

Pengekodan ialah konsep yang sering ditemui semasa mempelajari Node.js, dan pengekodan Node.js bukan sahaja termasuk set aksara. Saya harap artikel ini dapat membantu semua orang memahami pengekodan dan set aksara.

Untuk lebih banyak pengetahuan berkaitan pengaturcaraan, sila lawati:

Pengenalan kepada Pengaturcaraan! !

Atas ialah kandungan terperinci Mari bercakap tentang pengekodan dalam Node.js Buffer. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!