Rust propose une riche collection de types primitifs (Primitives), divisés en deux grandes catégories : les types scalaires et les types composés.
(I) Types scalaires (Scalar Types)
Ils représentent une seule valeur indépendante, il en existe 6 sortes :
- Entiers signés :
i8,i16,i32,i64,i128,isize(taille adaptée au pointeur système) - Entiers non signés :
u8,u16,u32,u64,u128,usize(taille adaptée au pointeur système) - Nombres à virgule flottante :
f32,f64 - Caractère char : stocke une valeur scalaire Unicode (ex:
'a','α','∞'), chaque caractère occupe 4 octets - Booléen bool : deux valeurs seulement
true,false - Type unité () : sa seule valeur est le tuple vide
(). Bien qu’il ressemble à un tuple, il ne contient qu’une unique valeur, donc ce n’est pas un type composé.
(II) Types composés (Compound Types) (étudiés à la fin)
Formés à partir de plusieurs valeurs :
- Tableau : exemple
[1, 2, 3] - Tuple : exemple
(1, true)
1) Manières d’annoter le type d’une variable
Toutes les variables peuvent recevoir un type manuellement. Les types numériques prennent en charge les suffixes de type ; sans annotation, un type par défaut est utilisé :
- Entier par défaut :
i32 - Flottant par défaut :
f64
Rust peut aussi déduire automatiquement le type selon le contexte du code.
2) Types des variables
1. Annotation explicite du type
Spécifiez directement le type après le nom de variable avec : type, valide pour toutes les variables.
fn main() {
let isOpen: bool = true;
let price: f64 = 1.0;
}Langage du code : JavaScript (javascript)Sur l’exemple ci-dessus, isOpen et price sont des variables ; le : nom_du_type après le nom déclare explicitement le type de la variable.
2. Annotation par suffixe numérique
Ajoutez un suffixe de type après une valeur numérique pour définir son type, uniquement applicable aux nombres.
fn main() {
let an_integer = 5i32;
}Langage du code : JavaScript (javascript)Ici, on ne spécifie pas le type via :, mais on indique un entier 32 bits avec le suffixe i32 au nombre assigné.
3. Règles des types par défaut
Sans annotation ni suffixe, le compilateur utilise un type par défaut :
- Littéral entier → par défaut
i32 - Littéral flottant → par défaut
f64
fn main() {
let default_float = 3.0; // automatiquement f64
let default_integer = 7; // automatiquement i32
}Langage du code : JavaScript (javascript)4. Déduction de type contextuelle
Le compilateur peut inférer automatiquement le vrai type de la variable à partir du code suivant, sans annotation manuelle.
fn main() {
let mut inferred_type = 12;
inferred_type = 4294967296i64; // cette ligne déduit que le type est i64
}Langage du code : JavaScript (javascript)Variables mutables & caractéristiques des variables
1 Variable mutable
Variable modifiée par le mot-clé mut, sa valeur peut être modifiée.
fn main() {
let mut mutable = 12;
mutable = 21; // autorisé, modification de la valeur
}Langage du code : JavaScript (javascript)2 Type immuable
Une fois le type d’une variable défini, il ne peut plus changer du tout ; assigner une valeur d’un autre type provoque une erreur de compilation immédiate.
fn main() {
let mut mutable = 12;
mutable = 21; // autorisé, modification de la valeur
mutable = true; // erreur : type initial i32, impossible d’assigner un bool
}Langage du code : JavaScript (javascript)C:\Users\Jack\Desktop\rustdemo>rustc hello.rs
error[E0308]: mismatched types
--> hello.rs:5:12
|
3 | let mut mutable = 12;
| -- expected due to this value
4 | mutable = 21; // autorisé, modification de la valeur
5 | mutable = true; // erreur : type initial i32, impossible d’assigner un bool
| ^^^^ expected integer, found `bool`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0308`.Langage du code : JavaScript (javascript)Attention
En Rust, la valeur d’une variable est immuable par défaut. Si vous voulez la modifier, ajoutez le mot-clé mut ; ce comportement diffère des autres langages.
Par exemple, le code ci-dessous est courant dans d’autres langages mais génère une erreur en Rust
fn main() {
let mutable:i32 = 12;
mutable = 21; // autorisé, modification de la valeur
}Langage du code : JavaScript (javascript)Erreur de compilation
C:\Users\Jack\Desktop\rustdemo>rustc hello.rs
error[E0384]: cannot assign twice to immutable variable `mutable`
--> hello.rs:4:2
|
3 | let mutable:i32 = 12;
| ------- first assignment to `mutable`
4 | mutable = 21; // autorisé, modification de la valeur
| ^^^^^^^^^^^^ cannot assign twice to immutable variable
|
help: consider making this binding mutable
|
3 | let mut mutable:i32 = 12;
| +++
warning: variable `mutable` is assigned to, but never used
--> hello.rs:3:6
|
3 | let mutable:i32 = 12;
| ^^^^^^^
|
= note: consider using `_mutable` instead
= note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
warning: value assigned to `mutable` is never read
--> hello.rs:4:2
|
4 | mutable = 21; // autorisé, modification de la valeur
| ^^^^^^^^^^^^
|
= help: maybe it is overwritten before being read?
= note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
error: aborting due to 1 previous error; 2 warnings emitted
For more information about this error, try `rustc --explain E0384`.Langage du code : JavaScript (javascript)3 Occultation de variable (Shadowing)
Réutiliser let pour déclarer une variable du même nom occulte l’ancienne variable ; ce sont deux variables indépendantes qui peuvent avoir des types différents.
fn main() {
let mutable = 12;
let mutable = true; // occulte la variable i32 du dessus, la nouvelle variable est de type bool
}Langage du code : JavaScript (javascript)Types composés : Tableau & Tuple
1. Tableau
- Syntaxe :
[type_élément; longueur], type et longueur fixes, tous les éléments doivent être du même type.
let my_array: [i32; 5] = [1, 2, 3, 4, 5];Langage du code : JavaScript (javascript)2. Tuple
- Encadré par
(), peut stocker plusieurs valeurs de types différents.
let my_tuple = (5u32, 1u8, true, -5.04f32);Langage du code : JavaScript (javascript)