Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

Tutoriel Rust Rust est un nouveau langage développé au sein de la fondation Moz

Tutoriel Rust Rust est un nouveau langage développé au sein de la fondation Mozilla et poussé par ses nombreux contributeurs sur GitHub. Ce tutoriel s'adresse à des développeurs ayant déjà programmé dans un autre langage. Ici, vous apprendrez toutes les bases afin que vous puissiez vous débrouiller tout seul par la suite. Sommaire I. Les bases de la programmation en Rust................................................................................................................p. 3 1. Présentation de Rust ............................................................................................................ p. 3 2. Mise en place des outils ....................................................................................................... p. 4 3. Premier programme .............................................................................................................. p. 6 4. Variables ............................................................................................................................... p. 7 5. Conditions et pattern matching ............................................................................................. p. 9 6. if let / while let ....................................................................................................................... p. 13 7. Les boucles ........................................................................................................................... p. 15 8. Les fonctions ......................................................................................................................... p. 19 9. Les expressions .................................................................................................................... p. 21 10. Gestion des erreurs ............................................................................................................ p. 23 11. Cargo .................................................................................................................................. p. 27 12. Utiliser des bibliothèques externes ..................................................................................... p. 32 13. Jeu du plus ou moins .......................................................................................................... p. 33 II. Spécificités de Rust ..................................................................................................................... p. 37 1. Le formatage des flux ........................................................................................................... p. 37 2. Les enums ............................................................................................................................ p. 39 3. Les structures ....................................................................................................................... p. 41 4. Les traits ............................................................................................................................... p. 45 5. Généricité ............................................................................................................................. p. 48 6. Propriété (ou ownership) ...................................................................................................... p. 53 7. Durée de vie (ou lifetime) ...................................................................................................... p. 56 8. Déréférencement .................................................................................................................. p. 57 9. Sized et String vs str ............................................................................................................. p. 59 10. Closure ............................................................................................................................... p. 61 11. Multi-fichier ......................................................................................................................... p. 63 12. Les macros ......................................................................................................................... p. 66 13. Box ...................................................................................................................................... p. 71 14. Les itérateurs ...................................................................................................................... p. 73 III. Aller plus loin .............................................................................................................................. p. 76 1. Utiliser du code compilé en C avec les FFI .......................................................................... p. 76 2. Documentation et rustdoc ..................................................................................................... p. 80 3. Ajouter des tests ................................................................................................................... p. 84 4. Rc et RefCell ......................................................................................................................... p. 88 5. Les threads ........................................................................................................................... p. 91 6. Le réseau .............................................................................................................................. p. 96 7. Codes annexes ..................................................................................................................... p. 102 Tutoriel Rust 3/103 I. Les bases de la programmation en Rust 1. Présentation de Rust Rust est un langage de programmation système, compilé et multi-paradigme. C'est un croisement entre langage impératif (C), objet (C+ +), fonctionnel (Ocaml) et concurrent (Erlang). Il s'inspire des recherches en théories des langages de ces dernières années et des langages de programmation les plus populaires afin d'atteindre trois objectifs : rapidité, sécurité (en mémoire notamment) et concurrent (partage des données sécurisé entre tâches). Le développement du langage, initié par Graydon Hoare, est opéré depuis 2009 par la fondation Mozilla, ainsi que par la communauté des développeurs Rust très présente sur Github. Pour suivre ce tutoriel, il est fortement recommandé d'avoir déjà développé dans au moins un autre langage (C, C++, Java, JavaScript, Python, etc.) car je ne passerai que très brièvement sur les bases. Ses points forts sont : ●La gestion de "propriété" (ownership) des variables ●La gestion de la mémoire ●Le typage statique ●L'inférence de type ●Le filtrage par motif (pattern matching) ●La généricité Nous reverrons tout cela plus en détails. Quelques liens utiles : ●Le site internet : rust-lang.org ●La documentation (toujours utile d'avoir ça sous la main !) ●Le dépôt Github (pour voir le code source) ●Le rustbook (le "cours" officiel, en anglais) ●Le reddit (pour poser une question) ●L'irc (pour obtenir de l'aide, en anglais). Le channel français est #rust-fr. Il est maintenant temps de commencer. Tutoriel Rust 4/103 2. Mise en place des outils Pour pouvoir développer en Rust, il va déjà falloir les bons outils. Ici, je ne ferai qu'une présentation rapide de ceux que je connais. Pour écrire le code, vous pouvez utiliser soit : ● L'éditeur de code Rust en ligne : ● Soit http://www.tutorialspoint.com/compile_rust_online.php qui permet d'éditer, compiler et exécuter des projets complets (répartis sur plusieurs fichiers) tout en proposant des outils d'import et d'export. ●Soit un IDE. Par-exemple visual studio. J'utilise personnellement Sublime Text. Si vous souhaitez l'utiliser et que vous voulez avoir la coloration syntaxique pour Rust, je vous invite à vous rendre sur cette page. Au final ça donne ceci : Tutoriel Rust 5/103 Après il vous suffit de suivre les instructions et vous aurez un éditeur de texte prêt à l'emploi ! Je tiens cependant à préciser que n'importe quel éditeur de texte fera l'affaire, Sublime Text n'est que ma préférence personnelle ! Le compilateur de Rust Si vous ne souhaitez pas utiliser l'éditeur Rust en ligne, il va vous falloir télécharger le compilateur de Rust disponible ici, puis l'installer. Nous pouvons maintenant commencer à nous intéresser au langage Rust à proprement parler ! Tutoriel Rust 6/103 3. Premier programme Pour pouvoir tester tout ce que nous avons mis en oeuvre dans le chapitre précédent, je vous propose d'écrire votre premier programme en Rust : Run the following code: fn main() { println!("Hello world!"); } Si vous n'utilisez pas play.rust-lang : Maintenant que nous avons créé le fichier, compilons-le : > rustc votre_fichier.rs Vous devriez maintenant avoir un exécutable votre_fichier. Lançons-le : Sous Windows : > .\votre_fichier.exe Sous Linux/macOS : > ./votre_fichier Et vous devriez obtenir : Hello world! Si jamais vous voulez changer le nom de l'exécutable généré, il vous faudra utiliser l'option -o. Exemple : > rustc votre_fichier.rs -o le_nom_de_l_executable Si vous utilisez play.rust-lang : Appuyez tout simplement sur le bouton "Run". Vous savez maintenant comment compiler et exécuter vos programmes. Tutoriel Rust 7/103 4. Variables La première chose à savoir en Rust est que toutes les variables sont constantes par défaut. Exemple : Run the following code: let i = 0; i = 2; // Erreur ! Pour déclarer une variable mutable, il faut utiliser le mot-clé mut : Run the following code: let mut i = 0; i = 2; // Ok ! Maintenant voyons comment fonctionnent les types en Rust. Ici, rien de nouveau, on a toujours des entiers, des flottants, des strings, etc. La seule différence viendra de leur syntaxe. Par exemple, pour déclarer un entier de 32 bits, vous ferez : Run the following code: let i: i32 = 0; // ou : let i = 0i32; Sachez aussi que le compilateur de Rust utilise l'inférence de type. En gros, on n'est pas obligé de déclarer le type d'une variable, il peut généralement le déduire tout seul. Exemple : Run the following code: let i = 0; // donc c'est un entier visiblement let max = 10i32; if i < max { // max est un i32, donc le compilateur en déduit que i en est un aussi println!("i est inférieur à max !"); } Donc pour résumer, voici une petite liste des différents types de base (aussi appelés "primitifs") disponibles : ●i8 : un entier signé de 8 bits ●i16 ●i32 ●i64 ●i128 ●u8 : un entier non-signé de 8 bits ●u16 ●u32 ●u64 ●u128 ●f32 : un nombre flottant de 32 bits ●f64 : un nombre flottant de 64 bits ●String ●slice (on va y revenir plus loin dans ce chapitre) Sachez cependant que les types isize et usize existent aussi et sont l'équivalent de intptr_t et de uintptr_t en C/C++. En gros, sur un système 32 bits, ils feront respectivement 32 bits tandis qu'ils feront 64 bits sur un système 64 bits. Dernier petit point à aborder : il est courant de croiser ce genre de code en C/C++/Java/etc... : Run the following code: i++; ++i; Cette syntaxe est invalide en Rust, il vous faudra donc utiliser : Tutoriel Rust 8/103 Run the following code: i += 1; Autre détail qui peut avoir son importance : si on fait commencer le nom d'une variable par un '_', nous n'aurons pas de warning du compilateur si elle est inutilisée. Ça a son utilité dans certains cas, bien que cela reste assez restreint. Exemple : Run the following code: let _i = 0; Il est temps de revenir sur les slices. Les slices Pour faire simple, une slice représente un morceau de tableau. Pour ceux qui auraient fait du C/C++, c'est tout simplement un pointeur et une taille. Exemple : Run the following code: let tab = &[0, 1, 2]; // tab est une slice contenant 0, 1 et 2 println!("{:?}", tab); // ça affichera "[0, 1, 2]" let s = &tab[1..]; // s est maintenant une slice commençant à partir du 2e élément de tab println!("{:?}", s); // ça affichera "[1, 2]" De la même façon qu'il est possible d'obtenir une slice à partir d'un tableau, on peut en obtenir à partir des Vecs : Run the following code: let mut v: Vec<u8> = Vec::new(); v.push(0); v.push(1); v.push(2); let s = &v; println!("{:?}", s); // ça affichera "[0, 1, 2]" let s = &v[1..]; println!("{:?}", s); // ça affichera "[1, 2]" Les types contenant des tableaux ont toujours une slice associée. Par-exemple, String a &str, OsString a OsStr, etc... Voilà qui conclut ce chapitre. Tutoriel Rust 9/103 5. Conditions et pattern matching Nous allons d'abord commencer par les conditions : if / else if / else Les if / else if / else fonctionnent de la même façon qu'en C/C++/Java : Run the following code: let age: i32 = 17; if age >= 18 { println! uploads/S4/ tuto-1-copie-en-conflit-de-laptop-9iu813sb-2022-01-13.pdf