Сочетания клавиш

Нажмите ← или → для навигации между главами

Нажмите S или / для поиска по книге

Нажмите ?, чтобы показать эту справку

Нажмите Esc, чтобы скрыть эту справку

Хранение текста в кодировке UTF-8 с помощью строк

Мы говорили о строках в главе 4, но теперь рассмотрим их более подробно. Новички в Rust обычно застревают на строках из-за сочетания трёх причин: склонности Rust к раскрытию возможных ошибок, того, что строки являются более сложной структурой данных, чем многие программисты готовы признать, и UTF-8. Эти факторы сочетаются так, что это может показаться сложным, когда вы приходите из других языков программирования.

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

Определение строк

Сначала мы определим, что мы подразумеваем под термином строка. В Rust есть только один строковый тип в основном языке, и это срез строки str, который обычно встречается в его заимствованной форме &str. В главе 4 мы говорили о срезах строк, которые являются ссылками на некоторые данные строки в кодировке UTF-8, хранящиеся в другом месте. Строковые литералы, например, хранятся в двоичном файле программы и поэтому являются срезами строк.

Тип String, который предоставляется стандартной библиотекой Rust, а не встроен в основной язык, — это расширяемый, изменяемый, владеющий строковый тип в кодировке UTF-8. Когда Rustaceans говорят о «строках» в Rust, они могут иметь в виду либо тип String, либо тип среза строки &str, а не только один из этих типов. Хотя этот раздел в основном о String, оба типа широко используются в стандартной библиотеке Rust, и оба — String и срезы строк — закодированы в UTF-8.

Создание новой строки

Многие из тех же операций, доступных с Vec<T>, доступны и с String, потому что String на самом деле реализован как обёртка вокруг вектора байтов с некоторыми дополнительными гарантиями, ограничениями и возможностями. Пример функции, которая работает одинаково с Vec<T> и String, — это функция new для создания экземпляра, показанная в листинге 8-11.

fn main() {
    let mut s = String::new();
}
Листинг 8-11: Создание новой пустой String

Эта строка создаёт новую пустую строку с именем s, в которую мы затем можем загрузить данные. Часто у нас есть некоторые начальные данные, с которых мы хотим начать строку. Для этого мы используем метод to_string, который доступен для любого типа, реализующего трейт Display, как и строковые литералы. Листинг 8-12 показывает два примера.

fn main() {
    let data = "initial contents";

    let s = data.to_string();

    // Метод также работает непосредственно с литералом:
    let s = "initial contents".to_string();
}
Листинг 8-12: Использование метода to_string для создания String из строкового литерала

Этот код создаёт строку, содержащую initial contents.

Мы также можем использовать функцию String::from для создания String из строкового литерала. Код в листинге 8-13 эквивалентен коду в листинге 8-12, который использует to_string.

fn main() {
    let s = String::from("initial contents");
}
Листинг 8-13: Использование функции String::from для создания String из строкового литерала

Поскольку строки используются для стольких вещей, мы можем использовать множество различных обобщённых API для строк, предоставляя нам много возможностей. Некоторые из них могут показаться избыточными, но у всех есть своё место! В этом случае String::from и to_string делают одно и то же, поэтому то, что вы выберете, — вопрос стиля и читаемости.

Помните, что строки закодированы в UTF-8, поэтому мы можем включать в них любые правильно закодированные данные, как показано в листинге 8-14.

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שלום");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}
Листинг 8-14: Хранение приветствий на разных языках в строках

Все они являются допустимыми значениями String.

Обновление строки

String может расти в размере, и её содержимое может меняться, так же как содержимое Vec<T>, если вы добавляете в неё больше данных. Кроме того, вы можете удобно использовать оператор + или макрос format! для конкатенации значений String.

Добавление с помощью push_str или push

Мы можем увеличить String, используя метод push_str для добавления среза строки, как показано в листинге 8-15.

fn main() {
    let mut s = String::from("foo");
    s.push_str("bar");
}
Листинг 8-15: Добавление среза строки к String с помощью метода push_str

После этих двух строк s будет содержать foobar. Метод push_str принимает срез строки, потому что мы не обязательно хотим брать на себя владение параметром. Например, в коде в листинге 8-16 мы хотим иметь возможность использовать s2 после добавления его содержимого к s1.

fn main() {
    let mut s1 = String::from("foo");
    let s2 = "bar";
    s1.push_str(s2);
    println!("s2 is {s2}");
}
Листинг 8-16: Использование среза строки после добавления его содержимого к String

Если бы метод push_str брал на себя владение s2, мы не смогли бы напечатать его значение в последней строке. Однако этот код работает так, как мы и ожидали!

Метод push принимает один символ в качестве параметра и добавляет его к String. Листинг 8-17 добавляет букву l к String с помощью метода push.

fn main() {
    let mut s = String::from("lo");
    s.push('l');
}
Листинг 8-17: Добавление одного символа к значению String с помощью push

В результате s будет содержать lol.

Конкатенация с помощью + или format!

