Rouille - Constante

Les constantes représentent des valeurs qui ne peuvent pas être modifiées. Si vous déclarez une constante, il n'y a aucun moyen que sa valeur change. Le mot clé pour utiliser les constantes estconst. Les constantes doivent être typées explicitement. Voici la syntaxe pour déclarer une constante.

const VARIABLE_NAME:dataType = value;

Convention de dénomination des constantes de rouille

La convention de dénomination des constantes est similaire à celle des variables. Tous les caractères d'un nom constant sont généralement en majuscules. Contrairement à la déclaration de variables, lelet Le mot clé n'est pas utilisé pour déclarer une constante.

Nous avons utilisé des constantes dans Rust dans l'exemple ci-dessous -

fn main() {
   const USER_LIMIT:i32 = 100;    // Declare a integer constant
   const PI:f32 = 3.14;           //Declare a float constant

   println!("user limit is {}",USER_LIMIT);  //Display value of the constant
   println!("pi value is {}",PI);            //Display value of the constant
}

Variables constantes v / s

Dans cette section, nous découvrirons les facteurs de différenciation entre les constantes et les variables.

• Les constantes sont déclarées en utilisant le const mot-clé tandis que les variables sont déclarées à l'aide du let mot-clé.

• Une déclaration de variable peut éventuellement avoir un type de données tandis qu'une déclaration de constante doit spécifier le type de données. Cela signifie que const USER_LIMIT = 100 entraînera une erreur.

• Une variable déclarée à l'aide du letLe mot-clé est par défaut immuable. Cependant, vous avez la possibilité de le faire muter en utilisant lemutmot-clé. Les constantes sont immuables.

• Les constantes peuvent être définies uniquement sur une expression constante et non sur le résultat d'un appel de fonction ou de toute autre valeur qui sera calculée au moment de l'exécution.

• Les constantes peuvent être déclarées dans n'importe quelle portée, y compris la portée globale, ce qui les rend utiles pour les valeurs que de nombreuses parties du code doivent connaître.

Ombrage des variables et des constantes

Rust permet aux programmeurs de déclarer des variables avec le même nom. Dans un tel cas, la nouvelle variable remplace la variable précédente.

Comprenons cela avec un exemple.

fn main() {
   let salary = 100.00;
   let salary = 1.50 ; 
   // reads first salary
   println!("The value of salary is :{}",salary);
}

Le code ci-dessus déclare deux variables par le nom salaire. La première déclaration se voit attribuer une valeur de 100,00 tandis que la deuxième déclaration reçoit une valeur de 1,50. La seconde variable masque ou masque la première variable lors de l'affichage de la sortie.

Production

The value of salary is :1.50

Rust prend en charge les variables avec différents types de données lors de l'observation.

Prenons l'exemple suivant.

Le code déclare deux variables par le nom uname. La première déclaration se voit attribuer une valeur de chaîne, tandis que la deuxième déclaration se voit attribuer un entier. La fonction len renvoie le nombre total de caractères dans une valeur de chaîne.

fn main() {
   let uname = "Mohtashim";
   let uname = uname.len();
   println!("name changed to integer : {}",uname);
}

Production

name changed to integer: 9

Contrairement aux variables, les constantes ne peuvent pas être ombrées. Si les variables du programme ci-dessus sont remplacées par des constantes, le compilateur lèvera une erreur.

fn main() {
   const NAME:&str = "Mohtashim";
   const NAME:usize = NAME.len(); 
   //Error : `NAME` already defined
   println!("name changed to integer : {}",NAME);
}