Как делает файл с китайскими символами, знают сколько байтов использовать на символ?

Отличным справочным материалом для этого являются UTF-8 и Unicode FAQ Маркуса Куна .

По сути, если он начинается с 0, это 7-битная кодовая точка. Если он начинается с 10, это продолжение многобайтовой кодовой точки. В противном случае число 1 говорит вам, сколько байтов кодируется этой кодовой точкой.

Первый байт указывает, сколько байтов кодирует кодовую точку.

0xxxxxxx 7 битов кодовой точки, закодированных в 1 байт

110xxxxx 10xxxxxx 10 битов кодовой точки, закодированных в 2 байта

110xxxxx 10xxxxxx 10xxxxxx и т. Д. 1110xxxx 11110xxx и т.д.

если вы собираетесь использовать jQuery, вы можете легко сделать это с помощью плагина blockUI. ... или чтобы ответить на ваш вопрос с помощью CSS, вам нужно будет расположить div над контентом, который вы хотите заблокировать. просто убедитесь, что абсолютно позиционированный div идет после того, как содержимое будет заблокировано для целей z-индексации.

<div style="position:relative;width: 200px;height: 200px;background-color:green">
    <div>
        <a href="#">Content to be blocked.</a>
    </div>
    <div style="position: absolute;top:0;left:0;width: 200px;height:200px;background-color: blue;z-index:2;opacity:0.4;filter: alpha(opacity = 50)"></div>
</div>

Извините за все встроенные CSS. вам придется сделать несколько хороших уроков. Кроме того, это было проверено только в Firefox и IE7.

Я дублирую таблицу, показывающую это, но оригинал находится на странице Википедии 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 предполагаются равными нулю, если они не заданы. Некоторые байты считаются недопустимыми в качестве начального байта, поскольку они либо:

• бесполезны: 2-байтовая последовательность, начинающаяся с 0xc0 или 0xc1, фактически дает кодовую точку меньше 0x80, которая может быть лучше представлена ​​с помощью 1-байтовой последовательности.
• используется RFC3629 для 4-байтовой последовательности выше U + 10FFFF или 5-байтовой и 6-байтовой последовательностей. Это байты с 0xf5 по 0xfd.
• просто не используются: байты 0xfe и 0xff.

Кроме того, последующие байты в многобайтовой последовательности, которые не начинаются с битов «10», также недопустимы.

В качестве примера рассмотрим последовательность [0xf4,0x8a, 0xaf, 0x8d]. Это 4-байтовая последовательность, так как первый байт находится в диапазоне от 0xf0 до 0xf7.

    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 (length = 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

3 байта
http://en.wikipedia.org/wiki/UTF-8#Description

Частичный список предложений:

• получить самый ужасный SQL, с которым вы сталкивались, и попросить кандидатов объяснить как можно больше неправильных вещей, как они могут

• спросить их, как они получат план запроса для tsql, который они пишут, и что следует избегать в планах запросов (и как они будут исправлять их, если они появятся); посмотрите, знают ли они, что такое полное сканирование таблицы или индекса

• , спросите их, понимают ли они, как работает оптимизатор сервера, и как это может иметь отношение к написанному ими tsql

• , спросите их, когда это хорошо используйте tempdb

• , посмотрите, знают ли они, какие предложения sql заставят использовать tempdb за кулисами; посмотрите, знают ли они, почему это важно

• , попросите их привести примеры, когда лучше не использовать курсор

• , спросите их, как обеспечить обновление на месте;

  • Если первый байт от 0x00 до 0x7F, это один байт.
  • От 0xC2 до 0xDF означает, что это два байта.
  • От 0xE0 до 0xEF означает, что это три байта.
  • От 0xF0 до 0xF4 означает, что это четыре байта.
• Или, вы можете просто посчитать количество последовательных байтов в диапазоне От 0x80 до 0xBF, поскольку все эти байты принадлежат к тому же символу, что и предыдущий байт.

Некоторые байты никогда не используются, например, от 0xC1 до 0xC2 или от 0xF5 до 0xFF, поэтому если вы встретите эти байты где-либо, то вы не смотрите на кодировка UTF-8.

Точки кода до 0x7ff сохраняются как 2 байта; до 0xffff как 3 байта; все остальное как 4 байта. (Технически, до 0x1fffff, но максимально допустимая кодовая точка в Unicode равна 0x10ffff.)

При декодировании первый байт многобайтовой последовательности используется для определения количества байтов, использованных для создания последовательности:

1. 110x xxxx => 2-байтовая последовательность
2. 1110 xxxx => 3-байтовая последовательность
3. 1111 0xxx => 4-байтовая последовательность

Все последующие байты в последовательности должны соответствовать паттерн 10xx xxxx .

Подсказка в этом предложении здесь:

В UTF-8 каждый код указывает 0-127 хранится в одном байте. Только код точки 128 и выше сохраняются с использованием 2, 3, фактически, до 6 байтов.

У каждой кодовой точки до 127 верхний бит установлен в ноль. Следовательно, редактор знает, что если он встречает байт, где верхний бит равен 1, это начало многобайтового символа.