00字符    码点    对齐到 4 字节整数
01'H' => U+48 => 0x00000048
02'e' => U+65 => 0x00000065
03'l' => U+6C => 0x0000006C
04'l' => U+6C => 0x0000006C
05'o' => U+6F => 0x0000006F
06',' => U+2C => 0x0000002C
07' ' => U+20 => 0x00000020
08'世' => U+4E16 => 0x00004E16
09'界' => U+754C => 0x0000754C

00// ⬇️ 🍰 的 unicode 码点 (0x1F370 的二进制形式)
01　  1 11110011 01110000   // ⬅️ 码点需要先减去 0x10000
02　- 1 00000000 00000000   //
03　----------------------- // ⬇️ 高代理（两字节） ⬇️ 低代理（两字节）
04　    11110011 01110000    1101100000111100  1101111101110000
05　    aaaaaabb bbbbbbbb    HHHHHH****aaaaaa  LLLLLLbbbbbbbbbb
06　                         将高低代理对写在一起就构成四字节的 utf16
07　                         0xD83C 0xDF70
08　// ⚠️ 注意:
09　// 1. HHHHHH 代表固定的高代理头, 110110 (0xD800 到 0xDBFF)
10　//    LLLLLL 代表固定的低代理头, 110111
11　// 2. 上述标 a 标 b 的部分其实就对应右边的标 a 标 b 部分,
12　//    从低位往左边填充，填完就就填 0 （也就是标星号 * 的那部分）

00utf16EncodeCodePoint(0x6C38) // 永 (码点为 U+6C38)
01// => [0x6C, 0x38]
02utf16EncodeCodePoint(0x1F370) // 🍰 (码点为 U+1F370)
03// => [0xD8, 0x3C, 0xDF, 0x70]

00/**
01 * high-half surrogates 0xD800 0xDBFF
02 * low-half surrogates 0xDC00 0xDFFF
03 * surrogates 0xD800-0xDFFFF
04 * @param codePoint 给定码点
05 * @returns 返回二字节或四字节 number[]
06 */
07export function utf16EncodeCodePoint(codePoint: number): number[] {
08  if (codePoint < 0x10000) { // 第一平面 (BMP)
09    const byte0 = (codePoint & 0b1111111100000000) >> 8;
10    const byte1 = codePoint & 0b0000000011111111;
11    return [byte0, byte1];
12  }
13
14  if (codePoint >= 0x100000) {
15    throw new Error('不支持大于 0x100000 的码点')
16  }
17
18  // 需要减去 0x10000 避免对第一平面重复编码
19  const buf = (codePoint - 0x10000);
20
21  const l10 = (buf & 0b00000000001111111111);
22  const h10 = (buf & 0b11111111110000000000) >> 10;
23
24  const h16 = h10 | 0b1101100000000000;
25  const l16 = l10 | 0b1101110000000000;
26
27  return [
28    (h16 & 0b1111111100000000) >> 8,
29    (h16 & 0b0000000011111111),
30    (l16 & 0b1111111100000000) >> 8,
31    (l16 & 0b0000000011111111),
32  ];
33}

00console.log('\uD83C\uDF70');
01// 将会输出 '🍰'

00console.log('\u{1F370}');
01// U+1F370 是 🍰 的码点, 将会输出 '🍰'

00console.log('🍰'.length);
01// => 2

00'🍰 Hello'.split('');
01// => ['\uD83C', '\uDF70', ' ', 'H', 'e', 'l', 'l', 'o']

00Array.from('🍰 Hello');
01// => ['🍰', ' ', 'H', 'e', 'l', 'l', 'o']
02
03[...'🍰 Hello'];
04// => ['🍰', ' ', 'H', 'e', 'l', 'l', 'o']

00Array.from('🍰 🍉').forEach(ch => {
01  console.log(`'${ch}'=>U+${ch.codePointAt(0).toString(16)}`);
02});
03// 将会输出
04// '🍰'=>U+1f370
05// ' '=>U+20
06// '🍉'=>U+1f349

