From 5aa692f5f3bbfa7b79224748dcfd8ca5fba7a8bc Mon Sep 17 00:00:00 2001 From: Adam Date: Fri, 12 Feb 2016 11:42:25 -0800 Subject: brainfuck->bf --- fr-fr/bf-fr.html.markdown | 87 ++++++++++++++++++++++++++++++++++++++++ fr-fr/brainfuck-fr.html.markdown | 87 ---------------------------------------- 2 files changed, 87 insertions(+), 87 deletions(-) create mode 100644 fr-fr/bf-fr.html.markdown delete mode 100644 fr-fr/brainfuck-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/bf-fr.html.markdown b/fr-fr/bf-fr.html.markdown new file mode 100644 index 00000000..0fae6032 --- /dev/null +++ b/fr-fr/bf-fr.html.markdown @@ -0,0 +1,87 @@ +--- +language: bf +filename: learnbrainfuck-fr.bf +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Baptiste Fontaine", "http://bfontaine.net"] +lang: fr-fr +--- + +Brainfuck (sans majuscule à part au début d’une phrase) est un langage +Turing-complet extrêmement simple avec seulement 8 commandes. + +``` +Tout caractère en dehors de "><+-.,[]" (en dehors des guillemets) est ignoré. + +Brainfuck est représenté par un tableau de 30 000 cellules initialisées à 0 et +un pointeur de données pointant sur la cellule courante. + +Il y a huit commandes : ++ : Incrémente la valeur de la cellule courante de un. +- : Décrémente la valeur de la cellule courante de un. +> : Déplace le pointeur de données sur la cellule suivante (à droite). +< : Déplace le pointeur de données sur la cellule précédente (à gauche). +. : Affiche la valeur ASCII de la cellule courante (par ex. 65 = 'A'). +, : Lit un caractère et le place dans la cellule courante. +[ : Si la valeur dans la cellule courante vaut 0, saute au ] correspondant. + Sinon, continue avec la commande suivante. +] : Si la valeur dans la cellule courante vaut 0, continue avec la commande + suivante. Sinon, retourne au [ correspondant. + +[ et ] forment une boucle « tant que » (« while »). Ils doivent évidemment +aller par paires. + +Regardons quelques programmes simples en brainfuck. + +++++++ [ > ++++++++++ < - ] > +++++ . + +Ce programme affiche la lettre 'A'. Il commence par incrémenter la première +cellule à 6. Il entre ensuite dans une boucle et se déplace sur la seconde +cellule. Il l’incrémente 10 fois, retourne sur la première cellule, et la +décrémente. Cette boucle est exécutée 6 fois (ce qui correspond aux 6 +décrémentations de la première cellule pour la faire atteindre 0, ce qui fait +sortir de la boucle). + +À ce moment-là, nous sommes sur la première cellule, qui a une valeur de 0, +tandis que la seconde cellule a une valeur de 60. Nous nous déplaçons sur +celle-ci, l’incrémentons 5 fois, pour une valeur de 65, et affichons sa valeur. +En ASCII, 65 correspond à 'A' donc le programme affiche 'A' dans le terminal. + +, [ > + < - ] > . + +Ce programme lit un caractère sur l’entrée standard et le copie dans la +première cellule. Il commence ensuite une boucle : il bouge sur la seconde +cellule, incrémente sa valeur, retourne sur la première et décrémente sa +valeur. Il continue jusqu’à ce que la valeur de la première cellule soit à 0, +et que la seconde cellule contienne l’ancienne valeur de la première. Comme +nous sommes sur la première cellule à la fin de la boucle, il bouge sur la +seconde et affiche sa valeur en ASCII. + +Souvenez-vous que les espaces sont uniquement là pour favoriser la lisibilité, +vous pourriez tout aussi aisément écrire le programme comme ceci : + +,[>+<-]>. + +Essayez et devinez ce que ce programme fait : + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Ce programme prend deux nombres en entrée, et les multiplie. + +Il commence par lire deux entrées, puis commence une boucle externe, qui a une +condition sur la première cellule. Il bouge ensuite sur la seconde, et commence +une boucle interne sur celle-ci, en incrémentant la troisième cellule. Il y a +cependant un problème : à la fin de la boucle interne, la valeur de la seconde +cellule est à zéro. Dans ce cas, la boucle interne ne fonctionnera pas une +seconde fois. Pour régler le problème, nous incrémentons aussi la quatrième +cellule, puis recopions sa valeur dans la seconde cellule. +À la fin, la troisième cellule contient le résultat de la multiplication. +``` + +Et voilà ce qu’est le brainfuck. Pas très dur, hein ? Pour le fun, vous pouvez +écrire vos propres programmes en brainfuck, ou écrire un interpréteur brainfuck +dans un autre langage. L’interpréteur est relativement simple à implémenter, +mais si vous êtes un masochiste, essayez d’écrire un interpréteur brainfuck en… +brainfuck. diff --git a/fr-fr/brainfuck-fr.html.markdown b/fr-fr/brainfuck-fr.html.markdown deleted file mode 100644 index 545e407e..00000000 --- a/fr-fr/brainfuck-fr.html.markdown +++ /dev/null @@ -1,87 +0,0 @@ ---- -language: brainfuck -filename: learnbrainfuck-fr.bf -contributors: - - ["Prajit Ramachandran", "http://prajitr.github.io/"] - - ["Mathias Bynens", "http://mathiasbynens.be/"] -translators: - - ["Baptiste Fontaine", "http://bfontaine.net"] -lang: fr-fr ---- - -Brainfuck (sans majuscule à part au début d’une phrase) est un langage -Turing-complet extrêmement simple avec seulement 8 commandes. - -``` -Tout caractère en dehors de "><+-.,[]" (en dehors des guillemets) est ignoré. - -Brainfuck est représenté par un tableau de 30 000 cellules initialisées à 0 et -un pointeur de données pointant sur la cellule courante. - -Il y a huit commandes : -+ : Incrémente la valeur de la cellule courante de un. -- : Décrémente la valeur de la cellule courante de un. -> : Déplace le pointeur de données sur la cellule suivante (à droite). -< : Déplace le pointeur de données sur la cellule précédente (à gauche). -. : Affiche la valeur ASCII de la cellule courante (par ex. 65 = 'A'). -, : Lit un caractère et le place dans la cellule courante. -[ : Si la valeur dans la cellule courante vaut 0, saute au ] correspondant. - Sinon, continue avec la commande suivante. -] : Si la valeur dans la cellule courante vaut 0, continue avec la commande - suivante. Sinon, retourne au [ correspondant. - -[ et ] forment une boucle « tant que » (« while »). Ils doivent évidemment -aller par paires. - -Regardons quelques programmes simples en brainfuck. - -++++++ [ > ++++++++++ < - ] > +++++ . - -Ce programme affiche la lettre 'A'. Il commence par incrémenter la première -cellule à 6. Il entre ensuite dans une boucle et se déplace sur la seconde -cellule. Il l’incrémente 10 fois, retourne sur la première cellule, et la -décrémente. Cette boucle est exécutée 6 fois (ce qui correspond aux 6 -décrémentations de la première cellule pour la faire atteindre 0, ce qui fait -sortir de la boucle). - -À ce moment-là, nous sommes sur la première cellule, qui a une valeur de 0, -tandis que la seconde cellule a une valeur de 60. Nous nous déplaçons sur -celle-ci, l’incrémentons 5 fois, pour une valeur de 65, et affichons sa valeur. -En ASCII, 65 correspond à 'A' donc le programme affiche 'A' dans le terminal. - -, [ > + < - ] > . - -Ce programme lit un caractère sur l’entrée standard et le copie dans la -première cellule. Il commence ensuite une boucle : il bouge sur la seconde -cellule, incrémente sa valeur, retourne sur la première et décrémente sa -valeur. Il continue jusqu’à ce que la valeur de la première cellule soit à 0, -et que la seconde cellule contienne l’ancienne valeur de la première. Comme -nous sommes sur la première cellule à la fin de la boucle, il bouge sur la -seconde et affiche sa valeur en ASCII. - -Souvenez-vous que les espaces sont uniquement là pour favoriser la lisibilité, -vous pourriez tout aussi aisément écrire le programme comme ceci : - -,[>+<-]>. - -Essayez et devinez ce que ce programme fait : - -,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> - -Ce programme prend deux nombres en entrée, et les multiplie. - -Il commence par lire deux entrées, puis commence une boucle externe, qui a une -condition sur la première cellule. Il bouge ensuite sur la seconde, et commence -une boucle interne sur celle-ci, en incrémentant la troisième cellule. Il y a -cependant un problème : à la fin de la boucle interne, la valeur de la seconde -cellule est à zéro. Dans ce cas, la boucle interne ne fonctionnera pas une -seconde fois. Pour régler le problème, nous incrémentons aussi la quatrième -cellule, puis recopions sa valeur dans la seconde cellule. -À la fin, la troisième cellule contient le résultat de la multiplication. -``` - -Et voilà ce qu’est le brainfuck. Pas très dur, hein ? Pour le fun, vous pouvez -écrire vos propres programmes en brainfuck, ou écrire un interpréteur brainfuck -dans un autre langage. L’interpréteur est relativement simple à implémenter, -mais si vous êtes un masochiste, essayez d’écrire un interpréteur brainfuck en… -brainfuck. -- cgit v1.2.3 From f3b10beb01795bf7513ec8d06c9e90ab98df7a83 Mon Sep 17 00:00:00 2001 From: Adam Date: Fri, 12 Feb 2016 23:04:31 -0800 Subject: Clean up various errors --- fr-fr/HTML-fr.html.markdown | 3 ++- fr-fr/d.html.markdown | 12 ++++++------ fr-fr/make-fr.html.markdown | 4 ++-- fr-fr/objective-c-fr.html.markdown | 3 +-- 4 files changed, 11 insertions(+), 11 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/HTML-fr.html.markdown b/fr-fr/HTML-fr.html.markdown index fdde9107..4d2da921 100644 --- a/fr-fr/HTML-fr.html.markdown +++ b/fr-fr/HTML-fr.html.markdown @@ -5,6 +5,7 @@ contributors: - ["Christophe THOMAS", "https://github.com/WinChris"] lang: fr-fr --- + HTML signifie HyperText Markup Language. C'est un langage (format de fichiers) qui permet d'écrire des pages internet. C’est un langage de balisage, il nous permet d'écrire des pages HTML au moyen de balises (Markup, en anglais). @@ -17,7 +18,7 @@ Comme tous les autres langages, HTML a plusieurs versions. Ici, nous allons parl Cet article porte principalement sur la syntaxe et quelques astuces. -```HTML +```html diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown index d9bd9b48..bfb9f2ce 100644 --- a/fr-fr/d.html.markdown +++ b/fr-fr/d.html.markdown @@ -8,7 +8,7 @@ translators: lang: fr-fr --- -```d +```c // Commençons par un classique module hello; @@ -30,7 +30,7 @@ D est activement développé par de nombreuses personnes très intelligents, gui [Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu). Après cette petite introduction, jetons un coup d'oeil à quelques exemples. -```d +```c import std.stdio; void main() { @@ -75,7 +75,7 @@ On peut définir de nouveaux types avec les mots-clés `struct`, `class`, `union` et `enum`. Ces types sont passés au fonction par valeur (ils sont copiés) De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques. -```d +```c // Ici, 'T' est un paramètre de type. Il est similaire au de C++/C#/Java. struct LinkedList(T) { T data = null; @@ -140,7 +140,7 @@ une méthode qui peut se comporter comme une lvalue. On peut donc utiliser la syntaxe des structures classiques (`struct.x = 7`) comme si il s'agissait de méthodes getter ou setter. -```d +```c // Considérons une classe paramétrée avec les types 'T' et 'U' class MyClass(T, U) { T _data; @@ -212,7 +212,7 @@ de premier ordre, les fonctions `pure` et les données immuables. De plus, tout vos algorithmes fonctionelles favoris (map, reduce, filter) sont disponibles dans le module `std.algorithm`. -```d +```c import std.algorithm : map, filter, reduce; import std.range : iota; // construit un intervalle excluant la dernière valeur. @@ -242,7 +242,7 @@ est de type A, comme si c'était une méthode de A. J'aime le parallélisme. Vous aimez les parallélisme ? Bien sur que vous aimez ça Voyons comment on le fait en D ! -```d +```c import std.stdio; import std.parallelism : parallel; import std.math : sqrt; diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown index 5a1e03e7..48d24549 100644 --- a/fr-fr/make-fr.html.markdown +++ b/fr-fr/make-fr.html.markdown @@ -1,9 +1,9 @@ --- language: make contributors: - - ["Robert Steed", "https://github.com/robochat"] + - ["Robert Steed", "https://github.com/robochat"] translators: - - ["altaris", "https://github.com/altaris"] + - ["altaris", "https://github.com/altaris"] filename: Makefile-fr lang: fr-fr --- diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown index 4e31c4bf..fbe1741e 100644 --- a/fr-fr/objective-c-fr.html.markdown +++ b/fr-fr/objective-c-fr.html.markdown @@ -1,5 +1,4 @@ --- - language: Objective-C contributors: - ["Eugene Yagrushkin", "www.about.me/yagrushkin"] @@ -9,7 +8,6 @@ translators: - ["Yannick Loriot", "https://github.com/YannickL"] filename: LearnObjectiveC-fr.m lang: fr-fr - --- L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs frameworks respectifs, Cocoa et Cocoa Touch. @@ -519,6 +517,7 @@ __unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais la variable n'es // l'objet est supprimé ``` + ## Lectures Complémentaires [La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C) -- cgit v1.2.3 From 484300f1db4509b08ed48526c61fcfcb48a6152b Mon Sep 17 00:00:00 2001 From: Zach Latta Date: Tue, 23 Feb 2016 16:12:44 -0800 Subject: Fix capitalization of GitHub --- fr-fr/markdown.html.markdown | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown index 66f0efbe..2e4e8461 100644 --- a/fr-fr/markdown.html.markdown +++ b/fr-fr/markdown.html.markdown @@ -62,8 +62,8 @@ __Celui-là aussi.__ **_Pareil ici_** *__Et là!__* - + ~~Ce texte est barré avec strikethrough.~~ @@ -172,7 +172,7 @@ fonctionne aussi à l'intérieur du bloc de code --> La fonction `run()` ne vous oblige pas à aller courir! - \`\`\`ruby @@ -183,7 +183,7 @@ puts "Hello world!" end \`\`\` -<-- Pas besoin d'indentation pour le code juste au dessus, de plus, Github +<-- Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub va utiliser une coloration syntaxique pour le langage indiqué après les ``` --> @@ -264,7 +264,7 @@ Pour taper *ce texte* entouré d'astérisques mais pas en italique : Tapez \*ce texte\*. - -- cgit v1.2.3 From 810178c3cc3e83d37efc8b73772b1a468f6117a9 Mon Sep 17 00:00:00 2001 From: Xuan-thi N Date: Sun, 26 Jun 2016 15:10:26 +0200 Subject: [Git/fr] Added translation for Git article (#1949) * Added translation for Git article * Took into account suggestions for modification * Forgot a fix --- fr-fr/git-fr.html.markdown | 583 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 583 insertions(+) create mode 100644 fr-fr/git-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/git-fr.html.markdown b/fr-fr/git-fr.html.markdown new file mode 100644 index 00000000..7a83704d --- /dev/null +++ b/fr-fr/git-fr.html.markdown @@ -0,0 +1,583 @@ +--- +category: tool +tool: git +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] + - ["Leo Rudberg" , "http://github.com/LOZORD"] + - ["Betsy Lorton" , "http://github.com/schbetsy"] + - ["Bruno Volcov", "http://github.com/volcov"] +translators: + - ["Xuan-thi Nguyen", "http://github.com/mellenguyen"] +filename: LearnGit-fr-.txt +lang: fr-fr +--- + +Git est un logiciel de contrôle de versions distribué et un système de gestion +du code source. + +Il effectue sa tâche via des séries d'instantanés (snapshots) du projet, et +travaille avec ces instantanés afin de fournir les fonctionnalités de gestion +de version et de code source. + +## Concepts du versionnage + +### Qu'est ce que le contrôle de version ? + +Le contrôle de version est un système qui enregistre les changements faits sur +un ou plusieurs fichiers au fil du temps. + +### Versionnage centralisé VS Versionnage distribué + +* Le contrôle de version centralisé se concentre sur la synchronisation, le +suivi et la sauvegarde des fichiers. +* Le contrôle de version distribué se focalise sur l'échange des changements. +Chaque changement a un identifiant unique. +* Les systèmes distribués n'ont pas de structure définie. Vous pouvez aisément +avoir un système centralisé de type SVN, avec Git. + +[Informations additionnelles](http://git-scm.com/book/fr/v1/D%C3%A9marrage-rapide-%C3%80-propos-de-la-gestion-de-version) + +### Pourquoi utiliser Git ? + +* Fonctionne hors ligne. +* Travailler avec les autres devient facile ! +* Ramifier le travail (créer des branches différentes) est facile ! +* Fusionner le travail est facile ! +* Git est rapide. +* Git est flexible. + +## Architecture Git + + +### Dépôt ("repository") + +Un ensemble de fichiers, dossiers, historiques de modifications, commits +(validations de changements) et de heads (état courant, "tête"). +Représentez-vous ceci comme une structure de données de code source, avec la +particularité que chaque "élement" vous donne, entre autres, accès à son +historique des révisions. + +Un dépôt Git comprend un répertoire .git et "l'arbre de travail" (working tree). + +### Répertoire .git (composant du dépôt) + +Le répertoire .git contient toutes les configurations, logs (journaux), +branches, HEAD et plus. +[Liste détaillée (EN)](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html) + +### Arbre de travail (composant du dépôt) + +Il s'agit de l'ensemble des répertoires et fichiers de votre dépôt. Il est +souvent qualifié de répertoire de travail ("working directory"). + +### Index (composant du répertoire .git) + +L'index est la zone de transit ("staging area") dans Git. Il s'agit d'une couche +séparant votre arbre de travail de votre dépôt Git. Ceci donne aux développeurs +plus de pouvoir sur ce qu'ils envoient au dépôt. + +### Commit + +Un "commit" (validation de changements) est un instantané d'un ensemble de +modifications de votre arbre de travail. Par exemple, si vous avez rajouté 5 +fichiers et enlevé 2 autres, ces changements seront contenus dans un commit +(ou "snapshot", instantané). Ce commit peut ensuite être poussé ("pushed") dans +d'autres dépôts, ou non ! + +### Branches + +Une branche consiste essentiellement en un pointeur vers le dernier commit que +vous avez fait. Au fur et à mesure de vos commits, ce pointeur se mettra +automatiquement à jour pour pointer vers le dernier commit. + +### Etiquette ("tag") + +Une étiquette est une marque sur un point spécifique de l'historique. +Typiquement, on utilise cette fonctionnalité pour marquer les états de +publication (v1.0, et ainsi de suite). + +### HEAD and head (composant du répertoire .git) + +HEAD est un pointeur pointant vers la branche courante. Un dépôt ne peut avoir +qu'un seul HEAD *actif*. +head est un pointeur pouvant pointer sur n'importe quel commit. Un dépôt peut +avoir un nombre illimité de heads. + +### Les états dans Git +* Modifié - Des changements on été faits à un fichier mais ce dernier n'a pas +encore été rajouté à l'ensemble des fichiers Git +* Indexé ("staged") - Indique qu'un fichier modifié ira dans le prochain commit +* Validé ("committed") - Les fichiers ont été validés dans l'ensemble de +fichiers + +### Ressources conceptuelles + +* [Git pour les informaticiens (EN)](http://eagain.net/articles/git-for-computer-scientists/) +* [Git pour les designers (EN)](http://hoth.entp.com/output/git_for_designers.html) + + +## Commandes + + +### init + +Créé un dépôt Git vide. Les paramètres du dépôt Git, les informations stockées +et plus sont dans un répertoire (un dossier) nommé ".git". + +```bash +$ git init +``` + +### config + +Configuration des paramètres. Que ce soit pour le dépôt, le système lui-même, +ou la configuration globale (le fichier de configuration globale +est `~/.gitconfig`). + + +```bash +# Lit et assigne quelques variables (globales) de configuration de base +$ git config --global user.email "monEmail@foo.com" +$ git config --global user.name "Mon nom" +``` + +[Apprenez-en plus à propos de git config.](https://git-scm.com/book/fr/v1/Personnalisation-de-Git-Configuration-de-Git) + +### help + +Vous donne un accès rapide à un guide extrêmement détaillé de chaque commande. +Ou juste vous donner un rappel rapide de la sémantique. + +```bash +# Vérifie rapidement les commandes disponibles +$ git help + +# Vérifie toutes les commandes disponibles +$ git help -a + +# Aide pour une commande spécifique - manuel utilisateur +# git help +$ git help add +$ git help commit +$ git help init +# ou git --help +$ git add --help +$ git commit --help +$ git init --help +``` + +### ignorer des fichiers + +Ne plus suivre certains fichiers et dossiers de Git. +Habituellement fait pour les fichiers privés et temporaires qui seraient, +autrement, partagés dans le dépôt. +```bash +$ echo "temp/" >> .gitignore +$ echo "cle_privee" >> .gitignore +``` + +### status + +Montre les différences entre le fichier indexé (typiquement votre copie/dépôt +de travail) et le HEAD actuel. + + +```bash +# Affiche la branche, les fichiers non suivis, les changements et autres +différences +$ git status + +# Pour en apprendre plus sur git status +$ git help status +``` + +### add + +Rajoute des fichiers à la zone d'index. Si vous ne faites pas `git add` sur les +nouveaux fichiers, ils ne seront pas inclus dans les commits ! + +```bash +# rajoute un fichier dans votre répertoire de travail actuel +$ git add HelloWorld.java + +# rajoute un fichier dans un répertoire imbriqué +$ git add /path/to/file/HelloWorld.c + +# Gestion des expressions régulières ! +$ git add ./*.java +``` + +On ne fait que rajouter des fichiers dans la zone d'index, on ne valide pas +les changements au répertoire/dépôt de travail. + +### branch + +Gère vos branches. Vous pouvez voir, éditer, créer et supprimer des branches en +utilisant cette commande. + +```bash +# Liste les branches existantes et distantes +$ git branch -a + +# Créé une nouvelle branche +$ git branch maNouvelleBranche + +# Supprime une branche +$ git branch -d maBranche + +# Renomme une branche +# git branch -m +$ git branch -m nomDeMaBranche nouveauNomDeMaBranche + +# Edite la description d'une branche +$ git branch nomDeMaBranche --edit-description +``` + +### tag + +Gère vos étiquettes + +```bash +# Liste les étiquettes +$ git tag + +# Créé une étiquette annotée +# L'option -m spécifie un message qui sera stockée dans l'étiquette. +# Si vous ne spécifiez pas de message pour une étiquette annotée, +# Git lance votre éditeur pour que vous puissiez le saisir. +$ git tag -a v2.0 -m 'ma version 2.0' + +# Affiche des informations à propos de l'étiquette +# comprenant des informations sur l'auteur, la date du commit correspondant, +# et le message d'annotation avant d'afficher les informations du commit. +$ git show v2.0 + +# Pousse une seule étiquette dans le dépôt distant +$ git push origin v2.0 + +# Pousse beaucoup d'étiquettes dans le dépôt distant +$ git push origin --tags +``` + +### checkout + +Met à jour tous les fichiers dans l'arbre de travail afin de correspondre à la +version de la zone d'index ou de l'arbre spécifié. + +```bash +# Obtenir une copie de travail du dépôt - par défaut on prend la branche master +$ git checkout + +# Bascule vers une branche spéficiée +$ git checkout nomDeLaBranche + +# Créé une nouvelle branche et bascule sur celle-ci +# Revient à faire "git branch ; git checkout " +$ git checkout -b nouvelleBranche +``` + +### clone + +Clone (ou copie) un dépôt existant dans un nouveau répertoire. Rajoute +également les branches distantes pour chaque branche du dépôt clôné, ce qui +vous permet de pousser vers une branche distante. + +```bash +# Clone learnxinyminutes-docs +$ git clone https://github.com/adambard/learnxinyminutes-docs.git + +# Clone superficiel ("shallow clone") - clone plus rapide qui récupère +seulement le dernier instantané ("snapshot") +$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git + +# Clone seulement une branche spécifique +$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch +``` + +### commit + +Conserve le contenu actuel de la zone d'index dans un nouveau "commit." Ce +commit contient les changements faits, accompagnés d'un message écrit par son +auteur. + +```bash +# Commit avec un message +$ git commit -m "Ajout de la fonction multiplierNombres() dans HelloWorld.c" + +# Rajoute automatiquement dans l'index les fichiers modifiés ou supprimés, +# à l'exception des nouveaux fichiers, puis commit +$ git commit -a -m "Modification de foo.php et suppression de bar.php" + +# Change le dernier commit (ceci supprime le commit précédent avec un +# nouveau commit) +$ git commit --amend -m "Message corrigé" +``` + +### diff + +Montre les différences entre un fichier dans le répertoire de travail, la zone +d'index and les commits. + +```bash +# Affiche les différences entre votre répertoire de travail et l'index +$ git diff + +# Affiche les différences entre l'index et le plus récent commit. +$ git diff --cached + +# Affiche les différences entre votre répertoire de travail et le plus récent +# commit +$ git diff HEAD +``` + +### grep + +Permet de faire une recherche rapide dans le dépôt. + +Configurations optionnelles : + +```bash +# Merci à Travis Jeffery pour ce qui suit +# Affiche les numéros des lignes dans les résultats de la recherche grep +$ git config --global grep.lineNumber true + +# Rend les résultats de recherche plus lisibles, en incluant les groupements +$ git config --global alias.g "grep --break --heading --line-number" +``` + +```bash +# Recherche de "nomDeVariable" dans tous les fichiers java +$ git grep 'nomDeVariable' -- '*.java' + +# Recherche une ligne contenant "nomDeTableau", et "rajouter" ou "enlever" +$ git grep -e 'nomDeTableau' --and \( -e rajouter -e enlever \) +``` + +Google est votre ami; pour plus d'exemples : +[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja) + +### log + +Affiche les commits d'un dépôt. + +```bash +# Montre tous les commits +$ git log + +# Montre seulement les messages de commits et leur référence +$ git log --oneline + +# Montre seulement les commits commits des merges (fusions) +$ git log --merges +``` + +### merge + +Fusionne les changements provenant de commits externes dans la branche +courante. + +```bash +# Fusionne la branche spécifiée dans la branche courante. +$ git merge nomDeBranche + +# Génère toujours un commit quand on fusionne +$ git merge --no-ff branchName +``` + +### mv + +Renomme ou déplace un fichier + +```bash +# Renomme un fichier +$ git mv HelloWorld.c HelloNewWorld.c + +# Déplace un fichier +$ git mv HelloWorld.c ./new/path/HelloWorld.c + +# Force le renommage ou le déplacement +# Si "fichierExistant" existe déjà dans le répertoire, il sera écrasé +$ git mv -f monFichier fichierExistant +``` + +### pull + +Récupère la version d'un dépôt et la fusionne avec une autre branche. + +```bash +# Met à jour votre dépôt local en y intégrant les changements +# depuis la branche "master" du dépôt distant "origin". +# git pull +$ git pull origin master + +# Par défaut, git pull mettra à jour votre branche actuelle +# en y intégrant les nouveaux changements venant de sa branche distante suivie +$ git pull + +# Intègre les changements de la branche distante et "rebase" +# les commits de la branche dans votre dépôt local, comme ceci: +#"git pull , git rebase " +$ git pull origin master --rebase +``` + +### push + +Pousse et fusionne les changements d'une dépôt local vers une branche distante. + +```bash +# Pousse et fusionne les changements d'un dépôt local vers la branche +# appelée "master" du dépôt distant "master". +# git push +$ git push origin master + +# Par défaut, git push poussera et fusionnera les changements de la branche +# courante vers sa branche distante suivie. +$ git push + +# Pour faire le lien entre la branche locale courante et sa branche distante, +# rajouter l'option -u : +$ git push -u origin master +# Dorénavant, à chaque fois que vous voulez pousser depuis cette même branche +# locale, utilisez ce raccourci : +$ git push +``` + +### stash + +Sauvegarde ("stash") l'état actuel de votre espace de travail et le garde dans +pile de changements non finis que vous pouvez réappliquer n'importe quand. + +Supposons que vous avez effectué du travail dans votre dépôt git, mais que vous +voulez récupérer la version de la branche distante. Depuis que vous avez des +changements "malpropres" (non commités) à quelques fichiers, vous ne pouvez pas +faire de `git pull`. A la place, vous pouvez utiliser `git stash` afin de +sauvegarder votre travail dans la pile ! + +```bash +$ git stash +Saved working directory and index state \ + "WIP on master: 049d078 added the index file" + HEAD is now at 049d078 added the index file + (To restore them type "git stash apply") +``` + +Vous pouvez maintenant pull ! + +```bash +git pull +``` +`...changes apply...` + +Vérifiez maintenant que tout est OK + +```bash +$ git status +# On branch master +nothing to commit, working directory clean +``` + +Vous pouvez constater quels "morceaux" vous avez stash jusque là en +utilisant `git stash list`. +Puisque les changements sont gardés dans une pile Last-In-First-Out, notre +changement le plus récent sera en premier. + +```bash +$ git stash list +stash@{0}: WIP on master: 049d078 rajout du fichier index +stash@{1}: WIP on master: c264051 annulation de "rajout de la taille_fichier" +stash@{2}: WIP on master: 21d80a5 ajout des chiffres aux logs +``` + +Appliquons maintenant les changements en les enlevant de notre pile. + +```bash +$ git stash pop +# On branch master +# Changes not staged for commit: +# (use "git add ..." to update what will be committed) +# +# modified: index.html +# modified: lib/simplegit.rb +# +``` + +`git stash apply` effectue le même travail + +Vous êtes maintenant prêt à retourner sur vos tâches de travail ! + +[Lecture additionelle.](https://git-scm.com/book/fr/v1/Utilitaires-Git-Le-remisage) + +### rebase (attention) + +Prend tous les changements qui ont été commités sur une branche, et les +ré-applique sur une autre branche. +*Ne rebasez pas les commits que vous avez poussés sur un dépôt publique*. + +```bash +# Expérimentation d'un rebase dans la branche "master" +# git rebase +$ git rebase master brancheExperience +``` + +[Lecture additionelle.](https://git-scm.com/book/fr/v1/Les-branches-avec-Git-Rebaser) + +### reset (attention) + +Réinitialise le pointeur HEAD courant à l'état spécifié. Ceci vous permet +d'annuler des fusions, des pulls, commits, ajouts et autres. C'est une commande +puissante mais également dangereuse si vous ne savez pas ce que vous faites. + +```bash +# Réinitialise la zone d'index afin de correspondre au dernier commit (laisse +# le répertoire inchangé). +$ git reset + +# Réinitialise la zone d'index afin de correspondre au dernier commit et +# réécrit le répertoire de travail. +$ git reset --hard + +# Déplace le pointeur de la branche courante au commit spécifié (laisse +# le répertoire inchangé). Tous les changements existents toujours dans +# le répertoire. +$ git reset 31f2bb1 + +# Déplace le pointeur de la branche courante en arrière, au commit spécifié +# et fait correspondre le répertoire de travail (supprime les changements +# non commités et tous les commits après le commit spécifié). +$ git reset --hard 31f2bb1 +``` + +### rm + +Le contraire de git add, git rm supprime les fichiers de l'arbre de travail +courant. + +```bash +# Supprime HelloWorld.c +$ git rm HelloWorld.c + +# Enlève un fichier d'un répertoire imbriqué. +$ git rm /chemin/vers/le/fichier/HelloWorld.c +``` + +## Informations complémentaires + +* [tryGit - A fun interactive way to learn Git (EN)](http://try.github.io/levels/1/challenges/1) + +* [Udemy Git Tutorial: A Comprehensive Guide (EN)](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/) + +* [git-scm - Tutoriaux vidéos](http://git-scm.com/videos) + +* [git-scm - Documentation](http://git-scm.com/docs) + +* [Atlassian Git - Tutoriaux et Workflows](https://www.atlassian.com/git/) + +* [SalesForce Cheat Sheet (EN)](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf) + +* [GitGuys (EN)](http://www.gitguys.com/) + +* [Git - the simple guide (EN)](http://rogerdudler.github.io/git-guide/index.html) + +* [Livre Pro Git](http://www.git-scm.com/book/fr/v1) + +* [Une introduction à Git et GitHub pour les débutants (tutoriel) (EN)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners) -- cgit v1.2.3 From cf309475adf6e26ec3977c81d58d033551361e18 Mon Sep 17 00:00:00 2001 From: ven Date: Sun, 26 Jun 2016 15:10:59 +0200 Subject: #1949 metadata fix --- fr-fr/git-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr') diff --git a/fr-fr/git-fr.html.markdown b/fr-fr/git-fr.html.markdown index 7a83704d..510459fe 100644 --- a/fr-fr/git-fr.html.markdown +++ b/fr-fr/git-fr.html.markdown @@ -8,7 +8,7 @@ contributors: - ["Bruno Volcov", "http://github.com/volcov"] translators: - ["Xuan-thi Nguyen", "http://github.com/mellenguyen"] -filename: LearnGit-fr-.txt +filename: LearnGit-fr.txt lang: fr-fr --- -- cgit v1.2.3 From e07de13721a6f434473839454fe161ed2cff3a6e Mon Sep 17 00:00:00 2001 From: Xuan-thi N Date: Wed, 29 Jun 2016 11:26:11 +0200 Subject: [fr/tmux] Tmux translated in French (#1861) * tmux article translated in French * Small typos * Added change suggestions --- fr-fr/tmux-fr.html.markdown | 261 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 261 insertions(+) create mode 100644 fr-fr/tmux-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/tmux-fr.html.markdown b/fr-fr/tmux-fr.html.markdown new file mode 100644 index 00000000..d353af3b --- /dev/null +++ b/fr-fr/tmux-fr.html.markdown @@ -0,0 +1,261 @@ +--- +category: tool +tool: tmux +contributors: + - ["mdln", "https://github.com/mdln"] +translators: + - ["Xuan-thi Nguyen", "https://github.com/mellenguyen"] +filename: LearnTmux-fr.txt +lang: fr-fr +--- + + +[Tmux](http://tmux.sourceforge.net) est un multiplexeur de terminal: il permet +de créer plusieurs terminaux, accédés et contrôlés depuis un seul écran. Tmux +peut être détaché de l'écran tout en continuant de fonctionner en tâche de +fond, puis rattaché de nouveau. + + +``` + + tmux [command] # Exécute une commande + # 'tmux' sans commande créé une nouvelle session + + new # Créé une nouvelle session + -s "Session" # Créé une session nommée "Session" + -n "Window" # Créé une fenêtre nommée "Window" + -c "/dir" # Démarre dans le dossier cible "/dir" + + attach # S'attache à la dernière session ou la session disponible + -t "#" # S'attache à la session cible + -d # Détache la session des autres instances + + ls # Liste les sessions ouvertes + -a # Liste toutes les sessions ouvertes + + lsw # Liste les fenêtres de la session courante + -a # Liste toutes les fenêtres + -s # Liste toutes les fenêtres en session + + lsp # Liste les panels + -a # Liste tous les panels + -s # Liste tous les panels en session + -t # Liste tous les panels dans la cible + + kill-window # Tue la fenêtre courante + -t "#" # Tue la fenêtre cible + -a # Tue toutes les fenêtres + -a -t "#" # Tue toutes les fenêtres sauf la cible + + kill-session # Tue la session courante + -t "#" # Tue la session cible + -a # Tue toutes les sessions + -a -t "#" # Tue toutes les sessions sauf la cible + +``` + + +### Raccourcis clavier + +Afin de contrôler une session tmux attachée, on utilise une combinaison de +touches appelées 'Préfixe'. Elle doit être pressée afin d'utiliser les +raccourcis. + +``` +-------------------------------------------------------------------------------- + (C-b) = Ctrl + b # Combinaison 'Préfixe' requise pour utiliser les raccourcis + + (M-1) = Meta + 1 -ou- Alt + 1 +-------------------------------------------------------------------------------- + + ? # Liste tous les raccourcis + : # Entre dans l'invite de commande de tmux + r # Force la redéfinition du client attaché + c # Créé une nouvelle fenêtre + + ! # Sépare le panel courant de sa fenêtre + % # Sépare le panel courant en deux, gauche et droite + " # Sépare le panel courant en deux, haut et bas + + n # Changer vers la fenêtre suivante + p # Changer vers la fenêtre précédente + { # Echange le panel courant avec le panel précédent + } # Echange le panel courant avec le panel suivant + + s # Sélectionne une nouvelle session pour le client attaché + # de manière interactive + w # Choisi la fenêtre courante de manière interactive + 0 to 9 # Sélectionne la fenêtre de 0 à 9 + + d # Détache le client courant + D # Choisi un client à détacher + + & # Tue la fenêtre courante + x # Tue le panel courant + + Up, Down # Change vers le panel au dessus, en dessous, à gauche + Left, Right # ou à droite + + M-1 to M-5 # Arrange les panels: + # 1) égaliser sur l'horizontale + # 2) égaliser sur la verticale + # 3) panel principal en haut et le reste en bas + # de gauche à droite + # 4) panel principal à gauche et le reste à droite + # de haut en bas + # 5) "tiled" : égalise les panels + # sur la hauteur et la largeur + + C-Up, C-Down # Redimensionne le panel courant par pas de une cellule + C-Left, C-Right + + M-Up, M-Down # Redimensionne le panel courant par pas de cinq cellules + M-Left, M-Right + +``` + + +### Configuration de ~/.tmux.conf + +tmux.conf peut être utilisé pour fixer les options automatiquement au +démarrage, comme .vimrc ou init.el. + +``` +# Exemple de tmux.conf +# 2014.10 + + +### Général +########################################################################### + +# Active UTF-8 +setw -g utf8 on +set-option -g status-utf8 on + +# Limite de l'historique +set -g history-limit 2048 + +# Indice de début du nombre de panels +set -g base-index 1 + +# Souris +set-option -g mouse-select-pane on + +# Force le rechargement du fichier de configuration +unbind r +bind r source-file ~/.tmux.conf + + +### Raccourcis clavier +########################################################################### + +# Annule C-b en tant que préfixe par défaut +unbind C-b + +# Définit un nouveau préfixe par défaut +set-option -g prefix ` + +# Retourne à la fenêtre précédente quand le préfixe est pressé deux fois +bind C-a last-window +bind ` last-window + +# Permet d'échanger C-a et ` en utilisant F11/F12 +bind F11 set-option -g prefix C-a +bind F12 set-option -g prefix ` + +# Préférences de raccourcis clavier +setw -g mode-keys vi +set-option -g status-keys vi + +# Navigue entre les panels avec les raccourcis clavier de vim +bind h select-pane -L +bind j select-pane -D +bind k select-pane -U +bind l select-pane -R + +# Navigation entre les fenêtres +bind e previous-window +bind f next-window +bind E swap-window -t -1 +bind F swap-window -t +1 + +# Commandes simples de séparation des panels +bind = split-window -h +bind - split-window -v +unbind '"' +unbind % + +# Active la session la plus imbriquée (en faisant de l'imbrication sous tmux) +# pour envoyer des commandes +bind a send-prefix + + +### Thème +########################################################################### + +# Palette de couleurs pour la barre de statuts +set-option -g status-justify left +set-option -g status-bg black +set-option -g status-fg white +set-option -g status-left-length 40 +set-option -g status-right-length 80 + +# Palette de couleurs pour les bordures des panels +set-option -g pane-active-border-fg green +set-option -g pane-active-border-bg black +set-option -g pane-border-fg white +set-option -g pane-border-bg black + +# Palette de couleurs pour les messages +set-option -g message-fg black +set-option -g message-bg green + +# Palette de couleurs pour les fenêtres +setw -g window-status-bg black +setw -g window-status-current-fg green +setw -g window-status-bell-attr default +setw -g window-status-bell-fg red +setw -g window-status-content-attr default +setw -g window-status-content-fg yellow +setw -g window-status-activity-attr default +setw -g window-status-activity-fg yellow + + +### UI +########################################################################### + +# Notification +setw -g monitor-activity on +set -g visual-activity on +set-option -g bell-action any +set-option -g visual-bell off + +# Définir automatiquement des titres de fenêtres +set-option -g set-titles on +# Numéro de fenêtre, nom du programme, actif (ou non) +set-option -g set-titles-string '#H:#S.#I.#P #W #T' + +# Réglages de la barre de statuts +set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]" + +# Présente des indicateurs de performance dans la barre de statuts +# Recquiert https://github.com/thewtex/tmux-mem-cpu-load/ +set -g status-interval 4 +set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]" + +``` + + +### Références + +[Tmux | Home](http://tmux.sourceforge.net) + +[Page du manuel Tmux](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux) + +[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux) + +[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux) + +[Montrer le pourcentage CPU/MEM dans la barre de statuts](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux) + +[tmuxinator - Gère des sessions tmux complexes](https://github.com/tmuxinator/tmuxinator) -- cgit v1.2.3 From df4dbee36f5a3b9b63292a2346327f8b7d282a28 Mon Sep 17 00:00:00 2001 From: Xuan-thi N Date: Wed, 29 Jun 2016 11:26:53 +0200 Subject: [fr/ruby-ecosytem] Translated ruby-ecosytem article in French (#1857) * Translated ruby-ecosytem article in French * Added change suggestions --- fr-fr/ruby-ecosystem-fr.html.markdown | 154 ++++++++++++++++++++++++++++++++++ 1 file changed, 154 insertions(+) create mode 100644 fr-fr/ruby-ecosystem-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/ruby-ecosystem-fr.html.markdown b/fr-fr/ruby-ecosystem-fr.html.markdown new file mode 100644 index 00000000..9b52069a --- /dev/null +++ b/fr-fr/ruby-ecosystem-fr.html.markdown @@ -0,0 +1,154 @@ +--- +category: tool +tool: ruby ecosystem +contributors: + - ["Jon Smock", "http://github.com/jonsmock"] + - ["Rafal Chmiel", "http://github.com/rafalchmiel"] +translators: + - ["Xuan-thi Nguyen", "http://github.com/mellenguyen"] +lang: fr-fr + +--- + +Les gens utilisant Ruby adoptent généralement un gestionnaire pour installer +différentes versions de Ruby, gérer leurs paquets (ou gems), et gérer les +dépendances des gems. + +## Ruby Managers + +Quelques plateformes possèdent Ruby pré-installé ou disponible en tant que +paquet. La plupart des rubyists ne les utilisent pas, ou si c'est le cas, ne +les utilise que pour faire démarrer un autre installateur ou implémentation de +Ruby. Les rubyists tendent plutôt à installer un manager Ruby pour installer +et changer entre les différentes et nombreuses versions de Ruby et les +environnements de leurs projets Ruby. + +Les gestionnaires d'environnement Ruby les plus populaires sont : + +* [RVM](https://rvm.io/) - Installe et navigue entre les rubies. RVM possède + églement le concept des gemsets pour isoler les environnements de projets + complètement. +* [ruby-build](https://github.com/sstephenson/ruby-build) - Installe seulement + les rubies. Utilisez-le pour un contrôle plus fin des installations des + rubies. +* [rbenv](https://github.com/sstephenson/rbenv) - Navigue seulement entre les + rubies. Utilisé avec ruby-build. Utilisez-le pour un contrôle plus fin des + chargements des rubies. +* [chruby](https://github.com/postmodern/chruby) - Navigue seulement entre les + rubies. Similaire à rbenv. Neutre sur comment les rubies sont installés. + +## Versions de Ruby + +Ruby a été créé par Yukihiro "Matz" Matsumoto, qui reste quelque peu un +[BDFL](https://fr.wikipedia.org/wiki/Benevolent_Dictator_for_Life), bien que +cela soit récemment en changement. Jusqu'à la standardisation du langage en +2011, l'implémentation de référence de Ruby était appelé MRI (Matz' Reference +Implementation). + +Les trois versions majeures de Ruby actuellement utilisées sont : + +* 2.0.0 - Sortie en février 2013. La plupart des librairies et frameworks + gèrent la versions 2.0.0. +* 1.9.3 - Sortie en octobre 2011. Il s'agit de la version que la majorité des + rubyists utilisent actuellement. [Fin de vie](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/) +* 1.8.7 - Sortie en juin 2006. [Fin de vie](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/). + +Les changements entre 1.8.7 à 1.9.x sont bien plus grands qu'entre 1.9.3 +jusqu'à 2.0.0. Par exemple, les versions 1.9 ont introduit le support des +encodages et d'une VM bytecode ([YARV](https://fr.wikipedia.org/wiki/YARV)). +Il y a toujours des projets sur 1.8.7, mais ils deviennent minoritaires, étant +donné que la majorité de la communauté a migré vers au moins 1.9.2 ou 1.9.3. + +## Implémentations Ruby + +L'écosystème Ruby comprend de nombreuses implémentations de Ruby, chacune avec +des points forts uniques et différents degrés de compatibilité. Les différentes +implémentations sont écrites dans différents languages. +Chaque implémentation a des "hooks" et des fonctionnalités spécifiques, elles +exécutent cependant très bien des fichiers Ruby classiques. +Par exemple, JRuby est écrit en Java, mais vous n'avez pas besoin de connaître +le Java pour l'utiliser. + +Très mature/compatible: + +* [MRI](https://github.com/ruby/ruby) - Ecrite en C, c'est l'implémentation de + référence de Ruby. Elle est par définition 100% compatible (avec elle-même). + Tous les autres rubies maintiennent la compatibilité avec MRI + (voir [RubySpec](#rubyspec) à la suite). +* [JRuby](http://jruby.org/) - Écrite en Java et Ruby, cette robuste + implémentation est assez rapide. + La force de JRuby réside surtout sur l'interopérabilité JVM/Java, faisant + levier sur des outils JVM, des projets et des langages existants. +* [Rubinius](http://rubini.us/) - Ecrite principalement en Ruby avec une VM + bytecode en C++. Egalement mature et rapide. Etant donné qu'elle est + implémentée en Ruby, elle couvre beaucoup de fonctionnalités de la + VM dans Ruby. + +Mpyennement mature/compatible: + +* [Maglev](http://maglev.github.io/) - Basée sur Gemstone, une VM Smalltalk. + Smalltalk possède quelques outils impressionnants, et ce projet tente + de les apporter dans le développement Ruby. +* [RubyMotion](http://www.rubymotion.com/) - Ruby pour développement iOS. +* [Opal](http://opalrb.org/) - Compile le Ruby en Javascript + +Les implémentations de Ruby peuvent avoir leurs propres numéros de versions, +mais elles ciblent toujours une versions spéficique de MRI pour la +compatibilité. +Beaucoup d'implémentations ont la capacité d'entrer dans différents modes +(par exemple, la version 1.8 ou 1.9) afin de spécifier quelle version de MRI +cibler. + +Une liste non exhaustive d'implémentations peut être trouvée [ici (EN)](https://github.com/cogitator/ruby-implementations/wiki/List-of-Ruby-implementations). + +## RubySpec + +La plupart des implémentations Ruby s'appuient fortement sur [RubySpec](http://rubyspec.org/). +Ruby n'a pas de spécification officielle, c'est pourquoi la commaunité a écrit +des spécifications exécutables en Ruby pour tester la compatibilité de leur +implémentation avec MRI. + +## RubyGems + +[RubyGems](http://rubygems.org/) est un gestionnaire de paquets communautaire +pour Ruby. +RubyGems est livré avec Ruby, il n'y a donc pas besoin de le télécharger +séparément. + +Les paquets Ruby sont appelés des "gems", et peuvent être hébergés par la +communauté à RubyGems.org. Chaque gem contient son code source et quelques +métadatas, includant des choses comme la version, les dépendances, +l(es) auteur(s) et la/les licence(s). + +## Bundler + +[Bundler](http://bundler.io/) est un résolveur de dépendances des gems. Il +utilise le Gemfile d'un projet ppur trouver les dépendances, et récupère +ensuite les dépendances de ces dépendances récursivement. Il déroule cet +algorithme jusqu'à ce que toutes les dépendances soient résolues et +téléchargées, ou s'arrête si un conflit est trouvé. + +Bundler lèvera une erreur s'il trouve des conflits de dépendances. Par exemple, +si la gem A recquiert la version 3 ou plus de gem Z, mais que gem B recquiert +seulement la version 2, Bundler vous notifiera ce conflict. Cela devient +extrêmement utile, étant donné que beaucoup de gems font référence à d'autres +gems (qui se réfèrent à d'autres gems), ce qui peut former un large graphe de +dépendance à résoudre. + +# Les tests + +Tester fait partie intégrante de la culture Ruby. Ruby fournit son propre +framework de tests unitaires appelé minitest (ou TestUnit pour Ruby +version 1.8.x). Il existe beaucoup de librairies de tests avec des buts +différents. + +* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) - Framework de tests intégré de Ruby version 1.8 style "Unit" +* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - Framework de tests intégré de Ruby version 1.9/2.0 +* [RSpec](http://rspec.info/) - Un framework de tests qui se focalise sur l'expressivité +* [Cucumber](http://cukes.info/) - Un framework de tests BDD ([behaviour-driven development](https://fr.wikipedia.org/wiki/Behavior_driven_development)) qui parse les tests formatés de Gherkin. + +## Soyez gentil + +La communauté Ruby est fière d'être une communauté ouverte, riche et +accueillante. Matz lui-même est extrêmement sociable, et la générosité des +rubyists est généralement remarquable. -- cgit v1.2.3 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 From 66c8b036dcdbcd538f914e14d073194d704159fa Mon Sep 17 00:00:00 2001 From: robochat Date: Sat, 3 Sep 2016 19:30:53 +0200 Subject: [html/en] adding translation of html/fr (#2354) * [html/en] adding a translation of html/fr. * [html/en] small changes and 1 bug fix. * [html/fr] small bug fix. * [html/en] small bug fix. --- fr-fr/HTML-fr.html.markdown | 2 ++ 1 file changed, 2 insertions(+) (limited to 'fr-fr') diff --git a/fr-fr/HTML-fr.html.markdown b/fr-fr/HTML-fr.html.markdown index 4d2da921..b52fd34a 100644 --- a/fr-fr/HTML-fr.html.markdown +++ b/fr-fr/HTML-fr.html.markdown @@ -106,6 +106,8 @@ Cet article porte principalement sur la syntaxe et quelques astuces. +``` + ## Utilisation Le HTML s'écrit dans des fichiers `.html`. -- 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') 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') 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 b552fe30c2f3562cf670a9e7655ff834deb3b551 Mon Sep 17 00:00:00 2001 From: Rafik NACCACHE Date: Sun, 2 Oct 2016 12:55:49 +0100 Subject: Add as-> macro documentation (#2392) * Add as-> macro documentation * Add as-> in english clojure.html.markdown --- fr-fr/clojure-fr.html.markdown | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/clojure-fr.html.markdown b/fr-fr/clojure-fr.html.markdown index 63bc25b5..65747c0d 100644 --- a/fr-fr/clojure-fr.html.markdown +++ b/fr-fr/clojure-fr.html.markdown @@ -275,7 +275,7 @@ ressemblent à toutes les autres formes: (let [name "Urkel"] (print "Saying hello to " name) (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel") - + ; Utilisez les Threading Macros (-> et ->>) pour exprimer plus ; clairement vos transformations, en y pensant de manière multi-niveaux. @@ -284,10 +284,10 @@ ressemblent à toutes les autres formes: ; de la forme suivante, constituant à chaque fois un nouvel étage ; de transformation. Par exemple: (-> - {:a 1 :b 2} + {:a 1 :b 2} (assoc :c 3) ;=> Génère ici (assoc {:a 1 :b 2} :c 3) (dissoc :b)) ;=> Génère ici (dissoc (assoc {:a 1 :b 2} :c 3) :b) - + ; Cette expression est ré-écrite en: ; (dissoc (assoc {:a 1 :b 2} :c 3) :b) ; et est évaluée en : {:a 1 :c 3} @@ -302,6 +302,14 @@ ressemblent à toutes les autres formes: (into [])) ;=> Génère ici (into [] (filter odd? (map inc (range 10))), ce qui est évalué au final à; ; [1 3 5 7 9] +; Quand vous êtes dans une situation où vous voulez plus de liberté pour choisir +; où mettre le résultat des étages précédents, vous pouvez utiliser la +; macro as->. Avec cette macro, donnez un nom spécifique au résultat de la transformation +; précédente pour le placer, à votre guise, où bon vous semble dans l'étage courant: +(as-> [1 2 3] input + (map inc input);=> Utilisation du résultat en dernière position + (nth input 4) ;=> et en deuxième position, dans la même expression + (conj [4 5 6] input [8 9 10])) ;=> ou au milieu ! ; Modules ;;;;;;;;;;;;;;; @@ -370,7 +378,7 @@ ressemblent à toutes les autres formes: ; STM ;;;;;;;;;;;;;;;;; -; La mémoire logiciel transactionnelle ("Software Transactional Memory") +; La mémoire logiciel transactionnelle ("Software Transactional Memory") ; est le mécanisme que Clojure utilise pour gérer les états persistents. ; Il y a plusieurs formes en Clojure qui utilisent cela. @@ -384,7 +392,7 @@ ressemblent à toutes les autres formes: (swap! my-atom assoc :a 1) ; Définit my-atom comme le résultat de (assoc {} :a 1) (swap! my-atom assoc :b 2) ; Définit my-atom comme le résultat de (assoc {:a 1} :b 2) -; Use '@' to dereference the atom and get the value +; Use '@' to dereference the atom and get the value my-atom ;=> Atom<#...> (Renvoie l'objet Atom) @my-atom ; => {:a 1 :b 2} -- cgit v1.2.3 From 15e74d22b5cdc859a7f71b0828786a85e19e337b Mon Sep 17 00:00:00 2001 From: Hughes Perreault Date: Thu, 27 Oct 2016 04:15:08 -0400 Subject: A translation of dynamic programming in french (#2465) * A translation of dynamic programming in french Issue #2464 * few small corrections voir => le voir, correction du spacing entre "{" "}", ajout d'espaces avant les ":", suppression de " ``` " inutile, suppression du proverbe Issue #2465 --- fr-fr/dynamic-programming-fr.html.markdown | 55 ++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 fr-fr/dynamic-programming-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/dynamic-programming-fr.html.markdown b/fr-fr/dynamic-programming-fr.html.markdown new file mode 100644 index 00000000..24e8c95f --- /dev/null +++ b/fr-fr/dynamic-programming-fr.html.markdown @@ -0,0 +1,55 @@ +--- +category: Algorithms & Data Structures +name: Dynamic Programming +contributors: + - ["Akashdeep Goel", "http://github.com/akashdeepgoel"] +translators: + - ["Hughes Perreault", "https://github.com/hperreault"] +lang: fr-fr +--- + + +# Programmation dynamique + +## Introduction + +La programmation dynamique est une technique très efficace pour résoudre une certaine classe de problèmes, comme nous allons le voir. L'idée est très simple, si nous avons résolu un problème avec une certaine entrée, alors nous sauvons le résultat pour pouvoir y accéder plus tard, pour éviter d'avoir à le calculer à nouveau. + +## Moyens de résoudre ces problèmes + +1.) *De haut en bas* : Commençons à résoudre le problème en le séparant en morceaux. Si nous voyons que le problème a déjà été résolu, alors nous retournons la réponse précédemment sauvegardée. Si le problème n'a pas été résolu, alors nous le résolvons et sauvegardons la réponse. C'est généralement facile et intuitif de réfléchir de cette façon. Cela s'appelle la Mémorisation. + +2.) *De bas en haut* : Il faut analyser le problème et trouver les sous-problèmes, et l'ordre dans lequel il faut les résoudre. Ensuite, nous devons résoudre les sous-problèmes et monter jusqu'au problème que nous voulons résoudre. De cette façon, nous sommes assurés que les sous-problèmes sont résolus avant de résoudre le vrai problème. Cela s'appelle la Programmation Dynamique. + +## Exemple de Programmation Dynamique + +Le problème de la plus grande sous-chaîne croissante est de trouver la plus grande sous-chaîne croissante dans une chaîne. Soit la chaîne `S = {a1, a2, a3, a4, ............., an-1, an}`, nous avons à trouver la plus grande chaîne telle que pour tout `j` et `i`, `j a[j] and LS[i] Date: Thu, 27 Oct 2016 04:15:29 -0400 Subject: A translation of the binary search in french (#2436) * A translation of the binary search in french This commit solves issue #2435 * A few modifications to the translation. issue #2436 * added a space issue #2436 * i.e. => Par exemple, issue #2436 --- fr-fr/binary-search-fr.html.markdown | 67 ++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 fr-fr/binary-search-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/binary-search-fr.html.markdown b/fr-fr/binary-search-fr.html.markdown new file mode 100644 index 00000000..4c34da0f --- /dev/null +++ b/fr-fr/binary-search-fr.html.markdown @@ -0,0 +1,67 @@ +--- +category: Algorithms & Data Structures +name: Binary Search +contributors: + - ["Abhishek Jaisingh", "http://github.com/abhishekjiitr"] +translators: + - ["Hughes Perreault", "https://github.com/hperreault"] +lang: fr-fr +--- + +# Recherche Binaire + +## Pourquoi la Recherche Binaire ? + +La recherche est un des principaux problèmes dans le domaine de l'informatique. De nos jours, il y a plus de 1 milliard de recherches par année, et nous avons besoin d'algorithmes pour faire cela rapidement. La recherche binaire est un des algorithmes les plus fondamentaux en informatique. Pour pouvoir l'explorer en détail, nous allons d'abord établir une base théorique, puis nous allons utiliser cette base pour implémenter l'algorithme en soi. + +## Introduction + +Une façon simple d'implémenter la recherche est de faire une recherche linéaire. Cependant, cette approche prend beaucoup de temps, et ce temps augmente linéairement avec la quantité de données. Par exemple, partons du premier élément d'un tableau t[], et un par un, comparons x avec chaque élément de t[]. Si x est égal à un élément, nous retournons l'index, si x n'égale aucun élément, nous retournons -1. + +``` +Recherche Linéaire: O (n) Temps Linéaire + +Recherche Binaire: O ( log(n) ) Temps Logarithmique + +``` +``` +def search(arr, x): + + for i in range(len(arr)): + + if arr[i] == x: + return i + + return -1 + +``` +## L'Algorithme de Recherche Binaire + +Le prérequis fondamental de la recherche binaire est que les éléments soient triés. + +### Algo + +``` +L'idée derrière la recherche binaire est d'utiliser le fait que le tableau est trié afin de réduire la complexité à O(Log(n)). Nous pouvons ignorer la moitié des éléments après la première comparaison. +1) Comparons x avec l'élément du milieu. +2) Si x est égal à cet élément, nous retournons l'index du milieu. +3) Sinon, si x est plus grand que l'élément du milieu, alors x peut seulement être dans la dernière moitié du tableau. Donc, nous recommençons la procédure avec cette dernière moitié. +4) Sinon (x est plus petit), nous recommençons la procédure avec la première moitié du tableau. +Ensuite nous avons une implémentation récursive de la recherche binaire. + +``` + +### Note de la fin + +Partie en construction. + +## Livre + +* [CLRS EN](https://mitpress.mit.edu/books/introduction-algorithms) +* [Algorithmes EN](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X) +* [Design d'Algorithmes EN](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651) + +## Ressources en ligne + +* [GeeksforGeeks EN](http://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/) +* [Topcoder Tutorial EN](https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/) -- cgit v1.2.3 From df52fda2e867c0e7ef31148ea498eaf3023df30b Mon Sep 17 00:00:00 2001 From: Gnomino Date: Thu, 27 Oct 2016 12:56:43 +0200 Subject: [jquery/fr] Adds French translation for jQuery (#2524) * Adds French translation for jQuery * Corrects French & JavaScript errors --- fr-fr/jquery-fr.html.markdown | 142 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 fr-fr/jquery-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/jquery-fr.html.markdown b/fr-fr/jquery-fr.html.markdown new file mode 100644 index 00000000..1842e02b --- /dev/null +++ b/fr-fr/jquery-fr.html.markdown @@ -0,0 +1,142 @@ +--- +category: tool +tool: jquery +contributors: + - ["Sawyer Charles", "https://github.com/xssc"] +translators: + - ["Sylvain Vaure", "https://github.com/Gnomino"] +filename: jquery-fr.js +lang: fr-fr +--- + +jQuery est une bibliothèque JavaScript dont le but est de permettre de "faire plus en écrivant moins" (do more, write less). Elle facilite l'écriture de nombreuses fonctions, notamment au niveau d'AJAX, de la gestion d'événements, ou encore de la manipulation de documents. +C'est pourquoi aujourd'hui, jQuery est utilisée par de nombreuses grandes entreprises et par des développeurs du monde entier. + +Étant donné que jQuery est une bibliothèque JavaScript, vous devriez d'abord [apprendre le JavaScript](https://learnxinyminutes.com/docs/fr-fr/javascript-fr/) +```js + + +/////////////////////////////////// +// 1. Les sélecteurs + +// On utilise les sélecteurs de jQuery pour sélectionner des éléments +var page = $(window); // Sélectionne tout le viewport + +// On peut aussi utiliser des sélecteurs CSS +var paragraph = $('p'); // Sélectionne tous les éléments paragraphes +var table1 = $('#table1'); // Sélectionne l'élément qui a l'id 'table1' +var squares = $('.square'); // Sélectionne tous les éléments avec la classe 'square' +var square_p = $('p.square') // Sélectionne tous les paragraphes avec la classe 'square' + + +/////////////////////////////////// +// 2. Événements et effets +// jQuery gère très bien ce qui se passe lorsqu'un événement est déclenché +// L'événement 'ready' est très souvent utilisé sur le document +// On utilise la méthode 'ready' pour attendre que l'élément ait fini de se charger +$(document).ready(function(){ + // Ce code ne s'exécutera pas avant que le document soit chargé (prêt) +}); +// On peut aussi utiliser des fonctions définies +function onAction() { + // Ceci est exécuté quand l'événement est déclenché +} +$('#btn').click(onAction); // Appelle onAction à chaque clic + +function onAction() { + // Ceci est exécuté quand un évènement est déclenché +} + +// D'autres évènements communs : +$('#btn').dblclick(onAction); // Double clic +$('#btn').hover(onAction); // Survol de la souris +$('#btn').focus(onAction); // Gain du focus +$('#btn').blur(onAction); // Perte du focus +$('#btn').submit(onAction); // Envoi (d'un formulaire) +$('#btn').select(onAction); // Quand un élement est sélectionné +$('#btn').keydown(onAction); // Quand une touche est enfoncée +$('#btn').keyup(onAction); // Quand une touche est relâchée +$('#btn').keypress(onAction); // Quand on appuie sur un touche +$('#btn').mousemove(onAction); // Quand la souris se déplace +$('#btn').mouseenter(onAction); // La souris entre dans l'élément +$('#btn').mouseleave(onAction); // La souris sort de l'élément + +// On peut aussi utiliser des fonctions lambdas +$('#btn').hover(function(){ + // exécuté lors d'un survol de la souris +}); + +// Il est possible de déclencher l'événement sans le gérer +// simplement en ne passant aucun paramètre à la méthode +$('#btn').dblclick(); // Simule un double clic sur l'élément + +// On peut gérer plusieurs événements en utilisant le sélecteur une seule fois +$('#btn').on( + {dblclick: myFunction1} // Déclenché à chaque double clic + {blur: myFunction1} // Déclenché quand l'élément perd le focus +); + +// On peut déplacer et cacher des éléments grâce à des fonctions d'effets +$('.table').hide(); // Cache le(s) élément(s) + +// Note: même avec un appel à une fonction dans ces méthodes +// cache quand même l'élément +$('.table').hide(function(){ + // L'élément est caché, puis la fonction est exécutée +}); + +// On peut stocker des sélecteurs dans des variables +var tables = $('.table'); + +// Des méthodes basique de manipulation de document : +tables.hide(); // Cache un(des) élément(s) +tables.show(); // Montre (dé-cache) un(des) élément(s) +tables.toggle(); // Change le statut le statut caché/montré +tables.fadeOut(); // Fait disparaître l'élément +tables.fadeIn(); // Fait apparaître l'élément +tables.fadeToggle(); // Fait apparaître ou disparaître +tables.fadeTo(0.5); // Fondu jusqu'à une certaine opacité (entre 0 et 1) +tables.slideUp(); // Cache l'élément avec un effet de glissement vers le haut +tables.slideDown(); // Fait apparaître l'élément avec un glissement vers le bas +tables.slideToggle(); // Cache/Montre l'élément avec un effet de glissement + +// Les méthodes ci-dessus prennent en arguments +// une vitesse (millisecondes) et une function callback +tables.hide(1000, myFunction); // Animation d'une seconde, puis appel à la fonction + +// fadeTo doit avoir une opacité entre 0 et 1 comme deuxième argument +tables.fadeTo(2000, 0.1, myFunction); // 2 sec. fade to 0.1 opacity then function + +// La méthode animate permet des animations légèrement plus poussées +tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction); +// La méthode prend un objet de css et de valeurs finales, +// des paramètres d'options facultatifs pour régler l'animation, +// et bien sûr la fonction callback + +/////////////////////////////////// +// 3. Manipulation + +// Ces méthodes sont similaires aux effets mais permettent d'aller plus loin +$('div').addClass('taming-slim-20'); // Ajoute la classe taming-slim-20 aux div + +// Méthodes ordinaires de manipulation +$('p').append('Hello world'); // Ajoute à la fin de l'élément +$('p').attr('class'); // Renvoie la valeur de l'attribut +$('p').attr('class', 'content'); // Change la valeur de l'attribut +$('p').hasClass('taming-slim-20'); // Renvoie vrai si l'élément est de la classe +$('p').height(); // Renvoie la hauteur de l'élément ou la change + + +// Pour beaucoup de méthodes de manipulation, récupérer des informations +// d'un élément renverra SEULEMENT ceelles du premier +$('p').height(); // Renvoie SEULEMENT la hauteur du premier élément 'p' + +// On peut utiliser 'each' pour parcourir tous les éléments +var heights = []; +$('p').each(function() { + heights.push($(this).height()); // Ajoute la hauteur de tous les éléments 'p' à la liste +}); + + +`` + -- cgit v1.2.3 From 9ac2eaa93fa8d3183714e1a5950cbb5d5947b839 Mon Sep 17 00:00:00 2001 From: Thibault Date: Fri, 28 Oct 2016 11:18:36 +0200 Subject: [vim/fr-fr] New translation (#2517) * Added translation in French for the Vim article * Fixed grammar/typo * Added required changes --- fr-fr/vim.html.markdown | 239 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 239 insertions(+) create mode 100644 fr-fr/vim.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/vim.html.markdown b/fr-fr/vim.html.markdown new file mode 100644 index 00000000..8e84bf33 --- /dev/null +++ b/fr-fr/vim.html.markdown @@ -0,0 +1,239 @@ +--- +category: tool +tool: vim +filename: LearnVim.txt +contributors: + - ["RadhikaG", "https://github.com/RadhikaG"] +translators: + - ["Thibault", "https://github.com/napnac"] +lang: fr-fr +--- + + +[Vim](www.vim.org) +(Vi IMproved) est le clone le plus populaire de l'éditeur de texte vi sous Unix. +Vim est un éditeur de texte omniprésent sur les systèmes de type Unix, et a pour +objectif la rapidité ainsi que l'augmentation de la productivité. Il a de +nombreux raccourcis claviers pour une navigation et une édition plus rapide. + +## Navigation basique avec Vim + +``` + vim # Ouvre avec vim + :q # Quitte vim + :w # Sauvegarde le fichier actuel + :wq # Sauvegarde le fichier actuel et quitte vim + :q! # Quitte vim sans sauvegarder + # ! *force* l'exécution de :q, ce qui par conséquent + # oblige vim à quitter sans sauvegarder + :x # Sauvegarde le fichier et quitte vim (raccourcis de :wq) + + u # Annuler + CTRL+R # Rétablir + + h # Déplace le curseur vers la gauche + j # Déplace le curseur vers le bas + k # Déplace le curseur vers le haut + l # Déplace le curseur vers la droite + + # Mouvements au sein d'une ligne + + 0 # Va au début de la ligne + $ # Va à la fin de la ligne + ^ # Va au premier caractère non blanc de la ligne + + # Rechercher dans un texte + + /mot # Surligne toutes les occurrences du mot après le curseur + ?mot # Surligne toutes les occurrences du mot avant le curseur + n # Déplace le curseur sur la prochaine occurrence du mot recherché + N # Déplace le curseur sur la précédente occurrence du mot recherché + + :%s/abc/def/g # Transforme les 'abc' en 'def' sur chaque ligne du texte + :s/abc/def/g # Transforme les 'abc' en 'def' sur la ligne actuelle + + # Se déplacer vers un caractère + + f # Se déplace en avant jusqu'à + t # Se déplace en avant juste avant + + # Par exemple + f< # Se déplace en avant jusqu'à < + t< # Se déplace en avant juste avant < + + # Se déplacer dans un mot + + w # Avance d'un mot + b # Recule d'un mot + e # Se déplace jusqu'à la fin du mot actuel + + # D'autres raccourcis pour se déplacer + + gg # Va au début du fichier + G # Va à la fin du fichier + :NB # Va à la ligne numéro NB (où NB est un nombre) + H # Se déplace jusqu'en haut de l'écran + M # Se déplace jusqu'au milieu de l'écran + L # Se déplace jusqu'en bas de l'écran +``` + +## Modes + +Vim est basé sur le concept de **modes**. + +Mode Commande - pour se déplacer et exécuter des commandes (vim démarre dans ce mode) +Mode Insertion - pour éditer le fichier +Mode Visuel - pour sélectionner du texte et réaliser des opérations dessus +Mode Ex - pour entrer des commandes avec ':' + +``` + i # Mode insertion, avant le curseur + a # Mode insertion, après le curseur + v # Mode visuel + : # Mode ex + # 'Echap' permet de revenir dans le mode commande + + # Copier/Coller du texte + + y # Copie le texte sélectionné + yy # Copie la ligne actuelle + d # Supprime ce qui est sélectionné + dd # Supprime la ligne actuelle + p # Colle après le curseur + P # Colle avant le curseur + x # Supprime le caractère sous le curseur +``` + +## La "Grammaire" de Vim + +Vim peut être vu comme un ensemble de commande sous la forme +'Verbe-Modificateur-Nom' : + +Verbe - notre action +Modificateur - la manière de faire l'action +Nom - l'objet désigné par l'action + +Quelques exemples importants de 'Verbes', 'Modificateurs', et de 'Noms' : + +``` + # 'Verbes' + + d # Supprime + c # Transforme + y # Copie + v # Sélectionne + + # 'Modificateurs' + + i # A l'intérieur + a # Autour + NB # Nombre + f # Cherche quelque chose et se déplace dessus + t # Cherche quelque chose et se déplace juste avant + / # Cherche une chaîne de caractères après le curseur + ? # Cherche une chaîne de caractères avant le curseur + + # 'Noms' + + w # Mot + s # Phrase + p # Paragraphe + b # Bloc + + # Exemple de 'phrases' ou commandes + + d2w # Supprime 2 mots + cis # Transforme l'intérieur de la phrase + yip # Copie l'intérieur du paragraphe + ct< # Transforme le texte du curseur jusqu'au caractère avant le < + d$ # Supprime jusqu'à la fin de la ligne +``` + +## Quelques raccourcis et astuces + +``` + > # Indente la sélection d'un bloc + < # Dé-indente la sélection d'un bloc + :earlier 15m # Retrouve le document comme il était il y a 15 minutes + :later 15m # Inverse la commande précédente + ddp # Echange la position de deux lignes consécutives (dd puis p) + . # Répète la dernière action effectuée +``` + +## Macros + +Les macros sont des actions enregistrables. +Quand on commence à enregistrer une macro, Vim enregistre **toutes** les actions +et les commandes que vous utilisez, jusqu'à ce que vous arrêtiez d'enregistrer. +Lorsque vous appelez une macro, elle applique exactement les mêmes actions et +commandes sur le texte sélectionné. + +``` + qa # Commence l'enregistrement de la macro 'a' + q # Arrête l'enregistrement + @a # Appelle la macro 'a' +``` + +### Configuration de ~/.vimrc + +Le fichier .vimrc est utilisé pour configurer Vim lors du démarrage. + +Voici un exemple de fichier ~/.vimrc : + +``` +" Exemple de ~/.vimrc +" 2015.10 + +" Nécessaire à Vim pour être 'iMproved' +set nocompatible + +" Détermine l'extension du fichier à partir du nom pour permettre une indentation +" automatique intelligente, etc. +filetype indent plugin on + +" Active la coloration syntaxique +syntax on + +" Une meilleure complétion de la ligne de commande +set wildmenu + +" Utilise une recherche insensible à la case sauf quand on utilise des majuscules +set ignorecase +set smartcase + +" Quand on commence une nouvelle ligne et qu'aucun type d'indentation n'est activé +" on utilise la même indentation que sur la ligne précédente +set autoindent + +" Affiche le numéro de la ligne sur la gauche de l'écran +set number + +" Options d'indentation, à changer en fonction des préférences personnelles + +" Nombre d'espaces visuels par tabulation +set tabstop=4 + +" Nombre d'espaces par tabulation +set softtabstop=4 + +" Nombre d'espaces indentés avec les opérations d'indentations (>> et <<) +set shiftwidth=4 + +" Convertis les tabulations en espaces +set expandtab + +" Active des tabulations et des espaces intelligents pour l'indentation et l'alignement +set smarttab +``` + +### Références + +[Vim | Home](http://www.vim.org/index.php) + +`$ vimtutor` + +[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/) + +[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about) + +[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim) -- cgit v1.2.3 From 98454c39cf3fab390fe794ebfe33436d06ed560d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andre=20Polykanine=20A=2EK=2EA=2E=20Menelion=20Elens=C3=BA?= =?UTF-8?q?l=C3=AB?= Date: Wed, 14 Dec 2016 04:24:03 +0200 Subject: Fixes #2593 (#2599) --- fr-fr/javascript-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr') diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown index f1977dac..faa22863 100644 --- a/fr-fr/javascript-fr.html.markdown +++ b/fr-fr/javascript-fr.html.markdown @@ -190,7 +190,7 @@ someNinthVar; // = 9 // Il y a des raccourcis pour les opérations mathématiques: someVar += 5; // équivalent pour someVar = someVar + 5; -someVar *= 10; // de même, someVar = someVar * 100; +someVar *= 10; // de même, someVar = someVar * 10; someVar++; // = someVar += 1; someVar--; // = someVar -= 1; -- cgit v1.2.3 From 601aae91ae16ff1968899f08f29f10433daad92d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Arnaud=20Fernand=C3=A9s?= Date: Fri, 23 Dec 2016 01:06:39 +0100 Subject: [crystal/fr] French language for crystal (#2602) * Add Crystal/FR * Spell checking --- fr-fr/crystal-fr.html.markdown | 555 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 555 insertions(+) create mode 100644 fr-fr/crystal-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/crystal-fr.html.markdown b/fr-fr/crystal-fr.html.markdown new file mode 100644 index 00000000..0bf6889c --- /dev/null +++ b/fr-fr/crystal-fr.html.markdown @@ -0,0 +1,555 @@ +--- +language: crystal +filename: learncrystal-fr.cr +contributors: + - ["Vitalii Elenhaupt", "http://veelenga.com"] + - ["Arnaud Fernandés", "https://github.com/TechMagister/"] +translators: + - ["Arnaud Fernandés", "http://github.com/TechMagister/"] +lang: fr-fr +--- + +```crystal + +# Ceci est un commentaire + +# Tout est object +nil.class #=> Nil +100.class #=> Int32 +true.class #=> Bool + +# Les valeurs fausses sont : nil, false et les pointeurs null +!nil #=> true : Bool +!false #=> true : Bool +!0 #=> false : Bool + +# Entiers + +1.class #=> Int32 + +# Quatre types d'entiers signés +1_i8.class #=> Int8 +1_i16.class #=> Int16 +1_i32.class #=> Int32 +1_i64.class #=> Int64 + +# Quatre types d'entiers non signés +1_u8.class #=> UInt8 +1_u16.class #=> UInt16 +1_u32.class #=> UInt32 +1_u64.class #=> UInt64 + +2147483648.class #=> Int64 +9223372036854775808.class #=> UInt64 + +# Nombre en base binaire +0b1101 #=> 13 : Int32 + +# Nombre en base octale +0o123 #=> 83 : Int32 + +# Nombres hexadécimaux +0xFE012D #=> 16646445 : Int32 +0xfe012d #=> 16646445 : Int32 + +# Nombres à virgule + +1.0.class #=> Float64 + +# Il y a deux types de nombres à virgule +1.0_f32.class #=> Float32 +1_f32.class #=> Float32 + +1e10.class #=> Float64 +1.5e10.class #=> Float64 +1.5e-7.class #=> Float64 + +# Caractères + +'a'.class #=> Char + +# Notation octale des caratères +'\101' #=> 'A' : Char + +# Notation unicode +'\u0041' #=> 'A' : Char + +# Chaînes de caratères + +"s".class #=> String + +# Les chaînes de caractères sont immuables +s = "hello, " #=> "hello, " : String +s.object_id #=> 134667712 : UInt64 +s += "Crystal" #=> "hello, Crystal" : String +s.object_id #=> 142528472 : UInt64 + +# Interpolation +"sum = #{1 + 2}" #=> "sum = 3" : String + +# Chaînes multilignes +"Ceci est une chaine sur +plusieurs lignes" + +# Une autre notation pour les chaînes de caratères +# qui permet d'insérer des guillemets +%(hello "world") #=> "hello \"world\"" + +# Symboles +# Ils sont immuables et réutilisables, ils sont représentés en interne par +# un Int32. Ils sont souvent utilisés à la place des chaînes de caractères +# quand l'identité est plus importante que le contenu + +:symbol.class #=> Symbol + +sentence = :question? # :"question?" : Symbol + +sentence == :question? #=> true : Bool +sentence == :exclamation! #=> false : Bool +sentence == "question?" #=> false : Bool + +# Tableaux + +[1, 2, 3].class #=> Array(Int32) +[1, "hello", 'x'].class #=> Array(Int32 | String | Char) + +# Un type doit être spécifié pour les tableaux vides +[] # Syntax error: for empty arrays use '[] of ElementType' +[] of Int32 #=> [] : Array(Int32) +Array(Int32).new #=> [] : Array(Int32) + +# Les tableaux peuvent être indexés +array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] : Array(Int32) +array[0] #=> 1 : Int32 +array[10] # lève l'exception IndexError +array[-6] # lève l'exception IndexError +array[10]? #=> nil : (Int32 | Nil) +array[-6]? #=> nil : (Int32 | Nil) + +# À partir de la fin +array[-1] #=> 5 + +# Avec un index de début et la taille +array[2, 3] #=> [3, 4, 5] + +# Ou avec un intervalle +array[1..3] #=> [2, 3, 4] + +# L'ajout à un tableau peut se faire avec l'opérateur << +array << 6 #=> [1, 2, 3, 4, 5, 6] + +# Enlève la dernière entrée +array.pop #=> 6 +array #=> [1, 2, 3, 4, 5] + +# Enlève la première entrée +array.shift #=> 1 +array #=> [2, 3, 4, 5] + +# Vérifie si un élément est présent dans le tableau +array.includes? 3 #=> true + +# Syntaxe spéciale pour un tableau de chaîne de caractères ou de symboles +%w(one two three) #=> ["one", "two", "three"] : Array(String) +%i(one two three) #=> [:one, :two, :three] : Array(Symbol) + +# Il y a une syntaxe spéciale pour les tableaux et autres types +# du moment qu'ils définissent une méthode .new et #<< +set = Set{1, 2, 3} #=> [1, 2, 3] +set.class #=> Set(Int32) + +# Ce qui est ci dessus est équivalent à : +set = Set(typeof(1, 2, 3)).new +set << 1 +set << 2 +set << 3 + +# Tableaux associatifs + +{1 => 2, 3 => 4}.class #=> Hash(Int32, Int32) +{1 => 2, 'a' => 3}.class #=> Hash(Int32 | Char, Int32) + +# Un type doit être spécifié pour les tableaux associatifs vides +{} # Syntax error +{} of Int32 => Int32 # {} +Hash(Int32, Int32).new # {} + +# L'accès se fait via une clé +hash = {"color" => "green", "number" => 5} +hash["color"] #=> "green" +hash["no_such_key"] #=> Missing hash key: "no_such_key" (KeyError) +hash["no_such_key"]? #=> nil + +# Vérifie l'existence d'une clé +hash.has_key? "color" #=> true + +# Notation spéciale pour les clés si ce sont des symboles +# ou chaînes de caractères +{key1: 'a', key2: 'b'} # {:key1 => 'a', :key2 => 'b'} +{"key1": 'a', "key2": 'b'} # {"key1" => 'a', "key2" => 'b'} + +# De même que pour les tableaux simples, une syntaxe spéciale +# existe du moment que le type définit une méthode .new et #[]= +class MyType + def []=(key, value) + puts "do stuff" + end +end + +MyType{"foo" => "bar"} + +# Ce qui est équivalent à : +tmp = MyType.new +tmp["foo"] = "bar" +tmp + +# Intervalle + +1..10 #=> Range(Int32, Int32) +Range.new(1, 10).class #=> Range(Int32, Int32) + +# Ils peuvent être inclusifs ou exclusifs +(3..5).to_a #=> [3, 4, 5] +(3...5).to_a #=> [3, 4] + +# Vérifie si un intervalle contient une valeur +(1..8).includes? 2 #=> true + +# les tuples sont fixés en taille, immuables et alloués sur la pile +{1, "hello", 'x'}.class #=> Tuple(Int32, String, Char) + +# L'accès peut se faire en utilisant un index +tuple = {:key1, :key2} +tuple[1] #=> :key2 +tuple[2] #=> syntax error : Index out of bound + +# Ils peuvent être scindés en plusieurs variables +a, b, c = {:a, 'b', "c"} +a #=> :a +b #=> 'b' +c #=> "c" + +# Les procédures ( Proc ) sont des pointeurs de fonction +# avec un contexte optionel. Ils sont généralement créés avec +# cette notation : +proc = ->(x : Int32) { x.to_s } +proc.class # Proc(Int32, String) +# Ou en utilisant la méthode new +Proc(Int32, String).new { |x| x.to_s } + +# On les invoque avec la méthode call +proc.call 10 #=> "10" + +# Contrôle de flux + +if true + "if statement" +elsif false + "else-if, optional" +else + "else, also optional" +end + +puts "if as a suffix" if true + +# Le si ( if ) peut être utilisé pour une déclaration +a = if 2 > 1 + 3 + else + 4 + end + +a #=> 3 + +# Opérateur ternaire +a = 1 > 2 ? 3 : 4 #=> 4 + +# Aiguillage à l'aide du mot clé "case" +cmd = "move" + +action = case cmd + when "create" + "Creating..." + when "copy" + "Copying..." + when "move" + "Moving..." + when "delete" + "Deleting..." +end + +action #=> "Moving..." + +# Boucle +index = 0 +while index <= 3 + puts "Index: #{index}" + index += 1 +end +# Index: 0 +# Index: 1 +# Index: 2 +# Index: 3 + +index = 0 +until index > 3 + puts "Index: #{index}" + index += 1 +end +# Index: 0 +# Index: 1 +# Index: 2 +# Index: 3 + +# Mais il est préférable d'utiliser #each +(1..3).each do |index| + puts "Index: #{index}" +end +# Index: 0 +# Index: 1 +# Index: 2 +# Index: 3 + +# Le type d'une variable dépend du type de l'expression +# dans la déclaration du if +if a < 3 + a = "hello" +else + a = true +end +typeof a #=> (Bool | String) + +if a && b + # ici a et b ne sont pas null +end + +if a.is_a? String + a.class #=> String +end + +# Fonctions + +def double(x) + x * 2 +end + +# Les fonctions et tous les blocs retournent la valeur de la dernière évaluation +double(2) #=> 4 + +# Les parenthèses sont optionnelle quand l'appel n'est pas ambigü +double 3 #=> 6 + +double double 3 #=> 12 + +def sum(x, y) + x + y +end + +# Les arguments sont séparés par une virgule +sum 3, 4 #=> 7 + +sum sum(3, 4), 5 #=> 12 + +# yield +# Toutes les méthodes on un paramètre optionel et implicite de type bloc +# il peut être appelé avec le mot clé 'yield' +def surround + puts '{' + yield + puts '}' +end + +surround { puts "hello world" } + +# { +# hello world +# } + +# Un bloc peut être passé à une fonction +# Le "&" marque une référence à un bloc +def guests(&block) + block.call "some_argument" +end + +# Une liste d'arguments peut être donnée, qui sera convertie en tableau +# Pour cela, utilisez l'opérateur "*" +def guests(*array) + array.each { |guest| puts guest } +end + +# Si une méthode retourne un tableau, il peut être scindé +def foods + ["pancake", "sandwich", "quesadilla"] +end +breakfast, lunch, dinner = foods +breakfast #=> "pancake" +dinner #=> "quesadilla" + +# Par convention, toutes les méthodes qui retournent un booléen +# finissent par un point d'interrogation +5.even? # false +5.odd? # true + +# Si une méthode finit avec un point d'exclamation, c'est qu'elle fait une +# opération destructrice. Quelques méthodes ont une version "!" pour faire +# des changements et une version non-"!" pour retourner une nouvelle version +company_name = "Dunder Mifflin" +company_name.gsub "Dunder", "Donald" #=> "Donald Mifflin" +company_name #=> "Dunder Mifflin" +company_name.gsub! "Dunder", "Donald" +company_name #=> "Donald Mifflin" + + +# Les classes se définissent avec le mot clé "class" +class Human + + # Une variable de classe, partagée par toutes les instances + @@species = "H. sapiens" + + # "name" est une chaine de caratère ( String ) + @name : String + + # Constructeur basique, assigne l'argument à la variable "name" + # si l'age n'est pas donné, sa valeur sera de 0 + def initialize(@name, @age = 0) + end + + # Mutateur + def name=(name) + @name = name + end + + # Accesseur + def name + @name + end + + # La macro "property" va générer les deux précédentes méthodes + property :name + + # Les accesseurs/mutateurs peuvent aussi être créés individuellement + getter :name + setter :name + + # Une méthode de classe utilise "self" pour se distinguer d'une + # méthode d'instance. Elle ne peut être appelée qu'à partir de la classe + def self.say(msg) + puts msg + end + + def species + @@species + end +end + + +# Instantie une classe +jim = Human.new("Jim Halpert") + +dwight = Human.new("Dwight K. Schrute") + +# Appelons quelques méthodes +jim.species #=> "H. sapiens" +jim.name #=> "Jim Halpert" +jim.name = "Jim Halpert II" #=> "Jim Halpert II" +jim.name #=> "Jim Halpert II" +dwight.species #=> "H. sapiens" +dwight.name #=> "Dwight K. Schrute" + +# Appel de la méthode de classe +Human.say("Hi") #=> Affiche "Hi" et retourne nil + +# Les variables qui commencent par @ ont une portée d'instance +class TestClass + @var = "Je suis une variable d'instance" +end + +# Les variables qui commencent par @@ ont une portée de classe +class TestClass + @@var = "Je suis une variable de classe" +end +# Les constantes commencent par une lettre majuscule +Var = "Je suis constante" +Var = "impossible" # Already initialized constant Var + +# La classe est aussi un objet +# Les variables de classe sont partagées avec les descendants + +# Classe de base +class Human + @@foo = 0 + + def self.foo + @@foo + end + + def self.foo=(value) + @@foo = value + end +end + +# Classe dérivée +class Worker < Human +end + +Human.foo #=> 0 +Worker.foo #=> 0 + +Human.foo = 2 #=> 2 +Worker.foo #=> 0 + +Worker.foo = 3 #=> 3 +Human.foo #=> 2 +Worker.foo #=> 3 + +module ModuleExample + def foo + "foo" + end +end + +# Inclure (include) des modules ajoute leurs méthodes aux instances +# Étendre (extend) ajoute les méthodes à la classe + +class Person + include ModuleExample +end + +class Book + extend ModuleExample +end + +Person.foo # => undefined method 'foo' for Person:Class +Person.new.foo # => 'foo' +Book.foo # => 'foo' +Book.new.foo # => undefined method 'foo' for Book + + +# Gestion des exceptions + +# Définit un type d'exeption +class MyException < Exception +end + +# Définit une autre exception +class MyAnotherException < Exception; end + +ex = begin + raise MyException.new +rescue ex1 : IndexError + "ex1" +rescue ex2 : MyException | MyAnotherException + "ex2" +rescue ex3 : Exception + "ex3" +rescue ex4 # attrape toutes les autres exceptions + "ex4" +end + +ex #=> "ex2" + +``` + +## Ressources additionnelles + +- [Documentation Officielle (EN)](http://crystal-lang.org/) -- cgit v1.2.3 From 728852dea14ffc77786121af3f5af298337cf5da Mon Sep 17 00:00:00 2001 From: ven Date: Fri, 23 Dec 2016 01:08:03 +0100 Subject: follow-up fixes for #2602 --- fr-fr/crystal-fr.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/crystal-fr.html.markdown b/fr-fr/crystal-fr.html.markdown index 0bf6889c..2c4e3dad 100644 --- a/fr-fr/crystal-fr.html.markdown +++ b/fr-fr/crystal-fr.html.markdown @@ -13,7 +13,7 @@ lang: fr-fr # Ceci est un commentaire -# Tout est object +# Tout est objet nil.class #=> Nil 100.class #=> Int32 true.class #=> Bool @@ -68,7 +68,7 @@ true.class #=> Bool 'a'.class #=> Char -# Notation octale des caratères +# Notation octale des caractères '\101' #=> 'A' : Char # Notation unicode -- 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') 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 feff890a569cfa3df3715a0283f87a7ef3e169f1 Mon Sep 17 00:00:00 2001 From: Bastien Date: Thu, 9 Feb 2017 17:41:11 +0100 Subject: `[fr/elisp]` Add french translation of the elisp tutorial (#2570) * clojure.html.markdown: Fix an error (s/value/key) * Add french translation of the elisp tutorial. * elisp: s/http/https * fr-fr/elisp: Fix typo and missing translation. * fr-fr/elisp: Fix spaces * elisp: Add contributor. * fr-fr/elisp: s/mini-buffer/minibuffer. * fr-fr/elisp: Fix translation. * fr-fr/elisp: Fix translation. * fr-fr/elisp: Fix typo. * fr-fr/elisp: Fix missing translation. * fr-fr/elisp: Fix content. * fr-fr/elisp: Fix typo. * fr-fr/elisp: Fix keybindings display. * fr-fr/elisp: Fix double space. * fr-fr/elisp: Fix double space. * fr-fr/elisp: Fix more spaces. * fr-fr:elisp: Fix double space. --- fr-fr/elisp-fr.html.markdown | 372 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 372 insertions(+) create mode 100644 fr-fr/elisp-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/elisp-fr.html.markdown b/fr-fr/elisp-fr.html.markdown new file mode 100644 index 00000000..2e0a9408 --- /dev/null +++ b/fr-fr/elisp-fr.html.markdown @@ -0,0 +1,372 @@ +--- +language: elisp +contributors: + - ["Bastien Guerry", "https://bzg.fr"] + - ["Saurabh Sandav", "http://github.com/SaurabhSandav"] +translators: + - ["Bastien Guerry", "https://bzg.fr"] +filename: learn-emacs-lisp-fr.el +lang: fr-fr +--- + +```scheme +;; Ceci est une introduction à Emacs Lisp en 15 minutes (v0.2d) +;; +;; Auteur : Bastien / @bzg2 / https://bzg.fr +;; +;; Prenez d'abord le temps de lire ce texte en anglais de Peter Norvig : +;; http://norvig.com/21-days.html +;; +;; Ensuite installez GNU Emacs 24.3 (ou une version ultérieure) : +;; +;; Debian : apt-get install emacs (voir les instructions pour votre distribution) +;; MacOSX : http://emacsformacosx.com/emacs-builds/Emacs-24.3-universal-10.6.8.dmg +;; Windows : http://ftp.gnu.org/gnu/windows/emacs/emacs-24.3-bin-i386.zip +;; +;; Vous trouverez plus d'informations sur l'installation : +;; http://www.gnu.org/software/emacs/#Obtaining + +;; Avertissement important : +;; +;; Suivre ce tutoriel ne risque pas d'endommager votre ordinateur, +;; sauf si vous vous énervez au point de le jeter par terre. En tout +;; cas, je décline toute responsabilité en cas de problème. +;; Amusez-vous bien ! + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Lancez Emacs. +;; +;; Tapez la touche "q" pour enlever le message d'accueil. +;; +;; Maintenant regardez la ligne grise au pied de la fenêtre : +;; +;; "*scratch*" est le nom de l'espace d'édition dans lequel vous vous +;; trouvez. Cet espace d'édition est appelé un "buffer". +;; +;; Le buffer scratch est le buffer par défaut quand on ouvre Emacs. +;; Vous n'éditez jamais de fichier directement : vous éditez des +;; buffers que vous pouvez sauvegarder dans des fichiers. +;; +;; "Lisp interaction" désigne le jeu de commandes disponible ici. +;; +;; Emacs a un jeu de commandes par défaut pour chaque buffer, et +;; plusieurs autres jeux de commandes disponibles quand vous activez +;; un mode particulier. Ici nous utilisons `lisp-interaction-mode', +;; qui propose des commandes pour évaluer et naviguer dans du code +;; Elisp. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Le point-virgule commence un commentaire partout sur une ligne. +;; +;; Les programmes Elisp sont composés d'expressions symboliques aussi +;; appelées "sexps" : +(+ 2 2) + +;; Cette expression symbolique se lit "Ajouter 2 à 2". + +;; Les sexps sont placées entre parenthèses, possiblement sur +;; plusieurs niveaux : +(+ 2 (+ 1 1)) + +;; Une expression symbolique contient des atomes ou d'autres +;; expressions symboliques. Dans les exemples ci-dessus, 1 et 2 sont +;; des atomes et (+ 2 (+ 1 1)) et (+ 1 1) des expressions symboliques. + +;; Dans le mode `lisp-interaction-mode' vous pouvez évaluer les sexps. +;; Placez le curseur juste après la parenthèse fermante, tenez la +;; touche "Control" enfoncée et appuyez sur la touche "j" (soit le +;; raccourci "C-j"). + +(+ 3 (+ 1 2)) +;; ^ curseur ici +;; `C-j' => 6 + +;; `C-j' insère le résultat de l'évaluation dans le buffer. + +;; `C-x C-e' affiche le même résultat dans la ligne tout en bas +;; d'Emacs, appelée le "minibuffer". On utilise en général `C-x C-e', +;; pour ne pas encombrer le buffer avec du texte inutile. + +;; `setq' assigne une valeur à une variable : +(setq my-name "Bastien") +;; `C-x C-e' => "Bastien" (affiché dans le minibuffer) + +;; `insert' va insérer "Hello!" là où se trouve le curseur : +(insert "Hello!") +;; `C-x C-e' => "Hello!" + +;; Nous utilisons `insert' avec un seul argument "Hello!", mais +;; nous pouvons passer plus d'arguments - ici nous en passons deux : + +(insert "Hello" " world!") +;; `C-x C-e' => "Hello world!" + +;; Vous pouvez utiliser des variables au lieu de chaînes de caractères : +(insert "Hello, I am " my-name) +;; `C-x C-e' => "Hello, I am Bastien" + +;; Vous pouvez combiner les sexps en fonctions : +(defun hello () (insert "Hello, I am " my-name)) +;; `C-x C-e' => hello + +;; Vous pouvez évaluer les fonctions : +(hello) +;; `C-x C-e' => Hello, I am Bastien + +;; Les parenthèses vides dans la définition de la fonction signifient +;; qu'elle ne prend pas d'argument. Mais toujours utiliser `my-name' +;; est ennuyant, demandons à la fonction d'accepter un argument (ici +;; l'argument est appelé "name") : + +(defun hello (name) (insert "Hello " name)) +;; `C-x C-e' => hello + +;; Maintenant appelons la fonction avec la chaîne de caractères "you" +;; comme valeur de son unique argument : +(hello "you") +;; `C-x C-e' => "Hello you" + +;; Youpi! + +;; Faites une pause. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Maintenant ouvrez un nouveau buffer appelé "*test*" dans une +;; nouvelle fenêtre : + +(switch-to-buffer-other-window "*test*") +;; `C-x C-e' +;; => [l'écran a deux fenêtres et le curseur est dans le buffer *test*] + +;; Placez la souris sur la fenêtre du haut et cliquez-gauche pour +;; retourner dans cette fenêtre. Ou bien utilisez `C-x o' (i.e. tenez +;; control-x appuyé et appuyez sur o) pour aller dans l'autre fenêtre +;; interactivement. + +;; Vous pouvez combiner plusieurs sexps avec `progn' : +(progn + (switch-to-buffer-other-window "*test*") + (hello "you")) +;; `C-x C-e' +;; => [L'écran a deux fenêtres et le curseur est dans le buffer *test*] + +;; Maintenant si ça ne vous dérange pas, je vais arrêter de vous +;; demander de faire `C-x C-e' : faites-le pour chaque sexp qui suit. + +;; Retournez toujours dans le buffer *scratch* avec la souris ou `C-x o'. + +;; Il est souvent utile d'effacer le contenu du buffer : +(progn + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (hello "there")) + +;; Ou d'aller à l'autre fenêtre : +(progn + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (hello "you") + (other-window 1)) + +;; Vous pouvez associer une valeur à une variable locale avec `let' : +(let ((local-name "you")) + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (hello local-name) + (other-window 1)) + +;; Dans ce cas pas besoin d'utiliser `progn' puisque `let' combine +;; aussi plusieurs sexps. + +;; Mettons en forme une chaîne de caractères : +(format "Hello %s!\n" "visitor") + +;; %s désigne l'emplacement de la chaîne, remplacé par "visitor". +;; \n est le caractère de saut de ligne. + +;; Améliorons notre fonction en utilisant "format" : +(defun hello (name) + (insert (format "Hello %s!\n" name))) + +(hello "you") + +;; Créons une autre fonction qui utilise `let' : +(defun greeting (name) + (let ((your-name "Bastien")) + (insert (format "Hello %s!\n\nI am %s." + name ; l'argument de la fonction + your-name ; la variable "let-bindée" "Bastien" + )))) + +;; Et évaluons-la : +(greeting "you") + +;; Certaines fonctions sont interactives : +(read-from-minibuffer "Enter your name: ") + +;; Évaluer cette fonction va renvoyer ce que vous avez saisi dans le +;; minibuffer. + +;; Faisons que notre fonction `greeting' vous demande votre nom : +(defun greeting (from-name) + (let ((your-name (read-from-minibuffer "Enter your name: "))) + (insert (format "Hello!\n\nI am %s and you are %s." + from-name ; l'argument de la fonction + your-name ; la variable "let-bindée", entrée dans le minibuffer + )))) + +(greeting "Bastien") + +;; Complétons la fonction pour qu'elle affiche le résultat dans +;; l'autre fenêtre : +(defun greeting (from-name) + (let ((your-name (read-from-minibuffer "Enter your name: "))) + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (insert (format "Hello %s!\n\nI am %s." your-name from-name)) + (other-window 1))) + +;; Maintenant testons : +(greeting "Bastien") + +;; Faites une pause. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; Stockons une liste de noms : +(setq list-of-names '("Sarah" "Chloe" "Mathilde")) + +;; Récupérez le premier élément de la liste avec `car' : +(car list-of-names) + +;; Récupérez tous les élements sauf le premier avec `cdr' : +(cdr list-of-names) + +;; Ajoutez un élément au début avec `push' : +(push "Stephanie" list-of-names) + +;; Note : `car' et `cdr' ne modifient pas la liste, mais `push' oui. +;; C'est une différence importante : certaines fonctions n'ont pas +;; d'effets de bord (comme `car') et d'autres oui (comme `push'). + +;; Évaluons `hello' pour tous les éléments dans `list-of-names' : +(mapcar 'hello list-of-names) + +;; Améliorons `greeting' pour dire hello aux noms de `list-of-names' : +(defun greeting () + (switch-to-buffer-other-window "*test*") + (erase-buffer) + (mapcar 'hello list-of-names) + (other-window 1)) + +(greeting) + +;; Vous vous souvenez de la fonction `hello' définie ci-dessus ? Elle +;; prend seulement un argument, un nom. `mapcar' appelle `hello' en +;; utilisant successivement chaque élément de `list-of-names' comme +;; argument de `hello'. + +;; Maintenant arrangeons un peu ce qui est affiché dans le buffer : + +(defun replace-hello-by-bonjour () + (switch-to-buffer-other-window "*test*") + (goto-char (point-min)) + (while (search-forward "Hello") + (replace-match "Bonjour")) + (other-window 1)) + +;; (goto-char (point-min)) va au début du buffer. +;; (search-forward "Hello") cherche la chaîne "Hello". +;; (while x y) évalue la sexp(s) y tant que x renvoie quelque chose. +;; Si x renvoie `nil' (rien), nous sortons de la boucle. + +(replace-hello-by-bonjour) + +;; Vous devriez voir toutes les occurrences de "Hello" dans le buffer +;; *test* remplacées par "Bonjour". + +;; Vous devriez aussi avoir une erreur : "Search failed: Hello". +;; +;; Pour éviter cette erreur, il faut dire à `search-forward' si la +;; recherche doit s'arrêter à un certain point du buffer, et si elle +;; doit s'arrêter silencieusement si aucune chaîne n'est trouvée. + +;; (search-forward "Hello" nil t) fait ça : + +;; L'argument `nil' indique que la recherche n'est pas limitée à une +;; position. L'argument `t' indique de s'arrêter silencieusement si +;; rien n'est trouvé. + +;; Nous utilisons cette sexp dans la fonction ci-dessous, qui ne +;; renvoie pas d'erreur : + +(defun hello-to-bonjour () + (switch-to-buffer-other-window "*test*") + (erase-buffer) + ;; Dit hello aux noms de `list-of-names' + (mapcar 'hello list-of-names) + (goto-char (point-min)) + ;; Remplace "Hello" par "Bonjour" + (while (search-forward "Hello" nil t) + (replace-match "Bonjour")) + (other-window 1)) + +(hello-to-bonjour) + +;; Mettons les noms en gras : + +(defun boldify-names () + (switch-to-buffer-other-window "*test*") + (goto-char (point-min)) + (while (re-search-forward "Bonjour \\(.+\\)!" nil t) + (add-text-properties (match-beginning 1) + (match-end 1) + (list 'face 'bold))) + (other-window 1)) + +;; Cette fonction introduit `re-search-forward' : au lieu de chercher +;; la chaîne "Bonjour", nous cherchons un "pattern" en utilisant une +;; "expression régulière" (le préfixe "re-" signifie "regular +;; expression"). + +;; L'expression régulière est "Bonjour \\(.+\\)!" et se lit : +;; la chaîne "Bonjour ", et +;; un groupe de | c'est la syntaxe \\( ... \\) +;; n'importe quel caractère | c'est le . +;; une ou plusieurs fois | c'est le + +;; et la chaîne "!". + +;; Prêt ? Testons ! + +(boldify-names) + +;; `add-text-properties' ajoute des propriétés textuelles telle que +;; des "faces" (une "face" définit la fonte, la couleur, la taille et +;; d'autres propriétés du texte.) + +;; Et voilà, c'est fini. Happy hacking! + +;; Si vous voulez en savoir plus sur une variable ou une fonction : +;; +;; C-h v une-variable RET +;; C-h f une-fonction RET +;; +;; Pour lire le manuel Emacs Lisp avec Emacs : +;; +;; C-h i m elisp RET +;; +;; Pour lire en ligne une introduction à Emacs Lisp : +;; https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html + +;; Merci à ces personnes pour leurs retours et suggetions : +;; - Wes Hardaker +;; - notbob +;; - Kevin Montuori +;; - Arne Babenhauserheide +;; - Alan Schmitt +;; - LinXitoW +;; - Aaron Meurer +``` -- 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') 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 From 63a6eb1182205389388e13b680962199ac9b3ffb Mon Sep 17 00:00:00 2001 From: Andy Date: Sat, 1 Apr 2017 22:19:58 +0200 Subject: [haskell] Updating second headline (#2695) * Haskell: Updating second headline * Haskell: Updating second headline (es) * Haskell: Updating second headline (fr) * Haskell: Updating second headline (pl) * Haskell: Updating second headline (pt) * Haskell: Updating second headline (ro) * Haskell: Updating second headline (ru) * Haskell: Updating second headline (cn) --- fr-fr/haskell.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr') diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown index d9d3151f..a34dc098 100644 --- a/fr-fr/haskell.html.markdown +++ b/fr-fr/haskell.html.markdown @@ -66,7 +66,7 @@ not False -- True ---------------------------------------------------- --- Listes et tuples +-- 2. Listes et tuples ---------------------------------------------------- -- Tous les éléments d'une liste doit avoir le même type. -- cgit v1.2.3 From 53d56bb4659dd9f8ef03190ca87eacd11a62bbc6 Mon Sep 17 00:00:00 2001 From: Alois Date: Thu, 18 May 2017 12:44:18 +0200 Subject: [WIP][fsharp/fr] I just finish to translate the F# tuto to fr (#2446) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Create fsharp-fr.html.markdown * Add introduction and basics * Update fsharp-fr.html.markdown * Fix old translation of progress a bit * Progress on types * Add the end part * Fix verb "créer" * Improve stuff * Remove trailing whitespaces * Move from C# highlighting to F# * Improve trad * Relecture Je doute encore sur les (?) --- fr-fr/fsharp-fr.html.markdown | 630 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 630 insertions(+) create mode 100644 fr-fr/fsharp-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/fsharp-fr.html.markdown b/fr-fr/fsharp-fr.html.markdown new file mode 100644 index 00000000..7336c6aa --- /dev/null +++ b/fr-fr/fsharp-fr.html.markdown @@ -0,0 +1,630 @@ +--- +language: F# +contributors: + - ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"] +translators: + - ["Alois de Gouvello", "https://github.com/aloisdg"] +filename: learnfsharp-fr.fs +--- + +F# est un langage de programmation fonctionnel et orienté objet. Il est gratuit et son code source est ouvert. Il tourne sur Linux, Mac, Windows et plus. + +Il possède un puissant système de type qui piège de nombreuses erreurs à la compilation, mais il utilise l'inférence de type ce qui lui permet d'être lu comme un langage dynamique. + +La syntaxe de F# est différente des langages héritant de C. + +* Les accolades ne sont pas utilisées pour délimiter les blocs de code. À la place, l'indentation est utilisée (à la manière de Python). +* Les espaces sont utilisés pour séparer les paramètres à la place des virgules. + +Si vous voulez essayer le code ci-dessous, vous pouvez vous rendre sur [tryfsharp.org](http://www.tryfsharp.org/Create) et le coller dans le [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop). + +```fsharp + +// Les commentaires d'une seule ligne commencent par un double slash +(* Les commentaires multilignes utilise les paires (* . . . *) + +-fin du commentaire multilignes- *) + +// ================================================ +// Syntaxe de base +// ================================================ + +// ------ "Variables" (mais pas vraiment) ------ +// Le mot clé "let" définit une valeur (immutable) +let myInt = 5 +let myFloat = 3.14 +let myString = "hello" // Notons qu'aucun type n'est nécessaire + +// ------ Listes ------ +let twoToFive = [2;3;4;5] // Les crochets créent une liste avec + // des point-virgules pour délimiteurs. +let oneToFive = 1 :: twoToFive // :: crée une liste avec un nouvel élément +// Le résultat est [1;2;3;4;5] +let zeroToFive = [0;1] @ twoToFive // @ concatène deux listes + +// IMPORTANT: les virgules ne sont jamais utilisées pour délimiter, +// seulement les point-virgules ! + +// ------ Fonctions ------ +// Le mot clé "let" définit aussi le nom d'une fonction. +let square x = x * x // Notons qu'aucune parenthèse n'est utilisée. +square 3 // Maitenant, exécutons la fonction. + // Encore une fois, aucune parenthèse. + +let add x y = x + y // N'utilisez pas add (x,y) ! Cela signifie + // quelque chose de complètement différent. +add 2 3 // À présent, exécutons la fonction. + +// Pour définir une fonction sur plusieurs lignes, utilisons l'indentation. +// Les point-virgules ne sont pas nécessaires. +let evens list = + let isEven x = x%2 = 0 // Définit "isEven" comme une fonction imbriquée + List.filter isEven list // List.filter est une fonction de la librairie + // à deux paramètres: un fonction retournant un + // booléen et une liste sur laquelle travailler + +evens oneToFive // À présent, exécutons la fonction. + +// Vous pouvez utilisez les parenthèses pour clarifier. +// Dans cet exemple, "map" est exécutée en première, avec deux arguments, +// ensuite "sum" est exécutée sur le résultat. +// Sans les parenthèses, "List.map" serait passé en argument à List.sum. +let sumOfSquaresTo100 = + List.sum ( List.map square [1..100] ) + +// Vous pouvez rediriger la sortie d'une fonction vers une autre avec "|>" +// Rediriger des données est très commun en F#, comme avec les pipes UNIX. + +// Voici la même fonction sumOfSquares écrite en utilisant des pipes +let sumOfSquaresTo100piped = + [1..100] |> List.map square |> List.sum // "square" est déclaré avant + +// Vous pouvez définir des lambdas (fonctions anonymes) grâce au mot clé "fun" +let sumOfSquaresTo100withFun = + [1..100] |> List.map (fun x -> x*x) |> List.sum + +// En F#, il n'y a pas de mot clé "return". Une fonction retourne toujours +// la valeur de la dernière expression utilisée. + +// ------ Pattern Matching ------ +// Match..with.. est une surcharge de la condition case/switch. +let simplePatternMatch = + let x = "a" + match x with + | "a" -> printfn "x is a" + | "b" -> printfn "x is b" + | _ -> printfn "x is something else" // underscore correspond à tout le reste + +// F# n'autorise pas la valeur null par défaut -- vous devez utiliser le type Option +// et ensuite faire correspondre le pattern. +// Some(..) et None sont approximativement analogue à des wrappers de Nullable +let validValue = Some(99) +let invalidValue = None + +// Dans cet exemple, match..with trouve une correspondance à "Some" et à "None", +// et affiche la valeur du "Some" en même temps. +let optionPatternMatch input = + match input with + | Some i -> printfn "input is an int=%d" i + | None -> printfn "input is missing" + +optionPatternMatch validValue +optionPatternMatch invalidValue + +// ------ Affichage ------ +// Les fonctions printf/printfn sont similaires aux fonctions +// Console.Write/WriteLine de C#. +printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true +printfn "A string %s, and something generic %A" "hello" [1;2;3;4] + +// Il y a aussi les fonctions printf/sprintfn pour formater des données +// en string. C'est similaire au String.Format de C#. + +// ================================================ +// Plus sur les fonctions +// ================================================ + +// F# est un véritable langage fonctionel -- les fonctions sont des +// entités de premier ordre et peuvent êtres combinées facilement +// pour créer des constructions puissantes + +// Les modules sont utilisés pour grouper des fonctions ensemble. +// L'indentation est nécessaire pour chaque module imbriqué. +module FunctionExamples = + + // définit un simple fonction d'addition + let add x y = x + y + + // usage basique d'une fonction + let a = add 1 2 + printfn "1+2 = %i" a + + // partial application to "bake in" parameters (?) + let add42 = add 42 + let b = add42 1 + printfn "42+1 = %i" b + + // composition pour combiner des fonctions + let add1 = add 1 + let add2 = add 2 + let add3 = add1 >> add2 + let c = add3 7 + printfn "3+7 = %i" c + + // fonctions de premier ordre + [1..10] |> List.map add3 |> printfn "new list is %A" + + // listes de fonction et plus + let add6 = [add1; add2; add3] |> List.reduce (>>) + let d = add6 7 + printfn "1+2+3+7 = %i" d + +// ================================================ +// Listes et collections +// ================================================ + +// Il y a trois types de collection ordonnée : +// * Les listes sont les collections immutables les plus basiques +// * Les tableaux sont mutables et plus efficients +// * Les séquences sont lazy et infinies (e.g. un enumerator) +// +// Des autres collections incluent des maps immutables et des sets +// plus toutes les collections de .NET + +module ListExamples = + + // les listes utilisent des crochets + let list1 = ["a";"b"] + let list2 = "c" :: list1 // :: pour un ajout au début + let list3 = list1 @ list2 // @ pour la concatenation + + // Compréhensions des listes (aka générateurs) + let squares = [for i in 1..10 do yield i*i] + + // Générateur de nombre premier + let rec sieve = function + | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ] + | [] -> [] + let primes = sieve [2..50] + printfn "%A" primes + + // le pattern matching pour les listes + let listMatcher aList = + match aList with + | [] -> printfn "the list is empty" + | [first] -> printfn "the list has one element %A " first + | [first; second] -> printfn "list is %A and %A" first second + | _ -> printfn "the list has more than two elements" + + listMatcher [1;2;3;4] + listMatcher [1;2] + listMatcher [1] + listMatcher [] + + // Récursion en utilisant les listes + let rec sum aList = + match aList with + | [] -> 0 + | x::xs -> x + sum xs + sum [1..10] + + // ----------------------------------------- + // Fonctions de la librairie standard + // ----------------------------------------- + + // map + let add3 x = x + 3 + [1..10] |> List.map add3 + + // filtre + let even x = x % 2 = 0 + [1..10] |> List.filter even + + // beaucoup plus -- se référer à la documentation + +module ArrayExamples = + + // les tableaux utilisent les crochets avec des barres + let array1 = [| "a";"b" |] + let first = array1.[0] // accès à l'index en utilisant un point + + // le pattern matching des tableaux est le même que celui des listes + let arrayMatcher aList = + match aList with + | [| |] -> printfn "the array is empty" + | [| first |] -> printfn "the array has one element %A " first + | [| first; second |] -> printfn "array is %A and %A" first second + | _ -> printfn "the array has more than two elements" + + arrayMatcher [| 1;2;3;4 |] + + // Fonctions de la librairie standard comme celles des listes + [| 1..10 |] + |> Array.map (fun i -> i+3) + |> Array.filter (fun i -> i%2 = 0) + |> Array.iter (printfn "value is %i. ") + +module SequenceExamples = + + // Les séquences utilisent des accolades + let seq1 = seq { yield "a"; yield "b" } + + // Les séquences peuvent utiliser yield et + // peuvent contenir des sous-sequences + let strange = seq { + // "yield" ajoute un élément + yield 1; yield 2; + + // "yield!" ajoute une sous-sequence complète + yield! [5..10] + yield! seq { + for i in 1..10 do + if i%2 = 0 then yield i }} + // test + strange |> Seq.toList + + // Les séquences peuvent être créées en utilisant "unfold" + // Voici la suite de fibonacci + let fib = Seq.unfold (fun (fst,snd) -> + Some(fst + snd, (snd, fst + snd))) (0,1) + + // test + let fib10 = fib |> Seq.take 10 |> Seq.toList + printf "first 10 fibs are %A" fib10 + +// ================================================ +// Types de données +// ================================================ + +module DataTypeExamples = + + // Toutes les données sont immutables par défaut + + // Les tuples sont de simple et rapide types anonymes + // -- Utilisons une virgule pour créer un tuple + let twoTuple = 1,2 + let threeTuple = "a",2,true + + // Pattern match pour déballer + let x,y = twoTuple // assigne x=1 y=2 + + // ------------------------------------ + // Record types ont des champs nommés + // ------------------------------------ + + // On utilise "type" avec des accolades pour définir un type record + type Person = {First:string; Last:string} + + // On utilise "let" avec des accolades pour créer un record + let person1 = {First="John"; Last="Doe"} + + // Pattern match pour déballer + let {First=first} = person1 // assigne first="john" + + // ------------------------------------ + // Union types (aka variants) ont un set de choix + // Un seul cas peut être valide à la fois. + // ------------------------------------ + + // On utilise "type" avec bar/pipe pour definir un union type + type Temp = + | DegreesC of float + | DegreesF of float + + // On utilise un de ces choix pour en créér un + let temp1 = DegreesF 98.6 + let temp2 = DegreesC 37.0 + + // Pattern match on all cases to unpack(?) + let printTemp = function + | DegreesC t -> printfn "%f degC" t + | DegreesF t -> printfn "%f degF" t + + printTemp temp1 + printTemp temp2 + + // ------------------------------------ + // Types récursif + // ------------------------------------ + + // Les types peuvent être combinés récursivement de façon complexe + // sans avoir à créer des sous-classes + type Employee = + | Worker of Person + | Manager of Employee list + + let jdoe = {First="John";Last="Doe"} + let worker = Worker jdoe + + // ------------------------------------ + // Modelling with types(?) + // ------------------------------------ + + // Les types union sont excellents pour modelling state without using flags(?) + type EmailAddress = + | ValidEmailAddress of string + | InvalidEmailAddress of string + + let trySendEmail email = + match email with // utilisations du pattern matching + | ValidEmailAddress address -> () // envoyer + | InvalidEmailAddress address -> () // ne pas envoyer + + // Combiner ensemble, les types union et les types record + // offrent une excellente fondation pour le domain driven design. + // Vous pouvez créer des centaines de petit types qui reflèteront fidèlement + // le domain. + + type CartItem = { ProductCode: string; Qty: int } + type Payment = Payment of float + type ActiveCartData = { UnpaidItems: CartItem list } + type PaidCartData = { PaidItems: CartItem list; Payment: Payment} + + type ShoppingCart = + | EmptyCart // aucune donnée + | ActiveCart of ActiveCartData + | PaidCart of PaidCartData + + // ------------------------------------ + // Comportement natif des types + // ------------------------------------ + + // Les types natifs ont un comportement "prêt-à-l'emploi" des plus utiles, sans code à ajouter. + // * Immutabilité + // * Pretty printing au debug + // * Egalité et comparaison + // * Sérialisation + + // Le Pretty printing s'utilise avec %A + printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A" + twoTuple person1 temp1 worker + + // L'égalité et la comparaison sont innés + // Voici un exemple avec des cartes. + type Suit = Club | Diamond | Spade | Heart + type Rank = Two | Three | Four | Five | Six | Seven | Eight + | Nine | Ten | Jack | Queen | King | Ace + + let hand = [ Club,Ace; Heart,Three; Heart,Ace; + Spade,Jack; Diamond,Two; Diamond,Ace ] + + // tri + List.sort hand |> printfn "sorted hand is (low to high) %A" + List.max hand |> printfn "high card is %A" + List.min hand |> printfn "low card is %A" + +// ================================================ +// Les Active patterns +// ================================================ + +module ActivePatternExamples = + + // F# a un type particulier de pattern matching nommé "active patterns" + // où le pattern peut être parsé ou détecté dynamiquement. + + // "banana clips" est la syntaxe pour l'active patterns + + // par exemple, on définit un "active" pattern pour correspondre à des types "character"... + let (|Digit|Letter|Whitespace|Other|) ch = + if System.Char.IsDigit(ch) then Digit + else if System.Char.IsLetter(ch) then Letter + else if System.Char.IsWhiteSpace(ch) then Whitespace + else Other + + // ... et ensuite on l'utilise pour rendre la logique de parsing plus claire + let printChar ch = + match ch with + | Digit -> printfn "%c is a Digit" ch + | Letter -> printfn "%c is a Letter" ch + | Whitespace -> printfn "%c is a Whitespace" ch + | _ -> printfn "%c is something else" ch + + // afficher une liste + ['a';'b';'1';' ';'-';'c'] |> List.iter printChar + + // ----------------------------------------- + // FizzBuzz en utilisant les active patterns + // ----------------------------------------- + + // Vous pouvez créer un partial matching patterns également + // On utilise just un underscore dans la définition, et on retourne Some si ça correspond. + let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None + let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None + + // la fonction principale + let fizzBuzz i = + match i with + | MultOf3 & MultOf5 -> printf "FizzBuzz, " + | MultOf3 -> printf "Fizz, " + | MultOf5 -> printf "Buzz, " + | _ -> printf "%i, " i + + // test + [1..20] |> List.iter fizzBuzz + +// ================================================ +// Concision +// ================================================ + +module AlgorithmExamples = + + // F# a un haut ratio signal/bruit, permettant au code de se lire + // presque comme un véritable algorithme + + // ------ Exemple: definir une fonction sumOfSquares ------ + let sumOfSquares n = + [1..n] // 1) Prendre tous les nombres de 1 à n + |> List.map square // 2) Elever chacun d'entre eux au carré + |> List.sum // 3) Effectuer leur somme + + // test + sumOfSquares 100 |> printfn "Sum of squares = %A" + + // ------ Exemple: definir un fonction de tri ------ + let rec sort list = + match list with + // Si la liste est vide + | [] -> + [] // on retourne une liste vide + // si la list n'est pas vide + | firstElem::otherElements -> // on prend le premier élément + let smallerElements = // on extrait les éléments plus petits + otherElements // on prend les restants + |> List.filter (fun e -> e < firstElem) + |> sort // et on les trie + let largerElements = // on extrait les plus grands + otherElements // de ceux qui restent + |> List.filter (fun e -> e >= firstElem) + |> sort // et on les trie + // On combine les 3 morceaux dans une nouvelle liste que l'on retourne + List.concat [smallerElements; [firstElem]; largerElements] + + // test + sort [1;5;23;18;9;1;3] |> printfn "Sorted = %A" + +// ================================================ +// Code Asynchrone +// ================================================ + +module AsyncExample = + + // F# inclus des fonctionnalités pour aider avec le code asynchrone + // sans rencontrer la "pyramid of doom" + // + // L'exemple suivant télécharge une séquence de page web en parallèle. + + open System.Net + open System + open System.IO + open Microsoft.FSharp.Control.CommonExtensions + + // Récupérer le contenu d'une URL de manière asynchrone + let fetchUrlAsync url = + async { // Le mot clé "async" et les accolades + // créent un objet "asynchrone" + let req = WebRequest.Create(Uri(url)) + use! resp = req.AsyncGetResponse() + // use! est un assignement asynchrone + use stream = resp.GetResponseStream() + // "use" déclenche automatiquement close() + // sur les ressources à la fin du scope + use reader = new IO.StreamReader(stream) + let html = reader.ReadToEnd() + printfn "finished downloading %s" url + } + + // une liste des sites à rapporter + let sites = ["http://www.bing.com"; + "http://www.google.com"; + "http://www.microsoft.com"; + "http://www.amazon.com"; + "http://www.yahoo.com"] + + // C'est parti! + sites + |> List.map fetchUrlAsync // créez une liste de tâche asynchrone + |> Async.Parallel // dites aux tâches de tourner en parallèle + |> Async.RunSynchronously // démarrez les! + +// ================================================ +// .NET compatabilité +// ================================================ + +module NetCompatibilityExamples = + + // F# peut réaliser presque tout ce que C# peut faire, et il s'intègre + // parfaitement avec les librairies .NET ou Mono. + + // ------- Travaillez avec les fonctions des librairies existantes ------- + + let (i1success,i1) = System.Int32.TryParse("123"); + if i1success then printfn "parsed as %i" i1 else printfn "parse failed" + + // ------- Implémentez des interfaces à la volée! ------- + + // Créer un nouvel objet qui implémente IDisposable + let makeResource name = + { new System.IDisposable + with member this.Dispose() = printfn "%s disposed" name } + + let useAndDisposeResources = + use r1 = makeResource "first resource" + printfn "using first resource" + for i in [1..3] do + let resourceName = sprintf "\tinner resource %d" i + use temp = makeResource resourceName + printfn "\tdo something with %s" resourceName + use r2 = makeResource "second resource" + printfn "using second resource" + printfn "done." + + // ------- Code orienté objet ------- + + // F# est aussi un véritable language OO. + // Il supporte les classes, l'héritage, les méthodes virtuelles, etc. + + // interface avec type générique + type IEnumerator<'a> = + abstract member Current : 'a + abstract MoveNext : unit -> bool + + // Classe de base abstraite avec méthodes virtuelles + [] + type Shape() = + // propriétés en lecture seule + abstract member Width : int with get + abstract member Height : int with get + // méthode non-virtuelle + member this.BoundingArea = this.Height * this.Width + // méthode virtuelle avec implémentation de la classe de base + abstract member Print : unit -> unit + default this.Print () = printfn "I'm a shape" + + // classe concrète qui hérite de sa classe de base et surcharge + type Rectangle(x:int, y:int) = + inherit Shape() + override this.Width = x + override this.Height = y + override this.Print () = printfn "I'm a Rectangle" + + // test + let r = Rectangle(2,3) + printfn "The width is %i" r.Width + printfn "The area is %i" r.BoundingArea + r.Print() + + // ------- extension de méthode ------- + + // Juste comme en C#, F# peut étendre des classes existantes avec des extensions de méthode. + type System.String with + member this.StartsWithA = this.StartsWith "A" + + // test + let s = "Alice" + printfn "'%s' starts with an 'A' = %A" s s.StartsWithA + + // ------- événements ------- + + type MyButton() = + let clickEvent = new Event<_>() + + [] + member this.OnClick = clickEvent.Publish + + member this.TestEvent(arg) = + clickEvent.Trigger(this, arg) + + // test + let myButton = new MyButton() + myButton.OnClick.Add(fun (sender, arg) -> + printfn "Click event with arg=%O" arg) + + myButton.TestEvent("Hello World!") + +``` + +## Plus d'information + +Pour plus de démonstration de F#, rendez-vous sur le site [Try F#](http://www.tryfsharp.org/Learn), ou suivez la série [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/). + +Apprenez en davantage à propose de F# sur [fsharp.org](http://fsharp.org/). -- cgit v1.2.3 From da3abd314b3e452299469dba3af95e73674a2bd4 Mon Sep 17 00:00:00 2001 From: ven Date: Thu, 18 May 2017 12:45:43 +0200 Subject: fixup #2446 --- fr-fr/fsharp-fr.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/fsharp-fr.html.markdown b/fr-fr/fsharp-fr.html.markdown index 7336c6aa..cab22e8a 100644 --- a/fr-fr/fsharp-fr.html.markdown +++ b/fr-fr/fsharp-fr.html.markdown @@ -295,14 +295,14 @@ module DataTypeExamples = // On utilise "type" avec des accolades pour définir un type record type Person = {First:string; Last:string} - // On utilise "let" avec des accolades pour créer un record + // On utilise "let" avec des accolades pour créer un record (enregistrement) let person1 = {First="John"; Last="Doe"} // Pattern match pour déballer let {First=first} = person1 // assigne first="john" // ------------------------------------ - // Union types (aka variants) ont un set de choix + // Union types (ou variants) ont un set (ensemble) de choix // Un seul cas peut être valide à la fois. // ------------------------------------ -- cgit v1.2.3 From d2a8a52017e993055bac2bd6c1c3688f869a5b2c Mon Sep 17 00:00:00 2001 From: Xuan-thi Nguyen Date: Thu, 18 May 2017 12:46:58 +0200 Subject: [fr/c++] c++ article translated in French (#1854) * c++ article translated in French * Typos --- fr-fr/c++-fr.html.markdown | 917 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 917 insertions(+) create mode 100644 fr-fr/c++-fr.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/c++-fr.html.markdown b/fr-fr/c++-fr.html.markdown new file mode 100644 index 00000000..5cabc98d --- /dev/null +++ b/fr-fr/c++-fr.html.markdown @@ -0,0 +1,917 @@ +--- +language: c++ +filename: learncpp-fr.cpp +contributors: + - ["Steven Basart", "http://github.com/xksteven"] + - ["Matt Kline", "https://github.com/mrkline"] + - ["Geoff Liu", "http://geoffliu.me"] + - ["Connor Waters", "http://github.com/connorwaters"] +translators: + - ["Xuan-thi Nguyen", "http://github.com/mellenguyen"] +lang: fr-fr +--- + +C++ est un langage de programmation système qui, +[selon son créateur Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote), +fut créé pour + +- être un "C amélioré" +- gérer l'abstraction des données +- gérer la programmation orienté objet +- gérer la programmation générique + +Bien que sa syntaxe puisse être plus difficile ou complexe que des langages +récents, il est largement utilisé car il compile en instructions natives qui +peuvent être directement exécutées par le processeur et offre un contrôle +rigoureux du matériel (comme le C) tout en fournissant des caractéristiques de +haut niveau telles que la généricité, les exceptions et les classes. +Cette combinaison de vitesse et de fonctionnalités rend le C++ un des langages +de programmation les plus utilisés au monde. + +```c++ +///////////////////////////////// +// Comparaison avec le C +///////////////////////////////// + +// C++ est _presque_ un sur-ensemble du C et partage sa syntaxe basique pour les +// déclarations de variables, les types primitifs et les fonctions. + +// Tout comme en C, le point d'entrée de votre programme est une fonction +// appelée main, avec un integer comme type de retour. +// Cette valeur constitue l'état de fin d'exécution du programme. +// Voir http://en.wikipedia.org/wiki/Exit_status pour plus d'informations. +int main(int argc, char** argv) +{ + // Les arguments de ligne de commande sont passés avec argc et argv de la + // même manière qu'en C. + // argc indique le nombre d'arguments, + // et argv est un tableau de chaînes façon C (char*) + // représentant les arguments. + // Le premier argument est le nom par lequel le programme est appelé. + // argc et argv peuvent être omis si vous ne vous souciez pas des + // arguments, nous donnant comme signature de fonction int main() + + // Un état de fin d'exécution 0 indique le succès. + return 0; +} + +// Cependant, C++ varie du C selon certains éléments: + +// En C++, les caractères littéraux sont des chars +sizeof('c') == sizeof(char) == 1 + +// En C, les caractères littéraux sont des ints +sizeof('c') == sizeof(int) + +// C++ a un prototypage strict +void func(); // fonction qui ne prend aucun argument + +// En C +void func(); // fonction qui peut prendre n'importe quel nombre d'arguments + +// Utilise nullptr au lieu de NULL in C++ +int* ip = nullptr; + +// Les en-têtes standards du C sont disponibles en C++, +// mais son préfixés avec "c" et n'ont pas de suffixe .h +#include + +int main() +{ + printf("Bonjour tout le monde!\n"); + return 0; +} + +///////////////////////////////// +// Surchage de fonctions +///////////////////////////////// + +// C++ gère la surchage de fonctions +// Chaque fonction fournie prend différents paramètres. + +void print(char const* maChaine) +{ + printf("Chaîne %s\n", maChaine); +} + +void print(int monEntier) +{ + printf("Mon entier est %d", monEntier); +} + +int main() +{ + print("Bonjour"); // Utilise void print(const char*) + print(15); // Utilise void print(int) +} + +///////////////////////////////////////////// +// Arguments par défaut de fonctions +///////////////////////////////////////////// + +// Vous pouvez fournir des arguments par défaut pour une fonction s'ils ne sont +// pas fournis par l'appelant. + +void faitDesChosesAvecDesEntiers(int a = 1, int b = 4) +{ + // Do something with the ints here +} + +int main() +{ + faitDesChosesAvecDesEntiers(); // a = 1, b = 4 + faitDesChosesAvecDesEntiers(20); // a = 20, b = 4 + faitDesChosesAvecDesEntiers(20, 5); // a = 20, b = 5 +} + +// Les arguments par défaut doivent être à la fin de la liste des arguments. + +void invalidDeclaration(int a = 1, int b) // Erreur ! +{ +} + + +////////////////////////// +// Espaces de nom +////////////////////////// + +// Les espaces de nom fournissent une séparation des portées pour les +// variables, fonctions, et autres déclarations. +// Les espaces de nom peuvent être imbriqués. + +namespace Premier { + namespace Imbrique { + void foo() + { + printf("Ceci est le Premier::Imbrique::foo\n"); + } + } // fin de l'espace de nom Imbrique +} // fin de l'espace de nom Premier + +namespace Second { + void foo() + { + printf("Ceci est le Second::foo\n") + } +} + +void foo() +{ + printf("Ceci est un foo global\n"); +} + +int main() +{ + // Inclut tous les symboles de l'espace de nom Second dans la portée + // actuelle. Notez que le foo() simple ne marche plus, car l'appel est + // ambigu entre le foo de l'espace de nom Second et celui de premier + // niveau. + using namespace Second; + + Second::foo(); // imprime "Ceci est le Second::foo" + Premier::Imbrique::foo(); // imprime "Ceci est le Premier::Imbrique::foo" + ::foo(); // imprime "Ceci est un foo global" +} + +///////////////////////// +// Entrée/Sortie +///////////////////////// + +// Les entrées et sorties en C++ utilisent des flux (streams) +// cin, cout et cerr représentent stdin, stdout et stderr. +// << est l'opérateur d'insertion et >> est l'opérateur d'extraction. + +#include // Inclusion pour les flux d'entrée/sortie + +// Les flux sont dans l'espace de nom std (librairie standard) +using namespace std; + +int main() +{ + int monEntier; + + // Imprime vers stdout (ou le terminal/l'écran) + cout << "Entrez votre chiffre favori:\n"; + // Prend l'entrée clavier + cin >> monEntier; + + // cout peut également être formaté + cout << "Votre chiffre favori est " << monEntier << "\n"; + // imprime "Votre chiffre favori est " + + cerr << "Utilisé pour les messages d'erreurs"; +} + +///////////////////////////////// +// Chaînes de caractères +///////////////////////////////// + +// Les chaînes de caractères en C++ sont des objets et ont plusieurs fonctions +// membres +#include + +// Les chaînes de caractères sont aussi dans l'espace de +// nom std (librairie standard) +using namespace std; + +string maChaine = "Bonjour"; +string monAutreChaine = " tout le monde !"; + +// + est utilisé pour la concaténation. +cout << maChaine + monAutreChaine; // Bonjour tout le monde !" + +cout << maChaine + " toi !"; // "Bonjour toi !" + +// Les chaînes de caractères C++ sont mutables et ont des valeurs sémantiques. +maChaine.append(" le chien !"); +cout << maChaine; // "Bonjour le chien !" + + +////////////////////// +// Références +////////////////////// + +// En plus des pointeurs comme ceux en C, +// C++ possède des _références_. +// Ce sont des types de pointeurs qui ne peuvent pas être réassignés une fois +// initialisés, et ne peuvent pas être nulles. +// Ils partagent la même syntaxe que les variables elles-mêmes: +// les * ne sont pas nécessaires pour les déréférencer et +// & (addresse de) n'est pas utilisé pour l'assignement. + +using namespace std; + +string foo = "Je suis foo"; +string bar = "Je suis bar"; + + +string& fooRef = foo; // Ceci créé une référence à foo +fooRef += ". Salut!"; // Modifie foo à travers la référence +cout << fooRef; // Imprime "Je suis foo. Salut!" + +// Ne réassigne pas "fooRef". Ceci revient à faire "foo = bar", et +// foo == "I am bar" +// après cette ligne. +cout << &fooRef << endl; // Imprime l'adresse de foo +fooRef = bar; +cout << &fooRef << endl; // Imprime toujours l'adresse de foo +cout << fooRef; // Imprime "Je suis bar" + +// L'adresse de fooRef reste la même, c.-à-d. référence toujours foo. + + +const string& barRef = bar; // Créé une référence constante de bar. +// Comme en C, les valeurs constantes (et pointeurs et références) ne peuvent +// être modifiées. + +// Erreur, les valeurs constantes ne peuvent être modifiées. +barRef += ". Salut!"; + +// Parenthèse: avant de développer le sujet des références, nous devons +// introduire un concept appelé un objet temporaire. Supposons que nous ayons +// le code suivant : +string objetTemporaireFun() { ... } +string valeurRetenu = objetTemporaireFun(); + +// Les différents événements se déroulant à la seconde ligne sont : +// - un objet chaîne de caractères est retourné de objetTemporaireFun +// - une nouvelle chaîne de caractères est construite avec la valeur +// retournée comme argument du constructeur +// - l'objet retourné est détruit. +// L'objet retourné est appelé un objet temporaire. Les objets temporaires sont +// créés chaque fois qu'une fonction retourne un objet, et sont détruits à la +// fin de l'évaluation de l'expression fermante (c'est ce que le standard +// énonce, mais les compilateurs sont autorisés à changer ce comportement. +// Cherchez "optimisation valeur de retour" si vous êtes intéressé par ce genre +// de détails). +// Dans cette ligne de code : +foo(bar(objetTemporaireFun())) + +// en supposant que foo et bar existent, l'objet retourné de objetTemporaireFun +// est passé à bar, et est détruit avant que foo soit appelé. + +// Revenons maintenant aux références. L'exception à la règle "objet détruit à +// la fin de l'expression fermante" s'applique dans le cas d'un objet +// temporaire lié à une référence constante, où sa durée de vie se voit +// prolongée à la portée courante : + +void referenceConstanteObjetTemporaireFun() { + // referenceConst prend l'objet temporaire, et est valide jusqu'à la fin de + // la fonction. + const string& referenceConst = objetTemporaireFun(); + ... +} + +// Un autre type de référence introduit en C++11 est spécifiquement pour les +// objets temporaires. Vous ne pouvez pas avoir de variable de ce type, mais +// il prime dans la résolution de surcharge : + +void fonctionFun(string& s) { ... } // Référence régulière +void fonctionFun(string&& s) { ... } // Référence un objet temporaire + +string foo; +// Appelle la version avec référence régulière +fonctionFun(foo); + +// Appelle la version avec référence temporaire +fonctionFun(objetTemporaireFun()); + +// Par exemple, vous aurez ces deux versions de constructeurs pour +// std::basic_string : +basic_string(const basic_string& other); +basic_string(basic_string&& other); + +// L'idéal étant de construire une nouvelle chaîne de caractères avec un objet +// temporaire (qui sera détruit de toute façon), nous pouvons ainsi avoir un +// constructeur qui "sauve" des parties de cette chaîne de caractères +// temporaire. Vous verrez ce concept sous le nom de "sémantique de mouvement". + +//////////////////////// +// Enumérations +//////////////////////// + +// Les énumérations sont un moyen d'assigner une valeur à une constante +// fréquemment utilisée pour une meilleure visualisation et lecture du code. +enum ETypesDeVoitures +{ + Berline, + Hayon, + 4x4, + Break +}; + +ETypesDeVoitures ObtenirVoiturePreferee() +{ + return ETypesDeVoitures::Hayon; +} + +// En C++11, il existe une manière simple d'assigner un type à une énumération, +// ce qui peut-être utile en sérialisation de données et conversion +// d'énumérations entre le type voulu et ses constantes respectives. +enum ETypesDeVoitures : uint8_t +{ + Berline, // 0 + Hayon, // 1 + 4x4 = 254, // 254 + Hybride // 255 +}; + +void EcrireOctetDansLeFichier(uint8_t ValeurEntree) +{ + // Sérialise la valeur d'entrée dans un fichier +} + +void EcrireTypeVoiturePrefereDansLeFichier(ETypesDeVoitures TypeVoitureEntree) +{ + // L'énumération est implicitement convertie en uint8_t du à la déclaration + // de son type d'énumération + EcrireOctetDansLeFichier(TypeVoitureEntree); +} + +// D'autre part, vous pourriez ne pas vouloir que des énumérations soient +// accidentellement converties en entiers ou en d'autres énumérations. Il est +// donc possible de créer une classe d'énumération qui ne sera pas +// implicitement convertie. +enum class ETypesDeVoitures : uint8_t +{ + Berline, // 0 + Hayon, // 1 + 4x4 = 254, // 254 + Hybride // 255 +}; + +void EcrireOctetDansLeFichier(uint8_t ValeurEntree) +{ + // Sérialise la valeur d'entrée dans un fichier +} + +void EcrireTypeVoiturePrefereDansLeFichier(ETypesDeVoitures TypeVoitureEntree) +{ + // Ne compilera pas même si ETypesDeVoitures est un uint8_t car + // l'énumération est déclarée en tant que "classe d'énumération" ! + EcrireOctetDansLeFichier(TypeVoitureEntree); +} + +/////////////////////////////////////////////////// +// Classes et programmation orientée objet +/////////////////////////////////////////////////// + +// Premier exemple de classes +#include + +// Déclare une classe. +// Les classes sont habituellement déclarées dans les fichiers d'en-tête (.h ou .hpp). +class Chien { + // Les variables et fonctions membres sont privées par défaut. + std::string nom; + int poids; + +// Tous les membres suivants sont publiques jusqu'à ce que "private:" ou +// "protected:" soit trouvé +public: + + // Constructeur par défaut + Chien(); + + // Déclaractions de fonctions membres (implémentations à suivre) + // Notez que nous utilisons std::string ici au lieu de placer + // using namespace std; + // au-dessus. + // Ne jamais utiliser une instruction "using namespace" dans l'en-tête. + void initialiserNom(const std::string& nomDuChien); + + void initialiserPoids(int poidsDuChien); + + // Les fonctions qui ne modifient pas l'état de l'objet devraient être + // marquées en constantes avec const. + // Ceci vous permet de les appeler avec une référence constante de l'objet. + // Notez aussi que les fonctions devant être surchargées dans des classes + // dérivées doivent être explicitement déclarées avec _virtual_. + // Les fonctions ne sont pas virtuelles par défault pour des raisons de + // performances. + virtual void imprimer() const; + + // Les fonctions peuvent également être définies à l'intérieur du corps de + // la classe. Ces fonctions sont automatiquement "inline". + void aboyer() const { std::cout << nom << " fait ouaf !\n"; } + + // En plus des constructeurs, C++ fournit des destructeurs. + // Ils sont appelés quand l'objet est supprimé ou dépasse le cadre de sa + // portée. Ceci permet de puissants paradigmes tels que RAII + // (voir plus loin) + // Le destructeur devrait être virtuel si la classe est abstraite; + // s'il n'est pas virtuel, alors le destructeur de la classe dérivée ne + // sera pas appelé si l'objet est détruit par le biais d'une référence à la + // classe de base ou d'un pointeur. + virtual ~Chien(); + +}; // Un semicolon doit clôre la définition de la classe. + +// Les fonctions membres de la classe sont habituellement implémentées dans des +// fichiers .cpp. +Chien::Chien() +{ + std::cout << "Un chien a été construit\n"; +} + +// Les objets (comme les chaînes de caractères) devraient être passés par +// référence si vous les modifiez ou par référence constante si vous ne les +// modifiez pas. +void Chien::initialiserNom(const std::string& nomDuChien) +{ + nom = nomDuChien; +} + +void Chien::initialiserPoids(int poidsDuChien) +{ + poids = poidsDuChien; +} + +// Notez que le mot-clé "virtual" est nécessaire uniquement à la déclaration, +// et non à la définition. +void Chien::imprimer() const +{ + std::cout << "Le chien s'appelle " << nom << " et pèse " << poids << "kg\n"; +} + +Chien::~Chien() +{ + cout << "Au revoir " << nom << " !\n"; +} + +int main() { + Chien monChien; // imprime "Un chien a été construit" + monChien.initialiserNom("Barkley"); + monChien.initialiserPoids(10); + monChien.imprime(); // imprime "Le chien s'appelle Barkley et pèse 10 kg" + return 0; +} // prints "Au revoir Barkley !" + +// Héritage : + +// Cette classe hérite de toutes les propriétés publiques et protégées de la +// classe Chien ainsi que celles privées, mais n'ont pas accès direct aux +// membres et méthodes privés sans l'aide d'une méthode publique ou protégée +class ChienDomestique : public ChienDomestique { + + void definirProprietaire(const std::string& proprietaireDuChien); + + // Surcharge le comportement de la fonction d'impression pour tous les + // ChienDomestiques. + // Voir https://fr.wikipedia.org/wiki/Polymorphisme_(informatique)#Polymorphisme_par_sous-typage + // pour une introduction plus générale si vous n'êtes pas familier avec le + // concept de polymorphisme par sous-typage (appelé aussi polymorphisme + // d'inclusion). + // Le mot-clé "override" est optionnel mais assure que vous surchargez bien + // la méthode de la classe de base. + void imprimer() const override; + +private: + std::string proprietaire; +}; + +// Pendant ce temps, dans le fichier .cpp correspondant : + +void ChienDomestique::definirProprietaire(const std::string& proprietaireDuChien) +{ + proprietaire = proprietaireDuChien; +} + +void ChienDomestique::imprimer() const +{ + // Appelle la fonction "imprimer" dans la classe de base Chien + Chien::imprimer(); + std::cout << "Le chien appartient à " << proprietaire << "\n"; + // Imprime "Le chien est et pèse " + // "Le chien appartient à " +} + +//////////////////////////////////////////////////// +// Initialisation et opérateur de surcharge +//////////////////////////////////////////////////// + +// En C++, vous pouvez surcharger le comportement d'opérateurs tels +// que +, -, *, /, etc. +// La surcharge se fait en définissant une fonction qui sera appelée à chaque +// fois que l'opérateur sera utilisé. + +#include +using namespace std; + +class Point { +public: + // Les variables membres peuvent avoir des valeurs par défaut + double x = 0; + double y = 0; + + // Définit un constructeur par défaut qui ne fait rien + // mais initialise le Point à la valeur par défaut (0, 0) + Point() { }; + + // La syntaxe suivante est connue comme une liste d'initialisation et est + // la façon correcte d'initialiser les valeurs des membres d'une classe. + Point (double a, double b) : + x(a), + y(b) + { /* Ne fait rien à part initialiser les valeurs */ } + + // Surcharge l'opérateur + + Point operator+(const Point& rhs) const; + + // Surcharge l'opérateur += + Point& operator+=(const Point& rhs); + + // Il serait également logique d'ajouter les opérateurs - et -=, + // mais nous les éclipsons par soucis de concision. +}; + +Point Point::operator+(const Point& rhs) const +{ + // Créé un nouveau point qui est la somme de celui-ci de rhs. + return Point(x + rhs.x, y + rhs.y); +} + +Point& Point::operator+=(const Point& rhs) +{ + x += rhs.x; + y += rhs.y; + return *this; +} + +int main () { + Point haut (0,1); + Point droite (1,0); + // Appelle l'opérateur + du Point + // Le point "haut" appelle la fonction + avec "droite" comme paramètre + Point resultat = haut + droite; + // Prints "Le résultat est haut-droite (1,1)" + cout << "Le résultat est haut-droite (" << resultat.x << ',' + << resultat.y << ")\n"; + return 0; +} + +//////////////////////////////// +// Patrons (templates) +//////////////////////////////// + +// Les modèles (patrons, ou encore "templates") en C++ sont majoritairement +// utilisés pour la programmation générique, bien qu'ils soient bien plus +// puissants que les constructeurs génériques dans d'autres langages. +// Ils gèrent également la spécialisation explicite et partielle ainsi que +// les classes fonctionnelles; en fait, ils sont un langage fonctionnelles +// Turing-complete embedded in C++ ! + +// Nous commencons avec le genre de programmation générique auquel vous êtes +// peut-être familier. Pour définir une classe ou fonction qui prend un type de +// paramètre particulier : +template +class Boite { +public: + // Dans cette classe, T représente n'importe quel type possible. + void inserer(const T&) { ... } +}; + +// Pendant la compilation, le compilateur génère des copies de chaque template +// avec les paramètres substitués; ainsi, la définition complète de chaque +// classe doit être présente à chaque appel. C'est pourquoi vous verrez les +// classes de templates définies entièrement dans les fichiers d'en-tête. + +// Pour instancier une classe de template sur la pile ("stack") : +Boite boiteDEntiers; + +// et vous pouvez l'utiliser comme prévu : +boiteDEntiers.inserer(123); + +// Vous pouvez, bien sûr, imbriquer les templates : +Boite > boiteDeBoites; +boiteDeBoites.inserer(boiteDEntiers); + +// Jusqu'à C++11, il était nécessaire de placer un espace entre les deux '>'s, +// sinon '>>' était parsé en tant qu'opérateur de décalage vers la droite. + +// Vous croiserez peut-être cette syntaxe +// template +// à la place. Les mot-clé 'class' et 'typename' sont _généralement_ +// interchangeables. Pour plus d'explications, allez à +// http://en.wikipedia.org/wiki/Typename +// ou +// https://fr.wikibooks.org/wiki/Programmation_C-C%2B%2B/Les_templates/Mot-cl%C3%A9_typename +// (oui, ce mot-clé a sa propre page Wikipedia). + +// De manière similaire, un patron de fonction : +template +void aboyerTroisFois(const T& entree) +{ + entree.aboyer(); + entree.aboyer(); + entree.aboyer(); +} + +// Remarquez ici que rien n'est spécifié à propos du type du paramètre. Le +// compilateur va générer et vérifier le type à chaque appel du patron, c'est +// pourquoi l'appel de fonction suivant marche pour n'importe quel type 'T' qui +// a une méthode constante 'aboyer' ! + +Chien docile; +docile.initialiserNom("Docile") +aboyerTroisFois(docile); // Imprime "Docile fait ouaf !" trois fois. + +// Les paramètres génériques (ou paramètres template) ne sont pas forcément des +// classes : +template +void imprimerMessage() { + cout << "Apprenez le C++ en " << Y << " minutes !" << endl; +} + +// Vous pouvez explicitement spécialiser les templates pour un code plus +// optimisé. Bien sûr, les utilisations effectives de la spécialisation ne sont +// pas aussi triviales que celle-ci. +// Notez que vous avez toujours besoin de déclarer la fonction (ou classe) +// comme template, même si vous spécifiez explicitement tous les paramètres. +template<> +void imprimerMessage<10>() { + cout << "Apprenez le C++ plus vite en seulement 10 minutes !" << endl; +} + +// Imprime "Apprenez le C++ en 20 minutes !" +imprimerMessage<20>(); +// Imprime "Apprenez le C++ plus vite en seulement 10 minutes !" +imprimerMessage<10>(); + +////////////////////////////////// +// Gestion des exceptions +////////////////////////////////// + +// La librairie standard fournit quelques types d'exception +// (voir http://en.cppreference.com/w/cpp/error/exception) +// mais n'importe quel type peut être lancé en tant qu'exception. +#include +#include + +// Toutes les exceptions lancées à l'intérieur d'un block _try_ peuvent être +// attrapées par les blocs de traitement d'erreurs (_catch_ handlers). +try { + // N'allouez pas des exceptions sur le tas (heap) en utilisant _new_. + throw std::runtime_error("Un problème s'est produit"); +} + +// Attrapez les exceptions avec des références constantes si ce sont des objets +catch (const std::exception& ex) +{ + std::cout << ex.what(); +} + +// Attrape n'importe quelle exception non attrapée par les blocs _catch_ +// précédents +catch (...) +{ + std::cout << "Exception inconnue attrapée"; + throw; // Re-lance l'exception +} + +//////////////// +// RAII +//////////////// + +// RAII signifie "Resource Acquisition Is Initialization", soit l'Acquisition +// d'une Ressource est une Initialisation en français. +// Il est souvent considéré comme le paradigme le plus puissant en C++ et +// est le concept simple qu'un constructeur d'un objet acquiert les ressources +// d'un objet et que le destructeur les libère. + +// Afin de comprendre son utilité, considérons une fonction qui utilise la +// gestion d'un fichier C : +void faireQuelqueChoseAvecUnFichier(const char* nomDuFichier) +{ + // Pour commencer, supposns que rien ne peut échouer. + + FILE* fh = fopen(nomDuFichier, "r"); // Ouvre le fichier en lecture + + faireQuelqueChoseAvecLeFichier(fh); + faireAutreChoseAvec(fh); + + fclose(fh); // Ferme la gestion du fichier. +} + +// Malheureusement, les choses deviennent compliquées avec la gestion +// d'erreurs. Supposons que fopen échoue, et que faireQuelqueChoseAvecLeFichier +// et faireAutreChoseAvec retournent des codes d'erreur si elles échouent. +// (Les exceptions sont le meilleur moyen de gérer l'échec, mais des +// programmeurs, surtout avec un passif en C, +// sont en désaccord avec l'utilité des exceptions). +// Nous devons maintenant vérifier chaque appel en cas d'échec et fermer la +// gestion du fichier si un problème se produit. +bool faireQuelqueChoseAvecUnFichier(const char* nomDuFichier) +{ + FILE* fh = fopen(nomDuFichier, "r"); // Open the file in read mode + if (fh == nullptr) // Le pointeur retourné est null à un échec. + return false; // Signale cet échec à l'appelant. + + // Suppose que chaque fonction retourne faux si elle échoue + if (!faireQuelqueChoseAvecLeFichier(fh)) { + fclose(fh); // Ferme la gestion du fichier pour que cela ne fuite pas + return false; // Propage l'erreur + } + if (!faireAutreChoseAvec(fh)) { + fclose(fh); // Ferme la gestion du fichier pour que cela ne fuite pas + return false; // Propage l'erreur + } + + fclose(fh); // Ferme la gestion du fichier pour que cela ne fuite pas + return true; // Indique le succès +} + +// Les programmeurs en C clarifient souvent tout cela en utilisant goto : +bool faireQuelqueChoseAvecUnFichier(const char* nomDuFichier) +{ + FILE* fh = fopen(nomDuFichier, "r"); + if (fh == nullptr) + return false; + + if (!faireQuelqueChoseAvecLeFichier(fh)) + goto echec; + + if (!faireAutreChoseAvec(fh)) + goto echec; + + fclose(fh); // Ferme la gestion du fichier + return true; // Indique le succès + +echec: + fclose(fh); + return false; // Propage l'erreur +} + +// Si les fonctions indiquent des erreurs en utilisant des exceptions, +// les choses sont un peu plus claires, mais toujours sous-optimales. +void faireQuelqueChoseAvecUnFichier(const char* nomDuFichier) +{ + FILE* fh = fopen(nomDuFichier, "r"); // Ouvre le fichier en lecture + if (fh == nullptr) + throw std::runtime_error("Ouverture du fichier impossible."); + + try { + faireQuelqueChoseAvecLeFichier(fh); + faireAutreChoseAvec(fh); + } + catch (...) { + // Assurez-vous de bien fermer le fichier si une erreur arrive + fclose(fh); + throw; // Puis re-lancer l'exception + } + + fclose(fh); // Ferme le fichier + // Tout s'est déroulé correctement +} + +// Comparez ceci à l'utilisation de la classe de flux de fichier +// en C++ (fstream). +// fstream utilise son destructeur pour fermer le fichier. +// Pour rappel, les destructeurs sont automatiquement appelée dès qu'un objet +// sort du cadre de sa portée. +void faireQuelqueChoseAvecUnFichier(const std::string& nomDuFichier) +{ + // ifstream is short for input file stream + std::ifstream fh(nomDuFichier); // Ouvre le fichier + + // Faire des choses avec le fichier + faireQuelqueChoseAvecLeFichier(fh); + faireAutreChoseAvec(fh); + +} // Le fichier est automatiquement fermé ici par le destructeur + +// Ceci a des avantages _énormes_ : +// 1. Peu importe la situation, la ressource (dans ce cas précis la gestion +// de fichier) sera libérée. Dès que le destructeur est écrit correctement, +// il est _impossible_ d'oublier de fermer la gestion et d'entraîner une +// une fuite de ressources. +// 2. Remarquez que le code est beaucoup plus clair. +// Le destructeur gère la fermeture du fichier discrètement sans avoir +// besoin de s'en préoccuper. +// 3. Le code est fiable par rapport aux exceptions. +// Une exception peut être lancée n'importe où dans la fonction, le +// nettoyage se fera toujours. + +// Tout code C++ idiomatique utilise considérablement RAII pour toutes les +// ressources. +// Des exemples additionnels inclus : +// - La mémoire utilisant unique_ptr et shared_ptr +// - Des conteneurs (containers) - la liste chaînée de la librairie standard, +// des vecteurs (c.-à-d. tableaux auto-redimensionnés), tables de hachage, et +// ainsi de suite. Tous détruisent leur contenu quand ils sortent du cadre +// de leur portée. +// - Les mutex utilisant lock_guard et unique_lock + + +////////////////// +// Divers +////////////////// + +// Ici sont regroupés des aspects du C++ qui peuvent être surprenants aux +// novices (et même à quelques habitués). +// Cette section est, malheureusement, grandement incomplète; C++ est un des +// langages où il est très facile de se tirer soi-même dans le pied. + +// Vous pouvez surcharger des méthodes privées ! +class Foo { + virtual void bar(); +}; +class FooSub : public Foo { + virtual void bar(); // Surcharge Foo::bar! +}; + +// 0 == false == NULL (la plupart du temps) ! +bool* pt = new bool; +*pt = 0; // Affecte false à la valeur de la variable pointée par 'pt'. +pt = 0; // Affecte le pointeur null à 'pt'. +// Les deux lignes compilent sans avertissement. + +// nullptr est supposé régler un peu ce problème : +int* pt2 = new int; +*pt2 = nullptr; // Ne compile pas +pt2 = nullptr; // Affecte null à pt2 + +// Il y a une exception faite pour les booléens. +// Ceci vous permet de tester les pointeurs null avec if(!ptr), +// mais par conséquent, vous pouvez assigner nullptr à un booléen directement ! +*pt = nullptr; // Ceci compile toujours, même si '*pt' est un booléen ! + +// '=' != '=' != '='! +// Appelle Foo::Foo(const Foo&) ou une variante du (voir sémantiques de mouvement) +// constructeur par copie. +Foo f2; +Foo f1 = f2; + +// Appelle Foo::Foo(const Foo&) ou une variante, mais copie seulement la partie +// 'Foo' de 'fooSub'. Tout membre extra de 'fooSub' est ignoré. +// Ce comportement parfois horrifiant est appelé "object slicing". +FooSub fooSub; +Foo f1 = fooSub; + +// Appelle Foo::operator=(Foo&) ou une variante. +Foo f1; +f1 = f2; + +// Comment vraiment nettoyer un conteneur : +class Foo { ... }; +vector v; +for (int i = 0; i < 10; ++i) + v.push_back(Foo()); + +// La ligne suivante affecte la taille de v à 0, mais les destructeurs ne sont +// appelés et les ressources ne sont pas libérées ! +v.empty(); +// La nouvelle valeur est copiée dans le premier Foo que nous avons inséré +v.push_back(Foo()); + +// Ceci nettoie toutes les valeurs de v. Voir la section à propos des objets +// temporaires pour comprendre pourquoi cela fonctionne. +v.swap(vector()); + +``` +Lecture complémentaire : + +Une référence à jour du langage est disponible à + + +Des ressources supplémentaires sont disponibles à \ No newline at end of file -- cgit v1.2.3 From f5cb3924ef5fd07bf8ea3d324106de9dc3263c2c Mon Sep 17 00:00:00 2001 From: ven Date: Thu, 18 May 2017 12:54:00 +0200 Subject: small changes to #1854 --- fr-fr/c++-fr.html.markdown | 57 +++++++++++++++++++++++----------------------- 1 file changed, 28 insertions(+), 29 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/c++-fr.html.markdown b/fr-fr/c++-fr.html.markdown index 5cabc98d..acbaed58 100644 --- a/fr-fr/c++-fr.html.markdown +++ b/fr-fr/c++-fr.html.markdown @@ -190,7 +190,7 @@ int main() { int monEntier; - // Imprime vers stdout (ou le terminal/l'écran) + // Affiche sur stdout (ou le terminal/l'écran) cout << "Entrez votre chiffre favori:\n"; // Prend l'entrée clavier cin >> monEntier; @@ -222,7 +222,7 @@ cout << maChaine + monAutreChaine; // Bonjour tout le monde !" cout << maChaine + " toi !"; // "Bonjour toi !" -// Les chaînes de caractères C++ sont mutables et ont des valeurs sémantiques. +// Les chaînes de caractères C++ sont mutables. maChaine.append(" le chien !"); cout << maChaine; // "Bonjour le chien !" @@ -233,8 +233,8 @@ cout << maChaine; // "Bonjour le chien !" // En plus des pointeurs comme ceux en C, // C++ possède des _références_. -// Ce sont des types de pointeurs qui ne peuvent pas être réassignés une fois -// initialisés, et ne peuvent pas être nulles. +// Ce sont des types de pointeurs qui ne peuvent pas être réassignés +// une fois initialisés, et ne peuvent pas être nulles. // Ils partagent la même syntaxe que les variables elles-mêmes: // les * ne sont pas nécessaires pour les déréférencer et // & (addresse de) n'est pas utilisé pour l'assignement. @@ -247,15 +247,15 @@ string bar = "Je suis bar"; string& fooRef = foo; // Ceci créé une référence à foo fooRef += ". Salut!"; // Modifie foo à travers la référence -cout << fooRef; // Imprime "Je suis foo. Salut!" +cout << fooRef; // Affiche "Je suis foo. Salut!" // Ne réassigne pas "fooRef". Ceci revient à faire "foo = bar", et // foo == "I am bar" // après cette ligne. -cout << &fooRef << endl; // Imprime l'adresse de foo +cout << &fooRef << endl; // Affiche l'adresse de foo fooRef = bar; -cout << &fooRef << endl; // Imprime toujours l'adresse de foo -cout << fooRef; // Imprime "Je suis bar" +cout << &fooRef << endl; // Affiche toujours l'adresse de foo +cout << fooRef; // Affiche "Je suis bar" // L'adresse de fooRef reste la même, c.-à-d. référence toujours foo. @@ -396,7 +396,6 @@ void EcrireTypeVoiturePrefereDansLeFichier(ETypesDeVoitures TypeVoitureEntree) // Classes et programmation orientée objet /////////////////////////////////////////////////// -// Premier exemple de classes #include // Déclare une classe. @@ -424,7 +423,7 @@ public: // Les fonctions qui ne modifient pas l'état de l'objet devraient être // marquées en constantes avec const. - // Ceci vous permet de les appeler avec une référence constante de l'objet. + // Ceci vous permet de les appeler avec une référence constante vers l'objet. // Notez aussi que les fonctions devant être surchargées dans des classes // dérivées doivent être explicitement déclarées avec _virtual_. // Les fonctions ne sont pas virtuelles par défault pour des raisons de @@ -445,7 +444,7 @@ public: // classe de base ou d'un pointeur. virtual ~Chien(); -}; // Un semicolon doit clôre la définition de la classe. +}; // Un point virgule doit clôre la définition de la classe. // Les fonctions membres de la classe sont habituellement implémentées dans des // fichiers .cpp. @@ -522,7 +521,7 @@ void ChienDomestique::imprimer() const // Appelle la fonction "imprimer" dans la classe de base Chien Chien::imprimer(); std::cout << "Le chien appartient à " << proprietaire << "\n"; - // Imprime "Le chien est et pèse " + // Affiche "Le chien est et pèse " // "Le chien appartient à " } @@ -548,7 +547,7 @@ public: // mais initialise le Point à la valeur par défaut (0, 0) Point() { }; - // La syntaxe suivante est connue comme une liste d'initialisation et est + // La syntaxe suivante s'appelle une liste d'initialisation et est // la façon correcte d'initialiser les valeurs des membres d'une classe. Point (double a, double b) : x(a), @@ -584,7 +583,7 @@ int main () { // Appelle l'opérateur + du Point // Le point "haut" appelle la fonction + avec "droite" comme paramètre Point resultat = haut + droite; - // Prints "Le résultat est haut-droite (1,1)" + // Affiche "Le résultat est haut-droite (1,1)" cout << "Le résultat est haut-droite (" << resultat.x << ',' << resultat.y << ")\n"; return 0; @@ -594,7 +593,7 @@ int main () { // Patrons (templates) //////////////////////////////// -// Les modèles (patrons, ou encore "templates") en C++ sont majoritairement +// Les templates (patrons) en C++ sont majoritairement // utilisés pour la programmation générique, bien qu'ils soient bien plus // puissants que les constructeurs génériques dans d'autres langages. // Ils gèrent également la spécialisation explicite et partielle ainsi que @@ -654,7 +653,7 @@ void aboyerTroisFois(const T& entree) Chien docile; docile.initialiserNom("Docile") -aboyerTroisFois(docile); // Imprime "Docile fait ouaf !" trois fois. +aboyerTroisFois(docile); // Affiche "Docile fait ouaf !" trois fois. // Les paramètres génériques (ou paramètres template) ne sont pas forcément des // classes : @@ -673,16 +672,16 @@ void imprimerMessage<10>() { cout << "Apprenez le C++ plus vite en seulement 10 minutes !" << endl; } -// Imprime "Apprenez le C++ en 20 minutes !" +// Affiche "Apprenez le C++ en 20 minutes !" imprimerMessage<20>(); -// Imprime "Apprenez le C++ plus vite en seulement 10 minutes !" +// Affiche "Apprenez le C++ plus vite en seulement 10 minutes !" imprimerMessage<10>(); ////////////////////////////////// // Gestion des exceptions ////////////////////////////////// -// La librairie standard fournit quelques types d'exception +// La bibliothèque standard fournit quelques types d'exception // (voir http://en.cppreference.com/w/cpp/error/exception) // mais n'importe quel type peut être lancé en tant qu'exception. #include @@ -743,22 +742,22 @@ void faireQuelqueChoseAvecUnFichier(const char* nomDuFichier) // gestion du fichier si un problème se produit. bool faireQuelqueChoseAvecUnFichier(const char* nomDuFichier) { - FILE* fh = fopen(nomDuFichier, "r"); // Open the file in read mode + FILE* fh = fopen(nomDuFichier, "r"); // Ouvre le fichier en mode lecture. if (fh == nullptr) // Le pointeur retourné est null à un échec. return false; // Signale cet échec à l'appelant. // Suppose que chaque fonction retourne faux si elle échoue if (!faireQuelqueChoseAvecLeFichier(fh)) { - fclose(fh); // Ferme la gestion du fichier pour que cela ne fuite pas - return false; // Propage l'erreur +        fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites +        return false; // Propage l'erreur } if (!faireAutreChoseAvec(fh)) { - fclose(fh); // Ferme la gestion du fichier pour que cela ne fuite pas - return false; // Propage l'erreur + fclose(fh); + return false; } - fclose(fh); // Ferme la gestion du fichier pour que cela ne fuite pas - return true; // Indique le succès + fclose(fh); + return true; } // Les programmeurs en C clarifient souvent tout cela en utilisant goto : @@ -822,9 +821,9 @@ void faireQuelqueChoseAvecUnFichier(const std::string& nomDuFichier) // Ceci a des avantages _énormes_ : // 1. Peu importe la situation, la ressource (dans ce cas précis la gestion -// de fichier) sera libérée. Dès que le destructeur est écrit correctement, +// de fichier) sera libérée. Si le destructeur est écrit correctement, // il est _impossible_ d'oublier de fermer la gestion et d'entraîner une -// une fuite de ressources. +// une fuite de ressources (si l'objet est sur la pile). // 2. Remarquez que le code est beaucoup plus clair. // Le destructeur gère la fermeture du fichier discrètement sans avoir // besoin de s'en préoccuper. @@ -914,4 +913,4 @@ Lecture complémentaire : Une référence à jour du langage est disponible à -Des ressources supplémentaires sont disponibles à \ No newline at end of file +Des ressources supplémentaires sont disponibles à -- cgit v1.2.3 From b55efa6fd179992148b29ab2167fda0938b1146c Mon Sep 17 00:00:00 2001 From: ven Date: Thu, 18 May 2017 13:59:03 +0200 Subject: close #2727 --- fr-fr/fsharp-fr.html.markdown | 1 + 1 file changed, 1 insertion(+) (limited to 'fr-fr') diff --git a/fr-fr/fsharp-fr.html.markdown b/fr-fr/fsharp-fr.html.markdown index cab22e8a..3fd41676 100644 --- a/fr-fr/fsharp-fr.html.markdown +++ b/fr-fr/fsharp-fr.html.markdown @@ -1,5 +1,6 @@ --- language: F# +lang: fr-fr contributors: - ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"] translators: -- cgit v1.2.3 From a2ee84b2010691d7a54a9b335b12e92b366c7eae Mon Sep 17 00:00:00 2001 From: Yan Zhang Date: Thu, 1 Jun 2017 17:31:14 +0800 Subject: fix broken URL for vim (#2744) --- fr-fr/vim.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr') diff --git a/fr-fr/vim.html.markdown b/fr-fr/vim.html.markdown index 8e84bf33..54c00b26 100644 --- a/fr-fr/vim.html.markdown +++ b/fr-fr/vim.html.markdown @@ -10,7 +10,7 @@ lang: fr-fr --- -[Vim](www.vim.org) +[Vim](http://www.vim.org) (Vi IMproved) est le clone le plus populaire de l'éditeur de texte vi sous Unix. Vim est un éditeur de texte omniprésent sur les systèmes de type Unix, et a pour objectif la rapidité ainsi que l'augmentation de la productivité. Il a de -- cgit v1.2.3 From ec10b157024de100522089421ea93c34395fb8db Mon Sep 17 00:00:00 2001 From: Julien Dehos Date: Sat, 24 Jun 2017 22:20:50 +0200 Subject: fix typo (#2772) --- fr-fr/d.html.markdown | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown index bfb9f2ce..8d98f9dc 100644 --- a/fr-fr/d.html.markdown +++ b/fr-fr/d.html.markdown @@ -54,7 +54,7 @@ void main() { } while(n > 0); // For et while sont très utiles, mais en D, on préfère foreach. - // Les deux points : '..', créent un intervalle continue de valeurs + // Les deux points : '..', créent un intervalle continu de valeurs // incluant la première mais excluant la dernière. foreach(i; 1..1_000_000) { if(n % 2 == 0) @@ -72,7 +72,7 @@ void main() { } ``` On peut définir de nouveaux types avec les mots-clés `struct`, `class`, -`union` et `enum`. Ces types sont passés au fonction par valeur (ils sont copiés) +`union` et `enum`. Ces types sont passés à la fonction par valeur (ils sont copiés) De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques. ```c @@ -88,7 +88,7 @@ struct LinkedList(T) { class BinTree(T) { T data = null; - // Si il n'y a qu'un seul paramètre de template, + // S'il n'y a qu'un seul paramètre de template, // on peut s'abstenir de mettre des parenthèses. BinTree!T left; BinTree!T right; @@ -152,7 +152,7 @@ class MyClass(T, U) { T _data; U _other; - // Les constructeurs s'apellent toujours 'this'. + // Les constructeurs s'appellent toujours 'this'. this(T t, U u) { // Ceci va appeller les setters ci-dessous. data = t; @@ -197,8 +197,8 @@ void main() { writefln("Later: data = %d, str = %s", mc.data, mc.other); } ``` -Avec les propriétés, on peut constuire nos setters et nos getters -comme on le souhaite, tout en gardant un syntaxe très propre, +Avec les propriétés, on peut construire nos setters et nos getters +comme on le souhaite, tout en gardant une syntaxe très propre, comme si on accédait directement à des membres de la classe. Les autres fonctionnalités orientées objets à notre disposition @@ -208,8 +208,8 @@ d'une seule classe et implémenter autant d'interface que voulu. Nous venons d'explorer les fonctionnalités objet du D, mais changeons un peu de domaine. D permet la programmation fonctionelle, avec les fonctions -de premier ordre, les fonctions `pure` et les données immuables. -De plus, tout vos algorithmes fonctionelles favoris (map, reduce, filter) +de premier ordre, les fonctions `pures` et les données immuables. +De plus, tout vos algorithmes fonctionels favoris (map, reduce, filter) sont disponibles dans le module `std.algorithm`. ```c @@ -217,11 +217,11 @@ import std.algorithm : map, filter, reduce; import std.range : iota; // construit un intervalle excluant la dernière valeur. void main() { - // On veut un algorithm qui affiche la somme de la listes des carrés + // On veut un algorithme qui affiche la somme de la liste des carrés // des entiers paires de 1 à 100. Un jeu d'enfant ! - // On se content de passer des expressions lambda en paramètre à des templates. - // On peut fournier au template n'importe quelle fonction, mais dans notre + // On se contente de passer des expressions lambda en paramètre à des templates. + // On peut fournir au template n'importe quelle fonction, mais dans notre // cas, les lambdas sont pratiques. auto num = iota(1, 101).filter!(x => x % 2 == 0) .map!(y => y ^^ 2) @@ -231,15 +231,15 @@ void main() { } ``` -Vous voyez comme on a calculé `num` comme on le ferait en haskell par exemple ? -C'est grâce à une innvoation de D qu'on appelle "Uniform Function Call Syntax". -Avec l'UFCS, on peut choisir d'écrire un appelle à une fonction de manière -classique, ou comme un appelle à une méthode. Walter Brighter a écrit un +Vous voyez qu'on a calculé `num` comme on le ferait en haskell par exemple ? +C'est grâce à une innovation de D qu'on appelle "Uniform Function Call Syntax". +Avec l'UFCS, on peut choisir d'écrire un appel à une fonction de manière +classique, ou comme un appel à une méthode. Walter Brighter a écrit un article en anglais sur l'UFCS [ici.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394) Pour faire court, on peut appeller une fonction dont le premier paramètre est de type A, comme si c'était une méthode de A. -J'aime le parallélisme. Vous aimez les parallélisme ? Bien sur que vous aimez ça +J'aime le parallélisme. Vous aimez le parallélisme ? Bien sûr que vous aimez ça. Voyons comment on le fait en D ! ```c @@ -248,7 +248,7 @@ import std.parallelism : parallel; import std.math : sqrt; void main() { - // On veut calculer la racine carré de tous les nombres + // On veut calculer la racine carrée de tous les nombres // dans notre tableau, et profiter de tous les coeurs // à notre disposition. auto arr = new double[1_000_000]; -- cgit v1.2.3 From 3d2f171cd82ebeaf75a69dfe8c86cd85bc5312bd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sylvain=20Ab=C3=A9lard?= Date: Tue, 11 Jul 2017 14:52:39 +0200 Subject: Update ruby-ecosystem-fr.html.markdown (#2795) Only french and typo fixes. The content might be outdated too: Ruby 2.5 instead of 2.0 --- fr-fr/ruby-ecosystem-fr.html.markdown | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/ruby-ecosystem-fr.html.markdown b/fr-fr/ruby-ecosystem-fr.html.markdown index 9b52069a..edc69068 100644 --- a/fr-fr/ruby-ecosystem-fr.html.markdown +++ b/fr-fr/ruby-ecosystem-fr.html.markdown @@ -6,6 +6,7 @@ contributors: - ["Rafal Chmiel", "http://github.com/rafalchmiel"] translators: - ["Xuan-thi Nguyen", "http://github.com/mellenguyen"] + - ["Sylvain Abélard", "http://github.com/abelards"] lang: fr-fr --- @@ -17,9 +18,9 @@ dépendances des gems. ## Ruby Managers Quelques plateformes possèdent Ruby pré-installé ou disponible en tant que -paquet. La plupart des rubyists ne les utilisent pas, ou si c'est le cas, ne -les utilise que pour faire démarrer un autre installateur ou implémentation de -Ruby. Les rubyists tendent plutôt à installer un manager Ruby pour installer +paquet. La plupart des rubyistes ne les utilisent pas, ou si c'est le cas, ne +les utilisent que pour faire démarrer un autre installateur ou implémentation de +Ruby. Les rubyistes tendent plutôt à installer un gestionnaire en Ruby pour installer et changer entre les différentes et nombreuses versions de Ruby et les environnements de leurs projets Ruby. @@ -47,14 +48,14 @@ Implementation). Les trois versions majeures de Ruby actuellement utilisées sont : -* 2.0.0 - Sortie en février 2013. La plupart des librairies et frameworks +* 2.0.0 - Sortie en février 2013. La plupart des bibliothèques et frameworks gèrent la versions 2.0.0. * 1.9.3 - Sortie en octobre 2011. Il s'agit de la version que la majorité des rubyists utilisent actuellement. [Fin de vie](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/) * 1.8.7 - Sortie en juin 2006. [Fin de vie](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/). -Les changements entre 1.8.7 à 1.9.x sont bien plus grands qu'entre 1.9.3 -jusqu'à 2.0.0. Par exemple, les versions 1.9 ont introduit le support des +Les changements entre 1.8.7 et 1.9.x sont bien plus grands qu'entre 1.9.3 +et 2.0.0. Par exemple, les versions 1.9 ont introduit le support des encodages et d'une VM bytecode ([YARV](https://fr.wikipedia.org/wiki/YARV)). Il y a toujours des projets sur 1.8.7, mais ils deviennent minoritaires, étant donné que la majorité de la communauté a migré vers au moins 1.9.2 ou 1.9.3. @@ -89,7 +90,7 @@ Mpyennement mature/compatible: * [Maglev](http://maglev.github.io/) - Basée sur Gemstone, une VM Smalltalk. Smalltalk possède quelques outils impressionnants, et ce projet tente de les apporter dans le développement Ruby. -* [RubyMotion](http://www.rubymotion.com/) - Ruby pour développement iOS. +* [RubyMotion](http://www.rubymotion.com/) - Ruby pour développement iOS et Android. * [Opal](http://opalrb.org/) - Compile le Ruby en Javascript Les implémentations de Ruby peuvent avoir leurs propres numéros de versions, @@ -122,17 +123,17 @@ l(es) auteur(s) et la/les licence(s). ## Bundler -[Bundler](http://bundler.io/) est un résolveur de dépendances des gems. Il -utilise le Gemfile d'un projet ppur trouver les dépendances, et récupère +[Bundler](http://bundler.io/) est un outil de résolution de dépendances des gems. Il +utilise le Gemfile d'un projet pour en trouver les dépendances, et récupère ensuite les dépendances de ces dépendances récursivement. Il déroule cet algorithme jusqu'à ce que toutes les dépendances soient résolues et téléchargées, ou s'arrête si un conflit est trouvé. Bundler lèvera une erreur s'il trouve des conflits de dépendances. Par exemple, si la gem A recquiert la version 3 ou plus de gem Z, mais que gem B recquiert -seulement la version 2, Bundler vous notifiera ce conflict. Cela devient +seulement la version 2 de la même gem Z, Bundler vous notifiera ce conflit. Cela devient extrêmement utile, étant donné que beaucoup de gems font référence à d'autres -gems (qui se réfèrent à d'autres gems), ce qui peut former un large graphe de +gems (qui se réfèrent à d'autres gems et ainsi de suite), ce qui peut former un large graphe de dépendance à résoudre. # Les tests @@ -151,4 +152,4 @@ différents. La communauté Ruby est fière d'être une communauté ouverte, riche et accueillante. Matz lui-même est extrêmement sociable, et la générosité des -rubyists est généralement remarquable. +rubyistes est généralement remarquable. -- cgit v1.2.3 From 11de91491dc6931ff4e23b1ec18d082b9e232fbe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sylvain=20Ab=C3=A9lard?= Date: Tue, 11 Jul 2017 15:37:49 +0200 Subject: [ruby fr-fr] more details, more examples (#2796) --- fr-fr/ruby-fr.html.markdown | 49 ++++++++++++++++++++++++++++----------------- 1 file changed, 31 insertions(+), 18 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown index 1564d2b6..6b487a07 100644 --- a/fr-fr/ruby-fr.html.markdown +++ b/fr-fr/ruby-fr.html.markdown @@ -7,9 +7,11 @@ contributors: - ["Luke Holder", "http://twitter.com/lukeholder"] - ["Tristan Hume", "http://thume.ca/"] - ["Nick LaMuro", "https://github.com/NickLaMuro"] + translators: - ["Geoffrey Roguelon", "https://github.com/GRoguelon"] - ["Nami-Doc", "https://github.com/Nami-Doc"] + - ["Sylvain Abélard", "http://github.com/abelards"] lang: fr-fr --- @@ -22,19 +24,23 @@ Personne ne les utilise Vous devriez en faire de même =end -# Tout d'abord : Tout est un objet. +# Tout d'abord : tout est un objet. # Les nombres sont des objets -3.class #=> Fixnum +3.class #=> Fixnum # on voit que c'est une classe Ruby et non un "type spécial" -3.to_s #=> "3" +3.to_s #=> "3" # on peut appeler des méthodes sur ces objets, comme `to_s` (transforme en texte) # Les opérateurs de base 1 + 1 #=> 2 8 - 1 #=> 7 10 * 2 #=> 20 -35 / 5 #=> 7 +22 / 7 #=> 3 # si les deux éléments sont entiers, c'est une division entière +22.0 / 7 #=> 3.142857142857143 +22 / 7.0 #=> 3.142857142857143 +2**10 #=> 1024 # exposant +1024 % 10 #=> 4 # modulo (reste de la division euclidienne) # Les opérateurs sont juste des raccourcis # pour appeler une méthode sur un objet @@ -42,9 +48,9 @@ Vous devriez en faire de même 10.* 5 #=> 50 # Les valeurs spéciales sont des objets -nil # Nul -true # Vrai -false # Faux +nil # nul, vide ou indéfini +true # vrai +false # faux nil.class #=> NilClass true.class #=> TrueClass @@ -60,8 +66,7 @@ false.class #=> FalseClass !true #=> false !false #=> true -# à part false lui-même, nil est la seule autre valeur 'false' - +# à part false lui-même, nil est la seule autre valeur "considérée comme fausse" !nil #=> true !false #=> true !0 #=> false @@ -73,7 +78,6 @@ false.class #=> FalseClass 2 >= 2 #=> true # Les chaînes de caractères sont des objets - 'Je suis une chaîne de caractères'.class #=> String "Je suis également une chaîne de caractères".class #=> String @@ -84,6 +88,15 @@ placeholder = "utiliser l'interpolation de chaîne de caractères" # Affichez un message puts "J'affiche à l'écran!" +# Il y a quelques autres raccourcis pour les chaînes de caractères +rb = "Ruby" +interpolation = "Bonjour Ruby" # s'écrit aussi %Q[Bonjour #{rb}] %Q{Bonjour #{rb}} avec l'interpolation +literal = "Bonjour \#{rb}" # avec le backslash, le dièse est un "vrai dièse" (le slash ne s'affiche que pour le debug) +literal == %q[Bonjour #{rb}] # le Q majuscule fait l'interpolation, le q minuscule ne la fait pas +multi = %Q[Cette chaîne +est sur plusieurs +lignes] # => "Cette chaîne\nest sur plusieurs\nlignes" # le caractère \n signifie retour à la ligne + # Variables x = 25 #=> 25 x #=> 25 @@ -131,7 +144,7 @@ array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] [1, "hello", false] #=> [1, "hello", false] # Les tableaux peuvent être indexés -# Du début +# Trouver la valeur en donnant la position en partant du début (le premier élément est à l'index 0) array[0] #=> 1 array[12] #=> nil @@ -140,13 +153,13 @@ array[12] #=> nil array.[] 0 #=> 1 array.[] 12 #=> nil -# Depuis la fin +# On peut compter en partant de la fin avec un index négatif (le dernier élément est à l'index -1) array[-1] #=> 5 -# Avec un index de début et de fin -array[2, 4] #=> [3, 4, 5] +# Avec un index de début et un nombre d'éléments [position, nombre] +array[1, 3] #=> [2, 3, 4] -# Ou avec un intervalle +# Ou avec un intervalle [index de début .. index de fin] array[1..3] #=> [2, 3, 4] # Ajoutez un élément au tableau comme ceci @@ -180,11 +193,11 @@ new_hash.keys #=> [:defcon, :action] # Structures de contrôle if true - "si instruction" + "si l'instruction est vraie" elsif false - "autrement si, facultatif" + "si l'instruction de départ n'était pas vraie, et que cette nouvelle condition est vraie (facultatif)" else - "autrement, également facultatif" + "tous les autres cas (il est également facultatif de faire une clause else)" end for compteur in 1..5 -- cgit v1.2.3