Rust - Types de données

Le système de types représente les différents types de valeurs pris en charge par la langue. Le système de types vérifie la validité des valeurs fournies avant qu'elles ne soient stockées ou manipulées par le programme. Cela garantit que le code se comporte comme prévu. Le système de types permet en outre des indications de code plus riches et une documentation automatisée.

Rust est un langage typé statiquement. Chaque valeur de Rust est d'un certain type de données. Le compilateur peut déduire automatiquement le type de données de la variable en fonction de la valeur qui lui est assignée.

Déclarer une variable

Utilisez le let mot-clé pour déclarer une variable.

fn main() {
   let company_string = "TutorialsPoint";  // string type
   let rating_float = 4.5;                 // float type
   let is_growing_boolean = true;          // boolean type
   let icon_char = '♥';                    //unicode character type

   println!("company name is:{}",company_string);
   println!("company rating on 5 is:{}",rating_float);
   println!("company is growing :{}",is_growing_boolean);
   println!("company icon is:{}",icon_char);
}

Dans l'exemple ci-dessus, le type de données des variables sera déduit des valeurs qui leur sont affectées. Par exemple, Rust attribuera un type de données chaîne à la variable company_string , un type de données float à rating_float , etc.

Le println! macro prend deux arguments -

Une syntaxe spéciale {} , qui est l'espace réservé
Le nom de la variable ou une constante

L'espace réservé sera remplacé par la valeur de la variable

La sortie de l'extrait de code ci-dessus sera -

company name is: TutorialsPoint
company rating on 5 is:4.5
company is growing: true
company icon is: ♥

Types scalaires

Un type scalaire représente une valeur unique. Par exemple, 10,3.14, «c». Rust a quatre types scalaires principaux.

Integer
Floating-point
Booleans
Characters

Nous en apprendrons davantage sur chaque type dans nos sections suivantes.

Entier

Un entier est un nombre sans composante fractionnaire. En termes simples, le type de données entier est utilisé pour représenter des nombres entiers.

Les entiers peuvent être classés comme signés et non signés. Les entiers signés peuvent stocker des valeurs négatives et positives. Les entiers non signés ne peuvent stocker que des valeurs positives. Une description détaillée si les types entiers sont donnés ci-dessous -

N ° Sr.	Taille	Signé	Non signé
1	8 bits	i8	u8
2	16 bits	i16	u16
3	32 bits	i32	u32
4	64 bits	i64	u64
5	128 bits	i128	u128
6	Cambre	isize	utiliser

La taille d'un entier peut être arch . Cela signifie que la taille du type de données sera dérivée de l' architecture de la machine. Un entier dont la taille est arch sera de 32 bits sur une machine x86 et de 64 bits sur une machine x64. Un entier arch est principalement utilisé lors de l'indexation d'une sorte de collection.

Illustration

fn main() {
   let result = 10;    // i32 by default
   let age:u32 = 20;
   let sum:i32 = 5-15;
   let mark:isize = 10;
   let count:usize = 30;
   println!("result value is {}",result);
   println!("sum is {} and age is {}",sum,age);
   println!("mark is {} and count is {}",mark,count);
}

La sortie sera comme indiqué ci-dessous -

result value is 10
sum is -10 and age is 20
mark is 10 and count is 30

Le code ci-dessus renverra une erreur de compilation si vous remplacez la valeur de l' âge par une valeur à virgule flottante.

Plage d'entiers

