一个包含中文字符的文件如何确定每个字符需要使用多少字节？

Question

我已经阅读过Joel的文章“软件开发人员绝对必须了解的有关Unicode和字符集（无任何借口！）的绝对最低限度”，但仍然不明白所有细节。一个示例将说明我的问题。请查看下面的文件：

_{(来源：yart.com.au)}

我已经在二进制编辑器中打开了该文件，以便仔细检查紧挨着第一个汉字后面的三个a中的最后一个：

_{(来源：yart.com.au)}

根据Joel的说法：

在UTF-8中，从0到127的每个代码点都存储在单个字节中。只有128及以上的代码点才使用2、3，事实上，最多6个字节存储。

那么编辑器是否说：

1. E6（230）在代码点128以上。
2. 因此我将解释以下字节为2、3、实际上是高达6个字节。

如果是这样，那么什么指示了解释超过2个字节？这如何由E6后面的字节表示？

我的中文字符是以2、3、4、5或6个字节存储的呢？

- Petras

---

你在十六进制编辑器中标记的两个字节是三个字节字符中的两个字节。 - thomasrutter

请注意，Joel提供的信息有点过时：UTF-8每个字符最多使用四个字节，而不是六个。它最初被设计用于编码潜在的2^31个字符，但在2003年被缩减为仅处理Unicode定义中覆盖的范围，即U+0000到U+10FFFF。 - Alan Moore

Answer 1

如果编码是UTF-8，那么以下表格展示了如何将Unicode代码点（最多21位）转换为UTF-8编码：

Scalar Value                 1st Byte  2nd Byte  3rd Byte  4th Byte
00000000 0xxxxxxx            0xxxxxxx
00000yyy yyxxxxxx            110yyyyy  10xxxxxx
zzzzyyyy yyxxxxxx            1110zzzz  10yyyyyy  10xxxxxx
000uuuuu zzzzyyyy  yyxxxxxx  11110uuu  10uuzzzz  10yyyyyy  10xxxxxx

有一些非法值，尤其是字节0xC1、0xC2和0xF5-0xFF在格式正确的UTF-8中永远不会出现。还有一些其他禁止组合。不规则性出现在第一个字节和第二个字节列中。请注意，代码U+D800 - U+DFFF保留用于UTF-16代理项，不能出现在有效的UTF-8中。

Code Points          1st Byte  2nd Byte  3rd Byte  4th Byte
U+0000..U+007F       00..7F
U+0080..U+07FF       C2..DF    80..BF
U+0800..U+0FFF       E0        A0..BF    80..BF
U+1000..U+CFFF       E1..EC    80..BF    80..BF
U+D000..U+D7FF       ED        80..9F    80..BF
U+E000..U+FFFF       EE..EF    80..BF    80..BF
U+10000..U+3FFFF     F0        90..BF    80..BF    80..BF
U+40000..U+FFFFF     F1..F3    80..BF    80..BF    80..BF
U+100000..U+10FFFF   F4        80..8F    80..BF    80..BF

这些表格摘自Unicode标准版本5.1。

---

在问题中，偏移量为0x0010到0x008F的材料产生了以下结果：

