Как идиоматически заменить определённые символы в строке в Rust?

Идиоматическая замена нескольких символов в Rust

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

1. Метод replace с цепочкой (простой, но неоптимальный)

Как вы уже заметили, это работает, но каждая замена создаёт новую String. Для замены 2-3 символов это приемлемо, но для десятков — уже нет.

let result = "hello-world_foo"
    .replace("-", " ")
    .replace("_", " ");
println!("{}", result); // "hello world foo"

2. Использование str::replace с массивом замен (идиоматично)

Самый популярный идиоматический способ — использовать итератор и метод fold:

fn replace_multiple(s: &str, replacements: &[(&str, &str)]) -> String {
    replacements.iter().fold(s.to_string(), |acc, (from, to)| acc.replace(from, to))
}

fn main() {
    let s = "hello-world_foo";
    let result = replace_multiple(s, &[("-", " "), ("_", " ")]);
    println!("{}", result); // "hello world foo"
}

Этот подход:

• Читается как декларация правил замены
• Легко расширяется (добавьте ещё пары в массив)
• Не требует внешних зависимостей

3. Использование str::chars и фильтрации (максимально производительно)

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

fn replace_chars(s: &str, replacements: &[(char, char)]) -> String {
    s.chars()
        .map(|c| {
            replacements
                .iter()
                .find(|&&(from, _)| from == c)
                .map(|&(_, to)| to)
                .unwrap_or(c)
        })
        .collect()
}

fn main() {
    let s = "hello-world_foo";
    let result = replace_chars(s, &[('-', ' '), ('_', ' ')]);
    println!("{}", result); // "hello world foo"
}

Преимущества:

• Один проход по строке, без выделения промежуточных строк
• Работает корректно с Unicode (важно для Rust!)
• Можно легко заменить на HashMap для частой замены

4. Использование регулярных выражений (для сложных правил)

Если правила замены сложнее (например, замена всех цифр на звёздочки), используйте крейт regex:

use regex::Regex;

fn main() {
    let re = Regex::new(r"[-_]").unwrap();
    let result = re.replace_all("hello-world_foo", " ");
    println!("{}", result); // "hello world foo"
}

Добавьте в Cargo.toml: regex = "1". Этот вариант мощный, но добавляет зависимость и может быть избыточным для простой замены.

Советы по производительности

• Для замены 1-3 символов — цепочка replace вполне нормальна
• Для многих символов в длинных строках — используйте chars() с HashMap
• Для подстрок — используйте fold с массивом замен
• Избегайте regex для простых замен — он тяжелее

Итог: самый идиоматичный способ для вашей задачи — второй вариант с fold. Он читаем, эффективен и не требует внешних зависимостей. Если же вам нужно заменить именно отдельные символы, используйте третий вариант с chars().

fn replace_delimiters(s: &str, delimiters: &[char], replacement: &str) -> String {
    s.split(|c: char| delimiters.contains(&c))
        .collect::>()
        .join(replacement)
}

fn main() {
    let s = "hello-world_foo";
    let result = replace_delimiters(s, &['-', '_'], " ");
    println!("{}", result); // "hello world foo"
}