Char сколько байт: C++ | Типы данных

c — Количество байт, которое занимает UTF8 символ в char * строке?

Для итерации по словам строки в кодировке UTF8 мне понадобилось разобраться в том, как узнать по-первому байту символа общее количество его байт. Я только начинаю разбираться с UTF8, поэтому не совсем понимаю наверняка механику битовых операций, которая для этого используется (судя по большинству примеров в интернете).

На StackOverflow я нашёл два решения:

1) Способ 1

size_t utf8_char_length(char firstbyte) {
    if ((firstbyte & 0xC0) == 0xC0) {
        if ((firstbyte & 0xF0) == 0xF0) {
            return 4;
        } else if ((firstbyte & 0xE0) == 0xE0) {
            return 3;
        } else {
            return 2;
        }
    } else {
        return 1;
    }
}

2) Второе решение найдено здесь, оно использует другой способ: вместо битовой операции & используется «lookup» по следующему массиву из 256 символов:

static const size_t utf8_skip_data[256] = {
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
    3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,1,1
};

К сожалению, я сейчас не имею возможности досконально разобраться с UTF8, поэтому просто ищу надёжную функцию, которая будет давать мне правильные результаты для символов в кодировке в UTF8 (точнее для первых байт этих символов). Мне больше нравится второе решение, но я хочу услышать мнение более опытных специалистов:

какую функцию стоит использовать для такой задачи: 1, 2 или, может быть, вы знаете какую-то проверенную свою функцию, которая лучше, чем эти две?

P. S. Кстати, если кто-то может объяснить, откуда взялась lookup-таблица, буду признателен. На SO пишут, что она взята из исходного кода glib's gutf8.c. Так вот интересно, какой принцип лежит в её основе.

Спасибо.

Java досконально разбирается в байтах char short int float long double

Я столкнулся с множеством вопросов о диапазоне числовых типов. Вот резюме. Мы можем понять диапазон значений, которые могут быть представлены различными числовыми типами, со многих аспектов.

Здесь мы говорим только о числовых типах в java.

Сначала произнесите байт:

Этот абзац взят из исходного кода в Byte.java в jdk

Отсюда мы можем видеть диапазон значений байта: -128 — 127;

Это можно объяснить с точки зрения принципа компоновки компьютера: байт занимает в компьютере 8 байтов, а байт представляет собой целое число со знаком. При выражении в двоичном формате старший бит является битом знака. 0 представляет положительное число, а 1 представляет отрицательное число.

Максимальное значение: 127 0111 1111 То есть 2 в 7-й степени минус 1;

Минимальное значение: -128 Это число беспокоило меня в течение долгого времени. Вы должны знать, что положительные числа существуют в исходной форме компьютера, а отрицательные числа существуют в форме его дополнения в компьютере. Тогда как вычисляется дополнение отрицательного числа? Какая? То есть исходный код абсолютного значения отрицательного числа преобразуется в двоичный, бит инвертируется, а затем добавляется 1,

Следующие 10 и -10 взяты в качестве примеров для представления: 10 Исходный код: 0000 1010 Его память в компьютере — 0000 1010, а как насчет -10? Разделите абсолютное значение 10 в соответствии с предыдущим вычислением и преобразуйте его в двоичное значение 0000 1010. Инвертируйте 1111 0101 и добавьте 1: 1111 0110, что является дополнением до -10. Хорошо, 1111 0110 в компьютере означает -10 Вверх.

Давайте посмотрим на двоичное представление -128 с абсолютным значением 128: 1000 0000, инвертированное битом 0111 1111 после добавления 1: 1000 0000, то есть представление -128 на компьютере равно 1000 0000, давайте посмотрим на -129 на компьютере. Указывает, что диапазон абсолютного значения 129 превысил количество байтов.

Вы все еще можете пройти

Выведите максимальное и минимальное значения байта.

Таким образом, диапазон значений байта может быть только: -128 — 127, то есть минус 1 от 7-й степени 2 до 7-й степени 2 минус 1.

Соответствующий short как 16-разрядное целое число со знаком, int как 32-разрядное целое число со знаком и long как 64-разрядное целое число со знаком может быть вычислено, как указано выше. Диапазон значений

Символьный как 16-битового целое число без знака, его диапазон 0 — от 2 до 15 мощности, который является неоспоримым

Взято из исходного кода в Character.java:

float как 32-битный тип с плавающей запятой:

Извлечено из исходного кода Float.java:

удваивается как 64 для чисел с плавающей запятой

Исходный код Double.java:

Перепечатано по адресу: https://www.cnblogs.com/sunyubin/p/9751213.html

Информатик БУ — Типы данных Pascal

Pascal – язык со строгой типизацией переменных. Это значит, что мы обязательно должны указывать тип каждой переменной, и не можем присвоить переменной одного типа значение другого типа (если только они не эквивалентны).

В качестве примера возьмем часть программы, которая вычисляет площадь круга по заданному радиусу:

S := r*r*3.14;

Если мы укажем, что у переменной S целочисленный тип, программа будет работать не верно, так как результатом выражения r*r*3.14  будет дробь, и присвоить целочисленной переменной дробное значение мы не можем.

Еще один пример. Программа складывает значение двух переменных:

a := 5;

b := 4;

c := a+b;

Если мы укажем, что a, b и c являются числами, то вполне логично предположить, что после выполнения программы значение c станет равно 9-ти. Но что будет, если a и b являются не числами, а простыми символами, а c – строкой?

a := ‘5’;

b := ‘4’;

c := a+b;

В этом случае мы не можем сложить математически два значения (ну правда, мы же не можем математически сложить две буквы), и символы просто подставятся друг к другу, то есть значение c будет равно ‘54’.

Кроме этого, после запуска программы для каждой переменной в оперативной памяти выделяется некоторое количество байт, которое зависит от типа этой переменной. И значения, которые может принять переменная, ограничены этим количеством байт. К примеру, переменной с типом данных byte выделяется 1 байт памяти, и она может принимать значения от 0 до 255, всего 256, что является количеством вариантов, которые можно закодировать одним байтом. Если же мы укажем для переменной тип byte, но присвоим ей значение, к примеру, 1000, программа работать не будет.

Целочисленные типы

Переменная целочисленного типа может принимать любое целое значение из диапазона значений этого типа. Также является порядковым типом.

