Le langage Rust gagne en popularité. Élu langage de programmation le plus apprécié par les développeurs pour la cinquième année consécutivel'enquête annuelle sur les débordements de cheminée. De nombreuses entreprises commemicrosoftoamazonasils sont également intéressés par le développement de vos solutions. Qu'est-ce qui rend la rouille si populaire ? Pourquoi s'intéresser ? C'est ce que nous allons découvrir dans cet article.
Il était une fois…
Rust a été créé en 2006 à partir d'un projet personnel de Graydon Hoare, alors employé de Mozilla. Mozilla a vu le potentiel du langage et en 2009 a décidé de soutenir le développement de Rust et l'a présenté pour la première fois en 2010 lors du Mozilla Summit. La première version stable de Rust est sortie en 2015.
Autant dire que Rust est très jeune par rapport à d'autres langages comme JavaScript qui est né en 1995, Python de 1991 ou encore le langage C qui est né en 1973.
Malgré sa jeunesse, Rust possède de nombreux atouts qui lui permettent aujourd'hui d'être de plus en plus utilisé dans de nombreux domaines, tels que :
- programmation de systèmes ;
- systèmes embarqués;
- Les nuages;
- développement web;
- outils de ligne de commande ;
- etc.
Il y a beaucoup de buzz autour de Rust, ce qui fait que de plus en plus d'entreprises s'y intéressent et n'hésitent pas à y migrer leurs solutions. Parmi ceux-ci, nous pouvons citerDropbox, Microsoft, Npm, Facebook ou Amazon.
Certains voient même Rust comme le successeur de C et C++.
Qu'est-ce que la rouille ?
Rust est un langage de programmation compilé statiquement, multiplateforme, multiparadigme, fortement typé, de bas niveau, axé sur la sécurité et les performances.
Oui, je sais, il fait des concepts. Allez, n'ayez pas peur, je vais tout vous expliquer.
un langage compilé
Contrairement à JavaScript ou Python, Rust est un langage compilé. Cela signifie qu'un programme appelé compilateur convertit le code source en code machine que votre ordinateur peut exécuter directement. L'avantage est que vous n'avez plus besoin d'utiliser un programme supplémentaire pour votre programme, comme cela peut être le cas avec un langage interprété. L'autre avantage dérivé de ce qui précède est qu'un programme compilé est généralement plus rapide à l'exécution puisqu'il n'y a pas d'étape d'interprétation.
Si vous voulez en savoir plus sur la façon de compiler et d'interpréter un programme, je vous recommandeCet article.
multiplateforme
Avec Rust, vous pouvez développer des programmes qui s'exécutent sur plusieurs plates-formes, que ce soit Windows, Linux ou macOS. La rouille est même utilisée pour le développement desystèmes embarquéset permet donc au développement de programmes de s'exécuter sur des microcontrôleurs.
Cependant, Rust étant un langage compilé, il est nécessaire de compiler le code source de ces différentes plateformes.
Multiparadigme
Multiparadigme signifie qu'avec Rust, il est possible de développer des programmes avec différents paradigmes.notions de programmationcomme la programmation fonctionnelle ou la programmation orientée objet.
niveau bas
Rust est souvent considéré comme un langage de bas niveau car il permet le développement de programmes qui font partie du système d'exploitation et sont donc souvent liés au matériel, comme le permet le langage C par exemple. Mais Rust propose des abstractions de langage de haut niveau, notamment une gestion efficace de la mémoire ou une gestion intelligente des erreurs.
saisie lourde et statique
Un langage fortement typé (ou fortement typé) signifie que le type d'une variable est garanti et ne peut pas changer pendant l'exécution, comme c'est le cas avec JavaScript par exemple. Par conséquent, les conversions de type implicites ne sont pas autorisées. Statique signifie que, contrairement à un langage à typage dynamique, ces vérifications de type sont effectuées au moment de la compilation plutôt qu'au moment de l'exécution.
Un langage puissant et sûr
Quand on parle de Rust, deux adjectifs viennent souvent à l'esprit : efficace et sûr.
efficace
Rust est rapide, très rapide, cette performance est souvent comparée à C/C++.Certains évoquent même la possibilité d'utiliser Rust au lieu de C++ lors du développement de jeux vidéo., un domaine très exigeant en termes de prestations.
Sûr
La gestion de la mémoire a toujours été un problème. En C/C++, c'est aux développeurs de gérer cela, ce qui conduit souvent à des échecs de programmation dus à de la mémoire non partagée ou même à des bogues.débordements de tampon(buffer overflow) qui peut entraîner des erreurs et même des violations de sécurité. D'autres langages comme Java ou Python résolvent la plupart des problèmes de mémoire en utilisant unÉboueur), mais au détriment des performances.
Rust offre une gestion sécurisée de la mémoire sans l'utilisation de ramasse-miettes, et donc sans perte de performances. Le compilateur vous signale toutes les erreurs au moment de la compilation, pas au moment de l'exécution. Je vous préviens, vous détesterez le compilateur Rust, mais cela vous évitera beaucoup de bugs.
Ces deux atouts font de Rust un langage de choix pour la programmation système. La rouille est même connue sous le nom deune alternative au C pour le développement du noyau Linux. La même choseMicrosoft envisage sérieusement d'utiliser Rust dans le développement de composants Windows.
Nous reviendrons plus en détail sur la gestion de la mémoire dans le prochain article Rust.
Découvrons la rouille
C'est bien beau, mais il est temps de découvrir les bases de Rust.
Installation
La première étape consiste à installer Rust. Pour ce faire, nous devons le télécharger via l'outilroseIl s'agit d'un outil de gestion des versions de Rust et de ses outils.
Si vous utilisez Linux ou Mac OS, ouvrez votre terminal et saisissez la commande suivante :
1 | curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | Sch |
Cette commande télécharge un script qui installe l'outilrosece que Rust va installer. Si tout se passe bien, vous devriez voir le message suivant :
1 | Rust est déjà installé. Gros! |
Si vous utilisez Windows, accédez simplement àle site officielet suivez les instructions.
Pour vous assurer que l'installation s'est bien déroulée, vous pouvez exécuter la commande suivante dans votre terminal :
1 | rustc --version |
Vous devriez voir le message suivant :
1 | rustc xyz (abcabcabc jjjj-mm-tt) |
Cela affiche le numéro de version, le hash de validation de la version et la date de sortie de ce dernier.
mettre à jour et désinstaller
Comme je l'ai déjà dit,rosepermet de gérer les versions de Rust, si vous souhaitez le mettre à jour il suffit de lancer la commande suivante dans votre terminal :
1 | Mise à jour RustUp |
Il en va de même pour la désinstallation, exécutez simplement la commande suivante dans votre terminal :
1 | Désinstallez Rustup vous-même |
Et le code dans tout ça ?
Passons aux choses sérieuses et voyons à quoi ressemble le code écrit en Rust.
Le traditionnel monde du salut
Commençons par le traditionnel Hello World. Alors ouvrez votre éditeur préféré et créez un fichierprincipal.rset écrivez le code suivant :
1 2 3 | fn principalement() { imprimer!("Salut monde!"); } |
Voyons la structure de ce code, qui n'est pas très compliqué à comprendre. Pour déclarer une fonction, on utilise le mot cléfnsuivi du nom de la fonction. Nous avons donc ici une fonction appeléeprincipalementIl s'agit d'une fonctionnalité un peu spéciale, car chaque programme Rust a une fonctionprincipalementc'est le point d'entrée du programme. Pour ceux qui viennent du langage C/C++, ne vous perdez pas.
une fonctionprincipalementcontient la déclaration suivanteprintln!("¡Hola Welt!");qui affiche simplement le messageSalut monde!sur la sortie standard.
Utiliser :Vous remarquerez peut-être un!à la fin de la fonctionimprimerindiquant qu'il ne s'agit pas d'une fonction mais d'une macro. Nous n'entrerons pas dans les détails de ce qu'est une macro, nous le verrons peut-être dans un prochain article.
Le corps d'une fonction est entouré d'accolades.{}et chaque instruction se termine par un point-virgule;
Compilons maintenant notre code. Pour cela, tapez la commande suivante dans votre terminal :
1 | rustc principal.rs |
Il ne se passe rien ? Mais si nous avons regardé de près, nous avons vu que Rust était un langage compilé et que l'étape de compilation nous permet de construire un binaire exécutable. Si vous regardez dans votre dossier, vous devriez voir un fichierprincipalement(oprincipal.exesous Windows). Pour exécuter le binaire, tapez simplement la commande suivante si vous utilisez Linux ou macOS :
1 | ./principalement |
Sous Windows, la commande est similaire, mais vous devez ajouter l'extension.EXE:
1 | .\principalement.EXE |
tu devrais voir le messageSalut monde!
Félicitations, vous venez d'écrire votre premier programme Rust.
Une brève introduction aux bases.
Pour continuer, faisons un petit tour des bases de Rust.
variables
Les variables dans Rust sont immuables par défaut ; h il n'est pas possible de modifier leur valeur après leur déclaration. Pour déclarer une variable dans Rust, il suffit d'utiliser le mot cléLaisser:
1 | Laisser Wert = 42; |
Essayons de changer la valeur de notre variable value :
1 2 | Laisser Wert = 42; Wert = 0; |
Essayons maintenant de compiler :
1 | rustc principal.rs |
Nous obtenons ce joli message d'erreur :
1 2 3 4 5 6 7 8 9 dix 11 12 13 14 | Erreur [E0384] : la variable immuable 'value' ne peut pas être affectée deux fois --> principal.rs:3:5 | 2 | laissez la valeur = 42 ; | ----- | | | première affectation à `value` | Aide : rendez cette liaison mutable : `mut value` 3 | Wert = 0 ; | ^^^^^^^^^ ne peut pas être affecté deux fois à une variable immuable Erreur : Annuler en raison d'une erreur précédente ; Voir rustc --explain E0384 pour plus d'informations sur cette erreur. |
Le compilateur Rust est vraiment cool, les erreurs s'expliquent d'elles-mêmes. Cela nous indique qu'il n'est pas possible d'attribuer une valeur à une variable immuable une seconde fois. Il nous dit même comment résoudre notre problème. Nous devons utiliser le mot-clépériodeavant le nom de la variable lorsque vous la déclarez mutable :
1 2 | Laisser période Wert = 42; Wert = 0; |
Il y a aussi le mot cléjusqu'à ce quedéclarer une constante. La première différence avec le mot-cléLaisserest que la valeur d'une constante doit être connue au moment de la compilation, il n'est donc pas possible d'obtenir une valeur à partir d'un appel de fonction. La seconde différence est que le type d'une constante doit aussi être déclaré explicitement :
1 2 3 | jusqu'à ce que un: i32 = 42; Laisser C = return_i32_value(); // D'ACCORD jusqu'à ce que b: i32 = return_i32_value(); // Erreur |
type primitif
Rust pratique ce qu'on appelle l'inférence de type, qui permet au compilateur de déduire automatiquement les types associés aux expressions, comme une déclaration de variable, sans les spécifier explicitement dans le code. Il est toujours possible de spécifier le type d'une variable. Reprenons notre exemple précédent et spécifions le type de la variableWert:
1 | Laisser Wert: i32 = 42; |
Variable matricielleWertest de typei32qui correspond à un entier représenté sur 4 octets (32 bits).
Examinons de plus près les types primitifs de Rust.
bourdonner
Le type des valeurs booléennes estbourdonner. Ce type peut prendre les valeursC'est correctoINCORRECT:
1 2 | Laisser X = C'est correct; Laisser j: bourdonner = INCORRECT; |
carboniser
Le typecarbonisercorrespond à un seul caractère :
1 2 | Laisser un = 'un'; Laisser b: carboniser = 'b'; |
Assurez-vous d'utiliser les guillemets avec un caractère'et non les guillemets doubles"A qui représente une chaîne de caractères. Contrairement à d'autres langages (comme le C), le typecarboniserde Rust est représenté en 4 octets pour le supportUnicode.
entiers signés
Les entiers signés contiennent des valeurs entières qui peuvent être positives ou négatives. On distingue cinq types d'entiers signés :
| jusqu'à ce que | valeur minimum | valeur maximum |
|---|---|---|
| i8 | -128 | 127 |
| i16 | -32768 | 32767 |
| i32 | -2147483648 | 2147483647 |
| i64 | -9223372036854775808 | 9223372036854775807 |
| i128 | -170141183460469231731687303715884105728 | 170141183460469231731687303715884105727 |
1 2 | Laisser X = 42; // Par défaut le type est i32 Laisser j: i8 = -42; |
entiers non signés
Les entiers non signés ne contiennent que des valeurs entières positives. On distingue cinq types d'entiers non signés :
| jusqu'à ce que | valeur minimum | valeur maximum |
|---|---|---|
| u8 | 0 | 255 |
| u16 | 0 | 65535 |
| u32 | 0 | 4294967295 |
| u64 | 0 | 18446744073709551615 |
| u128 | 0 | 340282366920938463463374607431768211455 |
1 2 | Laisser X : u8 = 42; Laisser j: u16 = 1400; |
décimales
Il existe deux types de décimauxf32etf64correspondant chacun à un nombre décimal représenté sur 4 octets (32 bits) et 8 octets (64 bits).
1 2 | Laisser X = 1.42; // Par défaut le type est f64 Laisser j: f32 = 1000.01; |
La table
Les tableaux dans Rust ont une taille fixe et ne peuvent contenir que des valeurs du même type.
1 2 3 4 5 6 7 8 9 dix 11 12 | Laisser un = [1, 2, 3]; // Un tableau de 3 entiers de type i32 Laisser b: [i8; 3] = [4, 5, 6]; // [aimable; size], voici un tableau de 3 éléments sur 1 octet (8 bits) Laisser période C: [i32; 3] = [7, 8, 9]; // Avec un tableau mutable, vous pouvez modifier ses valeurs, mais pas sa taille C[0] = dix; C[1] = 11; C[2] = 12; C[3] = 13; // Provoque une erreur : Index hors limites : la longueur est de 3, mais l'index est de 3 Laisser ré = ['ré'; 5]; // [Vaut; size], ici un tableau de 5 caractères 'd' imprimer!("{: ?}", ré); // {:?} affiche le contenu du tableau |
Utiliser :Il est possible d'avoir des "tableaux" dynamiques en Rust, il faut utiliser la structureChaque. Il y en a d'autresTypes de collections disponibles dans la bibliothèque standardrouille commelistes liéesou même des tables de hachage.
Tupel
Un tuple est une liste ordonnée d'éléments qui peuvent être de différents types. Les développeurs Python sont déjà familiarisés avec ce type de données.
1 2 3 4 5 6 7 8 9 dix 11 | Laisser un = (C'est correct, 'un', 1.5); // crée un tuple à partir de 3 éléments (bool, char, f64) Laisser b: (carboniser, i32, f64, bourdonner) = ('b', 1, 1.5, INCORRECT); // crée un tuple à partir de 4 éléments (char, i32, f64, bool) Laisser période C = (42, 10.5); // Un tuple mutable permet de changer ses valeurs, mais pas sa taille C.0 = dix; // Attention, la valeur doit être du même type que la déclaration C.1 = INCORRECT; // Erreur de cause : virgule flottante attendue, `bool` trouvé Laisser (ré, mi, F) = un; // d = vrai, e = 'a', f = 1,5 Laisser (gramme, _, _, h) = b; // g = 'b' vrai, h = faux imprimer!("{: ?}", un); // {:?} affiche le contenu du tuple |
desc
Sans entrer dans les détails et pour vous faciliter la tâche mecdescest une référence (d'où la présence du caractère&ce qui n'est pas nouveau pour les développeurs C++) à une partie d'une structure de données comme des tableaux :
1 2 3 4 5 6 7 8 9 | Laisser un: [i8; 5] = [1, 2, 3, 4, 5]; Laisser b: &[i8] = &un; // Nous créons une "tranche" dans toute la table Laisser C = &un[0..3]; // [de..à] Crée une "tranche" de l'élément 0 à l'élément 2 Laisser ré = &un[..]; // Nous créons une "tranche" dans toute la table Laisser mi = &un[1..4]; // [2, 3, 4] Laisser F = &un[1..]; // [2, 3, 4, 5] Laisser gramme = &un[..3]; // [1, 2, 3] |
Utiliser :L'opérateur..permet de définir une plage d'exclusion. Par exemple0..3représente les éléments de 0 à 3 (exclusif). Au contraire, l'opérateur..=définit un intervalle d'inclusion.0..=3représente donc les éléments de 0 à 3 (tous deux inclus).
instruments à cordes
Pour déclarer une chaîne, utilisez simplement les guillemets doubles":
1 2 | Laisser un = « La rouille, c'est génial ! »; Laisser b: &str= "Vraiment cool !"; |
Les cordes (Calle) dans Rust sont beaucoup plus complexes qu'il n'y paraît. Par conséquent, pour cet article, nous n'entrerons pas dans les détails.
les opérateurs
Nous n'entrerons pas dans les différents opérateurs. Vous pouvez les trouver dans le tableau suivant.
| opérateur | + - * / % |
| opérateurs de comparaison | == != < > <= >= |
| Opérateurs logiques | ! && || |
| Opérateurs d'affectation | = += -= *= /= %= &= |= ^= <<= >>= |
| Petit à petit les travailleurs | & | ^ << >> |
Structures de contrôle
Passons maintenant aux structures de contrôle.
oui - sinon oui - sinon
Comme pour la plupart des langues, on retrouve le trio traditionnel :et,sinon ouietAnders.
1 2 3 4 5 6 7 8 9 dix 11 12 13 14 coing seize | // et Laisser est requis = C'est correct; et est requis { // ... } // au contraire Laisser Wert = dix; et Wert % 2 == 0 { imprimer!("{} est juste", Wert); } Anders { imprimer!("{} est impair", Wert); } |
Il n'y a pas de condition ternaire comme dans la plupart des langues, mais il est possible de combinerLaisseretau contraireJ'aime ça :
1 2 | Laisser Wert = dix; Laisser c'est juste = et Wert % 2 == 0 { C'est correct } Anders { INCORRECT }; |
Rollon
pas d'instructionsChangeren Rust, et c'est pas si mal parce que je trouve çapersonnellement trop verbeux et souvent source d'erreur quand on oublie de faire une pause par exemple. Au lieu de cela, Rust utilise quelque chose appelé correspondance de modèle via la déclarationRollonqui est beaucoup plus puissant qu'un simpleChanger.
Voici un premier exemple avec des instructions.Rollonqui se comporte comme unChangerclassique:
1 2 3 4 5 6 7 8 9 | Laisser Langue = "FR"; Rollon Langue { "FR" => imprimer!("Français"), "DANS" => imprimer!("Anglais"), "VON" => imprimer!("Allemand"), "ES" => imprimer!("Espagnol"), _ => imprimer!("Langue inconnue") // Equivalent a au default du switch } |
Comme les instructionset, il est aussi possible d'effectuer un affect :
1 2 3 4 5 6 | Laisser a accès = C'est correct; Laisser rouler = Rollon a accès { C'est correct => "Administrateur", INCORRECT => "Utilisateur" }; |
Mais les consignesRollonIl ne s'arrête pas là, il propose des comparaisons beaucoup plus poussées :
1 2 3 4 5 6 7 8 9 | Laisser Wert = 5; Rollon Wert { 0 => imprimer!("Nul"), 1 | 2 | 3 => imprimer!("Un, deux ou trois"), 4..=dix => imprimer!("Entre quatre et dix"), X et X > dix => imprimer!("supérieur à 10"), _ => imprimer!("Autres") }; |
Tout cela n'est qu'un échantillon de ce qui est possible avec l'éducation.Rollon.
durant
L'instructiondurantvous permet de créer une boucle qui se poursuivra tant que votre condition sera remplie, comme dans d'autres langages :
1 2 3 4 5 6 | Laisser période compte = 0; durant compte <= 100 { imprimer!("{}", compte); compte += 1; } |
L'amour
L'instructionL'amourpermet de créer une boucle infinie (oui, il y a des cas où une boucle infinie est utile).
1 2 3 | L'amour { imprimer!("Boucle infinie!"); } |
C'est plus facile que de l'écrire avec la déclarationdurant:
1 2 3 | durant C'est correct { imprimer!("Boucle infinie!"); } |
Pour arrêter une boucleL'amourAppelez simplement l'instructiondu repos:
1 2 3 4 5 6 7 8 9 dix 11 12 | Laisser période compte = 0; L'amour { imprimer!("{}", compte); compte += 1; et compte == 100 { imprimer!("ARRÊTER!"); du repos; } } |
Pro
L'instructionProvon Rust aborde la leçonPropar Python. Vous pouvez l'utiliser pour parcourir les valeurs d'une expression qui renvoie un itérateur (en termes simples):
1 2 3 4 5 6 7 8 9 dix 11 12 13 14 coing seize | // Recherche des valeurs de 1 à 10 Pro Wertdans 0..=dix { imprimer!("{}", Wert); } // Recherche des valeurs de 0 à 10 par incréments de 2 Pro Wertdans (0..=dix).étape pour(2) { imprimer!("{}", Wert); } // Recherche un tableau Laisser Arr = [1, 2, 3, 4]; Pro Wert dans &arr{ imprimer!("{}", Wert); } |
les fonctions
Nous avons vu dans notre premier exemple que chaque programme Rust devrait avoir une fonction principale appeléeprincipalementc'est le point d'entrée du programme. Mais bien sûr il est possible de définir d'autres fonctions :
1 2 3 4 5 6 7 8 9 dix 11 12 13 14 coing seize 17 18 19 20 21 22 23 24 25 | //Fonction sans paramètre ni valeur de retour fn print_hello_world() { imprimer!("Salut monde!"); } // Fonction avec paramètres mais sans valeur de retour fn somme d'impression(X: i32, j: i32) { imprimer!("{} + {} = {}", X, j, X + j); } // Fonction avec paramètres et valeur de retour fn le total(X: i32, j: i32) -> i32 { X + j // Pas besoin d'appeler l'instruction return // x + y équivaut à renvoyer x + y ; } // Fonction avec paramètres et valeur de retour fn sum_with_return(X: i32, j: i32) -> i32 { revenir X + j; /* Notez qu'il est préférable d'utiliser le formulaire ci-dessus. Il est préférable d'utiliser le retour uniquement lorsque vous souhaitez quitter une fonction avant la fin */ } |
Il est également possible de définir des fonctions anonymes appelées fermetures (à ne pas confondre avec les fermetures JavaScript, elles ressemblent plus ici à des fonctions fléchées) :
1 2 3 4 5 | // Avec déclaration de type Laisser le total = |X: i32, j: i32| -> i32 { X + j }; // Sans déclaration de type Laisser somme_sans_types = |X, j| X + j; |
Et la POO dans tout ça ?
Nous allons maintenant voir comment il est possible de programmer de manière orientée objet avec Rust.
les constructions
Les structures sont plus proches des classes dans d'autres langages de programmation. Pour créer une structure, utilisez le mot cléLa structure:
1 2 3 4 | La structure rectangle { Grande: u32, Hauteur: u32, } |
L'instanciation s'effectue alors comme suit :
1 2 3 4 | Laisser angle droit = rectangle { Grande: dix, Hauteur: 20, }; |
Pour accéder aux attributs de notre objet, il suffit de spécifier leurs noms, comme il est d'usage en JavaScript :
1 | imprimer!("Largeur hauteur: {}", angle droit.Grande, angle droit.Hauteur); |
Il est également possible de définir des méthodes dans nos structures à l'aide du mot-cléimpl.. Revenons à notre structure.rectangleet ajouter deux méthodes, une méthode statiquenouveausert de constructeur et de méthode non statiquepressepour afficher la longitude et la latitude de nos objetsrectangle:
1 2 3 4 5 6 7 8 9 dix 11 12 13 14 coing seize 17 18 19 | La structure rectangle { Grande: u32, Hauteur: u32, } impl. rectangle { // Méthode statique : ici, new est utilisé comme constructeur fn nouveau(Grande: u32, Hauteur: u32) -> rectangle { rectangle { Grande: Grande, Hauteur: Hauteur, } } // Méthode non statique : le paramètre self fait référence à l'instance courante fn presse(&même) { imprimer!("Largeur hauteur: {}", même.Grande, même.Hauteur); } } |
Utilisons maintenant nos deux méthodes :
1 2 3 | Laisser angle droit = rectangle::nouveau(dix, 20); angle droit.presse(); |
Utiliser :Il n'y a pas de concept de constructeur dans Rust comme nous en avons l'habitude dans d'autres langages, la méthode statiquenouveauvu ci-dessus est simplement une convention.
les trains
À proprement parler, dans Rust, il n'y a pas d'héritage, nous avons plutôt le concept de propriétés. Les propriétés permettent de définir des comportements à partager, mais aussi des comportements à mettre en place comme suitinterfacesautres langages de programmation. Déclarons une propriétéFormeravec une méthoderégionqui doit être implémenté par des structures utilisant cette propriété :
1 2 3 | caractéristique Former { fn région(&même) -> u32; } |
La syntaxe pour implémenter un trait est la suivanteimpl <fonctionnalité> pour <structure>. Revenons à notre structure.rectangleet mettre en œuvre la propriétéFormerpour ca:
1 2 3 4 5 | impl. Former Pro rectangle { fn région(&même) -> u32 { même.Grande * même.Hauteur } } |
La méthoderégionalors les instances de la structure peuvent être appeléesrectangle:
1 2 3 | Laisser angle droit = rectangle::nouveau(dix, 20); imprimer!("Zone : {}", angle droit.région()); |
Il est tout à fait possible pour un framework d'implémenter plusieurs fonctionnalités. Il y a beaucoup plus à dire sur les traits, mais ce petit exemple vous donne déjà une bonne idée de la façon dont ils sont utilisés.
Module
Rust fournit un système modulaire pour créer des espaces de noms (ou espaces de noms) et organiser votre code en fichiers et dossiers.
espaces de noms
Commençons par la première utilisation des modules, qui consiste à créer des espaces de noms. Alors créons un espace de nomshttpavec le mot cléModification:
1 2 3 4 5 6 7 8 9 | Modification http { fn mettre en doute(){ imprimer!("Faire une demande!") } } fn principalement() { http::mettre en doute(); } |
Mais lorsque nous compilons, nous obtenons l'erreur suivante :
1 2 3 4 5 6 | Erreur [E0603] : la fonction 'Demande' est privée --> principal.rs:8:11 | 8 | http::demande(); | ^^^^^^^ événement privé | |
Par défaut, toutes les fonctions (ou structures) présentes dans un module sont privées. Pour les rendre publics, vous devez utiliser le mot-cléBar:
1 2 3 4 5 6 | Modification http { // La fonction est maintenant publique Bar fn mettre en doute() { imprimer!("Faire une demande!") } } |
Il est également possible de rendre publiques toutes les fonctions d'un module en ajoutant le mot cléBaravant le mot cléModification:
1 2 3 4 5 6 | // Toutes les fonctions du module seront publiques Bar Modification http { fn mettre en doute() { imprimer!("Faire une demande!") } } |
Divisez votre code en plusieurs fichiers
Il est également possible de diviser votre code en plusieurs fichiers. Pour cela, nous créons un fichierhttp.rset copiez notre code mais cette fois sans le mot cléModification:
1 2 3 | Bar fn mettre en doute() { imprimer!("Faire une demande!") } |
Importons notre module via un mot cléModificationsuivi du nom du fichier (icihttp) dans le fichierprincipal.rs, puis utilisez notre fonctionmettre en doute:
1 2 3 4 5 | Modification http; fn principalement() { http::mettre en doute(); } |
Nous pouvons également mettre notre module dans un dossier. L'avantage de cette méthode est que le code peut être réparti sur plusieurs fichiers.
Pour cela, créez simplement un dossierhttpet ajouter un fichiermod.rs(le nom est très important) avec le code de notre module. Ajoutez également un fichierestado_mensaje.rscontient une fonction pour obtenir le message d'état d'une requête à partir du code HTTP :
1 2 3 4 5 6 7 8 | Bar fn from_code(Code: i16) -> &'statique Calle { Rollon Code { 200 => "D'ACCORD", 201 => "Créé", // ... _ => "Code inconnu" } } |
Ce qui nous donne l'arborescence suivante :
1 2 3 4 5 | . ├── principal.rs ├── http ├── status_meldung.rs └── mod.rs |
Nous venons de créer un nouveau module appelémessage d'état. Ajoutons-les à notre fichier.http.rs:
1 2 3 4 5 6 | // status_message est un sous-module du module http Bar Modification message d'état; Bar fn mettre en doute() { imprimer!("Faire une demande!") } |
Nous pouvons maintenant utiliser notre modulehttpainsi que le sous-modulemessage d'étatdans notre dossierprincipal.rs:
1 2 3 4 5 6 | Modification http; fn principalement() { http::mettre en doute(); imprimer!("{}", http::message d'état::from_code(200)); } |
Parfois, il peut être fastidieux de devoir écrire entièrement des espaces de noms, il est donc possible d'utiliser le mot-cléutiliser. En reprenant notre exemple ci-dessus, nous pouvons utiliser l'espace de nomshttpcomme suit :
1 2 3 4 5 6 7 8 9 dix 11 | utiliser http::{ mettre en doute, message d'état::from_code, }; Modification http; fn principalement() { mettre en doute(); imprimer!("{}", from_code(200)); } |
charge
Nous avons couvert les bases de Rust, mais il y a une chose que je veux vous montrer avant que nous ayons terminé, et c'est l'outil de téléchargement. Cargo est le système d'emballage et de gestion de Rust.
Pour l'utiliser, créez simplement un nouveau projet avec la commande suivante :
1 | Nom du nouveau projet de chargement |
Cela créera automatiquement un dépôt Git de votre nouveau projet avec la structure suivante :
1 2 3 4 5 6 | . ├── Cargaison.toml ├── .git ├── .gitignore ├── Ceux └── principal.rs |
À l'heure actuelle, nous n'avons que les fichiers et dossiers suivants :
charger.toml: Il s'agit du fichier de configuration de téléchargement pour votre projet. Ce fichier a le formatTOML(Tom's Obvious, Minimal Language, inventé par Tom Preston-Werner, l'un des fondateurs de Github, à cause du peu d'informations.)
1 2 3 4 5 6 7 8 | [Forfait] nom = "Nom du projet" performance = "0.1.0" auteurs = ["Votre nom <votre@exemple.com>"] édition = "2018" [dépendances] Rand = "0.8.0" |
Ce dossier est divisé en plusieurs parties :
Forfait: Affiche toutes les informations sur votre paquet : le nom, le numéro de version, l'auteur et l'édition Rust à utiliser.dépendances: répertorie toutes les dépendances du projet nommées boîtes.
Il y a d'autres parties, mais nous n'en discuterons pas ici. Cependant, vous pouvez jeter un œildocuments officiels.
Celles: Le dossier qui contiendra votre code source. Cargo crée automatiquement le point d'entrée de votre programme, c'est-à-dire le fichierprincipal.rs
Compiler avec Cargo
au lieu de commanderrosePour compiler il est possible d'utiliser Cargo avec la commande suivante :
1 | frais de construction |
Cette commande crée l'exécutable de votre programme dans le dossier./target/debug
Vous remarquerez également qu'un fichierverrou de chargecréé. Concernant le dossierpackage lock.jsonun projet javascriptcompositeur.lockd'un projet PHP, cela permet de verrouiller les versions des dépendances.
Pour exécuter votre programme, exécutez simplement la commande suivante :
1 | coup de charge |
Cette commande vous permet de compiler ainsi que d'exécuter votre programme si nécessaire.
Si vous voulez juste vérifier que votre code ne contient pas d'erreurs de compilation, vous pouvez utiliser la commande suivante :
1 | Contrôle de charge |
Cette commande compile votre code sans créer d'exécutable, elle est donc beaucoup plus rapide que la commandefrais de construction.
Et la fabrication ?
Comme dit, nous compilons notre programme avec la commandefrais de constructioncréer un fichier exécutable dans le dossiercible/débogage. Cependant, cet exécutable n'est pas optimisé pour la production. Si vous souhaitez distribuer votre programme ou l'utiliser en production, exécutez simplement la commandefrais de constructionavec l'optionlancementJ'aime ça :
1 | Charge de construction --libération |
ajouter des dépendances
Si vous souhaitez ajouter une dépendance à votre projet, rendez-vous simplement sur le siteKisten.ioqui rassemble les modules créés par la communauté Rust et trouve ce qui vous intéresse. Une fois trouvé, il suffit de l'ajouter manuellement dans le fichier Cargo.toml dans la partiedépendances. Par exemple, si vous souhaitez ajouter la bibliothèqueRandPour générer des nombres aléatoires, ajoutez-le simplement comme ceci :
1 2 3 4 5 6 7 8 | [Forfait] nom = "Nom du projet" performance = "0.1.0" auteurs = ["Votre nom <votre@exemple.com>"] édition = "2018" [dépendances] Rand = "0.8.0" |
Et utilisez-le comme ceci dans votre code :
1 2 3 4 5 6 7 | utiliser Rand::timbre; fn principalement() { Laisser période Anneau = Rand::subproceso_rng(); imprimer!("Entier: {}", Anneau.gene_area(0, dix)); imprimer!("Décimales : {}", Anneau.gene_area(0,0, 10.0)); } |
Utiliser :Si la dépendance que vous utilisez n'est utile que pour le développement et non pour la production, vous pouvez l'ajouter dans une nouvelle partie[dépendances de développement]
Si vous souhaitez mettre à jour une dépendance, vous pouvez utiliser la commande suivante :
1 | charger la mise à jour |
Enfin…
Nous n'avons couvert que les bases de Rust dans cet article, et nous n'avons fait qu'effleurer la surface de ce que Rust propose car le langage est si riche. La courbe d'apprentissage est certainement raide par rapport à d'autres langues, mais le jeu en vaut clairement la peine. Si vous voulez sortir de votre zone de confort et que vous n'avez pas peur d'apprendre de nouvelles choses, commencez à apprendre Rust, cet investissement vous sera très utile à l'avenir.
J'espère vous avoir aidé à en apprendre un peu plus. Si oui, je vous invite à lireRessources disponibles sur le site officiel. Nous nous retrouverons plus tard pour d'autres articles dédiés à Rust.
Annonces de partenaires
Arkérone
Développeur back (nodejs et php), je fais aussi du front (react). Je partage mes connaissances et ma passion à travers mes articles. n'hésitez pas à me suivreSang.