Горячие клавиши

Нажмите ← или → для перехода между главами

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

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

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

Тип срез

Срезы позволяют ссылаться на непрерывную последовательность элементов в коллекции. Срез — это разновидность ссылки, поэтому он не владеет данными.

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

Примечание: для целей знакомства со срезами предполагается, что в этом разделе используется только ASCII; более подробное обсуждение обработки UTF-8 находится в разделе «Хранение текста в кодировке UTF-8 с помощью строк» главы 8.

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

fn first_word(s: &String) -> ?

Функция first_word имеет параметр типа &String. Владение не нужно, так что это нормально. (В идиоматичном Rust функции не забирают владение своими аргументами, если в этом нет необходимости, и причины этого станут ясны по ходу изложения.) Но что следует возвращать? В действительности нет способа описать часть строки. Однако можно вернуть индекс конца слова, обозначенный пробелом. Попробуем это, как показано в листинге 4-7.

Имя файла: src/main.rs
fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}
Листинг 4-7: Функция first_word, возвращающая значение байтового индекса в параметр String

Поскольку требуется пройти по String поэлементно и проверить, является ли значение пробелом, String преобразуется в массив байтов с помощью метода as_bytes.

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Далее создаётся итератор по массиву байтов с помощью метода iter:

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Итераторы подробнее рассматриваются в главе 13. Пока достаточно знать, что iter — это метод, возвращающий каждый элемент коллекции, а enumerate обёртывает результат iter и возвращает каждый элемент как часть кортежа. Первый элемент кортежа, возвращаемого enumerate, — это индекс, а второй элемент — ссылка на элемент. Это немного удобнее, чем вычислять индекс самостоятельно.

Поскольку метод enumerate возвращает кортеж, можно использовать шаблоны для деструктуризации этого кортежа. Шаблоны подробнее рассматриваются в главе 6. В цикле for указан шаблон, в котором i обозначает индекс в кортеже, а &item — отдельный байт в кортеже. Поскольку из .iter().enumerate() получена ссылка на элемент, в шаблоне используется &.

Внутри цикла for выполняется поиск байта, представляющего пробел, с помощью синтаксиса байтового литерала. Если найден пробел, возвращается позиция. В противном случае возвращается длина строки с помощью s.len().

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Теперь есть способ найти индекс конца первого слова в строке, но есть проблема. Возвращается usize сам по себе, но это осмысленное число только в контексте &String. Другими словами, поскольку это отдельное значение от String, нет гарантии, что оно останется действительным в будущем. Рассмотрим программу в листинге 4-8, которая использует функцию first_word из листинга 4-7.

Имя файла: src/main.rs
fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s); // word получит значение 5

    s.clear(); // это очищает String, делая её равной ""

    // здесь word всё ещё имеет значение 5, но s больше не содержит содержимого, которое
    // можно было бы осмысленно использовать со значением 5, поэтому word теперь полностью недействителен!
}
Листинг 4-8: Сохранение результата вызова функции first_word с последующим изменением содержимого String

Эта программа компилируется без ошибок, и это было бы так же, если бы word использовалась после вызова s.clear(). Поскольку word вообще не связана с состоянием s, word по-прежнему содержит значение 5. Можно было бы использовать это значение 5 с переменной s, чтобы попытаться извлечь первое слово, но это было бы ошибкой, потому что содержимое s изменилось с момента сохранения 5 в word.

Необходимость беспокоиться о том, что индекс в word рассинхронизируется с данными в s, утомительна и подвержена ошибкам! Управление этими индексами становится ещё более хрупким, если написать функцию second_word. Её сигнатура должна была бы выглядеть так:

fn second_word(s: &String) -> (usize, usize) {

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

К счастью, в Rust есть решение этой проблемы: строковые срезы.

Строковые срезы

Строковый срез — это ссылка на непрерывную последовательность элементов String, и он выглядит так:

fn main() {
    let s = String::from("hello world");

    let hello = &s[0..5];
    let world = &s[6..11];
}

Вместо ссылки на всю String, hello — это ссылка на часть String, указанную в дополнительной части [0..5]. Срезы создаются с помощью диапазона в квадратных скобках, указывая [starting_index..ending_index], где starting_index — первая позиция в срезе, а ending_index — на единицу больше последней позиции в срезе. Внутри структура данных среза хранит начальную позицию и длину среза, что соответствует ending_index минус starting_index. Таким образом, в случае let world = &s[6..11]; переменная world была бы срезом, содержащим указатель на байт с индексом 6 в s и значение длины 5.

На рисунке 4-7 это показано на диаграмме.

Три таблицы: таблица, представляющая данные стека для s, которая указывает
на байт с индексом 0 в таблице строковых данных "hello world"
в куче. Третья таблица представляет данные стека для среза world, который
имеет значение длины 5 и указывает на байт 6 таблицы данных в куче.

Рисунок 4-7: Строковый срез, ссылающийся на часть String

С синтаксисом диапазонов .. в Rust, если нужно начать с индекса 0, можно опустить значение перед двумя точками. Иными словами, эти строки эквивалентны:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let slice = &s[0..2];
let slice = &s[..2];
}

Таким же образом, если срез включает последний байт String, можно опустить завершающее число. Это означает, что эти строки эквивалентны:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let len = s.len();

let slice = &s[3..len];
let slice = &s[3..];
}

Можно также опустить оба значения, чтобы взять срез всей строки. Итак, эти строки эквивалентны:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let len = s.len();

let slice = &s[0..len];
let slice = &s[..];
}

Примечание: индексы диапазона строкового среза должны попадать на границы допустимых символов UTF-8. При попытке создать строковый срез в середине многобайтового символа программа завершится с ошибкой.