В заданиях ЕГЭ, как правило, достаточно использовать тип данных integer.

Вещественные типы

К вещественному типу относят дробные числа и числа с плавающей запятой. Тем не менее, мы можем присвоить вещественному типу целое значение.

Тип	Длина (байт)	Диапазон
single	4	1. 5*10-45 — 3.4*1038
real	6	2.9*10-39 — 1.7*1038
double	8	5*10-324 — 1.7*10308
extended	10	3.4*10-4932 — 1.1*104932

В заданиях ЕГЭ, как правило, достаточно использовать тип данных real.

Символьный тип

Любой одиночный символ.

Переменной типа char можно присвоить любую букву, цифру, или любой другой символ стандартной кодировки. Также является порядковым типом.

Строковый тип

Если char — это только один символ, то строка — это набор символов. Строкой может быть, к примеру, слово, состоящее из нескольких букв. Также строки относят к структурным типам.

Логический тип

Переменная логического типа может принимать только два значения: true или false (истина или ложь). Является порядковым типом.

Интервальный тип данных

Интервальный тип указывает, что переменная может принимать значения от одного значения, до другого. К примеру, мы знаем, что переменная может принимать значения только от 5 до 25. Мы можем объявить её тип так:

var

a: 5..25;

Память компьютера | Приложение 3. Представление информации в компьютере | Статьи | Программирование Realcoding.Net

<!—StartFragment —>

Память
компьютера

Память компьютера
состоит из ячеек (битов). Каждый бит может хранить одну двоичную цифру. Следовательно,
значением бита может быть ноль или единица. Восемь битов объединены в байт.
Максимальное число, которое можно записать при помощи восьми двоичных цифр —
это 11111111, что соответствует десятичному числу 255, минимальное — ноль. Поэтому
значением байта может быть число от нуля до 255.

Память используется
для хранения переменных. Так как переменные различных типов могут принимать
различные значения, то для их хранения нужно разное количество памяти. Память
под переменные выделяется целым числом байтов. Например, значением переменной
типа char может быть любой из 256 символов. Поэтому для хранения переменной
этого типа достаточно одного байта. Значением переменной типа integer может
быть число от -32 768 до 32 767 (65 535 значений), для хранения переменной этого
типа требуется два байта. Очевидно, что чем больше диапазон значений типа, тем
больше байтов нужно для хранения переменной этого типа (табл. П3.1).

Таблица
П3.1. Диапазоны значений и занимаемая память для разных типов переменных

В программе
для хранения одного и того же значения можно использовать переменные разных
типов (при этом будет применяться разное количество памяти). Например, если
в программе используется переменная Day, содержащая число месяца, то для нее
можно задать тип byte, integer или longint. В первом случае будет занят один
байт памяти, во втором — два, в третьем — четыре. Но реально будет использоваться
только один байт, а остальные будут только заняты. Поэтому, выбирая тип для
переменной, следует подбирать наиболее подходящий тип для каждой конкретной
ситуации. Особо необходимо обращать внимание на описание строковых переменных
и массивов.

Выделяя память
для строковых переменных, следует помнить, что если не указана предельная длина
строки, то переменной выделяется 256 байтов. Объявляя переменную, предназначенную,
например, для хранения имени человека, нужно писать name: string [30], а не
name: string.

Каждому массиву
программы выделяется память, объем которой определяется как типом элементов
массива, так и их количеством. Для хранения двумерного массива, например, 20×20
вещественных чисел нужно более 3 Кбайт памяти (20x20x8 = 3200).

Память компьютера
кажется неограниченной, но если ее использовать нерационально, то в некоторый
момент может возникнуть ситуация, связанная с нехваткой памяти.

Для решения задачи в любой программе выполняется обработка каких-либо данных. Они хранятся в памяти компьютера и могут быть самых различных типов: целыми и вещественными числами, символами, строками, массивами и т.д.

Тип данных определяет:

• возможные значения переменных, констант, функций, выражений, принадлежащих к данному типу;
• внутреннюю форму представления данных в ЭВМ, т.е. способ хранения чисел или символов в памяти компьютера, размер ячейки, в которую будет записано то или иное значение;
• операции и функции, которые могут выполняться над величинами, принадлежащими к данному типу.

Область памяти, в которой хранится значение определенного типа, называется переменной. У переменной есть имя (идентификатор), тип и значение. Имя служит для обращения к области памяти, в которой хранится значение. Во время выполнения программы значение переменной можно изменить. Перед использованием любая переменная должна быть описана. Описание переменных в языке Free Pascal осуществляется в разделе описания переменных.

Обязательное описание типа приводит к избыточности в тексте программ, но такая избыточность является важным вспомогательным средством разработки программ и рассматривается как необходимое свойство современных алгоритмических языков высокого уровня. В языке Паскаль существуют скалярные и структурированные типы данных.

К скалярным типам относятся стандартные типы и типы, определяемые пользователем. Стандартные скалярные типы включают в себя целые, действительные, символьный, логические и адресный типы. Скалярные типы, определяемые пользователем, – это перечисляемый и интервальный типы.

Структурированные типы имеют четыре разновидности: массивы, множества, записи и файлы.

Рассмотрим основные типы данных.

Символьный тип данных

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

Описывают символьный тип с помощью служебного слова char.

Например:

var
c: char;

В тексте программы значения переменных и константы символьного типа должны быть заключены в апострофы: ‘а’, ‘b’, ‘+’.

Целочисленный тип данных

Целочисленные типы данных могут занимать в памяти компьютера один, два, четыре или восемь байт. Диапазоны значений данных целочисленного типа представлены в табл. 1.

Таблица 1. Целочисленные типы данных

Описать целочисленных переменных в программе можно следующим образом:

var
b: byte;
i, j: integer;
W: word;
L_1, L_2: longint;

Переменная типа char имеет размер, естественный для хранения символа на данной машине, обычно 1 байт (8 бит).

Рис. 3. Каждый элемент данных символьного типа занимает один элемент памяти

Набор употребляемых символов включает в себя латинские буквы, 26 прописных и 26 строчных:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Za b c d e f g h i g k l m n o p q r s t u v w x y z

десять арабских цифр:

1 2 3 4 5 6 7 8 9 0

и специальные символы клавиатуры:*

! @ # $ % ^* ( ) _ + — = | \ } {‘ : ; ? /. , ~ `

