Grammaire de base Rust

Variable, types de base, fonctions, commentaires et flux de contrôle, ces concepts de programmation sont presque présents dans chaque langage de programmation.

Ces concepts de base existeront dans chaque programme Rust, et apprendre tôt ces concepts vous permettra d'apprendre l'utilisation de Rust le plus rapidement possible.

Variable

Il faut d'abord expliquer que Rust est un langage de type fort, mais il a la capacité de juger automatiquement le type des variables. Cela peut prêter à confusion avec les langages de type faible.

Pour déclarer une variable, il faut utiliser la clé let. Par exemple :

let a =　123;

Les développeurs qui n'ont appris que JavaScript sont très sensibles à cette phrase, tandis que les développeurs qui n'ont appris que le langage C ne la comprennent pas du tout.

Après cette déclaration, les trois lignes de code suivantes sont interdites :

a = "abc";
a =　4.56;　
a =　456;

L'erreur de la première ligne réside dans le fait que a est déclaré 123 À partir de maintenant, a est déterminé comme un nombre entier, il ne peut pas être assigné une valeur de type chaîne.

L'erreur de la deuxième ligne réside dans la perte de précision lors de la conversion automatique des nombres, Rust ne permet pas la conversion automatique des types de données avec perte de précision.

L'erreur de la troisième ligne réside dans le fait que a n'est pas une variable modifiable.

Les deux premiers types d'erreurs sont faciles à comprendre, mais qu'est-ce que le troisième signifie ? a n'est pas un variable, n'est-ce pas ?

Cela implique la conception de Rust pour la sécurité haute concurrence : au niveau du langage, essayer de limiter au maximum la modification des valeurs des variables. Par conséquent, la valeur de a est immuable. Cela ne signifie pas que a n'est pas un "variable" (variable en anglais), le document officiel le nomme "variable immuable".

Si une partie de notre programme s'exécute en supposant que certaines valeurs ne changeront jamais, tandis que l'autre partie du code change cette valeur, la première partie du code peut ne pas fonctionner comme prévu. Pour cette raison, les erreurs causées sont difficiles à trouver après coup. C'est pour cette raison que Rust a conçu ce mécanisme.

Bien sûr, rendre une variable "modifiable" (mutable) nécessite simplement une clé mut.

let mut a =　123;
a =　456;

Ce programme est correct.

Différence entre constante et variable immuable

Puisque les variables immuables sont immuables, n'est-ce pas une constante ? Pourquoi l'appeler une variable ?

Il y a une différence entre les variables et les constantes. Dans Rust, le programme suivant est légal :

let a =　123;
let a =　456;

Mais si a est une constante, cela est illégal :

const a: i32　=　123;
let a =　456;

La valeur d'une variable peut être "reliée" (rebinding), mais elle ne peut pas être modifiée avant de le faire, ce qui assure que le compilateur peut raisonnablement déduire la logique du programme après chaque "liaison". Bien que Rust ait la fonction de jugement automatique du type, il est plus pratique de déclarer le type dans certains cas :

let a: u64　=　123;

Ici, a est déclaré comme non signé 64 Variable de type entier binaire, si elle n'est pas déclarée avec un type, a sera automatiquement jugé comme signé 32 Variable de type entier binaire, ce qui a un grand impact sur la plage de valeurs de a.

Shadowing

Le concept de shadowing est différent de celui de "override" ou de "overload" dans les langages orientés objet. Le shadowing est ce que l'on appelle "rebinding", et pourquoi pas pour le remplacer sans avoir à introduire ce concept.

Le shadowing fait référence au mécanisme où le nom d'une variable peut être réutilisé :

fn main() {
　　　　let x =　5;
　　　　let x = x　+　1;
　　　　let x = x　*　2;
　　　　println!("La valeur de x est : {}", x);
}

Le résultat de l'exécution de ce programme :

La valeur de x est :　12

Le shadowing et l'affectation des variables mutables ne sont pas la même chose. Le shadowing signifie qu'un même nom peut représenter une autre entité de variable, dont le type, les attributs de mutabilité et la valeur peuvent changer. Cependant, l'affectation des variables mutables ne peut que changer la valeur.

let mut s = "123";
s = s.len();

Ce programme peut générer des erreurs : il est impossible d'affecter une valeur entière à une variable de chaîne.