Стандартная библиотека Rust: полный обзор основных модулей и возможностей

Стандартная библиотека Rust: полный обзор

Стандартная библиотека Rust (std) — это набор фундаментальных модулей, которые предоставляют разработчику все необходимое для создания надежных, быстрых и безопасных приложений. В отличие от многих других языков, Rust уделяет особое внимание безопасности памяти и параллелизму без сборщика мусора. В этой статье мы подробно разберем ключевые компоненты std с примерами кода.

1. Основные модули стандартной библиотеки

Библиотека разбита на несколько логических групп. Рассмотрим самые важные из них.

1.1. Модуль std::collections

Содержит структуры данных для хранения и управления коллекциями элементов. Наиболее популярные:

• Vec<T> — динамический массив (аналог ArrayList в Java).
• HashMap<K, V> — хеш-таблица для хранения пар ключ-значение.
• HashSet<T> — множество уникальных значений.
• BTreeMap и BTreeSet — отсортированные коллекции на основе красно-черного дерева.

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Alice"), 100);
    scores.insert(String::from("Bob"), 90);

    for (name, score) in &scores {
        println!("{}: {}", name, score);
    }
}

1.2. Модуль std::io

Отвечает за ввод-вывод: чтение с клавиатуры, работа с файлами, буферизированный ввод/вывод. Ключевые типажи: Read и Write.

use std::io::{self, BufRead};

fn main() -> io::Result<()> {
    let stdin = io::stdin();
    for line in stdin.lock().lines() {
        println!("Вы ввели: {}", line?);
    }
    Ok(())
}

1.3. Модуль std::thread

Позволяет создавать и управлять потоками выполнения. Rust гарантирует безопасность данных между потоками через систему владения и типажи Send и Sync.

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("Поток: {}", i);
        }
    });

    for i in 1..5 {
        println!("Главный поток: {}", i);
    }

    handle.join().unwrap();
}

2. Работа со строками и текстом

В Rust есть два строковых типа:

• String — изменяемая, владеющая строка (содержится в куче).
• &str — неизменяемый срез строки (ссылка на последовательность UTF-8).

fn main() {
    let mut hello = String::from("Привет, ");
    hello.push_str("мир!");
    println!("{}", hello); // Вывод: Привет, мир!

    let slice: &str = &hello[0..6];
    println!("Срез: {}", slice); // Вывод: Привет
}

3. Обработка ошибок

Вместо исключений Rust использует два перечисления:

• Option<T> — для случаев, когда значение может отсутствовать (Some или None).
• Result<T, E> — для операций, которые могут завершиться ошибкой (Ok или Err).

use std::fs::File;
use std::io::Read;

fn read_file(path: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() {
    match read_file("test.txt") {
        Ok(content) => println!("Содержимое: {}", content),
        Err(e) => eprintln!("Ошибка: {}", e),
    }
}

4. Итераторы и замыкания

Итераторы в Rust ленивые и мощные. Они позволяют обрабатывать последовательности данных без явных циклов.

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    // Цепочка итераторов
    let sum: i32 = numbers.iter()
        .filter(|&x| x % 2 == 0)  // только четные
        .map(|x| x * 2)          // удваиваем
        .sum();                  // суммируем

    println!("Результат: {}", sum); // Вывод: 12 (2*2 + 4*2 =