Rust est un langage puissant, mais par où commencer? Si vous êtes habitué à une autre langue, vous voudrez savoir comment Rust traite ces concepts familiers.
Depuis sa sortie en 2015, Rust est devenu l'un des langages de programmation préférés des développeurs. Rust offre d'excellentes fonctionnalités de performances et de sécurité avec une syntaxe intuitive et concise qui rend le langage souhaitable.
Rust est adapté à la création de divers programmes, notamment des applications Web, des outils de ligne de commande et des services réseau. Rust inclut de nombreuses fonctionnalités que vous attendez d'un langage de programmation moderne, comme la concurrence, l'inférence de type, etc.
Premiers pas avec Rust
Rust est un langage de programmation multiplateforme qui s'exécute sur la plupart des systèmes d'exploitation. Pour commencer avec Rust, rendez-vous sur le site officiel Site Web de Rust et installez la version préférée pour votre système d'exploitation.
Une fois que vous avez installé Rust, vous pouvez commencer à écrire des programmes dans des fichiers Rust avec un
.rs extension. Rust est polyvalent et facile à apprendre. Vous le trouverez simple si vous avez une expérience préalable en programmation.Variables et constantes dans Rust
Rust est très expressif et il existe plusieurs façons de déclarer des variables. Vous pouvez utiliser le laisser mot-clé pour déclarer des variables.
Voici comment vous pouvez déclarer des variables dans Rust :
laisser un: Chaîne;
laisser b: i32;
laisser c: () = ();
Le un et b les variables sont respectivement une chaîne et un entier. Le c variable est un type d'unité Rust qui agit comme un espace réservé pour les fonctions et les expressions.
Après la déclaration facultative du type de données, vous pouvez déclarer et initialiser des variables avec des valeurs utilisant un signe égal.
fnprincipal(){
laisser âge: Chaîne = Chaîne::depuis("cinq ans");
laisser âge = 5; // équivalent à let age: i32 = 5 ;
imprimez !("{}", âge);
}
Le programme déclare deux âge variables avant l'impression avec le imprimez ! macro. La première âge variable spécifie le type de données, et la seconde ne le fait pas.
Vous n'avez pas besoin de spécifier le type de données d'une variable lorsque vous la déclarez. Le compilateur Rust déduit le type à partir du type de données de la valeur au moment de la compilation.
Vous pouvez également déclarer des constantes dans Rust avec le constante mot-clé de la même manière que la déclaration de variables :
constante âge: &chaîne = "cinq ans";
Vous ne pouvez pas modifier la valeur d'une variable que vous déclarez comme constante.
Rust fournit des fonctionnalités pour les commentaires sur une seule ligne et les blocs. Vous pouvez utiliser des doubles barres obliques (//) pour les commentaires sur une seule ligne :
fnprincipal() {
// Ceci est un commentaire de ligne
laisser x = 5; // Ce commentaire explique le but de la variable `x`
}
Pour les commentaires multilignes (blocs de commentaires), utilisez une barre oblique suivie d'un astérisque (/*) et fermez le bloc avec un astérisque suivi d'une barre oblique (*/):
fnprincipal() {
/*
Il s'agit d'un commentaire de bloc qui s'étend sur plusieurs lignes.
Il est souvent utilisé pour décrire un plus grand bloc de code.
*/
laisser x = 5;
}
Vos commentaires doivent être concis et directs.
Tableaux en Rust
Les tableaux sont une collection de taille fixe d'éléments du même type de données. Rust alloue des tableaux sur la pile par défaut.
Voici comment vous pouvez déclarer des tableaux dans Rust :
fnprincipal() {
laisser nombres = [1, 2, 3, 4, 5];
}
Le Nombres tableau contient cinq éléments. Vous pouvez accéder à la valeur à un emplacement dans un tableau en utilisant son index :
fnprincipal() {
laisser nombres = [1, 2, 3, 4, 5];
laisser x = nombres[3];
imprimez !("{}", X)
}
Le principal la fonction imprime le X variable qui accède au quatrième élément du tableau.
Vecteurs dans Rust
Rust fournit des vecteurs pour couvrir les limites du tableau. Les vecteurs sont dimensionnés dynamiquement; ils peuvent grandir et rétrécir au besoin.
Voici comment vous pouvez déclarer des vecteurs dans Rust :
fnprincipal() {
laisser mon_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
laisser x = mon_vec[3];
imprimez !("{}", X)
}
Le mon_vec vector est un vecteur d'entiers 32 bits. Le X la variable accède au quatrième élément du vecteur, et la principal fonction imprime la valeur sur la console.
Les déclarations conditionnelles de Rust
Les instructions conditionnelles sont l'une des Structures de contrôle de Rust pour la prise de décision dans les programmes. Vous pouvez utiliser le si et autre mots-clés pour gérer les décisions dans vos programmes.
Voici un si instruction qui imprime une chaîne sur la console en fonction de l'égalité de deux entiers.
fnprincipal() {
laisser un: i32 = 12;
si un == 12 {
imprimez !("a est égal à douze");
}
}
Le principal fonction imprime la chaîne avec le imprimez ! macro puisque la variable est égale à 12.
Vous pouvez utiliser le autre mot clé pour gérer les cas où le si l'instruction est fausse :
fnprincipal() {
laisser un: i32 = 12;
si un == 123 {
imprimez !("a est égal à douze");
} autre {
imprimez !("a n'est pas égal à douze");
}
}
Dans cet exemple, le autre s'exécute car la valeur de a n'est pas égale à 123.
Vous pouvez déclarer des instructions de correspondance avec le correspondre mot-clé pour les conditionnels complexes :
fnprincipal() {
laisser âge: i32 = 7;
correspondre âge {
1 => imprimez !("un"),
2 => imprimez !("deux"),
3 => imprimez !("trois"),
_ => imprimez !("zéro"),
}
}
Le principal fonction correspond à la âge variable selon les cas dans le correspondre instruction et exécute l'expression qui correspond à la valeur. Le trait de soulignement (_) est l'instruction par défaut qui s'exécute s'il existe une correspondance pour la valeur.
Boucles en rouille
Rust fournit des boucles pour les tâches répétitives. Rust a trois principaux types de boucles: boucle, alors que, et pour boucles.
Le boucle Le mot-clé crée une boucle infinie qui s'exécute jusqu'à ce qu'il rencontre un mot-clé break :
fnprincipal() {
boucle {
imprimez !("imprimé à plusieurs reprises jusqu'à ce que l'instruction break soit rencontrée.");
casser;
}
}
Le alors que loop est pratique lorsque vous souhaitez répéter un bloc de code tant qu'une condition est évaluée à true :
fnprincipal() {
laissermuet compter = 0;
alors que compter < 5 {
imprimez !("Le nombre est {}", compter);
compter += 1;
}
}
UN pour loop est bon pour itérer sur une collection d'éléments, comme un tableau :
fnprincipal() {
laisser nombres = [1, 2, 3, 4, 5];
pour article dans nombres.iter() {
imprimez !("L'élément actuel est {}", article);
}
}
Ce pour la boucle parcourt le Nombres array et imprime chaque élément sur la console.
Déclarer et appeler des fonctions Rust
Utilisez le fn mot-clé à déclarer une fonction Rust, suivi du nom de la fonction, d'une liste de paramètres et d'un type de retour (le cas échéant).
Voici comment déclarer une fonction avec des paramètres et un type de retour :
fnajouter(un: i32, b: i32) -> i32 {
retour un + b ;
}
Le ajouter La fonction prend deux entiers 32 bits et renvoie un entier 32 bits, la somme des deux paramètres.
Pour appeler une fonction depuis un autre endroit de votre code, spécifiez simplement le nom et les arguments (le cas échéant) :
fnprincipal() {
laisser résultat = ajouter(2, 3);
imprimez !("2 + 3 = {}", résultat);
}
Le résultat variable contient le résultat de l'appel de la ajouter fonction. Le principal fonction imprime le résultat sur la console à l'aide de la imprimez ! macro.
Structures en Rust
Rust fournit des structures pour définir des types de données personnalisés qui regroupent des valeurs associées. Les structures sont des plans pour créer des objets avec des propriétés spécifiques.
Voici comment vous pouvez déclarer une structure :
structurePersonne {
nom: Chaîne,
âge: u32,
est_male: bourdonner,
}
Le Personne struct a trois champs: une chaîne, un entier 32 bits non signé et un booléen.
Après avoir défini une structure, vous pouvez en créer des instances dans d'autres parties de votre programme :
fnprincipal() {
laisser personne1 = Personne {
nom: Chaîne::depuis("Candice Flynn"),
âge: 16,
est_male: FAUX,
};
}
Le personne1 variable est une instance de Personne structure. Lors de l'instanciation, vous pouvez affecter des valeurs aux champs struct. Vous pouvez créer autant d'instances d'une structure que vous le souhaitez.
Vous pouvez implémenter des concepts OOP dans Rust
Rust est flexible et vous pouvez implémenter les concepts OOP dans Rust avec des structures de données intégrées telles que des structures.
Vous utiliserez des structures comme alternative aux classes. Avec la structure de Rust, vous pouvez définir un plan pour le type et implémenter les différents concepts de POO avec les fonctionnalités fournies par Rust sur les structures.