Часто вам нужно объединить две существующие строки. Один из способов сделать это — использовать оператор +, как показано в листинге 8-18.

fn main() {
    let s1 = String::from("Hello, ");
    let s2 = String::from("world!");
    let s3 = s1 + &s2; // обратите внимание: s1 была перемещена сюда и больше не может использоваться
}
Листинг 8-18: Использование оператора + для объединения двух значений String в новое значение String

Строка s3 будет содержать Hello, world!. Причина, по которой s1 больше не действительна после сложения, и причина, по которой мы использовали ссылку на s2, связаны с сигнатурой метода, который вызывается при использовании оператора +. Оператор + использует метод add, сигнатура которого выглядит примерно так:

fn add(self, s: &str) -> String {

В стандартной библиотеке вы увидите add, определённый с использованием обобщений и ассоциированных типов. Здесь мы подставили конкретные типы, что происходит, когда мы вызываем этот метод со значениями String. Мы обсудим обобщения в главе 10. Эта сигнатура даёт нам подсказки, необходимые для понимания хитрых моментов оператора +.

Во-первых, у s2 есть &, что означает, что мы добавляем ссылку на вторую строку к первой строке. Это связано с параметром s в функции add: мы можем добавлять срез строки только к String; мы не можем сложить два значения String вместе. Но подождите — тип &s2 — это &String, а не &str, как указано во втором параметре add. Так почему же листинг 8-18 компилируется?

Причина, по которой мы можем использовать &s2 в вызове add, заключается в том, что компилятор может привести аргумент &String к &str. Когда мы вызываем метод add, Rust использует разыменовывающее приведение (deref coercion), которое здесь превращает &s2 в &s2[..]. Мы обсудим разыменовывающее приведение более подробно в главе 15. Поскольку add не берёт на себя владение параметром s, s2 всё ещё будет действительной String после этой операции.

Во-вторых, мы можем видеть в сигнатуре, что add берёт на себя владение self, потому что у self нет &. Это означает, что s1 в листинге 8-18 будет перемещён в вызов add и больше не будет действителен после этого. Так что, хотя let s3 = s1 + &s2; выглядит так, как будто он скопирует обе строки и создаст новую, эта инструкция на самом деле берёт на себя владение s1, добавляет копию содержимого s2 и затем возвращает владение результатом. Другими словами, кажется, что он делает много копий, но это не так; реализация эффективнее копирования.

Если нам нужно объединить несколько строк, поведение оператора + становится громоздким:

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = s1 + "-" + &s2 + "-" + &s3;
}

На этом этапе s будет tic-tac-toe. Со всеми этими символами + и " трудно понять, что происходит. Для более сложных способов объединения строк мы можем вместо этого использовать макрос format!:

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = format!("{s1}-{s2}-{s3}");
}

Этот код также устанавливает s в tic-tac-toe. Макрос format! работает как println!, но вместо вывода на экран он возвращает String с содержимым. Версия кода с использованием format! гораздо легче читается, и код, генерируемый макросом format!, использует ссылки, так что этот вызов не берёт на себя владение ни одним из своих параметров.

Индексация строк

Во многих других языках программирования доступ к отдельным символам в строке по индексу является допустимой и распространённой операцией. Однако если вы попытаетесь получить доступ к частям String, используя синтаксис индексации в Rust, вы получите ошибку. Рассмотрим недопустимый код в листинге 8-19.

fn main() {
    let s1 = String::from("hi");
    let h = s1[0];
}
Листинг 8-19: Попытка использовать синтаксис индексации с String

Этот код приведёт к следующей ошибке:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
error[E0277]: the type `str` cannot be indexed by `{integer}`
 --> src/main.rs:3:16
  |
3 |     let h = s1[0];
  |                ^ string indices are ranges of `usize`
  |
  = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
  = note: you can use `.chars().nth()` or `.bytes().nth()`
          for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
help: `usize` implements trait `SliceIndex<T>`
 --> /rustc/2d8144b7880597b6e6d3dfd63a9a9efae3f533d3/library/core/src/slice/index.rs:214:0
  |
  = note: `SliceIndex<[T]>`
 --> /rustc/2d8144b7880597b6e6d3dfd63a9a9efae3f533d3/library/core/src/bstr/traits.rs:197:0
  |
  = note: `SliceIndex<ByteStr>`
  = note: required for `String` to implement `Index<{integer}>`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `collections` (bin "collections") due to 1 previous error

Ошибка рассказывает всю историю: строки Rust не поддерживают индексацию. Но почему нет? Чтобы ответить на этот вопрос, нам нужно обсудить, как Rust хранит строки в памяти.

Внутреннее представление

String — это обёртка над Vec<u8>. Давайте посмотрим на некоторые из наших правильно закодированных примеров строк UTF-8 из листинга 8-14. Сначала на эту:

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שלום");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

В этом случае len будет равно 4, что означает, что вектор, хранящий строку "Hola", имеет длину 4 байта. Каждая из этих букв занимает 1 байт в кодировке UTF-8. Следующая строка, однако, может вас удивить (обратите внимание, что эта строка начинается с заглавной кириллической буквы Зе, а не с цифры 3):

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שלום");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