Например, если вы пишете тест, в котором испытуемый должен выбрать один из четырех вариантов ответа — А, Б, В или Г, — каждая буква будет являться отдельным элементом символьных данных.

К символьному типу относятся и специальные управляющие коды, для хранения которых Си отводит столько же памяти, сколько и для единичного символа.

Заметьте, что символьные данные могут быть представлены в виде цифр — 1, 2, 3, — однако Си проводит различия между символом «1» и числом 1. Как символ единица не может использоваться в математических операциях, поскольку она не рассматривается в этом случае как математическая величина. Как число единица участвует в вычислениях, при этом, как вы скоро увидите, для хранения символа «1» Си отводит объем памяти вполовину меньший, чем для хранения числа 1.

Строки

Строкой называют набор символов, слов, фраз или предложений. В отличие от некоторых других языков, в Си строка не выделяется в отдельный тип данных. Язык Си работает со строкой как с последовательностью данных символьного типа, используя так называемый массив. Строка может состоять из любой комбинации букв, цифр, знаков препинания и управляющих кодов, которые тоже могут использоваться в качестве символьных данных. Язык Си проводит различия между строкой цифр и числом. Строка «123» будет восприниматься не как математическое значение сто двадцать три, а как комбинация символов «1», «2», «3».

____________________

Сюда же относятся и буквы русского алфавита: 33 прописных и 33 строчных.

Целочисленные величины

Если вы хотите производить математические операции, то должны использовать числовой тип данных. Язык Си имеет несколько типов числовых данных в зависимости от значения, которое может быть им присвоено, и занимаемого объема памяти.

Целые числа (int, от английского integer) — это числа, не имеющие дробной части. Их значение может быть положительным, отрицательным или нулевым, но никогда не имеет в своем составе знаков после точки. В языке Си есть простая аксиома, которая гласит: «Используйте для подсчетов целые числа». Используйте целые числа всегда, когда есть возможность представить некое значение в виде целого числа, например, при подсчете количества повторов определенного события.

Как показано на рис. 4, каждый элемент целочисленных данных занимает в памяти столько же места, сколько два элемента символьных, независимо от величины самого числа (и число 2, и число 2000 требуют для хранения одинакового объема памяти). Но для того чтобы занимаемое место не превышало двух элементов памяти, величина целочисленных данных в языке Си ограничена. К целочисленным данным (собственно тип int) относятся величины, значение которых находится в промежутке между –32768 и +32767. Величины, значение которых выходит за эти пределы, требуют для хранения больше двух элементов памяти.

Рис. 4. Целочисленные данные занимают два элемента памяти

Для того чтобы обеспечить возможность работы с числами любой величины, в большинстве компиляторов Си определено несколько типов целочисленных данных. Границы для разных типов могут различаться в зависимости от конкретного компилятора.

Вещественные числа

Числа, которые могут содержать десятичную часть (вещественные), называются числами с плавающей точкой (floating-point values). Для работы с ними в языке Си используется тип данных с плавающей точкой (float). Так как числа с плавающей точкой могут быть чрезвычайно маленькими или большими, для их записи часто используют экспоненциальную форму, например, значение числа с плавающей точкой может равняться 3.4е+38. Расшифровать это можно следующим образом: «передвинуть точку вправо на 38 пунктов, добавив соответствующее количество нулей». Существуют дополнительные типы данных для работы в очень широких пределах величин:

Тип данных с плавающей точкой имеет предел точности, диапазон которого зависит от компилятора. Например, число 6.12345678912345 в пределах допустимого диапазона для чисел типа float может быть записано компьютером только как 6.12345. Этот тип, как принято говорить, является типом с одинарной точностью, что означает, что точность его ограничена пятью или шестью знаками после точки. Тип double принято называть типом с двойной точностью, он имеет 15–16 знаков после точки.

Рис. 5. Требования к объему памяти данных различных типов

Для записи данных с одинарной точностью резервируется четыре элемента памяти; двойная точность требует резервирования восьми, повышенная (long double) — десяти.

На рис. 5 мы просуммировали сведения о типах данных в языке Си и их требованиях к резервированию памяти.

Статьи к прочтению:

Разбор заданий 10 и 13. ЕГЭ по информатике 2015

Похожие статьи:

• Список переменного размера

  Министерство общего и профессионального образования Российской Федерации Самарский государственный университет Кафедра БЕЗОПАСНОСТИ ИНФОРМАЦИОННЫХ СИСТЕМ…

• Строковые данные. типы char и string

  Перечисляемый тип данных. Строковый тип. Множества. Записи. Файлы Перечисляемый тип данных Перечисляемый тип является простым и порядковым. Он позволяет…

Какой длины ваша строка? — JavaTutor.net

Какой длины ваша текстовая строка? Вам понадобится ответ на этот вопрос, чтобы проверить допустимые ли данные ввел пользователь в поле данных ограниченной длины. Текстовое поле баз данных обычно ограничивают входные данные определенной длиной, так что вам надо сначала подтвердить длину текста, прежде чем отправить его. Какова бы ни была причина, нам всем иногда необходимо узнать длину текстового поля. Чтобы получить эту информацию, многие программисты используют метод length объекта String. И в большинстве случаев метод length обеспечивает правильный результат. Однако, это не единственный и не всегда верный способ узнать длину объекта String.

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

1. количество знаков char в коде
2. количество символов (characters) или кодовых единиц
3. число байтов

Подсчет знаков

char

В платформе Java используется Unicode Standard для определения символов. Unicode Standard определяет и фиксирует для каждого символа значение, состоящее из 16 битов, в пределе от U+0000 до U+FFFF. Префикс U+ означает допустимое значение в Юникоде как шестнадцатеричное число. В языке Java стандарт фиксированного размера символов удобно преобразуется в тип char. Таким образом значение char может быть представлено любым символом в 16-битном Юникоде.

Большинство программистов знакомы с методом length. Код, приведенный ниже, считает количество знаков char в примере строки. Обратите внимание, что пример объекта String содержит несколько простых символов и несколько символов, определенных в \u нотации языка Java. \u нотация определеяет шестнадцатеричное число и является аналогом нотации U+, используемой Unicode Standard.

private String testString = "abcd\u5B66\uD800\uDF30";
int charCount = testString.length();
System.out.printf("char count: %d\n", charCount);

Метод length считает количество знаков char в объекте String. Вот что выведет этот код:

