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') 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