Учитывая всю эту информацию, перепишем first_word так, чтобы она возвращала срез. Тип, обозначающий «строковый срез», записывается как &str:

Имя файла: src/main.rs
fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {}

Индекс конца слова получается так же, как в листинге 4-7, путём поиска первого вхождения пробела. Когда найден пробел, возвращается строковый срез, использующий начало строки и индекс пробела в качестве начального и конечного индексов.

Теперь при вызове first_word возвращается одно значение, привязанное к базовым данным. Значение состоит из ссылки на начальную точку среза и количества элементов в срезе.

Возврат среза также сработал бы для функции second_word:

fn second_word(s: &String) -> &str {

Теперь есть простой в использовании API, который гораздо сложнее испортить, потому что компилятор гарантирует, что ссылки на String останутся действительными. Вспомним ошибку в программе из листинга 4-8, когда был получен индекс конца первого слова, но затем строка была очищена, и индекс стал недействительным. Тот код был логически некорректен, но не показывал немедленных ошибок. Проблемы проявились бы позже, если бы продолжались попытки использовать индекс первого слова с опустошённой строкой. Срезы делают эту ошибку невозможной и позволяют гораздо раньше узнать, что в коде есть проблема. Использование версии first_word со срезом вызовет ошибку времени компиляции:

Имя файла: src/main.rs
fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    s.clear(); // ошибка!

    println!("the first word is: {word}");
}

Вот ошибка компилятора:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
  --> src/main.rs:18:5
   |
16 |     let word = first_word(&s);
   |                           -- immutable borrow occurs here
17 |
18 |     s.clear(); // ошибка!
   |     ^^^^^^^^^ mutable borrow occurs here
19 |
20 |     println!("the first word is: {word}");
   |                                   ---- immutable borrow later used here

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

Вспомним из правил заимствования, что если есть неизменяемая ссылка на что-либо, нельзя также взять изменяемую ссылку. Поскольку clear нужно обрезать String, требуется получить изменяемую ссылку. println! после вызова clear использует ссылку в word, поэтому неизменяемая ссылка должна оставаться активной в этой точке. Rust запрещает изменяемой ссылке в clear и неизменяемой ссылке в word существовать одновременно, и компиляция не удаётся. Rust не только сделал API проще в использовании, но и устранил целый класс ошибок на этапе компиляции!

Строковые литералы как срезы

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

#![allow(unused)]
fn main() {
let s = "Hello, world!";
}

Тип s здесь — &str: это срез, указывающий на конкретную точку бинарного файла. Именно поэтому строковые литералы неизменяемы; &str — неизменяемая ссылка.

Строковые срезы как параметры

Знание того, что можно брать срезы от литералов и значений String, приводит к ещё одному улучшению first_word, а именно к её сигнатуре:

fn first_word(s: &String) -> &str {

Более опытный Rustacean написал бы сигнатуру, показанную в листинге 4-9, потому что она позволяет использовать одну и ту же функцию как со значениями &String, так и со значениями &str.

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // `first_word` работает со срезами `String`, как частичными, так и целыми.
    let word = first_word(&my_string[0..6]);
    let word = first_word(&my_string[..]);
    // `first_word` также работает со ссылками на `String`, которые эквивалентны
    // целым срезам `String`.
    let word = first_word(&my_string);

    let my_string_literal = "hello world";

    // `first_word` работает со срезами строковых литералов, как частичными, так и
    // целыми.
    let word = first_word(&my_string_literal[0..6]);
    let word = first_word(&my_string_literal[..]);

    // Поскольку строковые литералы *являются* строковыми срезами,
    // это тоже работает, без синтаксиса среза!
    let word = first_word(my_string_literal);
}
Листинг 4-9: Улучшение функции first_word путём использования строкового среза для типа параметра s

Если есть строковый срез, его можно передать напрямую. Если есть String, можно передать срез String или ссылку на String. Такая гибкость использует преимущества разыменовывающего приведения типов — возможности, которая будет рассмотрена в разделе «Использование разыменовывающего приведения типов в функциях и методах» главы 15.

Определение функции, принимающей строковый срез вместо ссылки на String, делает API более общим и полезным без потери какой-либо функциональности:

Имя файла: src/main.rs
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // `first_word` работает со срезами `String`, как частичными, так и целыми.
    let word = first_word(&my_string[0..6]);
    let word = first_word(&my_string[..]);
    // `first_word` также работает со ссылками на `String`, которые эквивалентны
    // целым срезам `String`.
    let word = first_word(&my_string);

    let my_string_literal = "hello world";

    // `first_word` работает со срезами строковых литералов, как частичными, так и
    // целыми.
    let word = first_word(&my_string_literal[0..6]);
    let word = first_word(&my_string_literal[..]);

    // Поскольку строковые литералы *являются* строковыми срезами,
    // это тоже работает, без синтаксиса среза!
    let word = first_word(my_string_literal);
}

Другие срезы

Строковые срезы, как можно догадаться, специфичны для строк. Но есть и более общий тип среза. Рассмотрим этот массив:

#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];
}

Точно так же, как может потребоваться ссылаться на часть строки, может потребоваться ссылаться на часть массива. Это делается так:

#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];

let slice = &a[1..3];

assert_eq!(slice, &[2, 3]);
}

Этот срез имеет тип &[i32]. Он работает так же, как строковые срезы, сохраняя ссылку на первый элемент и длину. Такой вид среза используется для всевозможных других коллекций. Эти коллекции подробно рассматриваются при обсуждении векторов в главе 8.

Итоги

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

Владение влияет на то, как работают многие другие части Rust, поэтому эти концепции будут обсуждаться и далее на протяжении всей книги. Перейдём к главе 5 и рассмотрим группировку фрагментов данных вместе в struct.