Подсчет символов

Когда Unicode версии 4.0 определяет важные новые символы выше U+FFFF, 16-битный тип char не может более представлять все символы. Начиная с Java 2 Platform, Standard Edition 5.0 (J2SE 5.0), платформа Java поддерживает новые символы Юникода — пары 16-битных знаков char, которые называются
суррогатными парами (surrogate pair). Два знака char действуют как суррогатное представление символов Юникода в диапазоне от U+10000 до U+10FFFF. Символы в таком новом диапазоне называются дополнительные символы (supplementary characters).

Хотя единичный знак char все еще может представлять значение в Юникоде более U+FFFF, только суррогатная пара из двух char может представлять дополнительные символы. Главное или бóльшее значение в паре лежит в диапазоне от U+D800 до U+DBFF. Следующее или меньшее — от U+DC00 до U+DFFF. Unicode Standard
выделил два этих диапазона, чтобы специально использовать в суррогатных парах. Стандарт также определяет алгоритм для преобразования между суррогатными парами и символами, значения которых лежат выше U+FFFF. Используя суррогатные пары, программисты могут представить любой символ в Unicode Standard. Такое специальное использование 16-битных знаков называется UTF-16, и Java Platform пользуется UTF-16 для представления символов в Юникоде. Теперь тип char — это знак в коде UTF-16, необязательно целый символ Юникода (кодовая единица).

Метод length не может считать дополнительные символы, так как он считает только знаки char. К счастью в J2SE 5.0 API есть новый метод String:
codePointCount(int beginIndex, int endIndex). Этот метод показывает, сколько единиц Юникода (символов) между двумя индексами. Значения индексов ссылаются на код, обозначающий местоположение знака char. Значение выражения endIndex - beginIndex такое же как и значение, полученное с помощью метода length. Но это не всегда равно значению, возвращаемому методом codePointCount. Если ваш текст содержит суррогатные пары, вычисляемая длина сильно изменится. Суррогатная пара определяет код одного символа, который может состоять из одного или двух знаков char.

Чтобы узнать, сколько символов Юникода в строке, используйте метод codePointCount:

private String testString = "abcd\u5B66\uD800\uDF30";
int charCount = testString.length();
int characterCount = testString.codePointCount(0, charCount);
System.out.printf("character count: %d\n", characterCount);

Этот пример выведет следующее:

Переменная testString содержит два интересных символа: японский иероглиф, обозначающий «учение», и буква готского алфавита А (GOTHIC LETTER AHSA). Японский иероглиф в Юникоде имеет значение U+5B66 и такой же номер знака char в шестнадцатеричной системе \u5B66. Значение готской буквы — U+10330. В UTF-16 готская буква состоит из суррогатной пары \uD800\uDF30. Пара представляет один целый символ в Юникоде, таким образом число символов в строке равно 6, а не 7.

Подсчет байтов

Сколько байт в строке String? Ответ зависит от использованной кодировки. Одной из наиболее распространенных причин спрашивать «сколько байт?» является желание убедится, что вы удовлетворили ограничением на длину строки в базе данных. Метод getBytes преобразует символы Юникода в байтовую кодировку (в кодировку, работающую не с символами, а байтами) и возвращает количество байт: byte[]. Одной из байтовых кодировок является UTF-8. Это самая распространенная байтовая кодировка, потому что может точно представлять символы Юникода.

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

byte[] utf8 = null;
int byteCount = 0;
try {
  utf8 = str.getBytes("UTF-8");
  byteCount = utf8.length;
} catch (UnsupportedEncodingException ex) {
  ex.printStackTrace();
}
System.out.printf("UTF-8 Byte Count: %d\n", byteCount);

Наш набор символов определяет, сколько создано байтов. Кодировка UTF-8 преобразует один символ Юникода в один или несколько (до 4) 8-битовых единиц (байтов). Символы a, b, c и d требуют всего четыре байта. Японский иероглиф превращается в три байта. А готская буква занимает четыре байта. Вот каким будет результат:

Рисунок
1. Строки имеют различную длину, зависящую от того, что вы считаете.

В заключение

Даже используя дополнительные символы, вы никогда не увидите разницу между возвращаемыми значениями метода length и метода codePointCount. Однако, когда вы используете символы выше U+FFFF, вам пригодится умение определять длину различными способами. Если вы будете посылать свои продукты в Японию или Китай, то наверняка попадете в ситуацию, когда методы length и codePointCount вернут различные значения. Базы данных и некоторые форматы публикаций поощряют использование в качестве кодировки UTF-8. Но даже в этом случае измерение длины текста может дать различные результаты. В зависимости от того, как вы будете использовать длину, у вас есть различные способы ее измерить.

Дополнительная информация

Используйте эти ресурсы, чтобы найти информацию по теме данного технического совета:

http://java. sun.com/mailers/techtips/corejava/2006/tt0822.html#1

Архив проектов | Лаборатория VAST

Как Python сохраняет память при хранении строк

Начиная с Python 3, тип str использует представление Unicode. Строки Unicode могут занимать до 4 байтов на символ в зависимости от кодировки, что иногда может быть дорогостоящим с точки зрения памяти.

Чтобы уменьшить потребление памяти и повысить производительность, Python использует три вида внутренних представлений для строк Unicode:

• 1 байт на символ (кодировка Latin-1)
• 2 байта на символ (кодировка UCS-2)
• 4 байта на символ (кодировка UCS-4)

При программировании на Python все строки ведут себя одинаково, и большую часть времени мы не замечаем никакой разницы.Однако разница может быть очень заметной, а иногда и неожиданной при работе с большими объемами текста.

Чтобы увидеть разницу во внутренних представлениях, мы можем использовать функцию sys.getsizeof , которая возвращает размер объекта в байтах:

  >>> import sys
>>> строка = 'привет'
>>> sys.getsizeof (строка)
54
>>> # 1-байтовая кодировка
>>> sys.getsizeof (строка + '!') - sys.getsizeof (строка)
1
>>> # 2-байтовая кодировка
>>> строка2 = '你'
>>> sys.getsizeof (строка2 + '好') -sys.getsizeof (строка2)
2
>>> sys.getsizeof (строка2)
76
>>> # 4-байтовая кодировка
>>> строка3 = '🐍'
>>> sys.getsizeof (строка3 + '💻') - sys.getsizeof (строка3)
4
>>> sys.getsizeof (строка3)
80
  

