Le mois dernier j’avais demandé à ChatGPT de me faire un tuto Python. Ce mois-ci, le stagiaire artificiel est de retour avec un tuto Rust !
C’est parti !
Introduction
Rust est un langage de programmation développé par Mozilla, créé pour la performance, la sécurité et la concurrence. Conçu pour être à la fois rapide et sûr, Rust offre aux développeurs la possibilité de créer des applications performantes, robustes et fiables.
Rust a été créé en réponse aux défis de la programmation moderne, où les développeurs doivent écrire des programmes qui fonctionnent sur de multiples plateformes, gèrent des quantités massives de données en temps réel et sont à l’abri des erreurs de programmation. Rust a été conçu pour répondre à ces besoins, en fournissant un langage de programmation moderne, efficace et facile à apprendre.
Rust est un langage de programmation système, ce qui signifie qu’il est conçu pour écrire des logiciels qui fonctionnent directement sur le système d’exploitation, comme des pilotes de périphériques ou des bibliothèques système. En tant que tel, Rust offre un accès direct à la mémoire, ce qui permet aux développeurs de créer des applications hautement optimisées. Cependant, Rust est également conçu pour être sûr, offrant des garanties de sécurité qui empêchent les erreurs de programmation courantes, telles que les débordements de mémoire ou les pointeurs nuls.
Rust est un langage de programmation moderne, offrant des fonctionnalités telles que les fermetures, la gestion de la mémoire sans marquage, la sécurité de la mémoire et la concurrence. Il est facile à apprendre pour les débutants en programmation, mais suffisamment puissant pour les programmeurs expérimentés. En outre, Rust dispose d’une grande communauté de développeurs passionnés, ce qui en fait un langage de programmation très actif et évolutif.
En résumé, Rust est un langage de programmation moderne, efficace et sûr, offrant des fonctionnalités de pointe pour la programmation système. Il est facile à apprendre et dispose d’une grande communauté de développeurs passionnés, ce qui en fait un excellent choix pour les développeurs qui cherchent à créer des applications hautement optimisées et fiables.
Installation
Pour utiliser Rust, vous devez télécharger et installer l’outil rustup depuis le site officiel : https://www.rust-lang.org/learn/get-started . Il vous permettra d’installer l’environnement de développement Rust, incluant l’outil cargo qui vous permettra de gérer les dépendances de vos projets.
Après l’installation, Rust devrait être disponible dans votre terminal. Pour vérifier que tout fonctionne correctement, exécutez la commande suivante :
rustc --version
Cette commande affichera la version de Rust installée sur votre système.
Variables
Les variables sont déclarées en utilisant le mot-clé « let », suivi du nom de la variable, du signe égal (=) et de la valeur. Par exemple: « let x = 5; ». Rust est un langage fortement typé, il faudra donc spécifier le type de données de votre variable ou laisser le compilateur le déduire.
// Déclaration d'une variable avec une valeur initiale
let x = 5;
// Déclaration d'une variable avec un type spécifié
let y: i32 = 10;
// Modification de la valeur d'une variable
x = 10;
// Utilisation de la variable
println!("La valeur de x est : {}", x);
Types de données
Rust prend en charge plusieurs types de données de base, comme les nombres entiers (i32, u32, etc.), les flottants (f32, f64), les booléens (bool), les chaînes de caractères (String, &str) et les tableaux (Vec<T>, [T; n]). Il est également possible de créer des types de données personnalisés en utilisant les structures (struct) et les enums (enum).
// Déclaration d'un nombre entier
let x = 5;
// Déclaration d'un flottant
let y = 3.14;
// Déclaration d'un booléen
let z = true;
// Déclaration d'une chaîne de caractères
let w = "Hello World";
// Déclaration d'un tableau
let v = [1, 2, 3, 4, 5];
Opérations arithmétiques
Les opérations arithmétiques de base telles que l’addition, la soustraction, la multiplication et la division sont effectuées à l’aide des opérateurs habituels (+, -, *, /). Rust prend également en charge les opérateurs de modulo (%), d’exponentiation (**) et de racine carrée(sqrt).
// Déclaration de variables
let x = 5;
let y = 10;
// Addition
let z = x + y;
println!("La somme de x et y est : {}", z);
// Soustraction
let z = x - y;
println!("La différence de x et y est : {}", z);
// Multiplication
let z = x * y;
println!("Le produit de x et y est : {}", z);
// Division
let z = x / y;
println!("Le quotient de x et y est : {}", z);
Structures de contrôle de flux
Rust prend en charge les structures de contrôle de flux courantes telles que les boucles for, les boucles while, les conditions if-else et les instructions match qui permet de tester des valeurs pour des patterns. Les boucles peuvent être écrites avec des itérateurs (for x in y) ou avec des range (for x in 0..10).
// Boucle for
for i in 0..10 {
println!("{}", i);
}
// Boucle while
let mut x = 5;
while x > 0 {
println!("{}", x);
x -= 1;
}
// Condition if-else
let x = 5;
if x > 0 {
println!("x est positif");
} else {
println!("x est négatif");
}
// Instruction match
let x = 5;
match x {
0 => println!("x est zéro"),
1 | 2 => println!("x est un ou deux"),
3..=10 => println!("x est entre 3 et 10"),
_ => println!("x est plus grand que 10"),
}
Fonctions
Les fonctions sont déclarées en utilisant le mot-clé « fn », suivi du nom de la fonction, des paramètres entre parenthèses, et du corps de la fonction entre accolades. Les fonctions peuvent retourner une valeur en utilisant le mot-clé « return ».
// Déclaration d'une fonction
fn add(x: i32, y: i32) -> i32 {
return x + y;
}
// Appel de la fonction
let result = add(5, 10);
println!("La somme de 5 et 10 est : {}", result);
Modules
Les modules permettent de diviser un programme en plusieurs fichiers, et de les organiser en sous-dossiers. Les modules sont déclarés en utilisant le mot-clé « mod », suivi du nom du module. Vous pouvez utiliser les fonctions et les variables des modules en utilisant leur nom de module comme préfixe.
// création d'un fichier nommé 'module1.rs'
// dans le fichier module1.rs
mod module1 {
fn func1() {
println!("This is function 1 from module 1");
}
}
// Dans le fichier principal
mod module1;
fn main() {
module1::func1();
}
Conclusion
C’est la fin de cette introduction à Rust. Il est maintenant temps pour vous de continuer à apprendre et à expérimenter avec Rust en créant vos propres programmes et en explorant les différentes bibliothèques disponibles. N’oubliez pas que l’apprentissage continu est essentiel pour devenir un développeur expérimenté et qu’il est important de continuer à apprendre et à se perfectionner dans le développement Rust.
Documentation
La documentation officielle de Rust se trouve sur le site web officiel de Rust : https://doc.rust-lang.org. Il est divisé en différentes sections, comme les guides de démarrage, les références de langage, les guides pour les différentes parties du langage, les bibliothèques standard, les outils de développement, etc. Il y a également une section de tutoriels pour les débutants et une section de questions fréquentes. Il y a également une communauté active qui peut vous aider à résoudre les problèmes que vous rencontrez en utilisant Rust, sur le forum officiel : https://users.rust-lang.org/