Chaque variante signée peut stocker des nombres de - (2 ^ (n-1) à 2 ^ (n-1) -1 , où n est le nombre de bits utilisé par la variante. Par exemple, i8 peut stocker des nombres de - (2 ^ 7) à 2 ^ 7 -1 - ici nous avons remplacé n par 8.

Chaque variante non signée peut stocker des nombres de 0 à (2 ^ n) -1 . Par exemple, u8 peut stocker des nombres de 0 à 2 ^ 7 , ce qui est égal à 0 à 255.

Débordement d'entier

Un dépassement d'entier se produit lorsque la valeur affectée à une variable entière dépasse la plage définie par Rust pour le type de données. Comprenons cela avec un exemple -

fn main() {
   let age:u8 = 255;

   // 0 to 255 only allowed for u8
   let weight:u8 = 256;   //overflow value is 0
   let height:u8 = 257;   //overflow value is 1
   let score:u8 = 258;    //overflow value is 2

   println!("age is {} ",age);
   println!("weight is {}",weight);
   println!("height is {}",height);
   println!("score is {}",score);
}

La plage valide de la variable u8 non signée est comprise entre 0 et 255. Dans l'exemple ci-dessus, les variables reçoivent des valeurs supérieures à 255 (limite supérieure pour une variable entière dans Rust). Lors de l'exécution, le code ci-dessus renverra un avertissement -warning − literal out of range for u8pour les variables de poids, de taille et de score. Les valeurs de dépassement après 255 commenceront à partir de 0, 1, 2, etc. La sortie finale sans avertissement est comme indiqué ci-dessous -

age is 255
weight is 0
height is 1
score is 2

Flotte

Le type de données Float dans Rust peut être classé comme f32 et f64. Le type f32 est un flotteur simple précision et f64 a une double précision. Le type par défaut est f64. Considérez l'exemple suivant pour en savoir plus sur le type de données float.

fn main() {
   let result = 10.00;        //f64 by default
   let interest:f32 = 8.35;
   let cost:f64 = 15000.600;  //double precision
   
   println!("result value is {}",result);
   println!("interest is {}",interest);
   println!("cost is {}",cost);
}

La sortie sera comme indiqué ci-dessous -

interest is 8.35
cost is 15000.6

Coulée de type automatique

La fonte de type automatique n'est pas autorisée dans Rust. Considérez l'extrait de code suivant. Une valeur entière est affectée à la variable floatinterest.

fn main() {
   let interest:f32 = 8;   // integer assigned to float variable
   println!("interest is {}",interest);
}

Le compilateur lance un mismatched types error comme indiqué ci-dessous.

error[E0308]: mismatched types
   --> main.rs:2:22
   |
 2 | let interest:f32=8;
   |    ^ expected f32, found integral variable
   |
   = note: expected type `f32`
      found type `{integer}`
error: aborting due to previous error(s)

Séparateur de nombres

Pour une lisibilité facile des grands nombres, nous pouvons utiliser un séparateur visuel _ souligné pour séparer les chiffres. C'est-à-dire 50 000 peut être écrit comme 50_000. Ceci est illustré dans l'exemple ci-dessous.

fn main() {
   let float_with_separator = 11_000.555_001;
   println!("float value {}",float_with_separator);
   
   let int_with_separator = 50_000;
   println!("int value {}",int_with_separator);
}

La sortie est donnée ci-dessous -

float value 11000.555001
int value 50000

Booléen

Les types booléens ont deux valeurs possibles: true ou false . Utilisez lebool mot-clé pour déclarer une variable booléenne.

Illustration

fn main() {
   let isfun:bool = true;
   println!("Is Rust Programming Fun ? {}",isfun);
}

La sortie du code ci-dessus sera -

Is Rust Programming Fun ? true

Personnage

Le type de données caractère dans Rust prend en charge les nombres, les alphabets, Unicode et les caractères spéciaux. Utilisez lecharmot-clé pour déclarer une variable de type de données caractère. Le type char de Rust représente une valeur scalaire Unicode, ce qui signifie qu'il peut représenter beaucoup plus qu'un simple ASCII. Les valeurs scalaires Unicode vont deU+0000 à U+D7FF et U+E000 à U+10FFFF compris.

Prenons un exemple pour en savoir plus sur le type de données Character.

fn main() {
   let special_character = '@'; //default
   let alphabet:char = 'A';
   let emoji:char = '';
   
   println!("special character is {}",special_character);
   println!("alphabet is {}",alphabet);
   println!("emoji is {}",emoji);
}

La sortie du code ci-dessus sera -

special character is @
alphabet is A
emoji is

↰ Previous page Next page ↱

Rust - Types de données

Déclarer une variable

Types scalaires

Entier

Illustration

Plage d'entiers

Débordement d'entier

Flotte

Coulée de type automatique

Séparateur de nombres

Booléen

Illustration

Personnage

Tutoriel Rust