Как видите, в зависимости от содержимого строки Python использует разные кодировки. Обратите внимание, что каждая строка в Python требует дополнительных 49-80 байт памяти, где хранится дополнительная информация, такая как хэш, длина, длина в байтах, тип кодировки и строковые флаги.Поэтому пустая строка занимает 49 байт памяти.

Мы можем получить кодировку непосредственно из объекта, используя ctypes :

  import ctypes

класс PyUnicodeObject (ctypes.Structure):
    # внутренние поля строкового объекта
    _fields_ = [("ob_refcnt", ctypes.c_long),
                ("ob_type", ctypes.c_void_p),
                ("длина", ctypes.c_ssize_t),
                ("хеш", ctypes.c_ssize_t),
                ("интернированный", ctypes.c_uint, 2),
                ("вид", ctypes.c_uint, 3),
                ("компактный", ctypes.c_uint, 1),
                ("ascii", ctypes.c_uint, 1),
                ("готово", ctypes.c_uint, 1),
                # ...
                # ...
                ]


def get_string_kind (строка):
    вернуть PyUnicodeObject.from_address (id (строка)). kind
  

  >>> get_string_kind ('Привет')
1
>>> get_string_kind ('你好')
2
>>> get_string_kind ('🐍')
4
  

Если все символы в строке могут соответствовать диапазону ASCII, то они кодируются с использованием 1-байтовой кодировки Latin-1.По сути, Latin-1 представляет первые 256 символов Unicode. Он поддерживает множество латинских языков, таких как английский, шведский, итальянский, норвежский и так далее. Однако он не может хранить нелатинские языки, такие как китайский, японский, иврит, кириллица. Это потому, что их кодовые точки (числовые индексы) определены вне 1-байтового (0-255) диапазона.

  >>> ord ('а')
97
>>> ord ('你')
20320
>>> ord ('!')
33
  

Большинство популярных естественных языков могут соответствовать 2-байтовой кодировке (UCS-2).4-байтовая кодировка (UCS-4) используется, когда строка содержит специальные символы, смайлы или редкие языки. В стандарте Unicode почти 300 блоков (диапазонов). Вы можете найти 4-байтовые блоки после блока 0xFFFF.

Предположим, у нас есть 10 ГБ текста ASCII, и мы хотим загрузить его в память. Если вы вставите один смайлик в наш текст, размер строки увеличится в 4 раза! Это огромная разница, с которой вы можете столкнуться на практике при работе с задачами НЛП.

Почему Python не использует кодировку UTF-8 для внутренних целей

Самая известная и популярная кодировка Unicode — это UTF-8, но Python не использует ее для внутренних целей.

Когда строка сохраняется в кодировке UTF-8, каждый символ кодируется с использованием 1–4 байтов в зависимости от символа, который он представляет. Это кодирование, эффективное для хранения, но у него есть один существенный недостаток. Поскольку каждый символ может иметь разную длину в байтах, невозможно получить произвольный доступ к отдельному символу по индексу без сканирования строки. Итак, чтобы выполнить простую операцию, такую ​​как строка [5] с UTF-8, Python потребуется сканировать строку, пока не найдет требуемый символ.Кодировки фиксированной длины не имеют такой проблемы, чтобы найти символ по индексу, Python просто умножает номер индекса на длину одного символа (1, 2 или 4 байта).

Интернирование строки

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

  >>> a = 'привет'
>>> b = 'мир'
>>> a [4], b [1]
('о', 'о')
>>> id (a [4]), id (b [1]), a [4] равно b [1]
(4567926352, 4567926352, Верно)
>>> идентификатор ('')
4545673904
>>> идентификатор ('')
4545673904
  

Как видите, оба строковых фрагмента указывают на один и тот же адрес в памяти.Это возможно, потому что строки Python неизменяемы.

В Python интернирование строк не ограничивается символами или пустыми строками. Строки, созданные во время компиляции кода, также могут быть интернированы, если их длина не превышает 20 символов.

Сюда входят:

• имена функций и классов
• имена переменных
• имена аргументов
• константы (все строки, которые определены в коде)
• ключи словарей
• имена атрибутов

Когда вы нажимаете Enter в Python REPL ваш оператор компилируется до байт-кода.Вот почему все короткие строки в REPL также интернированы.

  >>> a = 'teststring'
>>> b = 'тестовая строка'
>>> id (a), id (b), a равно b
(4569487216, 4569487216, Верно)
>>> a = 'тест' * 5
>>> b = 'тест' * 5
>>> len (a), id (a), id (b), a равно b
(20, 4569499232, 4569499232, Верно)
>>> a = 'тест' * 6
>>> b = 'тест' * 6
>>> len (a), id (a), id (b), a равно b
(24, 4569479328, 4569479168, ложь)
  

Этот пример не будет работать, потому что такие строки не являются константами:

  >>> open ('test.txt ',' w '). write (' привет ')
5
>>> open ('test.txt', 'r'). read ()
'Привет'
>>> a = open ('test.txt', 'r'). read ()
>>> b = open ('test.txt', 'r'). read ()
>>> id (a), id (b), a равно b
(4384934576, 4384934688, ложь)
>>> len (a), id (a), id (b), a равно b
(5, 4384934576, 4384934688, ложь)
  

Метод интернирования строк позволяет сэкономить десятки тысяч дублированных размещений строк. Внутренне интернирование строк поддерживается глобальным словарем, в котором строки используются в качестве ключей.Чтобы проверить, есть ли в памяти уже идентичная строка, Python выполняет операцию членства в словаре.

Объект unicode — это почти 16 000 строк кода C, поэтому есть много небольших оптимизаций, которые не упоминаются в этой статье. Если вы хотите узнать больше о Unicode в Python, я бы порекомендовал вам прочитать PEP о строках и проверить код объекта unicode.

В чем разница между байтом и символом в Java?

