From a0b6af45345b957c749dd2cd2e54117006af08be Mon Sep 17 00:00:00 2001 From: "J. Ryan Rembert" Date: Tue, 16 Aug 2016 03:42:20 -0700 Subject: [rust/fr] - French translation for Rust tutorial (#2297) * Initial pass at a fr translation of Rust tutorial * Clean up formatting * Add GFM rust modifer to code black * Final pre-PR fixes * Edit YAML front-matter * Grammar and typo fixes --- fr-fr/rust-fr.html.markdown | 319 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 319 insertions(+) create mode 100644 fr-fr/rust-fr.html.markdown (limited to 'fr-fr/rust-fr.html.markdown') diff --git a/fr-fr/rust-fr.html.markdown b/fr-fr/rust-fr.html.markdown new file mode 100644 index 00000000..0fa16075 --- /dev/null +++ b/fr-fr/rust-fr.html.markdown @@ -0,0 +1,319 @@ +--- +language: rust +contributors: + - ["P1start", "http://p1start.github.io/"] +translators: + - ["Ryan Rembert", "http://jrrembert.github.io"] +filename: learnrust-fr.rs +lang: fr-fr +--- + +Rust est un langage de programmation développé par Mozilla Research. Rust combine le contrôle de bas niveau sur la performance avec la commodité et la sécurité garanties de haut niveau. + +Il atteint ces objectifs sans avoir besoin d'un ramasse-miettes ou environnement d'exécution, ce qui rend possible l'utilisation de bibliothèques Rust comme une substitution directe pour C. + +La première version de Rust, 0.1, est sortie en janvier 2012 et a tellement évolué rapidement que jusqu'à récemment, l'utilisation de versions stables était déconseillée - à la place ce était conseillé d'utiliser les nightly builds. + +Le 15 mai 2015, Rust 1.0 a été libéré avec une garantie complète de compatibilité ascendante. Améliorations aux temps de compilation et d'autres aspects du compilateur sont actuellement disponibles dans la nightly builds. Rust a adopté un modèle de libération à bord du train avec les versions régulières toutes les six semaines. Rust 1.1 beta a été mis à la disposition dans le même temps de la libération de Rust 1.0. + +Bien que Rust soit un langage relativement bas niveau, Rust a quelques concepts fonctionnels qui se trouvent généralement dans les langues de niveau supérieur. Cela rend Rust non seulement rapide, mais aussi efficace et facile à coder. + +```rust +// Ceci est un commentaire. commentaires de ligne ressemblent à ceci ... +// Et prolonger plusieurs lignes comme celle-ci. + +/// Les commentaires de documentation ressemblent à ceci et à soutenir +/// la notation de démarques. +/// # Exemples +/// +/// ``` +/// let cinq = 5 +/// ``` + +/////////////// +// 1. Basics // +/////////////// + +// Les fonctions +// `I32` est le type 32 bits entiers signés +fn add2(x: i32, y: i32) -> i32 { +    // Retour implicite (pas virgule) +    x + y +} + +// Fonction principale +fn main() { +    // Nombres // + +    // Reliures immutable +    let x: i32 = 1; + +    // Entier suffixes/float +    let y: I32 = 13i32; +    let f: f64 = 1.3f64; + +    // Type Inférence +    // La plupart du temps, le compilateur Rust peut déduire le type de variable + // est, donc vous ne devez pas écrire une annotation de type explicite. +    // Tout au long de ce tutoriel, les types sont explicitement annotées dans + // de nombreux endroits, mais seulement à des fins de démonstration. + // L'inférence de type peut gérer cela pour vous la plupart du temps. +    let implicit_x = 1; +    let implicit_f = 1,3; + +    // Arithmétique +    let somme = x + y + 13; + +    // Variable Mutable +    let mut mutable = 1; +    let mutable = 4; +    let mutable += 2; + +    // Chaînes // + +    // Littéraux chaîne +    let x: &str = "Bonjour tout le monde!"; + +    // Impression +    println!("{} {}", f, x); // 1.3 Bonjour tout le monde + +    // A `Chaîne` - une chaîne de tas alloué +    let s: String = "Bonjour tout le monde".to_string(); + +    // Une tranche de chaîne - une vue immutable dans une else chaîne. +    // Ceci est essentiellement un pointeur immutable à une chaîne - il n'a pas +    // contient effectivement le contenu d'une chaîne, juste un pointeur vers +    // quelque chose qui fait(dans ce cas, `s`). +    let s_slice: &str = &s; + +    println!("{} {}", s, s_slice); // Bonjour monde Bonjour tout le monde + +    // Vecteurs/tableau // + +    // Un tableau de taille fixe +    let four_ints: [i32; 4] = [1, 2, 3, 4]; + +    // Un tableau dynamique(vecteur) +    let mut vecteur: Vec = vec![1, 2, 3, 4]; +    vecteur.push(5); + +    // Une tranche - une vue immutable dans un vecteur ou un tableau. +    // Ceci est un peu comme une tranche de chaîne, mais pour les vecteurs. +    let tranche: &[i32] = &vecteur; + +    // Utiliser `{:?}` pour imprimer quelque chose de débogage de style +    println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5] + +    // Tuples // + +    // Un tuple est un ensemble de valeurs de peut-être différents types. + // de taille fixe +    let x:(i32, &str, f64) = (1, "bonjour", 3.4); + +    // Déstructurante `let` +    let (a, b, c) = x; +    println!("{} {} {}", a, b, c); // 1 bonjour 3.4 + +    // indexation +    println!("{}", x.1); // Bonjour + +    ////////////// +    // 2. Types // +    ////////////// + +    // Struct +    struct Point { +        x: i32, +        y: i32, +    } + +    let origine: Point = Point { x: 0, y: 0 }; + +    // Un struct avec des champs sans nom, appelé 'tuple struct'. +    struct Point2(i32, i32); + +    let origine2 = Point2(0, 0); + +    // Basic C-like enum +    enum Direction { +        Àgauche, +        Droite, +        En_Haut, +        Vers_Le_Bas, +    } + +    let en_haut = Direction::En_Haut; + +    // Enum avec des champs +    enum OptionnelI32 { +        AnI32(I32), +        Rien, +    } + +    let deux: OptionnelI32 = OptionnelI32::AnI32(2); +    let rien = OptionnelI32::Rien; + +    // Generics // + +    struct Foo { bar: T } + +    // Ceci est défini dans la bibliothèque standard comme `Option`. +    enum Optionnel { +        SomeVal(T), +        NoVal, +    } + +    // Méthodes // + +    impl Foo { +        // Méthodes prennent un paramètre explicite `de self`. +        fn get_bar(self) -> T { +            self.bar +        } +    } + +    let a_foo = Foo { bar: 1 }; +    println!("{}", a_foo.get_bar()); // 1 + +    // Traits (connu sous le nom des interfaces ou des classes de types dans + // d'elses langues). + +    trait Frobnicate { +        fn frobnicate(self) -> Option; +    } + +    impl Frobnicate for Foo { +        fn frobnicate(self) -> Option { +            Some(self.bar) +        } +    } + +    let another_foo = Foo { bar: 1 }; +    println!("{:?}", another_foo.frobnicate()); // Some(1) + +    ///////////////////////// +    // 3. Motif correspondant // +    ///////////////////////// + +    let foo = OptionnelI32::AnI32(1); +    match foo { +        OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n), +        OptionnelI32::Rien => println!("Il n'y a rien!"), +    } + +    // Motif avancé correspondant +    struct FooBar { x: i32, y: OptionnelI32 } +    let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) }; + +    match bar { +        FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} => +            println!("Les chiffres sont nuls!"), +        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m => +            println!("Les chiffres sont les mêmes"), +        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} => +            println!("Différents numéros: {} {}", n, m)!, +        FooBar { x: _, y: OptionnelI32 :: Rien} => +            println!("Le deuxième numéro est rien!"), +    } + +    ///////////////////// +    // 4. Flux de contrôle // +    ///////////////////// + +    // `for` boucles / itération +    let array = [1, 2, 3]; +    for i in array.iter() { +        println!("{}", i); +    } + +    // Ranges +    for i in 0u32..10 { +        print!("{}", i); +    } +    println!(""); +    // imprime `0 1 2 3 4 5 6 7 8 9` + +    // `if` +    if 1 == 1 { +        println!("Maths est travaille!"); +    } else { +        println!("Oh non ...!"); +    } + +    // `if` comme expression +    let valeur = if true { +        "bien" +    } else { +        "mal" +    }; + +    // `while` boucle +    while 1 == 1 { +        println!("L'univers fonctionne normalement."); +    } + +    // Boucle infinie +    loop { +        println!("Bonjour!"); +    } + +    ///////////////////////////////// +    // 5. Sécurité & pointeurs mémoire // +    ///////////////////////////////// + + // Pointeur occasion - une seule chose peut "posséder" pointeur à un moment. +    // Cela signifie que lorsque le `Box` laisse son champ d'application, il + // peut être automatiquement libérée en toute sécurité. +    let mut mien: Box = Box::new(3); +    *mien = 5; // déréférencer +    // Ici, `now_its_mine` prend possession de` mine`. En d'elses termes, + // `mien` est déplacé. +    let mut now_its_mine = mien; +    *now_its_mine += 2; + +    println!("{}", now_its_mine); // 7 +    // println!("{}", de la mine); // Cela ne compile pas parce + // que `now_its_mine` possède maintenant le pointeur + +    // Référence - un pointeur immutable qui fait référence à d'elses données. +    // Quand une référence est prise à une valeur, nous disons que la valeur + // a été "emprunté". +    // Même si une valeur est emprunté immutablement, il ne peut pas être + // muté ou déplacé. +    // Un emprunt dure jusqu'à la fin de la portée, il a été créé. +    let mut var = 4; +    var = 3; +    let ref_var: &i32 = &var; + +    println!("{}", var); // Contrairement `box`, `var` peut encore être utilisé +    println!("{}", *ref_var); +    // Var = 5; // Cela ne compile pas parce que `var` est emprunté. +    // *ref_var = 6; // Ce ne serait pas non plus, parce que `ref_var` est une + // référence immutable. + +    // Référence Mutable +    // Même si une valeur est mutably emprunté, il ne peut pas être + // accessible à tous. +    let mut var2 = 4; +    let ref_var2: &mut i32 = &mut var2; + // '*' est utilisé pour pointer vers le var2 mutably emprunté. + *ref_var2 += 2; + + println!("{}", * ref_var2); // 6, // var2 ne serait pas compiler. +    // ref_var2 est de type &mut i32 donc stocke il référence à i32, + // pas la valeur. +    // var2 = 2; // Cela ne compile pas parce que `var2` est emprunté. +} +``` + +## Autres lectures + +Il y a beaucoup plus à Rust -- ce est juste l'essentiel de Rust afin que vous puissiez comprendre +les choses les plus importantes. Pour en savoir plus sur Rust, lire [La Programmation Rust +Langue](http://doc.rust-lang.org/book/index.html) et etudier la +[/r/rust](http://reddit.com/r/rust) subreddit. Les gens sur le canal de #rust sur +irc.mozilla.org sont aussi toujours prêts à aider les nouveaux arrivants. + +Vous pouvez également essayer caractéristiques de Rust avec un compilateur en ligne sur le fonctionnaire +[Rust parc](http://play.rust-lang.org) ou sur la principale +[Site Rust](http://rust-lang.org). -- cgit v1.2.3 From 970aff0dadeeed4362881f8088e81f4d703000a7 Mon Sep 17 00:00:00 2001 From: Rob Wu Date: Tue, 27 Sep 2016 16:42:40 +0200 Subject: Fix comment in Rust docs: box -> mine (#2365) The "box" is referring to the Box variable a few lines back, but that is called "mine", not "box". --- fr-fr/rust-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr/rust-fr.html.markdown') diff --git a/fr-fr/rust-fr.html.markdown b/fr-fr/rust-fr.html.markdown index 0fa16075..5a1f8268 100644 --- a/fr-fr/rust-fr.html.markdown +++ b/fr-fr/rust-fr.html.markdown @@ -285,7 +285,7 @@ fn main() {     var = 3;     let ref_var: &i32 = &var; -    println!("{}", var); // Contrairement `box`, `var` peut encore être utilisé +    println!("{}", var); // Contrairement `mien`, `var` peut encore être utilisé     println!("{}", *ref_var);     // Var = 5; // Cela ne compile pas parce que `var` est emprunté.     // *ref_var = 6; // Ce ne serait pas non plus, parce que `ref_var` est une -- cgit v1.2.3 From ceb6b37b63420cb40dc2cfc1fc4a2e96a46ee9a1 Mon Sep 17 00:00:00 2001 From: ven Date: Tue, 27 Sep 2016 16:45:30 +0200 Subject: Fix mistakes in rust --- fr-fr/rust-fr.html.markdown | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) (limited to 'fr-fr/rust-fr.html.markdown') diff --git a/fr-fr/rust-fr.html.markdown b/fr-fr/rust-fr.html.markdown index 5a1f8268..6ab559a3 100644 --- a/fr-fr/rust-fr.html.markdown +++ b/fr-fr/rust-fr.html.markdown @@ -176,7 +176,7 @@ fn main() {     println!("{}", a_foo.get_bar()); // 1     // Traits (connu sous le nom des interfaces ou des classes de types dans - // d'elses langues). + // d'autres langues).     trait Frobnicate {         fn frobnicate(self) -> Option; @@ -264,18 +264,18 @@ fn main() { // Pointeur occasion - une seule chose peut "posséder" pointeur à un moment.     // Cela signifie que lorsque le `Box` laisse son champ d'application, il // peut être automatiquement libérée en toute sécurité. -    let mut mien: Box = Box::new(3); -    *mien = 5; // déréférencer -    // Ici, `now_its_mine` prend possession de` mine`. En d'elses termes, - // `mien` est déplacé. -    let mut now_its_mine = mien; +    let mut mine: Box = Box::new(3); +    *mine = 5; // déréférencer +    // Ici, `now_its_mine` prend possession de `mine`. En d'autres termes, + // `mine` est déplacé. +    let mut now_its_mine = mine;     *now_its_mine += 2;     println!("{}", now_its_mine); // 7 -    // println!("{}", de la mine); // Cela ne compile pas parce +    // println!("{}", now_its_mine); // Cela ne compile pas parce // que `now_its_mine` possède maintenant le pointeur -    // Référence - un pointeur immutable qui fait référence à d'elses données. +    // Référence - un pointeur immutable qui fait référence à d'autres données.     // Quand une référence est prise à une valeur, nous disons que la valeur // a été "emprunté".     // Même si une valeur est emprunté immutablement, il ne peut pas être @@ -285,22 +285,22 @@ fn main() {     var = 3;     let ref_var: &i32 = &var; -    println!("{}", var); // Contrairement `mien`, `var` peut encore être utilisé +    println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé     println!("{}", *ref_var);     // Var = 5; // Cela ne compile pas parce que `var` est emprunté. -    // *ref_var = 6; // Ce ne serait pas non plus, parce que `ref_var` est une +    // *ref_var = 6; // Ce ne serait pas correct non plus, parce que `ref_var` est une // référence immutable.     // Référence Mutable -    // Même si une valeur est mutably emprunté, il ne peut pas être +    // Même si une valeur est empruntée de façon mutable, elle ne peut pas être // accessible à tous.     let mut var2 = 4;     let ref_var2: &mut i32 = &mut var2; // '*' est utilisé pour pointer vers le var2 mutably emprunté. *ref_var2 += 2; - println!("{}", * ref_var2); // 6, // var2 ne serait pas compiler. -    // ref_var2 est de type &mut i32 donc stocke il référence à i32, + println!("{}", * ref_var2); // 6, // var2 ne compilerait pas. +    // ref_var2 est de type &mut i32 donc stocke la référence à i32, // pas la valeur.     // var2 = 2; // Cela ne compile pas parce que `var2` est emprunté. } -- cgit v1.2.3 From 30d63b3709472daed27b2d837c0834ca1db84888 Mon Sep 17 00:00:00 2001 From: raph Date: Mon, 2 Jan 2017 16:13:26 +0100 Subject: Update rust-fr.html.markdown (#2616) --- fr-fr/rust-fr.html.markdown | 51 ++++++++++++++++++++++----------------------- 1 file changed, 25 insertions(+), 26 deletions(-) (limited to 'fr-fr/rust-fr.html.markdown') diff --git a/fr-fr/rust-fr.html.markdown b/fr-fr/rust-fr.html.markdown index 6ab559a3..5a384864 100644 --- a/fr-fr/rust-fr.html.markdown +++ b/fr-fr/rust-fr.html.markdown @@ -19,11 +19,11 @@ Le 15 mai 2015, Rust 1.0 a été libéré avec une garantie complète de compati Bien que Rust soit un langage relativement bas niveau, Rust a quelques concepts fonctionnels qui se trouvent généralement dans les langues de niveau supérieur. Cela rend Rust non seulement rapide, mais aussi efficace et facile à coder. ```rust -// Ceci est un commentaire. commentaires de ligne ressemblent à ceci ... -// Et prolonger plusieurs lignes comme celle-ci. +// Ceci est un commentaire. Les commentaires de ligne ressemblent à ceci... +// et continuent sur plusieurs lignes comme cela. -/// Les commentaires de documentation ressemblent à ceci et à soutenir -/// la notation de démarques. +/// Les commentaires de documentation ressemblent à ça et supportent la +/// syntaxe Markdown. /// # Exemples /// /// ``` @@ -37,7 +37,7 @@ Bien que Rust soit un langage relativement bas niveau, Rust a quelques concepts // Les fonctions // `I32` est le type 32 bits entiers signés fn add2(x: i32, y: i32) -> i32 { -    // Retour implicite (pas virgule) +    // Retour implicite (pas de point virgule)     x + y } @@ -45,19 +45,19 @@ fn add2(x: i32, y: i32) -> i32 { fn main() {     // Nombres // -    // Reliures immutable +    // Liaison immutable     let x: i32 = 1; -    // Entier suffixes/float +    // Suffixes entiers et flottants     let y: I32 = 13i32;     let f: f64 = 1.3f64; -    // Type Inférence -    // La plupart du temps, le compilateur Rust peut déduire le type de variable - // est, donc vous ne devez pas écrire une annotation de type explicite. +    // Inférence de type +    // La plupart du temps, le compilateur Rust peut déduire quel est le type + // de variable, donc vous n'avez pas à écrire une annotation de type explicite.     // Tout au long de ce tutoriel, les types sont explicitement annotées dans // de nombreux endroits, mais seulement à des fins de démonstration. - // L'inférence de type peut gérer cela pour vous la plupart du temps. + // L'inférence de type peut les générer pour vous la plupart du temps.     let implicit_x = 1;     let implicit_f = 1,3; @@ -71,22 +71,22 @@ fn main() {     // Chaînes // -    // Littéraux chaîne -    let x: &str = "Bonjour tout le monde!"; +    // Chaîne littérales +    let x: &str = "Bonjour tout le monde !"; -    // Impression +    // Affichage     println!("{} {}", f, x); // 1.3 Bonjour tout le monde -    // A `Chaîne` - une chaîne de tas alloué +    // Une `Chaîne` - une chaîne de tas alloué     let s: String = "Bonjour tout le monde".to_string(); -    // Une tranche de chaîne - une vue immutable dans une else chaîne. -    // Ceci est essentiellement un pointeur immutable à une chaîne - il n'a pas -    // contient effectivement le contenu d'une chaîne, juste un pointeur vers -    // quelque chose qui fait(dans ce cas, `s`). +    // Un morceau de chaîne - une vue immutable sur une autre chaîne. +    // C'est essentiellement un pointeur immutable sur une chaîne - ça ne +    // contient effectivement pas le contenu d'une chaîne, juste un pointeur vers +    // le début et la fin de la chaîne.     let s_slice: &str = &s; -    println!("{} {}", s, s_slice); // Bonjour monde Bonjour tout le monde +    println!("{} {}", s, s_slice); // Bonjour tout le monde Bonjour tout le monde     // Vecteurs/tableau // @@ -97,20 +97,19 @@ fn main() {     let mut vecteur: Vec = vec![1, 2, 3, 4];     vecteur.push(5); -    // Une tranche - une vue immutable dans un vecteur ou un tableau. -    // Ceci est un peu comme une tranche de chaîne, mais pour les vecteurs. +    // Une tranche - une vue immutable sur un vecteur ou un tableau. +    // Ceci est un peu comme un morceau de chaîne, mais pour les vecteurs.     let tranche: &[i32] = &vecteur; -    // Utiliser `{:?}` pour imprimer quelque chose de débogage de style +    // Utiliser `{:?}` pour afficher quelque chose en mode debug     println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]     // Tuples // -    // Un tuple est un ensemble de valeurs de peut-être différents types. - // de taille fixe +    // Un tuple est un ensemble de valeurs qui peuvent être de différents types.     let x:(i32, &str, f64) = (1, "bonjour", 3.4); -    // Déstructurante `let` +    // Déstructurer `let`     let (a, b, c) = x;     println!("{} {} {}", a, b, c); // 1 bonjour 3.4 -- cgit v1.2.3 From 14e264720095cbdc3841369143d554c40eacdbf7 Mon Sep 17 00:00:00 2001 From: Etienne Charignon Date: Wed, 22 Mar 2017 13:32:55 +0100 Subject: Update rust-fr.html.markdown (#2687) --- fr-fr/rust-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr/rust-fr.html.markdown') diff --git a/fr-fr/rust-fr.html.markdown b/fr-fr/rust-fr.html.markdown index 5a384864..b3675f5b 100644 --- a/fr-fr/rust-fr.html.markdown +++ b/fr-fr/rust-fr.html.markdown @@ -14,7 +14,7 @@ Il atteint ces objectifs sans avoir besoin d'un ramasse-miettes ou environnement La première version de Rust, 0.1, est sortie en janvier 2012 et a tellement évolué rapidement que jusqu'à récemment, l'utilisation de versions stables était déconseillée - à la place ce était conseillé d'utiliser les nightly builds. -Le 15 mai 2015, Rust 1.0 a été libéré avec une garantie complète de compatibilité ascendante. Améliorations aux temps de compilation et d'autres aspects du compilateur sont actuellement disponibles dans la nightly builds. Rust a adopté un modèle de libération à bord du train avec les versions régulières toutes les six semaines. Rust 1.1 beta a été mis à la disposition dans le même temps de la libération de Rust 1.0. +Le 15 mai 2015, Rust 1.0 a été libéré avec une garantie complète de compatibilité ascendante. Améliorations aux temps de compilation et d'autres aspects du compilateur sont actuellement disponibles dans la nightly builds. Rust a adopté un modèle de train de livraison avec les versions régulières toutes les six semaines. Rust 1.1 beta a été mis à disposition au moment de la livraison de Rust 1.0. Bien que Rust soit un langage relativement bas niveau, Rust a quelques concepts fonctionnels qui se trouvent généralement dans les langues de niveau supérieur. Cela rend Rust non seulement rapide, mais aussi efficace et facile à coder. -- cgit v1.2.3