Rust propose des tutoriels pour tous

Présentation de Rust

Rust est un langage de programmation qui vise à offrir une sécurité et une performance exceptionnelles. Les tutoriels de Rust sont conçus pour être accessibles à tous, quels que soient leur niveau et leur expérience.

Fonctionnement de Rust

Rust repose sur des concepts tels que les structures de données et les traits. Par exemple, on peut définir une structure Person avec des champs name et company_name, puis implémenter des méthodes pour cette structure.

struct Person {
       name: String,
       company_name: String,
   }
   impl Person {
       fn new(name: String, company_name: String) -> Self {
           Self { name, company_name }
       }
       fn intro(&self) -> String {
           format!("I'm {} from {}", self.name, self.company_name)
       }
   }

On peut également définir des traits pour ajouter des fonctionnalités à nos structures de données. Par exemple, on peut créer un trait Greet pour personnaliser les salutations.

trait Greet {
       const PREFIX: &'static str = "Hello";
       fn greet(&self) -> String {
           format!("{}!", String::from(Self::PREFIX))
       }
   }

Exemples d'utilisation

Rust offre une grande flexibilité dans la manipulation des données. On peut par exemple utiliser des fonctions pour traiter des tableaux de données, comme dans l'exemple suivant :

let marks = ["10", "20", "30", "0.4", "0.5", "invalid"];
   let sum: i32 = marks
       .iter()
       .filter_map(|&s| s.parse::<f64>().ok())
       .map(|num| if num  1.0 { num * 100.0 } else { num })
       .inspect(|&val| println!("Parsed: {val}"))
       .map(|num| num as i32)
       .sum();

Cet exemple montre comment Rust peut être utilisé pour traiter des données de manière efficace et sécurisée.

Utilisation avancée

Rust propose également des fonctionnalités avancées pour la manipulation de données, telles que les énumérations et les cartes. On peut par exemple définir une énumération Data pour représenter des données de différents types.

enum Data<K, V> {
       Value(V),
       KeyValue(K, V),
   }

On peut alors utiliser des fonctions pour traiter ces données et les accumuler dans une carte.

let data = vec![
       Data::KeyValue("Steve", 10),
       Data::Value(20),
       Data::KeyValue("Bill", 30),
       Data::Value(40),
   ];
   let map = data
       .into_iter()
       .map(|item| match item {
           Data::KeyValue(k, v) => {
               println!("{}: {}", k, v);
               (k.to_string(), v)
           }
           Data::Value(v) => {
               println!("unknown: {}", v);
               ("unknown".to_string(), v)
           }
       })
       .fold(HashMap::new(), |mut map, (key, value)| {
           map.entry(key)
               .and_modify(|existing| *existing += value)
               .or_insert(value);
           map
       });

Cet exemple montre comment Rust peut être utilisé pour manipuler des données de manière complexe et efficace.