{"id":16489962,"url":"https://github.com/crowdagger/fr_rust_book","last_synced_at":"2026-02-11T00:31:20.984Z","repository":{"id":147373205,"uuid":"43838804","full_name":"crowdagger/fr_rust_book","owner":"crowdagger","description":"Traduction française du rustbook","archived":false,"fork":false,"pushed_at":"2015-10-10T20:03:34.000Z","size":152,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":2,"default_branch":"master","last_synced_at":"2025-08-23T22:45:37.405Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":null,"has_issues":false,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/crowdagger.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2015-10-07T19:09:31.000Z","updated_at":"2023-11-12T07:35:24.000Z","dependencies_parsed_at":"2023-04-09T12:16:46.466Z","dependency_job_id":null,"html_url":"https://github.com/crowdagger/fr_rust_book","commit_stats":null,"previous_names":["crowdagger/fr_rust_book"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/crowdagger/fr_rust_book","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/crowdagger%2Ffr_rust_book","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/crowdagger%2Ffr_rust_book/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/crowdagger%2Ffr_rust_book/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/crowdagger%2Ffr_rust_book/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/crowdagger","download_url":"https://codeload.github.com/crowdagger/fr_rust_book/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/crowdagger%2Ffr_rust_book/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":29323519,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-02-10T20:44:44.282Z","status":"ssl_error","status_checked_at":"2026-02-10T20:44:43.393Z","response_time":65,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-10-11T13:46:00.354Z","updated_at":"2026-02-11T00:31:20.967Z","avatar_url":"https://github.com/crowdagger.png","language":null,"funding_links":[],"categories":[],"sub_categories":[],"readme":"% Le langage de programmation Rust\n\nBienvenue ! Ce livre va vous apprendre le [langage de programmation Rust][rust].\nRust est un langage de programmation système axé sur les trois buts suivants :\nsécurité, rapidité et concurrence. Il atteint ces trois buts sans utiliser de\nramasse-miette, le rendant utile dans un grand nombre de cas où d'autres\nlangages ne conviendraient pas : utilisation dans d'autres langages, logiciels\navec un espace défini et des performances restreintes ainsi que l'écriture de\ncode bas niveau (comme des drivers ou des systèmes d'exploitation). Il est plus\nperformant que les langages existants visant ces buts grâce à des vérifications\nau moment de la compilation qui permettent d'éviter des coûts de performance\nau moment de l'exécution tout en éliminant les risques de situation de\ncompétition. Rust a aussi pour but d'achever ‘zero-cost abstractions’ (ou\n\"abstration sans surcoût lors de l'exécution\") même si certaines de ces\nabstractions sont similaires à celles d'un langage de haut niveau. Malgré cela,\nRust permet quand même un contrôle précis tout comme un langage de bas niveau\nle ferait.\n\n[rust]: https://www.rust-lang.org\n\n\"Le langage de programmation Rust\" est divisé en huit sections. Cette\nintroduction est la première. Après il y a :\n\n* [Bien commencer][gs] - Configurer son ordinateur pour développer en Rust.\n* [Apprendre Rust][lr] - Apprendre à programmer en Rust au travers de petits projets.\n* [Rust en action][er] - Concepts de plus haut niveau pour écrire de l'excellent code Rust.\n* [Syntaxe et Sémantiques][ss] - Chaque petit bout de rust, Each bit of Rust, décomposé en petits morceaux.\n* [Nightly Rust][nr] - Dernières fonctionnalités pas encore disponibles dans la version stable.\n* [Sommaire][gl] - Une référence des termes utilisés dans ce livre.\n* [Bibliographie][bi] - Background des influences de Rust, articles parlant de Rust.\n\n[gs]: commencer.html\n[lr]: apprendre-rust.html\n[er]: rust-en-action.html\n[ss]: syntaxe-et-semantiques.html\n[nr]: rust-nightly.html\n[gl]: sommaire.html\n[bi]: bibliographie.html\n\nAprès avoir lu cette introduction, vous voudrez sans doute commencer par \"Apprendre Rust\"\nou \"Syntaxe et Sémantiques\". Selon votre préférence : \"Apprendre Rust\" si vous souhaitez\nplonger dans un projet, ou \"Syntaxe et Sémantiques\" si vous préférez commencer plus petit\net apprendre les concepts les uns après les autres. Des liens sont faits entre les deux\nparties.\n\n### Contribuer\n\nLes fichiers sources depuis lesquels ce livre est généré peuvent être trouvé sur Github :\n[https://github.com/GuillaumeGomez/fr_rust_doc/edit/master](https://github.com/GuillaumeGomez/fr_rust_doc/edit/master) et la version originale (en anglais) est disponible à cette adresse :\n[github.com/rust-lang/rust/tree/master/src/doc/trpl](https://github.com/rust-lang/rust/tree/master/src/doc/trpl).\n\n## Une brève introduction à Rust\n\nEst-ce que Rust est un langage qui pourrait vous intéresser ? Examinons quelques bouts de\ncode pour démontrer quelques-unes de ces forces.\n\nLe principal concept qui rend Rust unique est appelé \"propriété\" (ou \"ownership\"). Regardez\nl'exemple suivant :\n\n```rust\nfn main() {\n    let mut x = vec![\"Hello\", \"world\"];\n}\n```\n\nCe programme crée une [variable][var] appelée `x`. La valeur de cette assignation\nest un `Vec\u003cT\u003e`, un \"vecteur\", que nous créons avec une [macro][macro] définie\ndans la bibliothèque standard. Cette macro est appelée `vec`, et nous appelons\nles macros avec un `!`. Cela suit un principe global de Rust : rendre les choses\nexplicites. Les macros peuvent faire des choses beaucoup plus compliquées que\nde simple appels de fonctions, et sont visuellement distinctes. Le `!` aide aussi\npour le parsing, rendant les outils plus simple à écrire, ce qui est aussi\nimportant.\n\nNous avons utiliser `mut` pour rendre `x` mutable : les variables sont\nconstantes par défaut en Rust. Nous modifierons ce vecteur plus tard dans cet\nexemple.\n\nIl est aussi important de noter que n'avons pas eu besoin de donner un type à\nnotre variable ici : tant que Rust est statiquement typé, nous n'avions pas\nbesoin de définir le type explicitement. Rust fait de l'inférence de type\npour contrebalancer les forces du typage statique avec la verbosité des\nannotations de type.\n\nRust préfère les allocations sur la pile (stack memory) plutôt que sur le tas\n(heap memory) : `x` est mis directement sur la pile. Cependant, le type\n`Vec\u003cT\u003e` alloue de l'espace pour ses éléments sur le tas. Si vous n'êtes pas\nfamiliers avec cette distinction, vous pouvez vous contenter de l'ignorer pour\nle moment ou bien aller lire [‘The Stack and the Heap’][heap]. En tant que\nlangage de programmation système, Rust vous donne la possibilité de contrôler\nla façon dont votre mémoire est allouée, mais quand vous commencez, cela pas\nd'importance.\n\n[var]: variables.html\n[macro]: macros.html\n[heap]: the-stack-and-the-heap.html\n\nPlus tôt, nous avons mentionné le fait que la \"propriété\" est le nouveau concept\nclé en Rust. Dans le langage de Rust, `x` est désigné comme étant le\n\"propriétaire\" du vecteur. Cela signifie que quand `x` sort du scope (portée),\nla mémoire du vecteur va être libérée. C'est fait par le compilateur de Rust de\nmanière déterministe plutôt qu'à travers un mécanisme tel qu'un ramasse-miette.\nEn d'autres mots, en Rust, vous n'appelez pas des fonctions telles que `malloc`\net `free` vous-même : le compilateur va déterminer statiquement quand est-ce que\nvous aurez besoin d'allouer ou libérer de la mémoire, et ajoutera ces appels lui-\nmême. L'erreur est humaine, mais les compilateurs n'oublient jamais.\n\nAjoutons une autre ligne à notre exemple :\n\n```rust\nfn main() {\n    let mut x = vec![\"Hello\", \"world\"];\n\n    let y = \u0026x[0];\n}\n```\n\nNous avons introduit une nouvelle variable : `y`. Dans le cas présent, `y` est\nune référence sur le premier élément du vecteur. Les références en Rust sont\nsimilaires aux pointeurs dans d'autres langages, mais avec une vérification de\nsécurité supplémentaire au moment de la compilation. Les références intéragissent\navec le système de propriété en [\"empruntant\"][borrowing] (ou \"borrowing\") ce sur\nquoi elles pointent plutôt que d'en devenir le propriétaire. La différence est\nque, lorsque la référence est détruite, la mémoire de l'objet pointé ne l'est\npas. Si c'était le cas, nous aurions une double libération de mémoire, ce qui\nserait assez problématique !\n\n[borrowing]: references-et-emprunt.html\n\nAjoutons maintenant une troisième ligne. Ça semble assez innocent, mais cause\npourtant une erreur du compilateur :\n\n```rust,ignore\nfn main() {\n    let mut x = vec![\"Hello\", \"world\"];\n\n    let y = \u0026x[0];\n\n    x.push(\"foo\");\n}\n```\n\n`push` est une méthode de `Vec` qui permet d'ajouter un élément à la fin du\nvecteur. Quand on essaie de compiler ce code, on obtient l'erreur suivante :\n\n```text\nerror: cannot borrow `x` as mutable because it is also borrowed as immutable\n    x.push(\"foo\");\n    ^\nnote: previous borrow of `x` occurs here; the immutable borrow prevents\nsubsequent moves or mutable borrows of `x` until the borrow ends\n    let y = \u0026x[0];\n             ^\nnote: previous borrow ends here\nfn main() {\n\n}\n^\n```\n\nWhew ! La compilateur Rust donne des erreurs plutôt détaillées à certains moments,\net c'est justement l'un de ces moments. Comme l'erreur l'explique, alors que nous\navons crée une variable mutable, nous ne pouvons pas utiliser la méthode `push`.\nC'est parce que nous avons déjà une référence sur un élément du vecteur, `y`.\nModifier quelque chose alors qu'une autre référence sur cet objet existe est\ndangereux, parce que cela pourrait rendre cette référence invalide. Dans ce cas\nspécifique, quand nous créons le vecteur, nous n'avons alloué de la mémoire que\npour deux éléments. En ajouter un troisième signifierait allouer un nouveau bout\nde mémoire pour tous ces nouveaux éléments, copier les anciennes valeurs dedans\net mettre à jour le pointeur interne pointant sur cette mémoire. Ça fonctionne\ntrès bien. Le problème est que `y` ne serait pas mis à jour et nous nous\nretrouverions avec un pointeur invalide. Ce qui n'est pas bon. Tout usage de `y`\nserait une erreur dans ce contexte, et donc le compilateur nous a montré notre\nerreur.\n\nDonc maintenant, comment résoudre ce problème ? Il y a 2 façons de faire. La\npremière est de créer une copie plutôt que d'utiliser une référence :\n\n```rust\nfn main() {\n    let mut x = vec![\"Hello\", \"world\"];\n\n    let y = x[0].clone();\n\n    x.push(\"foo\");\n}\n```\n\nRust utilise la [sémantique move][move] par défaut, donc si nous voulons créer une\ncopie de données, nous pouvons appeler la méthode `clone()`. Dans cet exemple, `y`\nn'est plus une référence sur le vecteur stocké dans `x`, mais une copie de son\npremier élément, `\"Hello\"`. Maintenant que nous n'avons plus de référence, notre\n`push()` fonctionne parfaitement.\n\n[move]: propriete.html#move-semantics\n\nSi nous voulons vraiment une référence, nous allons devoir utiliser l'autre\nsolution : sortir du scope courant avant d'essayer de modifier notre variable.\nÇa ressemble à ça :\n\n```rust\nfn main() {\n    let mut x = vec![\"Hello\", \"world\"];\n\n    {\n        let y = \u0026x[0];\n    }\n\n    x.push(\"foo\");\n}\n```\n\nNous avons créé un sous-scope (inner scope) en ajoutant des accolades. `y` sortira\ndu scope avant que l'on appelle `push()`, et donc tout est bon.\n\nCe concept de propriété n'est pas seulement bon pour prévenir des pointeurs invalides,\nmais aussi un ensemble complets d'autres problèmes liés, comme des itérateurs\ninvalides, de la concurrence et bien plus.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcrowdagger%2Ffr_rust_book","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcrowdagger%2Ffr_rust_book","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcrowdagger%2Ffr_rust_book/lists"}