00//　     unicode 码点               UTF-8
01永    11011000 0111000    11100110 10110000 10111000
02　                        ----     --       --
03　                                 10 开头   10 开头   
04　        第一个字节开头的 1110 代表总共 3 个字节
05　        其后每一个字节的开头都是 10,
06　        然后将码点按位填充到剩下的位得到最终结果
07　        (转 16 进制后为: 0xE6 0xB0 0xB8)

00/** 将单个码点转为 utf-8 编码 */
01export function utf8EncodeCodePoint(codePoint: number): number[] {
02  // 0b01111111 及以下的情况跟 ASCII 保持一致，直接返回即可
03  if (codePoint <= 0b01111111) {
04    return [codePoint]
05  }
06
07  // 先将 codePoint 按 0b10 + 6 位的方式隔开成 number[]
08  const result: number[] = [];
09  for (;;) {
10    const _6bit = codePoint & 0b111111;
11    const _8bit = 0b10000000 | _6bit;
12    result.unshift(_8bit);
13    codePoint = codePoint >> 6;
14    if (codePoint === 0) break;
15  }
16
17  // 处理 `utf 头`
18  const header = ((1 << result.length) - 1) << 1;
19  const restBits = 8 - 1 - result.length;
20
21  // 判断第一位放不得下 header
22  if ((1 << restBits) > (result[0] & 0b111111)) {
23    const headerByte = (header << restBits);
24    result[0] = (result[0] & 0b111111) | headerByte;
25  } else {
26    // 放不下则单独开一个字节塞到最前面
27    result.unshift(((header + 1) << 1) << (restBits - 1));
28  }
29
30  return result;
31}

00/**
01 * 将 arr 当作 utf-8 buffer 进行解码，将其解码位码点数组
02 */
03export function utf8Decode(arr: ArrayLike<number>) {
04  let result: number[] = [];
05  let i = 0;
06  while (i < arr.length) {
07    const firstByte = arr[i];
08
09    // 先扫描 utf 头搞到总长度
10    let scanner = 0b10000000;
11    let utfLength = 0;
12    while (firstByte & scanner) {
13      utfLength ++;
14      scanner = scanner >> 1;
15    }
16
17    // 第一位通过前面的 scanner 就能快速取出其有效的数据位
18    let buf = firstByte & (scanner - 1);
19    for (let offset = 1; offset < utfLength; offset ++) {
20      buf = buf << 6;
21      buf = buf | (arr[i + offset] & 0b00111111);
22    }
23
24    result.push(buf);
25    i = i + utfLength;
26  }
27
28  return result;
29}

000xEF => 11101111 (开头 1110 代表一共 3 字节, 低 4 位是有效位: 1111)
010xBB => 10111011 (低 6 位是有效位: 111011)
020xBF => 10111111 (低 6 位是有效位: 111111)
03有效位拼接后得到 0b1111111011111111
04转成十六进制恰好就是 0xFEFF 这恰好就是 UTF-16 的 BOM

00// Node REPL
01> str = Buffer.from([0xEF, 0xBB, 0xBF, 0x41]).toString()
02// => 显示为 'A'
03> console.log(str.length)
04// => 2 实际为 '\uFEFFA', 只是显示不出 0xFEFF 了

000xEF => 11101111 (开头 1110 代表一共 3 字节, 低 4 位是有效位: 1111)
010xBB => 10111011 (低 6 位是有效位: 111011)
020cBF => 10111111 (低 6 位是有效位: 111111)
03有效位拼接后得到 0b1111111011111111
04转成十六进制恰好就是 0xFEFF 这恰好就是 UTF-16 的 BOM

00const http = require('http');
01http.createServer((req, res) => {
02  res.setHeader('Content-Type', 'text/html; charset=utf-8');
03  res.write(Buffer.from([0xEF]));
04  res.end();
05}).listen(3000);

00<Buffer E6>
01<Buffer B0 B8>

00<Buffer E6>.toString()
01<Buffer B0 B8>.toString()

00Buffer.concat([
01  <Buffer E6>,
02  <Buffer B0 B8>,
03]).toString()