Коллекции и строки в Rust

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

Вектор

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

Вектор — это линейный список, представленный в Rust как Vec<T>.

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

let vector: Vec<i32> = Vec::new(); // 创建类型为 i32 的空向量
let vector = vec![1, 2, 4, 8];     // 通过数组创建向量

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

, вектор вернёт ошибку.

fn main() {
    let mut vector = vec![1, 2, 4, 8];
    vector.push(16);
    vector.push(32);
    vector.push(64);
    println!("{:?}", vector);
}

Вывод:

[1, 2, 4, 8, 16, 32, 64]

Метод append используется для присоединения одного вектора к концу другого:

Пример

fn main() {
    let mut v1: Vec<i32> = vec![1, 2, 4, 8];
    let mut v2: Vec<i32> = vec![16, 32, 64];
    v1.append(&mut v2);
    println!("{:?}", v1);
}

Вывод:

[1, 2, 4, 8, 16, 32, 64]

Метод get используется для получения значения из вектора:

Пример

fn main() {
    let mut v = vec![1, 2, 4, 8];
    println!("{}", match v.get(0) {
        Some(value) => value.to_string(),
        None => "None".to_string()
    });
}

Вывод:

1

Поскольку длину вектора невозможно логически вывести, метод get не может гарантировать, что значение будет возвращено, поэтому тип возвращаемого значения метода get — это перечисление Option, которое может быть None.

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

Пример

fn main() {
    let v = vec![1, 2, 4, 8];
    println!("{}", v[1]);
}

Вывод:

2

Но если мы попытаемся обратиться к v

Итерирование по вектору:

Пример

fn main() {
    let v = vec![100, 32, 57];
    for i in &v {
            println!("{}", i);
    }
}

Вывод:

100
32
57

Если вам нужно изменить значение переменной во время итерации:

Пример

fn main() {
    let mut v = vec![100, 32, 57];
    for i in &mut v {
        *i += 50;
    }
}

String

Тип String активно использовался вплоть до этой главы, поэтому многие его методы уже знакомы читателям. В этой главе в основном представлены строковые методы и особенности UTF-8.

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

let string = String::new();

Преобразование базовых типов в строки:

let one = 1.to_string();         // 整数到字符串
let float = 1.3.to_string();     // 浮点数到字符串
let slice = "slice".to_string(); // 字符串切片到字符串

Строки, содержащие символы UTF-8:

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");

Добавление в строку:

let mut s = String::from("run");
s.push_str("oob"); // 追加字符串切片
s.push('!');       // 追加字符

Конкатенация строк с помощью знака +:

let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2;

Этот синтаксис также может включать срезы строк:

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

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

Использование макроса format!:

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

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

Длина строки:

let s = "hello";
let len = s.len();

Здесь значение len равно 5.

let s = "你好";
let len = s.len();

Здесь значение len равно 6. Поскольку китайский язык в кодировке UTF-8, каждый символ занимает 3 байта, поэтому длина равна 6. Однако Rust поддерживает объекты символов UTF-8, поэтому если вы хотите подсчитать количество символов, можно сначала преобразовать строку в коллекцию символов:

let s = "hello你好";
let len = s.chars().count();

Здесь значение len равно 7, потому что всего 7 символов. Подсчёт символов намного медленнее, чем получение длины в байтах.

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

Пример

fn main() {
    let s = String::from(hello Chinese);
    for c in s.chars() {
        println!("{}", c);
    }
}

Вывод:

h
e
l
l
o
中
文

Получение одного символа из строки:

Пример

fn main() {
    let s = String::from(EN Chinese);
    let a = s.chars().nth(2);
    println!("{:?}", a);
}

Вывод:

Some('中')

Примечание: функция nth — это метод для получения значения из итератора. Пожалуйста, не используйте её таким образом при итерации! Потому что длина каждого символа в UTF-8 не обязательно одинакова!

Если вы хотите извлечь подстроку из строки:

Пример

fn main() {
    let s = String::from(EN Chinese);
    let sub = &s[0..2];
    println!("{}", sub);
}

Вывод:

EN

Но обратите внимание, что такое использование может разбить символ UTF-8! Это вызовет ошибку:

Пример

fn main() {
    let s = String::from(EN Chinese);
    let sub = &s[0..3];
    println!("{}", sub);
}

Вывод:

thread 'main' panicked at 'byte index 3 is not a char boundary; it is inside '中' (bytes 2..5) of `EN中文`', src\libcore\str\mod.rs:2069:5 
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

Map

Ассоциативные массивы широко распространены в других языках. Наиболее часто используется хеш-таблица «ключ-значение».

Создание новой хеш-таблицы:

Пример

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();

    map.insert("color", "red");
    map.insert("size", "10 m^2");

    println!("{}", map.get("color").unwrap());
}

Примечание: Причина, по которой мы не объявили обобщённый тип хеш-таблицы, заключается в механизме автоматического вывода типов Rust.

Вывод:

red

Методы insert и get — два наиболее часто используемых метода ассоциативного массива.

Ассоциативные массивы поддерживают итераторы:

Пример

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();

    map.insert("color", "red");
    map.insert("size", "10 m^2");

    for p in map.iter() {
        println!("{:?}", p);
    }
}

Вывод:

("color", "red") 
("size", "10 m^2")

Итерируемые элементы — это кортежи, представляющие пары ключ-значение.

map в Rust — очень удобная структура данных. При использовании метода insert для добавления новой пары ключ-значение, если такой же ключ уже существует, он напрямую перезапишет соответствующее значение. Если вы хотите «безопасно вставить», то есть выполнить вставку только после подтверждения, что ключа сейчас не существует, можно сделать так:

map.entry("color").or_insert("red");

Это означает: если нет пары ключ-значение с ключом "color", добавьте её и установите значение "red"; иначе она будет пропущена.

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

Пример

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert(1, "a");
   
    if let Some(x) = map.get_mut(&1) {
        *x = "b";
    }
}
Другие расширения