Ce sont des valeurs booléennes courantes qui peuvent être vraies ou fausses.

personnage

Ce type est caractérisé par la largeur de bits. La longueur maximale prise en charge par Rust est de 128 bits.

Un entier signé de taille variable (la taille dépend de la taille du pointeur sous-jacent).

Entier non signé de taille variable (la taille dépend de la taille du pointeur sous-jacent).

type à virgule flottante f32 bits

Type à virgule flottante f64 bits

Un tableau de taille fixe, T représente le type d'élément, N représente le nombre d'éléments et est une constante non négative au moment de la compilation.

Une vue dimensionnée dynamiquement d’une séquence contiguë, T représentant n’importe quel type.

Découpage de chaînes, principalement utilisé comme référence, c'est-à-dire &str

Les séquences finies, T et U peuvent être de types différents.

Une fonction qui reçoit un paramètre de type i32 et renvoie un paramètre de type i32. Les fonctions ont également un type.

fn ajouter (a : u64, b : u64) -> u64 { un B } fn main() { soit a : u64 = 17 ; soit b = 3; soit result = add(a, b); println!("Résultat {}", résultat); }

fn main() { soit doubler = |x| x * 2; soit valeur = 5 ; soit deux fois = doubler (valeur); println!("{} doublé est {}", valeur, deux fois); laissez big_closure = |b, c| soit z = bc; z * deux fois } ; let some_number = big_closure(1, 2); println!("Résultat de la fermeture : {}", some_number); }

fn main() { let question = "Comment vas-tu ?"; let person: String = "Bob".to_string(); let namaste = String::from("zd"); println!("{}! {} {}", namaste, question, personne); }

Dans le code ci-dessus, le type de personne et le nom sont String et le type de question est &str. Il existe de nombreuses façons de créer des données de type String. Les données de type chaîne sont allouées sur le tas. Les données de type &str sont généralement un pointeur vers une chaîne existante. Ces chaînes se trouvent sur la pile et le tas, ou elles peuvent être des chaînes dans le segment de données du code objet compilé.

fn main() { laissez rust_is_awesome = true ; si rust_is_awesome { println!("En effet"); } autre { println!("Eh bien, tu devrais essayer Rust!"); } }

fn main() { soit résultat = si 1 == 2 { "Attends quoi?" } autre { "La rouille a du sens" } ; println!("Tu sais quoi ? {}.", résultat); }

Lorsque la valeur à attribuer est renvoyée par l'expression if else, nous devons utiliser un point-virgule comme marque de fin. Par exemple, if est une expression, alors let est une instruction qui s'attend à ce que nous ayons un point-virgule à la fin.

fn req_status() -> u32 { 200 } fn main() { let status = req_status(); statut du match { 200 => println!("Succès"), 404 => println!("Introuvable"), autre => { println!("La demande a échoué avec le code : {}", autre); } } }

fn main() { soit mut x = 1024 ; boucle { si x < 0 { casser; } println!("{} encore des courses à faire", x); x-= 1 ; } }

fn silly_sub(a : i32, b : i32) -> i32 { soit mut résultat = 0 ; 'incrément : boucle { si résultat == a { soit mut déc = b; 'décrémenter : boucle { ifdec==0{ casser 'incrément; } autre { résultat -= 1 ; décembre -= 1 ; } } } autre { résultat = 1 ; } } résultat } fn main() { soit a = 10 ; soit b = 4; soit result = silly_sub(a, b); println!("{} moins {} est {}", a, b, résultat); }

fn main() { print!("Plage normale : "); pour moi dans 0..10 { imprimer!("{},", je); } println!(); print!("Plage incluse : "); pour je dans 0..=10 { imprimer!("(),", je); } }

Dans Rust, il existe trois formes de déclaration de structure. La plus simple d'entre elles est la structure unitaire, qui est déclarée à l'aide du mot-clé struct, suivi de son nom et se terminant par un point-virgule.

La deuxième forme de structure est la structure tuple, à laquelle sont associées des données. Chacun de ces champs n'est pas nommé, mais est référencé en fonction de sa position dans la définition.

Les structures de tuples sont idéales lors de la modélisation de données avec moins de 5 attributs. Tout choix autre que celui-ci entravera la lisibilité et le raisonnement du code. Pour les types de données comportant plus de 3 champs, construisez des structures en utilisant un langage de type C. Il s'agit du troisième formulaire et du formulaire le plus couramment utilisé.

Les énumérations sont un bon moyen de procéder lorsque vous devez modéliser différents types de choses. Il est créé à l'aide du mot-clé enum, suivi du nom de l'énumération et d'une paire d'accolades. À l’intérieur des accolades, nous pouvons écrire tous les types possibles, c’est-à-dire les variantes. Ces variantes peuvent être définies avec ou sans données, et les données contenues peuvent être de n'importe quel type far, structure, structure de tuple ou même un type d'énumération.

Nous pouvons ajouter un comportement à une structure définie en utilisant deux mécanismes : des fonctions de type constructeur et des méthodes getter et setter.

Les énumérations sont largement utilisées dans les machines à états et, lorsqu'elles sont utilisées avec des expressions de correspondance, elles peuvent rendre le code de transition d'état très concis. Ils peuvent également être utilisés pour la modélisation de types d’erreurs personnalisés.

Chaque programme Rust nécessite un module racine. Pour les fichiers exécutables, il s'agit généralement du fichier main.rs, et pour les bibliothèques, il s'agit généralement du fichier lib.rs.

Les modules peuvent être déclarés dans d'autres modules ou organisés en fichiers et répertoires.

Pour que le compilateur reconnaisse notre module, nous devons utiliser le mot-clé mod déclaration. Dans notre module racine, nous devons utiliser le mot-clé use avant le nom du module, ce qui signifie amener l'élément dans la portée.

Les éléments définis dans un module sont privés par défaut et doivent être exposés aux appelants à l'aide du mot-clé pub.

Les tableaux ont une longueur fixe et peuvent stocker des éléments du même type. Ils sont représentés par [T, N], où T représente n'importe quel type et N représente le nombre d'éléments du tableau. La taille du tableau ne peut pas être représentée par une variable et doit être une valeur littérale de usize.

sous-thème