0x61           = U+0061
0x61           = U+0061
0x61           = U+0061
0xE6 0xBE 0xB3 = U+6FB3
0xE5 0xA4 0xA7 = U+5927
0xE5 0x88 0xA9 = U+5229
0xE4 0xBA 0x9A = U+4E9A
0xE4 0xB8 0xAD = U+4E2D
0xE6 0x96 0x87 = U+6587
0xE8 0xAE 0xBA = U+8BBA
0xE5 0x9D 0x9B = U+575B
0x2C           = U+002C
0xE6 0xBE 0xB3 = U+6FB3
0xE6 0xB4 0xB2 = U+6D32
0xE8 0xAE 0xBA = U+8BBA
0xE5 0x9D 0x9B = U+575B
0x2C           = U+002C
0xE6 0xBE 0xB3 = U+6FB3
0xE6 0xB4 0xB2 = U+6D32
0xE6 0x96 0xB0 = U+65B0
0xE9 0x97 0xBB = U+95FB
0x2C           = U+002C
0xE6 0xBE 0xB3 = U+6FB3
0xE6 0xB4 0xB2 = U+6D32
0xE4 0xB8 0xAD = U+4E2D
0xE6 0x96 0x87 = U+6587
0xE7 0xBD 0x91 = U+7F51
0xE7 0xAB 0x99 = U+7AD9
0x2C           = U+002C
0xE6 0xBE 0xB3 = U+6FB3
0xE5 0xA4 0xA7 = U+5927
0xE5 0x88 0xA9 = U+5229
0xE4 0xBA 0x9A = U+4E9A
0xE6 0x9C 0x80 = U+6700
0xE5 0xA4 0xA7 = U+5927
0xE7 0x9A 0x84 = U+7684
0xE5 0x8D 0x8E = U+534E
0x2D           = U+002D
0x29           = U+0029
0xE5 0xA5 0xA5 = U+5965
0xE5 0xB0 0xBA = U+5C3A
0xE7 0xBD 0x91 = U+7F51
0x26           = U+0026
0x6C           = U+006C
0x74           = U+0074
0x3B           = U+003B

- Jonathan Leffler

Answer 2

这都是UTF8编码的一部分（它只是Unicode的一种编码方案）。

可以通过检查第一个字节来确定大小，如下所示：

• 如果以位模式"10" (0x80-0xbf)开头，则不是序列的第一个字节，应向后退回到找到开始的任何以"0"或"11"开头的字节（感谢Jeffrey Hantin在评论中指出这一点）。
• 如果以位模式"0" (0x00-0x7f)开头，则为1个字节。
• 如果以位模式"110" (0xc0-0xdf)开头，则为2个字节。
• 如果以位模式"1110" (0xe0-0xef)开头，则为3个字节。
• 如果以位模式"11110" (0xf0-0xf7)开头，则为4个字节。

我将重复显示此表格，但原始表格在维基百科UTF8页面此处。

+----------------+----------+----------+----------+----------+
| Unicode        | Byte 1   | Byte 2   | Byte 3   | Byte 4   |
+----------------+----------+----------+----------+----------+
| U+0000-007F    | 0xxxxxxx |          |          |          |
| U+0080-07FF    | 110yyyxx | 10xxxxxx |          |          |
| U+0800-FFFF    | 1110yyyy | 10yyyyxx | 10xxxxxx |          |
| U+10000-10FFFF | 11110zzz | 10zzyyyy | 10yyyyxx | 10xxxxxx |
+----------------+----------+----------+----------+----------+

上表中的Unicode字符由以下比特构成：

000z-zzzz yyyy-yyyy xxxx-xxxx

假设 z 和 y 位在没有给出时都为0。由于以下原因，某些字节被视为非法的起始字节：

• 无用：以0xc0或0xc1开头的2字节序列实际上给出小于0x80的代码点，可以使用1字节序列更好地表示。
• 被RFC3629用于U+10FFFF以上的4字节序列、5字节和6字节序列。这些字节是0xf5到0xfd。
• 未使用：字节0xfe和0xff。

此外，在多字节序列中，不以"10"位开始的后续字节也是非法的。

例如，考虑序列[0xf4,0x8a,0xaf,0x8d]。由于第一个字节在0xf0和0xf7之间，这是一个4字节序列。

    0xf4     0x8a     0xaf     0x8d
= 11110100 10001010 10101111 10001101
       zzz   zzyyyy   yyyyxx   xxxxxx

= 1 0000 1010 1011 1100 1101
  z zzzz yyyy yyyy xxxx xxxx

= U+10ABCD

对于您特定的查询，第一个字节为0xe6（长度=3），字节序列如下：

    0xe6     0xbe     0xb3
= 11100110 10111110 10110011
      yyyy   yyyyxx   xxxxxx

= 01101111 10110011
  yyyyyyyy xxxxxxxx

= U+6FB3

如果您在这里查找代码，您会看到它是您在问题中提到的那个：澳。