Byte и char — это два числовых типа данных в Java, и оба могут представлять целые числа в диапазоне, но они сильно отличаются друг от друга. Основное различие между типом данных byte и char заключается в том, что байт используется для хранения необработанных двоичных данных, а другой используется для хранения символов или текстовых данных. Вы можете сохранить символьный литерал в переменной типа char, например. char a = ‘а’; Символьный литерал заключен в одинарные кавычки. С точки зрения диапазона байтовая переменная может содержать любое значение от -128 до 127, но переменная типа char может содержать любое значение от 0 до 255. Еще одно различие между байтом и символом в Java заключается в том, что размер байтовой переменной составляет 8 бит, в то время как размер переменной char составляет 16 бит.Еще одна разница между char и байтом заключается в том, что байт может представлять отрицательных значения , но char может представлять только положительных значения , поскольку его диапазон составляет от -128 до 127. Другими словами, байт является типом данных со знаком. где первый байт представляет знак числа, т.е. 0 для положительного числа и 1 для отрицательного числа, но тип данных char беззнаковый. Давайте посмотрим еще на несколько различий между byte и char в Java.

байт против типа данных char в Java

Одна из ключевых вещей, которые нужно знать о типах байтов и символов, — это как преобразовать байт в char? Это область, в которой большинство программистов испытывают трудности, потому что вам нужна кодировка символов для сопоставления необработанных байтов с символом.Одинаковые байты будут отображаться на другой символ в другой кодировке символов, поэтому вы должны использовать ту же кодировку символов при преобразовании байта в char и наоборот.

В Java классы, которые выполняют это преобразование, например FileReader или InputStreamReader по умолчанию использует кодировку символов по умолчанию платформы, которая может быть правильной или неправильной. Вы также можете прочитать Core Java для нетерпеливых, чтобы узнать больше о преобразовании байтов в символы в Java. 16 — 1, что составляет 65535.

4) Вы можете инициализировать переменную типа char, используя символьный литерал, например. char ch = ‘c’, в этом случае значение ASCII символа ‘c’ будет сохранено в переменной char «ch».

5) Класс оболочки, соответствующий примитиву байта, — это java.lang.Byte, а класс оболочки, соответствующий примитиву char, — это класс java.lang.Character.

Вот и все, что касается разницы между типом данных byte и char в Java . Если вы знаете какое-либо другое отличие, которое, по вашему мнению, важно изучить, не стесняйтесь добавлять.Вы также можете прочитать Core Java Volume 1 — Fundamentals, чтобы узнать больше о различных типах данных и о том, когда их использовать в программах Java, например. float, double, long, int, boolean и short.

Дальнейшее обучение
Структуры данных и алгоритмы: глубокое погружение с использованием Java
Основы Java: язык Java
Полный мастер-класс по Java

Типы данных VARCHAR, CHAR и String в SQL Server

Ваша база данных состоит из данных; данные определяются типами данных.Типы данных настолько важны, что их часто упускают из виду, но вот несколько очень распространенных вопросов и ответы на них.

Могу я просто использовать VARCHAR для всего?

Короткий ответ: Нет .

Конечно, VARCHAR очень гибкий и принимает большинство типов данных. Но использование VARCHAR для всего лишает вашу базу данных критически важных функций, согласованности данных и производительности.

Рассмотрим пример хранения данных даты в столбце VARCHAR.Мы мгновенно потеряли функциональность, потому что не можем легко складывать, вычитать или сравнивать наши данные о датах. Если мы используем один из типов данных даты (например, DATETIME, SMALLDATE и т. Д.), То у нас есть множество системных функций, таких как DATEADD и DATEPART.

Другая проблема с хранением данных даты в VARCHAR заключается в том, что у нас нет встроенного элемента управления форматом. Наша система теперь легко принимает все следующие данные как «действительные» даты:

• 1 февраля 2010 г.
• e 1 февраля 2010 г.
• 1 февраля 2010 г.
• Дата звезды 002.1.2010.304
• 2-1-2010
• 1-1-2010 15:03
• 02012010
• 020110
• 31 февраля 2010 г.

Мы хотим унифицировать и применять формат даты в базе данных, чтобы мы могли легко находить ошибки даты (например, 31 февраля) и сравнивать дату, например: ВЫБРАТЬ столбцы ИЗ таблицы1, ГДЕ myDate> «1/1/2010».

Мы сталкиваемся с одними и теми же проблемами независимо от того, какой нестроковый тип мы пытаемся сохранить в VARCHAR.

В чем разница между CHAR и VARCHAR?

Короткий ответ: VARCHAR — это переменная длина, а CHAR — фиксированная длина.

CHAR — это строковый тип данных фиксированной длины, поэтому любое оставшееся пространство в поле заполняется пробелами. CHAR занимает 1 байт на символ. Итак, поле (или переменная) CHAR (100) занимает на диске 100 байтов, независимо от того, какая строка в нем содержится.

VARCHAR — это строковый тип данных переменной длины, поэтому он содержит только те символы, которые вы ему присвоили. VARCHAR занимает 1 байт на символ, + 2 байта для хранения информации о длине. Например, если вы установите тип данных VARCHAR (100) = ‘Jen’, то он займет 3 байта (для J, E и N) плюс 2 байта, или всего 5 байтов.

Вы можете видеть, что использование VARCHAR в большинстве случаев предпочтительнее для экономии места. Давайте посмотрим на сценарий; он объявляет переменные CHAR и VARCHAR, устанавливает каждую равную строке «SQL», а затем выбирает каждую переменную для отображения того, что на самом деле хранится:

DECLARE @myChar CHAR (100), @myVarchar VARCHAR (100)
SET @myChar = 'SQL'
SET @myVarchar = 'SQL'
SELECT '[BEGIN]' + @myChar + '[END]' AS CHAR_Data
SELECT '[BEGIN]' + @myVarchar + '[END]' AS VARCHAR_Data

Вот результат при запуске скрипта:

Char_Data

[BEGIN] SQL [END]

Петри. com каждую пятницу публикует статьи о глубоких технологиях от MVP и наших собственных экспертов. Подпишитесь на этот еженедельный информационный бюллетень, наполненный наиболее впечатляющими статьями Petri.com за эту неделю.

Petri.com может использовать вашу контактную информацию для предоставления обновлений, предложений и ресурсов, которые могут вас заинтересовать. Вы можете отписаться в любое время. Чтобы узнать больше о том, как мы управляем вашими данными, вы можете прочитать нашу Политику конфиденциальности и Условия использования.

! Уже зарегистрированы на Petri.com? Войдите здесь для регистрации в 1 клик.

Varchar_Data

[BEGIN] SQL [END]

Эта демонстрация просто наглядно демонстрирует все лишнее заполнение (и потраченное впустую пространство), которое использует CHAR.

