Depuis sa sortie en 2015, Rust a gagné en popularité comme l’un des langages de programmation préférés des développeurs. Rust offre d’excellentes performances et des fonctionnalités de sécurité avec une syntaxe intuitive et concise qui rendent le langage désirable.
Rust est adapté à la construction de divers programmes, notamment des applications web, des outils en ligne de commande et des services réseau. Rust inclut de nombreuses fonctionnalités que vous attendez d’un langage de programmation moderne, comme la concurrence, l’inférence de type, etc.
Démarrer avec Rust
Rust est un langage de programmation multiplateforme qui fonctionne sur la plupart des systèmes d’exploitation. Pour commencer à utiliser Rust, rendez-vous sur le site officiel de Rust et installez la version correspondant à votre système d’exploitation.
Une fois Rust installé, vous pouvez commencer à écrire des programmes dans des fichiers Rust à l’aide d’un fichier .rs extension. Rust est polyvalent et facile à apprendre. Vous le trouverez simple si vous avez une expérience préalable de la programmation.
Variables et constantes en Rust
Rust est très expressif, et il y a plusieurs façons de déclarer des variables. Vous pouvez utiliser l’élément let mot-clé pour déclarer des variables.
Voici comment déclarer des variables en Rust :
let a: String;
let b: i32;
let c: () = ();
La fonction a et b sont respectivement une chaîne de caractères et un nombre entier. Les variables c variable est un type d’unité Rust qui sert d’espace réservé pour les fonctions et les expressions.
Après la déclaration du type de données optionnel, vous pouvez déclarer et initialiser des variables avec des valeurs en utilisant un signe égal.
fn main(){
let age: String = String::from("five years old");
let age = 5; // equivalent to let age: i32 = 5;
println!("{}", age);
}
Le programme déclare deux âge avant l’impression à l’aide de la fonction println ! macro. La première macro âge spécifie le type de données, alors que la seconde ne le spécifie pas.
Il n’est pas nécessaire de spécifier le type de données d’une variable lorsque vous la déclarez. Le compilateur Rust déduit le type à partir du type de données de la valeur au moment de la compilation.
Vous pouvez également déclarer des constantes en Rust à l’aide de la fonction const de la même manière que pour la déclaration de variables :
const age: &str = "five years old";
Vous ne pouvez pas modifier la valeur d’une variable que vous déclarez comme constante.
Commentez vos programmes Rust
Rust fournit des fonctionnalités pour les commentaires d’une seule ligne et de blocs. Vous pouvez utiliser des doubles barres obliques (//) pour les commentaires d’une seule ligne :
fn main() {
// This is a line comment
let x = 5; // This comment explains the purpose of the `x` variable
}
Pour les commentaires sur plusieurs lignes (commentaires en bloc), utilisez une barre oblique suivie d’un astérisque (/*) et fermer le bloc avec un astérisque suivi d’une barre oblique (*/) :
fn main() {
/*
This is a block comment that spans multiple lines.
It is often used to describe a larger block of code.
*/
let x = 5;
}
Vos commentaires doivent être concis et directs.
Les tableaux en Rust
Les tableaux sont une collection de taille fixe d’éléments du même type de données. Par défaut, Rust alloue les tableaux sur la pile.
Voici comment déclarer des tableaux en Rust :
fn main() {
let numbers = [1, 2, 3, 4, 5];
}
La fonction numéros contient cinq éléments. Vous pouvez accéder à la valeur d’un emplacement dans un tableau en utilisant son index :
fn main() {
let numbers = [1, 2, 3, 4, 5];
let x = numbers[3];
println!("{}", x)
}
L’indice principal La fonction « main » imprime le x qui accède au quatrième élément du tableau.
Les vecteurs en rouille
Rust fournit des vecteurs pour couvrir les limitations des tableaux. Les vecteurs ont une taille dynamique ; ils peuvent grandir et rétrécir selon les besoins.
Voici comment déclarer des vecteurs en Rust :
fn main() {
let my_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
let x = my_vec[3];
println!("{}", x)
}
La fonction mon_vec vector est un vecteur d’entiers de 32 bits. Le vecteur x accède au quatrième élément du vecteur, et la variable principal imprime la valeur sur la console.
Les déclarations conditionnelles de Rust
Les instructions conditionnelles sont l’une des structures de contrôle de Rust pour la prise de décision dans les programmes. Vous pouvez utiliser l’élément if et autre mots-clés pour gérer les décisions dans vos programmes.
Voici un si qui imprime une chaîne de caractères sur la console en fonction de l’égalité de deux entiers.
fn main() {
let a: i32 = 12;
if a == 12 {
println!("a equals twelve");
}
}
L’instruction principal imprime la chaîne de caractères avec l’attribut println ! macro puisque la variable est égale à 12.
Vous pouvez utiliser la macro autre pour gérer les cas où le mot-clé si évalue faux :
fn main() {
let a: i32 = 12;
if a == 123 {
println!("a equals twelve");
} else {
println!("a does not equal twelve");
}
}
Dans cet exemple, l’instruction else s’exécute car la valeur de a n’est pas égale à 123.
Vous pouvez déclarer des instructions de correspondance avec l’option match mot-clé pour les conditionnelles complexes :
fn main() {
let age: i32 = 7;
match age {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
_ => println!("zero"),
}
}
Le mot-clé principal correspond à la fonction âge variable en fonction des cas dans la match et exécute l’expression qui correspond à la valeur. Le trait de soulignement (_) est l’instruction par défaut qui s’exécute en cas de correspondance avec la valeur.
Les boucles en Rust
Rust propose des boucles pour les tâches répétitives. Rust dispose de trois types principaux de boucles : boucle, tout en, et pour boucles.
Les boucle crée une boucle infinie qui s’exécute jusqu’à ce qu’elle rencontre un mot-clé break :
fn main() {
loop {
println!("printed repeatedly until break statement is encountered.");
break;
}
}
Le mot-clé tout en est pratique lorsque vous souhaitez répéter un bloc de code tant qu’une condition est évaluée comme vraie :
fn main() {
let mut count = 0;
while count < 5 {
println!("The count is {}", count);
count += 1;
}
}
A pour permet d’itérer sur une collection d’éléments, comme un tableau :
fn main() {
let numbers = [1, 2, 3, 4, 5];
for item in numbers.iter() {
println!("The current item is {}", item);
}
}
Cette pour itère à travers la boucle nombres et affiche chaque élément sur la console.
Déclarer et appeler des fonctions Rust
Utiliser la fonction fn pour déclarer une fonction Rust, suivie du nom de la fonction, d’une liste de paramètres et d’un type de retour (le cas échéant).
Voici comment déclarer une fonction avec des paramètres et un type de retour :
fn add(a: i32, b: i32) -> i32 {
return a + b;
}
La fonction add prend deux entiers de 32 bits et renvoie un entier de 32 bits, la somme des deux paramètres.
Pour appeler une fonction à partir d’un autre endroit de votre code, il suffit de spécifier le nom et les arguments (le cas échéant) :
fn main() {
let result = add(2, 3);
println!("2 + 3 = {}", result);
}
La fonction résultat Cette variable contient le résultat de l’appel à la fonction ajouter fonction. La fonction principal imprime le résultat sur la console à l’aide de la fonction println ! macro.
Les structures en rouille
Rust fournit des structures pour définir des types de données personnalisés qui regroupent des valeurs apparentées. Les structures sont des plans pour créer des objets avec des propriétés spécifiques.
Voici comment déclarer une structure :
struct Person {
name: String,
age: u32,
is_male: bool,
}
La fonction Personne comporte trois champs : une chaîne de caractères, un entier non signé de 32 bits et un booléen.
Après avoir défini une structure, vous pouvez en créer des instances dans d’autres parties de votre programme :
fn main() {
let person1 = Person {
name: String::from("Candace Flynn"),
age: 16,
is_male: false,
};
}
La structure personne1 est une instance de la variable Personne struct. Lors de l’instanciation, vous pouvez attribuer des valeurs aux champs de la structure. Vous pouvez créer autant d’instances d’une structure que vous le souhaitez.
Vous pouvez implémenter des concepts OOP en Rust
Rust est flexible, et vous pouvez implémenter les concepts de la POO en Rust avec des structures de données intégrées comme les structs.
Vous utiliserez les structures comme alternative aux classes. Avec la structure de Rust, vous pouvez définir un schéma directeur pour le type et mettre en œuvre les différents concepts de la POO avec les fonctionnalités que Rust fournit sur les structures.