Если бы вас спросили, какой длины эта строка, вы могли бы сказать 12. На самом деле ответ Rust — 24: это количество байтов, необходимое для кодирования «Здравствуйте» в UTF-8, потому что каждое скалярное значение Unicode в этой строке занимает 2 байта памяти. Следовательно, индекс в байтах строки не всегда будет соответствовать допустимому скалярному значению Unicode. Чтобы продемонстрировать это, рассмотрим этот недопустимый код Rust:

let hello = "Здравствуйте";
let answer = &hello[0];

Вы уже знаете, что answer не будет З, первой буквой. В кодировке UTF-8 первый байт З — это 208, а второй — 151, так что казалось бы, что answer должен на самом деле быть 208, но 208 сам по себе не является допустимым символом. Возврат 208, вероятно, не то, что хотел бы пользователь, если бы он попросил первую букву этой строки; однако это единственные данные, которые есть у Rust по байтовому индексу 0. Пользователи обычно не хотят получать байтовое значение, даже если строка содержит только латинские буквы: если бы &"hi"[0] был допустимым кодом, возвращающим байтовое значение, он вернул бы 104, а не h.

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

Байты, скалярные значения и кластеры графем

Ещё один момент о UTF-8 заключается в том, что на самом деле существует три значимых способа смотреть на строки с точки зрения Rust: как на байты, как на скалярные значения и как на кластеры графем (наиболее близкое к тому, что мы назвали бы буквами).

Если мы посмотрим на хинди слово «नमस्ते», написанное шрифтом деванагари, оно хранится как вектор значений u8, который выглядит так:

[224, 164, 168, 224, 164, 174, 224, 164, 184, 224, 165, 141, 224, 164, 164,
224, 165, 135]

Это 18 байтов, и именно так компьютеры в конечном итоге хранят эти данные. Если мы посмотрим на них как на скалярные значения Unicode, которыми является тип char в Rust, эти байты выглядят так:

['न', 'म', 'स', '्', 'त', 'े']

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

["न", "म", "स्", "ते"]

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

Последняя причина, по которой Rust не позволяет нам индексировать String для получения символа, заключается в том, что операции индексации, как ожидается, всегда занимают постоянное время (O(1)). Но невозможно гарантировать такую производительность с String, потому что Rust пришлось бы проходить по содержимому с начала до индекса, чтобы определить, сколько допустимых символов было.

Срезы строк

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

Вместо индексации с помощью [] с одним числом вы можете использовать [] с диапазоном, чтобы создать срез строки, содержащий определённые байты:

#![allow(unused)]
fn main() {
let hello = "Здравствуйте";

let s = &hello[0..4];
}

Здесь s будет &str, содержащим первые 4 байта строки. Ранее мы упоминали, что каждый из этих символов занимает 2 байта, что означает, что s будет Зд.

Если бы мы попытались срезать только часть байтов символа с помощью чего-то вроде &hello[0..1], Rust запаниковал бы во время выполнения так же, как если бы был получен доступ к недопустимому индексу в векторе:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.43s
     Running `target/debug/collections`

thread 'main' (6017738) panicked at src/main.rs:4:19:
end byte index 1 is not a char boundary; it is inside 'З' (bytes 0..2 of string)
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

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

Итерация по строкам

Лучший способ работать с частями строк — быть явным относительно того, хотите ли вы символы или байты. Для отдельных скалярных значений Unicode используйте метод chars. Вызов chars для «Зд» разделяет и возвращает два значения типа char, и вы можете итерировать по результату, чтобы получить доступ к каждому элементу:

#![allow(unused)]
fn main() {
for c in "Зд".chars() {
    println!("{c}");
}
}

Этот код напечатает следующее:

З
д

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

#![allow(unused)]
fn main() {
for b in "Зд".bytes() {
    println!("{b}");
}
}

Этот код напечатает 4 байта, составляющие эту строку:

208
151
208
180

Но помните, что допустимые скалярные значения Unicode могут состоять более чем из 1 байта.

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

Обработка сложностей строк

Подводя итог, строки сложны. Разные языки программирования делают разные выборы в том, как представить эту сложность программисту. Rust решил сделать правильную обработку данных String поведением по умолчанию для всех программ на Rust, что означает, что программисты должны больше думать об обработке данных UTF-8 заранее. Этот компромисс раскрывает больше сложности строк, чем очевидно в других языках программирования, но он предотвращает необходимость обрабатывать ошибки, связанные с не-ASCII символами, позже в жизненном цикле разработки.

Хорошая новость заключается в том, что стандартная библиотека предлагает много функциональности, построенной на типах String и &str, чтобы помочь правильно обрабатывать эти сложные ситуации. Обязательно ознакомьтесь с документацией для полезных методов, таких как contains для поиска в строке и replace для замены частей строки на другую строку.

Давайте переключимся на что-то немного менее сложное: хеш-таблицы!