Rust les bases : Les Types de donées partie 1 Cours 4

Nous allons continuez avec les types de données histoire de comprendre mieux certaines chose .

Alors il faut savoir que chaque valeur dans Rust est d’un certains type de donnée ce qui indique ainsi au Rust quel type de donnée est spécifiée comme l'on peux le voire sur la figure ci-déçue. Ainsi nous allons voir 2 sous ensemble de type de données : Les Scalaire & les Composés .

Nb : Le Rust est un Langage à typage statique cet à dire qu’il doit connaitre les types de toutes les variables au moment de la compilation.Tout de même comme j’ai évoquez dans le chapitre 2 le compilateur peut déduire le type que nous voulons utilisez en fonction bien sure de la valeur et de la manière dont nous l’utilisons , en gros en fonction du contexte.

Les Entiers

Tout doucement commencons par les Entiers : un Entier est un nombre sans composante fractionnaire . En gros des nombres sans virgule. Illustrons tout ceci par un exemple en déclarants deux variables Entières notées varEnt et varEnt2 ou varEnt seras représente implicitement et varEnt2 seras représente explicitement .

println! ("A LES ENTIERS ") ;

let monEnt = 5 ; // implicite
println!("Le contenue de votre variable est :{}", monEnt );
let monEnt2:u32 = 5 ; // explicite
println!("Le contenue de votre variable est :{}", monEnt2 );

Alors cette déclaration ( déclaration explicite )de type indique que la valeur à laquelle il est associée doit être un entier non signé qui prend 32 bits d’espace. Notez que les types d’entiers signés commencent par i au lieu de u qui évoque les types d’entiers non signés . Voici un tableau qui montre les différents types d’entiers intégrés dans rust . Notez de manière indicatif que chaque variante dans les colonnes signé et Non Signé peut être utilisée pour déclarer le type d’une valeur entière.

Length ( Taille )	Signed ( Signé )	Unsigned ( Non Signé )
8-bit	i8	u8
16-bit	i16	u16
64-bit	i64	u64
128-bit	i128	u128
Arch	isize	usize

Figure : Classification des Types d’entiers en Rust

Pour la dernier ligne j’explique vite fait bien fait avant que vous essayez en vain de comprendre du moins pour la plupart , Eh bien les types isize et usize vont dépendre du type d’ordinateur sur lequel votre programme fonctionne : 64 bits si vous êtes sur une architecture 64 bits et 32 bits si vous êtes sur une architecture 32 bits notez que se servira généralement lors de l’indexation d’une collection qui seras traitez plus tard.

Les Flottants

Alors Concernant les Flottants , ce sont tout simplement des nombres à virgule flottantes ou encore des nombres a poids décimaux on en distingue deux le f32 et le f64 qui sont respectivement sur 32 bits et 64 bits . Le type par défaut est f64 bits , mais le f32 est plus rapide que celui-ci du moins de mon point de vue.
Illustrations :

println! ("B LES FLOTTANTS ") ;

let monFlot = 5.1 ; // implicite
println!("Le contenue de votre variable est :{}", monFlot );
let monFlot2:f32 = 5.1 ; // explicite
println!("Le contenue de votre variable est :{}", monFlot2 );

Les Booléens

Alors un type Booleen est un type de variable à deux états, destiné à représenter les valeurs de vérité de la logique et l'algèbre booléenne. Un rust un booléen à deux valeurs possibles true ou false , ils ont une taillle d’un octet et sont repésentés par le mot clé Bool .
Illustration :

println! ("C LES BOOLEENS ") ;

let monBool = false ; // implicite
println!("Le contenue de votre variable est :{}", monBool);
let monBool2:bool = true ; // explicite
println!("Le contenue de votre variable est :{}", monBool2 );

Les Caractères

Le type caractère en rust est le type alphabétique le plus primitif de notre langue en gros les lettres de l’alphabet quoi !
Illustration :

println! ("D LES CARACTERES ") ;

let monCar = 'j' ; // implicite
println!("Le contenue de votre variable est :{}", monCar );
let monCar2 = ' ' ; // explicite
println!("Le contenue de votre variable est :{}", monCar2 );
let monCar2 = ' ' ; // explicite
println!("Le contenue de votre variable est :{}", monCar2 );