Variables de rouille

En programmation, une variable fait référence à un conteneur de stockage utilisé pour stocker les valeurs. En termes simples, une variable est un emplacement de stockage nommé où le programme peut stocker et récupérer des données. Bien que le concept fondamental d'une variable soit universel dans tous les langages de programmation, Rust traite un peu les variables différemment.

Dans Rust, une variable est associée à un type spécifique. Le compilateur utilisera le type de données pour déterminer la disposition de la mémoire de la variable et l'espace pour allouer à la variable.

Dans cette course, nous explorerons comment travailler avec des variables dans la rouille et comment les utiliser pour stocker différents types d'informations.

Nommage variable de la rouille

Comme nous l'avons mentionné, une variable est un emplacement de stockage nommé dans un programme. Cela signifie que nous devons créer un identifiant que d'autres parties du programme peuvent référencer.

Bien que nommer quelque chose comme variable peut sembler très trivial, il existe certaines règles auxquelles nous adhérons.

Ceux-ci inclus:

• Un nom de variable ne peut pas commencer par un chiffre ou des caractères spéciaux en dehors d'un soulignement.
• Un nom peut être composé de caractères alphanumériques minuscules ou majuscules ou un soulignement.
• Les noms de variables sont sensibles à la casse en rouille. Par conséquent, l'âge et l'âge des variables ne sont pas les mêmes.
• Bien qu'il ne soit pas une exigence, les règles de dénomination de la rouille définissent une variable locale qui devrait utiliser un cas de serpent pour rejoindre les noms. Par exemple, Total_points au lieu de points totaux.

Ce qui précède est quelques règles de dénomination pour respecter lors du nom d'une variable. Vous pouvez vérifier les règles de dénomination de la rouille dans la ressource ci-dessous:

https: // Rust-Lang.github.IO / API Guidelines / Naming.html

Déclaration variable de la rouille

Nous pouvons déclarer une variable en utilisant le mot-clé LET ou const ou const. Après le mot-clé LET, nous définissons le nom de la variable et son type de données.

La syntaxe est comme indiqué:

LET VARIABLE_NAME: TYPE;

Un exemple de programme avec déclaration variable est le cas indiqué:

fn main ()
Laissez URL:&str;

Ce qui précède déclare une variable appelée URL de type et Str.

Type Annotation in Rust est facultatif. Cela signifie que le compilateur peut déduire le type à partir de la valeur attribuée à la variable.

Un exemple de déclaration variable sans annotation de type est illustré ci-dessous:

fn main ()
Laissez url = "https: // linuxhint.com ";

Le mot-clé const de rouille vous permet de définir les variables des constantes. Contrairement au mot de clé LET, vous devez effectuer l'annotation de type lorsque vous utilisez le mot clé const du const.

Un exemple est comme indiqué:

fn main ()
const Url: & str = "https: // linuxhint.com ";

Nous ne pouvons pas modifier la valeur d'une valeur constante plus tard dans le programme après la déclaration. Une constante vivra également pour la durée de vie du programme et n'a pas d'adresse de mémoire fixe.

NOTE: Les constantes sont fondamentalement immuables, contrairement à ne supporte pas le mot-clé Mut. Vérifiez les sections de mutabilité variables pour en savoir plus.

Deuxième: La valeur d'une constante doit être, bien, constante. Ne définissez pas la valeur d'une variable const sur une expression à évaluer au moment de l'exécution.

Troisième: Bien qu'ils suivent les règles de dénomination variable. Les constantes utilisent Screaming_snake_case pour leurs noms.

Mutabilité variable de la rouille

Dans Rust, les variables sont des objets immuables par défaut. Cela signifie que nous ne pouvons pas modifier leurs valeurs après la déclaration.

Prenez l'exemple ci-dessous:

fn main ()
Laissez url = "https: // linuxhint.com ";
url = "https: // google.com ";

Si nous compilons le code ci-dessus, nous devons obtenir une erreur comme indiqué ci-dessous:

La sortie ci-dessus montre que le compilateur n'autorise pas la réaffectation des variables par défaut.

Cependant, Rust vous permet de créer des variables mutables. Vous pouvez utiliser le mot clé Mut pendant la déclaration de fonction pour le rendre mutable.

Considérez l'exemple ci-dessous:

fn main ()
Laissez mut url = "https: // linuxhint.com ";
url = "https: // google.com ";

Le programme ci-dessus crée une variable mutable appelée URL. Nous pouvons maintenant réaffecter sa valeur plus tard dans le programme.

Ombrage variable de la rouille

Rust offre une fonctionnalité connue sous le nom d'observation; Eh bien, la plupart des Rustacés le référent à cela. Il s'agit d'une fonctionnalité dans laquelle vous pouvez déclarer une variable avec le même nom qu'une variable qui a déjà été déclarée et définir une nouvelle valeur ou un nouveau type.

J'aime à le considérer comme un moyen d'introduire une mutabilité temporaire à une variable.

Prenez l'exemple de programme ci-dessous:

fnmain ()
letUrl = "https: // linuxhint.com ";

// la deuxième variable ombrage le premier
letUrl = "https: // google.com ";
println!("", url);

println!("", url);

Dans le programme ci-dessus, nous déclarons une variable immuable appelée URL dans la portée globale. Nous créons ensuite une portée intérieure qui redéclare la variable URL et lui attribue une nouvelle valeur. La variable URL dans la portée intérieure ombarde la variable globale dans ce cas.

Si nous exécutons le programme ci-dessus, nous devrions obtenir une sortie comme:

Gardez à l'esprit que l'observation variable diffère de la mutabilité variable. Ceci est dû au fait,

• Nous créons une nouvelle variable lors de l'utilisation du mot-clé LET.
• Cette fonctionnalité est volatile et la fonction reste immuable mais avec une nouvelle valeur.

Fermeture

Nous avons exploré comment les variables fonctionnent dans le langage de programmation de rouille. Continuez à pratiquer ou consultez la documentation pour en savoir plus.