Rust est un langage de programmation moderne à typage statique conçu pour la performance, la fiabilité et la sécurité. Comme dans les autres langages à typage statique, vous déclarez les types de données Rust au moment de la compilation. Il est ainsi plus facile de détecter les erreurs de type avant d’exécuter votre code.
Rust propose des types scalaires, composés, de référence, des structs, des enums et des chaînes de caractères. Son inférence de type fournit des fonctionnalités pour écrire du code concis tout en maintenant la sécurité d’un langage à typage statique.
Les nombres entiers en Rust
Rust fournit des types d’entiers signés et non signés classés en fonction du nombre de bits. Les types d’entiers signés sont i8, i16, i32et i64 représentant respectivement des entiers signés de 8, 16, 32 et 64 bits. Il prend également en charge les types d’entiers non signés sont u8, u16, u32et u64représentant des entiers non signés de 8, 16, 32 et 64 bits.
// signed integers
let a: i8 = -10;
let b: i16 = -2048;
let c: i32 = -2147483648;
let d: i64 = -9223372036854775808;
// unsigned integers
let e: u8 = 255;
let f: u16 = 65535;
let g: u32 = 4294967295;
let h: u64 = 18446744073709551615;
Rust utilise le i32 type pour les littéraux entiers par défaut.
Types de virgule flottante Rust
Rust fournit f32 et f64 comme types de virgule flottante qui représentent les nombres à virgule flottante de simple précision et de double précision. Le site f32 utilise 32 bits pour stocker les valeurs, et le type f64 Le type utilise 64 bits.
Les nombres à virgule flottante dans Rust suivent la norme IEEE 754 pour l’arithmétique à virgule flottante.
let a = 3.14159265358979323_f32;
let b = 2.718281828459045235_f64;
Utilisation des booléens en Rust
Rust fournit un bool type à représenter vrai ou faux valeurs. Les booléens sont souvent utilisés dans les instructions conditionnelles et de flux de contrôle pour la prise de décision dans les programmes.
let variable_1: bool = true;
let variable_2: bool = false;
Vous pouvez comparer des valeurs booléennes avec l’opérateur d’égalité, ==et l’opérateur d’inégalité, !=. Rust ne définit pas les opérateurs de comparaison, < ;, > ;, <=, et >=, pour bool valeurs.
let variable_1: bool = true;
let variable_2: bool = false;
if variable_1 == variable_2 {
println!("variable_1 is equal to variable_2");
} else if variable_1 != variable_2 {
println!("variable_1 is not equal to variable_2");
}
Le type Char
La rouille char représente une valeur scalaire Unicode unique qui peut représenter n’importe quel caractère de la norme Unicode. Vous pouvez spécifier un char valeur entre guillemets simples.
// Declaring a char value
let c = 'a';
Le site char est utile pour travailler avec les emojis en Rust.
Les tuples en Rust
La structure de données tuple vous permet de regrouper plus d’une valeur en une seule valeur composée. Ces valeurs peuvent avoir le même type ou des types différents. Vous pouvez déclarer des tuples en les écrivant sous la forme d’une liste de valeurs séparées par des virgules et entourées de parenthèses.
Voici comment vous pouvez déclarer un tuple avec des valeurs entières 32 bits, des chaînes de caractères et des valeurs float64.
let tup: (i32, &str, f64) = (500, "Hello", 3.14);
Les tuples ont une longueur fixe et vous pouvez les utiliser pour renvoyer plusieurs valeurs à partir d’une fonction ou passer plusieurs valeurs aux fonctions comme un seul argument.
Vous pouvez accéder aux éléments individuels d’un tuple en le déstructurant à l’aide d’une correspondance de motifs ou en accédant directement aux éléments individuels à l’aide de la syntaxe point (.) et d’un index.
Voici comment vous pouvez accéder aux éléments individuels d’une structure en utilisant le filtrage :
let my_tuple = (10, "Hello, World!", false);
let (x, y, z) = my_tuple;
println!("The first element is: {}", x);
println!("The second element is: {}", y);
println!("The third element is: {}", z);
Voici comment accéder à des éléments individuels en utilisant la notation par points :
let my_tuple = (10, "Hello, World!", false);
println!("The first element is: {}", my_tuple.0);
println!("The second element is: {}", my_tuple.1);
println!("The third element is: {}", my_tuple.2);
Les tuples sont très utiles pour regrouper des données connexes en une seule valeur. Ils peuvent également améliorer la lisibilité de votre code si vous les utilisez avec parcimonie.
Les tableaux en Rust
Un tableau est une collection d’éléments du même type avec une longueur fixe. Les tableaux Rust s’écrivent comme une liste de valeurs entre crochets, séparées par des virgules.
Voici comment vous pouvez déclarer des tableaux en Rust :
let arr = [1, 2, 3, 4, 5];
Vous ne pouvez pas changer le nombre d’éléments d’un tableau une fois que vous l’avez déclaré, mais vous pouvez accéder, modifier et manipuler les éléments individuels d’un tableau en utilisant l’indexation.
let mut my_array = [1, 2, 3, 4, 5];
// Accessing elements
println!("The first element is: {}", my_array[0]);
// Modifying elements
my_array[0] = 100;
println!("The first element after modification is: {}", my_array[0]);
// Looping over an array and manipulating elements
for i in 0..my_array.len() {
my_array[i] *= 2;
}
// printing the array
println!("The array after manipulation: {:?}", my_array);
Rust Les tableaux sont stockés sur la pile et bénéficient d’une allocation de mémoire contiguë, de sorte que l’accès aux éléments d’un tableau est rapide et efficace. Les tableaux sont donc adaptés aux situations où vous devez stocker et traiter de nombreux éléments.
Travailler avec les tranches Rust
Une tranche est une structure de données qui permet de référencer une séquence contiguë d’éléments dans une collection. Les tranches sont représentées par l’élément & ;[T] type, où T est le type des éléments stockés dans la tranche.
fn main() {
// declare an array
let my_array = [1, 2, 3, 4, 5];
// create a slice from the array
let my_slice = &my_array[1..3];
// print the slice
println!("Slice: {:?}", my_slice);
}
Remarquez comment la syntaxe de la plage, ..extrait une tranche d’un tableau en utilisant l’indice de départ et un indice supérieur d’une unité à l’indice de fin :
Les tranches sont dynamiques, donc Rust peut déterminer leur longueur au moment de l’exécution. Vous pouvez également passer les tranches comme arguments aux fonctions sans avoir besoin d’allocation de tas.
Vous utiliserez couramment les slices pour les opérations sur les chaînes de caractères et pour passer des sous-ensembles de données aux fonctions. Elles constituent un outil puissant et efficace pour gérer les collections dans Rust, offrant une alternative plus flexible aux tableaux.
Vous pouvez créer des applications Web frontales alimentées par WebAssembly en Rust.
La connaissance des types de données est essentielle pour votre voyage dans Rust, car vous les utiliserez pour la plupart des opérations lors de la création d’applications.
WebAssembly est un format binaire de bas niveau qui fonctionne sur les navigateurs web modernes, avec des performances quasi-natives. Il vous permet d’écrire du code dans de nombreux langages différents et de le transposer en WebAssembly.
WebAssembly est de plus en plus adopté par Rust. Il existe de nombreux frameworks comme Yew, Sycamore et Seed que vous pouvez utiliser pour construire des frontaux alimentés par WebAssembly avec Rust.