Когда следует использовать CHAR вместо VARCHAR?

Короткий ответ: Почти никогда .

VARCHAR стоит только два «дополнительных» байта по сравнению с CHAR. Это только в редких случаях, когда использование CHAR действительно сэкономит вам место и усилия. Примеры таких случаев:

• CHAR (2) для сокращения штата.Если в ваших бизнес-правилах указано, что столбец State ВСЕГДА будет состоять из двух символов, используйте CHAR (2).
• Коды продуктов с фиксированной длиной (например, CHAR (8) для кодов продуктов, таких как «004-3228»). Также как государство; если у вас есть поле, такое как код продукта, которое ВСЕГДА (сейчас и навсегда) имеет заданную длину, то предпочтительнее использовать CHAR.
• Однобуквенная строка. Например, мы должны использовать CHAR (1) для среднего начального столбца.

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

Дополнительная литература

Типы данных CHAR и VARCHAR в различных ядрах баз данных

Механизмы хранения могут вас удивить. Например, возьмем тип данных CHAR. Он ожидает точное количество символов и по определению хранит фиксированное количество информации. Однако необязательно заполнять все доступное пространство CHAR — подойдет более короткое значение. Это настолько похоже на VARCHAR, что я решил изучить различия между этими двумя типами.

Прежде чем углубляться в детали, давайте начнем с основной информации.CHAR и VARCHAR — это типы данных SQL, предназначенные для хранения символьных значений. Они доступны почти в каждом ядре базы данных. Из-за особенностей базы данных и кодирования хранение символьных значений в столбцах CHAR и VARCHAR различается.

В этой статье мы рассмотрим, как типы данных CHAR и VARCHAR ведут себя в:

• MySQL
• PostgreSQL
• SQLite
• Оракул
• MS SQL Server

MySQL

Справочное руководство MySQL: типы Char и Varchar

Чтобы продемонстрировать различия между CHAR и VARCHAR , я создал следующие тестовые таблицы:

Сохранение значений CHAR

Выбор значений CHAR

Функция length () — возвращает длину строки в байтах.
Функция char_length () — возвращает длину строки в символах.

Вставленное значение	Длина извлеченной строки	Описание
»	0 байтов	4 байта (конечные пробелы) удаляются во время поиска
‘ab’	2 байта	2 байта (конечные пробелы) удаляются во время поиска
‘abcd’	4 байта	Получено 4 байта
‘d’	1 байт	Во время сохранения были сохранены символ «d» и пробел.Были добавлены два дополнительных места. Во время поиска было удалено всего пространства с (включая намеренно сохраненное пространство).

Хранение значений VARCHAR

Выбор значений VARCHAR

* Значения, превышающие длину столбца, усекаются только при отключенном строгом режиме SQL. В противном случае возникает ошибка.

PostgreSQL

Документация PostgreSQL: Типы символов

Я вычислил количество символов / байтов в сохраненной строке, используя функции Postgres octet_length () и char_length () . Чтобы увидеть результаты, взгляните на таблицы и экраны ниже.

Сохранение значений CHAR

Хранение значений VARCHAR

Значение	VARCHAR (4)	Длина сохраненной строки	Описание
»	»	0 байт	Никаких дополнительных символов не добавляется при сохранении пустого значения
‘ab’	‘ab’	2 байта	2 байта для данных
‘abcd’	‘abcd’	4 байта	4 байта для данных
‘abcdefgh’			Если все лишние символы не являются пробелами, возникает следующая ошибка: «слишком длинное значение для символа типа (4)» .

Примечание. CHAR (n) обычно является самым медленным типом данных (по сравнению с VARCHAR или TEXT) из-за дополнительных затрат на хранение.

SQLite

типов данных в SQLite версии 3

База данных SQLite заметно отличается от традиционной реляционной СУБД . В SQLite вместо типов данных существуют классы хранения в системе типизации манифеста (NULL, INTEGER, REAL, TEXT, BLOB). Типы данных приводятся или преобразуются в различные места хранения на основе сходства (TEXT, NUMERIC, INTEGER, REAL, BLOB).Сходство столбца определяется его объявленным типом. Если объявленный тип содержит «CHAR», «VARCHAR», «TEXT» или аналогичные типы, с ним будет связана привязка TEXT.

Когда мы используем оператор CREATE TABLE и вводим столбцы VARCHAR и CHAR, они будут обрабатываться базой данных SQLite как TEXT.

Числовые аргументы в скобках, следующие за именем типа (varchar (255)), SQLite игнорирует. SQLite не накладывает никаких ограничений на длину (кроме глобального ограничения SQLITE_MAX_LENGTH) для строк, больших двоичных объектов или числовых значений.

Чтобы проиллюстрировать различия между типами данных CHAR и VARCHAR в MySQL, я создал две тестовые таблицы со столбцами CHAR (4), и VARCHAR (4) . Используя функцию SQLite length () , я вычислил количество символов в сохраненной строке. Функция typeof () возвращает строку, указывающую тип данных.

Чтобы увидеть результаты, взгляните на таблицы и экраны ниже:

Как видите, оба столбца обрабатываются одинаково.

Оракул

Oracle User’s Guide: CHAR против VARCHAR2 Семантика

	Столбцы CHAR	Столбцы VARCHAR2
Длина	Фиксированная длина, которая указывает количество символов или байтов, объявленных при создании таблицы. Длина может быть любым значением от 1 до 2000 байтов. По умолчанию 1 байт.	Длина строки может быть переменной, но максимальная длина указывается при создании таблицы. Длина может принимать любое значение от 1 до 4000 байтов.
Сохранение	При сохранении более коротких значений CHAR они дополняются пробелами до указанной длины. Если вставлено значение CHAR , длина которого превышает указанную длину, вставка прерывается и генерируется ошибка.	Короче Значения VARCHAR2 не заполняются пробелами во время хранения. Если вставлено значение VARCHAR2 , длина которого превышает указанную длину, вставка прерывается и генерируется ошибка.
Получение	При получении значений CHAR конечные пробелы удаляются.	Пробелы сохраняются во время извлечения.

Предупреждение: Oracle обрабатывает пустые строки как пустые.

Чтобы проиллюстрировать различия между типами данных CHAR и VARCHAR в Oracle, я создал две тестовые таблицы с CHAR (4) и VARCHAR2 (4) столбцами.

