Littéral : ce sont des données constantes écrites directement dans le code, dont on voit immédiatement la valeur, c’est la forme de représentation de données la plus basique d’un programme.
La valeur est fixe et immuable, écrite en dur dans le code, elle ne peut pas changer pendant l’exécution ; aucun calcul ni analyse de variable n’est nécessaire, le terme signifie littéralement « valeur écrite telle quelle ».
Exemple : les nombres 13 et 3,14 ci-dessous sont des littéraux, on les appelle aussi valeurs littérales dans d’autres langages.
fn main() {
println!("{}", 13);
println!("{}", 3.14);
}Langage du code : JavaScript (javascript)Pour faciliter l’apprentissage, l’équipe officielle propose un éditeur Rust en ligne. Pas besoin d’installer d’environnement local pour pratiquer les syntaxes basiques de Rust, cliquez sur le lien ci-dessous
Les littéraux
Rust prend en charge les littéraux de ces types : entier, nombre à virgule flottante, caractère, chaîne de caractères, booléen, unité (unit).
- Entier :
11 - Caractère :
'a'(guillemets simples) - Chaîne :
"abc"(guillemets doubles) - Booléen :
true/false - Type unité :
()
Différentes bases pour les entiers
On distingue les bases grâce à un préfixe, valide uniquement pour les entiers :
- Hexadécimal : début par
0x, ex :0x1F - Octal : début par
0o, ex :0o77 - Binaire : début par
0b, ex :0b1010
Séparateur numérique
On peut insérer un trait bas _ dans les littéraux numériques pour améliorer la lisibilité, cela ne modifie pas la valeur réelle :
- Entier :
1_000=1000 - Flottant :
0.000_001=0.000001
Notation scientifique
Les nombres flottants acceptent la notation scientifique avec E, leur type par défaut est f64 :
1e6= 10000007.6e-4= 0,00076
Suffixes de type des littéraux (essentiel)
Rust impose de préciser le type des littéraux, voici les suffixes courants :
u32: entier non signé 32 bits (valeurs positives ou nulles uniquement)i32: entier signé 32 bits (positifs et négatifs autorisés)
Attention : on ne peut pas mélanger des entiers signés et non signés dans des calculs, cela provoque immédiatement une erreur.
Exemple :
fn main() {
// 1. Littéral entier simple
println!("Entier: {}", 13);
// Entiers binaire, octal, hexadécimal
println!("Binaire: {}", 0b1010);
println!("Octal: {}", 0o77);
println!("Hexadécimal: {}", 0x2A);
// Entier avec séparateur (meilleure lisibilité)
println!("Entier avec underscore: {}", 1_000_000);
// Entier avec suffixe de type
println!("Entier u32 non signé: {}", 100u32);
println!("Entier i32 signé: {}", -50i32);
// 2. Littéral flottant
println!("Flottant: {}", 3.14);
// Flottant avec underscore
println!("Flottant avec underscore: {}", 0.000_001);
// Flottant en notation scientifique
println!("Notation scientifique: {}", 1e6);
println!("Notation scientifique négative: {}", 7.6e-4);
// 3. Littéral chaîne (guillemets doubles)
println!("Chaîne: {}", "hello world");
// 4. Littéral caractère (guillemets simples, un seul caractère uniquement)
println!("Caractère: {}", 'a');
println!("Caractère chinois: {}", '中');
// 5. Littéral booléen
println!("Booléen true: {}", true);
println!("Booléen false: {}", false);
// 6. Littéral unité () (type unité de Rust)
println!("Type unité: {:?}", ());
}Langage du code : JavaScript (javascript)Les opérateurs
Les règles et priorités des opérateurs Rust sont identiques à celles des langages de type C.
1. Opérateurs arithmétiques
Opérations basiques comme l’addition et la soustraction, à utiliser avec les suffixes de type des entiers :
- Addition :
+ - Soustraction :
-
2. Opérateurs logiques booléens (court-circuit)
Ne fonctionnent que sur des valeurs booléennes true/false :
- Et
&&: résultat true uniquement si les deux côtés valent true - Ou
||: résultat true si au moins un côté vaut true - Non
!: inverse la valeur booléenne
| Expression | Résultat du calcul |
|---|---|
| true && true | true |
| true && false | false |
| false && true | false |
| false && false | false |
| true || true | true |
| true || false | true |
| false || true | true |
| false || false | false |
| !true | false |
| !false | true |
3. Opérateurs binaires (manipulation des bits)
Surtout utilisés sur les entiers, l’exemple utilise {:04b} pour afficher un nombre binaire sur 4 bits formaté :
- ET bit à bit
&: le bit résultat vaut 1 si les deux bits de même position valent 1 - OU bit à bit
|: le bit résultat vaut 1 si au moins un bit de même position vaut 1 - OU exclusif bit à bit
^: le bit résultat vaut 1 si les bits de même position sont différents, sinon 0 - Décalage gauche
<<: décaler tous les bits vers la gauche (équivaut à ×2ⁿ) - Décalage droit
>>: décaler tous les bits vers la droite (équivaut à ÷2ⁿ)
0 0 1 1
& 0 1 0 1
-----------
0 0 0 1
0 0 1 1
| 0 1 0 1
-----------
0 1 1 1
0 0 1 1
^ 0 1 0 1
-----------
0 1 1 0
Décalage gauche <<
Binaire : 00000001
Décalage de 5 bits → 00100000, résultat = 32
Décalage droit >>
0x80 binaire : 10000000
Décalage de 2 bits → 00100000 (hexadécimal 0x20), résultat = 32fn main() {
// ========== Opérateurs arithmétiques ==========
// Addition d'entier : u32 entier 32 bits non signé
// Résultat : 1 + 2 = 3
println!("1 + 2 = {}", 1u32 + 2);
// Soustraction d'entier : i32 entier 32 bits signé, supporte les négatifs
// Si on remplace par 1u32, erreur : un entier non signé ne peut pas représenter un nombre négatif
// Résultat : 1 - 2 = -1
println!("1 - 2 = {}", 1i32 - 2);
// ========== Littéraux flottants - notation scientifique ==========
// Résultat : 1e4 vaut 10000, -2.5e-3 vaut -0.0025
println!("1e4 vaut {}, -2.5e-3 vaut {}", 1e4, -2.5e-3);
// ========== Opérateurs logiques booléens (court-circuit) ==========
// ET logique && : résultat true uniquement si les deux côtés sont true
// Résultat : true ET false = false
println!("true ET false = {}", true && false);
// OU logique || : résultat true si un côté est true
// Résultat : true OU false = true
println!("true OU false = {}", true || false);
// NON logique ! : inverse une valeur booléenne
// Résultat : NON true = false
println!("NON true = {}", !true);
// ========== Opérateurs binaires (manipulation de bits) ==========
// {:04b} affiche systématiquement 4 bits binaires, complétés par 0 à gauche si besoin
// ET bit à bit & : bit résultat à 1 si les deux bits correspondants sont à 1
// Résultat : 0011 ET bit à bit 0101 = 0001
println!("0011 ET bit à bit 0101 = {:04b}", 0b0011u32 & 0b0101);
// OU bit à bit | : bit résultat à 1 si un bit correspondant est à 1
// Résultat : 0011 OU bit à bit 0101 = 0111
println!("0011 OU bit à bit 0101 = {:04b}", 0b0011u32 | 0b0101);
// OU exclusif bit à bit ^ : bit résultat à 1 si les bits correspondants sont différents
// Résultat : 0011 OU exclusif bit à bit 0101 = 0110
println!("0011 OU exclusif bit à bit 0101 = {:04b}", 0b0011u32 ^ 0b0101);
// Décalage gauche << : décaler l'ensemble des bits de 5 positions vers la gauche
// Résultat : 1 décalé de 5 bits à gauche = 32
println!("1 décalé de 5 bits à gauche = {}", 1u32 << 5);
// Décalage droit >> : décaler l'ensemble des bits de 2 positions vers la droite, {:x} affichage hexadécimal
// Résultat : 0x80 décalé de 2 bits à droite = 0x20
println!("0x80 décalé de 2 bits à droite = 0x{:x}", 0x80u32 >> 2);
// ========== Séparateur numérique _ ==========
// L’underscore améliore seulement la lisibilité, sans modifier la valeur
// Résultat : Un million s’écrit : 1000000
println!("Un million s’écrit : {}", 1_000_000u32);
}Langage du code : JavaScript (javascript)III. Compléments sur l’exécution du code
- Remplacer
1i32par1u32et effectuer la soustraction1u32 - 2génère une erreur : un entier non signé ne peut pas représenter de nombres négatifs. {:04b}: syntaxe de formatage,bsignifie binaire,04complète par des zéros à gauche si moins de 4 bits.- On conseille d’utiliser l’underscore pour les grands nombres (ex :
1_000_000u32) afin de rendre le code plus lisible.