为了展示解码是如何工作的，我回到了我的档案中找到了我的UTF8处理代码。我不得不对它进行一些改变，以使其成为一个完整的程序，并且已经删除了编码（因为问题实际上是关于解码的），所以我希望我没有从剪切和粘贴中引入任何错误：

#include <stdio.h>
#include <string.h>

#define UTF8ERR_TOOSHORT -1
#define UTF8ERR_BADSTART -2
#define UTF8ERR_BADSUBSQ -3
typedef unsigned char uchar;

static int getUtf8 (uchar *pBytes, int *pLen) {
    if (*pLen < 1) return UTF8ERR_TOOSHORT;

    /* 1-byte sequence */
    if (pBytes[0] <= 0x7f) {
        *pLen = 1;
        return pBytes[0];
    }

    /* Subsequent byte marker */
    if (pBytes[0] <= 0xbf) return UTF8ERR_BADSTART;

    /* 2-byte sequence */
    if ((pBytes[0] == 0xc0) || (pBytes[0] == 0xc1)) return UTF8ERR_BADSTART;
    if (pBytes[0] <= 0xdf) {
        if (*pLen < 2) return UTF8ERR_TOOSHORT;
        if ((pBytes[1] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
        *pLen = 2;
        return ((int)(pBytes[0] & 0x1f) << 6)
            | (pBytes[1] & 0x3f);
    }

    /* 3-byte sequence */
    if (pBytes[0] <= 0xef) {
        if (*pLen < 3) return UTF8ERR_TOOSHORT;
        if ((pBytes[1] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
        if ((pBytes[2] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
        *pLen = 3;
        return ((int)(pBytes[0] & 0x0f) << 12)
            | ((int)(pBytes[1] & 0x3f) << 6)
            | (pBytes[2] & 0x3f);
    }

    /* 4-byte sequence */
    if (pBytes[0] <= 0xf4) {
        if (*pLen < 4) return UTF8ERR_TOOSHORT;
        if ((pBytes[1] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
        if ((pBytes[2] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
        if ((pBytes[3] & 0xc0) != 0x80) return UTF8ERR_BADSUBSQ;
        *pLen = 4;
        return ((int)(pBytes[0] & 0x0f) << 18)
            | ((int)(pBytes[1] & 0x3f) << 12)
            | ((int)(pBytes[2] & 0x3f) << 6)
            | (pBytes[3] & 0x3f);
    }

    return UTF8ERR_BADSTART;
}

static uchar htoc (char *h) {
    uchar u = 0;
    while (*h != '\0') {
        if ((*h >= '0') && (*h <= '9'))
            u = ((u & 0x0f) << 4) + *h - '0';
        else
            if ((*h >= 'a') && (*h <= 'f'))
                u = ((u & 0x0f) << 4) + *h + 10 - 'a';
            else
                return 0;
        h++;
    }
    return u;
}

int main (int argCount, char *argVar[]) {
    int i;
    uchar utf8[4];
    int len = argCount - 1;

    if (len != 4) {
            printf ("Usage: utf8 <hex1> <hex2> <hex3> <hex4>\n");
            return 1;
    }
    printf ("Input:      (%d) %s %s %s %s\n",
        len, argVar[1], argVar[2], argVar[3], argVar[4]);

    for (i = 0; i < 4; i++)
            utf8[i] = htoc (argVar[i+1]);

    printf ("   Becomes: (%d) %02x %02x %02x %02x\n",
        len, utf8[0], utf8[1], utf8[2], utf8[3]);

    if ((i = getUtf8 (&(utf8[0]), &len)) < 0)
        printf ("Error %d\n", i);
    else
        printf ("   Finally: U+%x, with length of %d\n", i, len);

    return 0;
}

你可以按照以下方式使用你的字节序列来运行它（你需要4个字节，所以用0进行填充）：

> utf8 f4 8a af 8d
Input:      (4) f4 8a af 8d
   Becomes: (4) f4 8a af 8d
   Finally: U+10abcd, with length of 4

> utf8 e6 be b3 0
Input:      (4) e6 be b3 0
   Becomes: (4) e6 be b3 00
   Finally: U+6fb3, with length of 3

> utf8 41 0 0 0
Input:      (4) 41 0 0 0
   Becomes: (4) 41 00 00 00
   Finally: U+41, with length of 1

> utf8 87 0 0 0
Input:      (4) 87 0 0 0
   Becomes: (4) 87 00 00 00
Error -2

> utf8 f4 8a af ff
Input:      (4) f4 8a af ff
   Becomes: (4) f4 8a af ff
Error -3

> utf8 c4 80 0 0
Input:      (4) c4 80 0 0
   Becomes: (4) c4 80 00 00
   Finally: U+100, with length of 2

- paxdiablo

---

如果以“10”开头，则表示这是一个多字节字符的续部。 - Jeffrey Hantin

Answer 3

这里有一个非常好的参考资料，是Markus Kuhn的UTF-8和Unicode FAQ。

- Greg Hewgill

Answer 4

基本上，如果以0开头，它是一个7位码点。如果以10开头，则是多字节码点的继续。否则，1的数量告诉您这个码点编码为多少个字节。

第一个字节指示多少个字节编码该码点。

0xxxxxxx 1个字节编码7位码点

110xxxxx 10xxxxxx 2个字节编码10位码点

110xxxxx 10xxxxxx 10xxxxxx 等等。 1110xxxx 11110xxx 等等。

- caskey

Answer 5

Unicode中，编码点在0x7ff及以下的字符使用2个字节存储；在0xffff及以下的字符使用3个字节存储；其他所有字符使用4个字节存储。（严格来说，最高可允许的编码点为0x10ffff）

解码时，多字节序列的第一个字节用于确定该序列使用的字节数：

1. 110x xxxx => 2字节序列
2. 1110 xxxx => 3字节序列
3. 1111 0xxx => 4字节序列

序列中的所有后续字节必须符合 10xx xxxx 的模式。

- C. K. Young

Answer 6

3字节
http://zh.wikipedia.org/wiki/UTF-8#描述

- ja.

Answer 7

UTF-8是这样构建的，以至于字符的起始位置和它有多少个字节是没有任何歧义的。它真的很简单。

一个在0x80到0xBF范围内的字节永远不会是一个字符的第一个字节。任何其他字节总是一个字符的第一个字节。

UTF-8有很多冗余。

如果你想知道一个字符有多少个字节长，有多种方法可以告诉你：

第一个字节总是告诉你字符有多少个字节长：

- 如果第一个字节是0x00到0x7F，则为一个字节。 - 0xC2到0xDF表示它有两个字节。 - 0xE0到0xEF表示它有三个字节。 - 0xF0到0xF4表示它有四个字节。

或者，你可以只数0x80到0xBF范围内连续的字节数，因为这些字节都属于与前一个字节相同的字符。

一些字节从未被使用过，比如0xC1到0xC2或0xF5到0xFF，所以如果你在任何地方遇到这些字节，那么你不是在看UTF-8。

- thomasrutter

Answer 8

提示在这句话里：

在 UTF-8 中，0-127 的每个码位都存储在单个字节中。只有 128 及以上的码位使用 2、3，实际上最多达到 6 个字节进行存储。

每个码点都有一个顶部位为零的 127。因此，编辑器知道如果遇到一个顶部位为 1 的字节，它就是多字节字符的开始。

- 1800 INFORMATION

---

编辑器知道，如果遇到第一个字节的前两个位是11，则它是多字节字符的开头。如果前两个位是10，则它是多字节字符的连续字节。 - Jonathan Leffler

Answer 9

为什么有这么多复杂的答案？

一个中文字符需要3个字节。使用这个函数（在jQuery下）：

function get_length(field_selector) {
  var escapedStr = encodeURI($(field_selector).val())
  if (escapedStr.indexOf("%") != -1) {
    var count = escapedStr.split("%").length - 1
    if (count == 0) count++  //perverse case; can't happen with real UTF-8
    var tmp = escapedStr.length - (count * 3)
    count = count + tmp
  } else {
    count = escapedStr.length
  }
  return count
}

- Siwei