Utilizzo delle espressioni regolari

Rust:
Utilizzo delle espressioni regolari

Come fare:

La libreria regex di Rust è la scelta principale per lavorare con le espressioni regolari. Per usarla, devi prima aggiungerla al tuo Cargo.toml:

[dependencies]
regex = "1"

Poi, puoi iniziare ad implementare le funzionalità delle regex nel tuo codice Rust. Ecco come eseguire alcune operazioni comuni:

Corrispondenza di un Modello in una Stringa

use regex::Regex;

fn main() {
    let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
    let date = "2023-04-15";

    println!("Il testo corrisponde al modello di data? {}", re.is_match(date));
    // Output: Il testo corrisponde al modello di data? true
}

Trovare e Accedere alle Corrispondenze

use regex::Regex;

fn main() {
    let text = "Rust 2023, C++ 2022, Python 2021";
    let re = Regex::new(r"\b(\w+)\s(\d{4})").unwrap();

    for cap in re.captures_iter(text) {
        println!("Linguaggio: {}, Anno: {}", &cap[1], &cap[2]);
    }
    // Output:
    // Linguaggio: Rust, Anno: 2023
    // Linguaggio: C++, Anno: 2022
    // Linguaggio: Python, Anno: 2021
}

Sostituzione del Testo

use regex::Regex;

fn main() {
    let re = Regex::new(r"\b(\w+)\s(\d{4})").unwrap();
    let text = "Rust 2023, C++ 2022, Python 2021";
    let replaced = re.replace_all(text, "$1 è stato aggiornato nel $2");

    println!("Testo aggiornato: {}", replaced);
    // Output: Testo aggiornato: Rust è stato aggiornato nel 2023, C++ è stato aggiornato nel 2022, Python è stato aggiornato nel 2021
}

Divisione del Testo Usando una Regex

use regex::Regex;

fn main() {
    let re = Regex::new(r"\W+").unwrap(); // dividi per ogni carattere non di parola
    let text = "Rust-C++-Python-Go";

    let fields: Vec<&str> = re.split(text).collect();

    for field in fields {
        println!("Linguaggio: {}", field);
    }
    // Output:
    // Linguaggio: Rust
    // Linguaggio: C++
    // Linguaggio: Python
    // Linguaggio: Go
}

Questi esempi forniscono una guida di base per iniziare con le espressioni regolari in Rust. Man mano che le tue esigenze diventano più sofisticate, il crate regex offre una vasta gamma di funzionalità per compiti complessi di corrispondenza di modelli e manipolazione del testo.