Используя функцию Oracle length () , я вычислил количество символов в сохраненной строке. Функция lengthb () вычисляет длину сохраненной строки в байтах. Чтобы увидеть результаты, взгляните на таблицы и экраны ниже.

Хранение строк CHAR

Хранение строк VARCHAR2

MS SQL Server

Справочник по Transact SQL

: CHAR и VARCHAR

	Столбцы CHAR	Столбцы VARCHAR
Длина	Длина фиксирована и указывает количество байтов, объявленных при создании таблицы. Столбцы CHAR не могут хранить символы Unicode. Длина может быть любым значением от 1 до 8000 байт.	Хранит строки переменной длины. Максимальная длина указывается при создании таблицы. Длина может быть любым значением от 1 до 8000 байт. Размер строки равен действительной длине введенных данных + 2 байта.
Сохранение	Если для параметра ANSI_PADDING установлено значение ON, столбцы CHAR заполняются пробелами.	2 байта
Когда вставляются значения CHAR , длина которых превышает указанную длину, вставка прерывается и генерируется ошибка.	Более короткие значения VARCHAR не заполняются пробелами во время хранения. Когда вставляются значения VARCHAR , длина которых превышает указанную длину, вставка прерывается и генерируется ошибка.	4 байта
Получение	При получении значений CHAR конечные пробелы удаляются.	Пробелы сохраняются во время извлечения.

Хранение строк CHAR

Хранение строк VARCHAR

Макс.

байтов в символе UTF-8? — Stijn de Witt

.

4.

Максимум

4 байт в одном символе Юникода в кодировке UTF-8.

А вот как в двух словах работает схема кодирования.

Источник: Википедия (также сбивает с толку 6 возможных байтов, когда на самом деле 4 — это максимум)

Подождите, я слышал, может быть 6?

№
Вы ошиблись.

Многие люди, в том числе уважаемый Джоэл Спольски из Joel on Software, думают, что символы UTF-8 могут содержать до 6 байтов.

К чему такая путаница?

Эта путаница произошла из-за истории Unicode.

Когда это началось, Unicode должен был оставаться в пределах 16 бит. Кодирование фиксированной длины UCS-2 можно было бы использовать для хранения всех возможных 65536 кодовых точек, и срок службы был бы хорош…

За исключением того, что люди понимали, что Unicode не сможет вместить все символы и символы и, следовательно, больше не будет очень универсальным Uni … Поэтому они решили увеличить ширину кодировки с фиксированной шириной до 32 бит , любое другое число от 16 до 32 бит не очень практично.

2 миллиарда — это толпа

С 32-битными числами и зарезервировав один бит в качестве знакового бита для целых чисел, используемых в большинстве языков программирования, вы можете получить 2 миллиарда кодовых точек. Пытаясь втиснуть все это в кодировку переменной длины, где весь ASCII умещается в одном байте, вам потребуется… * барабанная дробь *… не более 6 байтов. Это привело к тому, что в ранних спецификациях UTF-8 говорилось о максимум 6 байтах на символ.

Тем не менее, люди быстро поняли, что даже несмотря на то, что 64К символов может быть слишком мало для универсального набора символов, 2 миллиарда — это слишком много.Поэтому они пошли на компромисс. Тот, который решил проблему, которую они создали, когда их 16-битная кодировка с фиксированной длиной фактически не могла кодировать все символы.

Рассчитаться меньше

Они ограничили Unicode возможным 1112 064 действительными кодовыми точками. Обратите внимание, что даже сегодня в Unicode 7.0.0 фактически определено только 112 218 символов. Все остальные позиции не используются. Они даже зарезервировали огромное количество 137 468 кодовых точек для символов частного использования.

Наивысшая возможная допустимая кодовая точка — Ux10FFFF, и они зарезервировали 66 позиций для «несимволов» и 2048 позиций для «суррогатных» кодовых точек.Используя их, они могли создавать « суррогатные пары », трюк для создания новой кодировки переменной длины с именем UTF-16, которая была обратно совместима со старым 16-битным UCS-2 фиксированной длины, но все же могла кодировать все символы в теперь более 1,1 миллиона символов Unicode 2 и выше.

Все хорошо, что хорошо кончается

Мораль этой истории заключается в том, что, хотя сначала это может показаться, что Unicode 32-битный, если мы присмотримся, мы увидим, что на самом деле мы могли бы втиснуть все символы Unicode, используемые сегодня, всего в 17 бит.Даже если к тому времени, когда мы перейдем к Unicode 99. 0.0 или что-то в этом роде, все 1,1+ миллиона кодовых точек будут фактически назначены, мы все равно сможем уместить его всего в 21 бит.

И о чудо … Если мы вычислим максимальное количество байтов, необходимое для одного символа, когда нам нужно только закодировать 1,1 миллиона возможных различных символов вместо 2 миллиардов, нам больше не понадобится 6 байтов. Мы можем довольствоваться 4. И мы так и сделали. Это было сделано окончательно в RFC 3629.

Нравится:

Нравится Загрузка …

Связанные

SQL: думаете, что varchar (10) означает 10 символов? Если так, подумайте еще раз…

Если вы прочитаете почти любую книгу по языку SQL, вы увидите определения, где:

varchar (n)

означает символьный тип данных переменной длины, а где n — количество символов, которое он может хранить.

SQL Server 2019 меняет ситуацию

Если вы это видели, SQL Server 2019 изменит ваше понимание. Группа разработчиков продукта указала, что n на самом деле было количеством байтов, и что «это никогда не было количеством символов».

Я почти гарантирую, что если я посмотрю на старые документы и курсы Microsoft, они скажут, что это было количество символов.

Теперь, учитывая, что единственными символами, которые мы могли хранить в varchar, были символы ASCII с одним байтом на символ, неудивительно, что все думают о n как о количестве символов.

Но в SQL Server 2019 и введении сопоставлений на основе UTF-8, которые могут храниться в varchar, один символ может быть одним, двумя, тремя или четырьмя байтами.Обратите внимание, что мы говорим здесь о varchar, а не о nvarchar.

Итак, если у вас есть столбец varchar (20), вы не знаете, сколько символов может в нем поместиться, если только вы не используете только символы ASCII и никогда не используете UTF-8. (Но имейте в виду, что UTF-8 сейчас довольно популярен).