diff options
Diffstat (limited to 'fr-fr')
| -rw-r--r-- | fr-fr/bash-fr.html.markdown | 230 | ||||
| -rw-r--r-- | fr-fr/brainfuck-fr.html.markdown | 87 | ||||
| -rw-r--r-- | fr-fr/css-fr.html.markdown | 221 | ||||
| -rw-r--r-- | fr-fr/go-fr.html.markdown | 439 | ||||
| -rw-r--r-- | fr-fr/haskell.html.markdown | 2 | ||||
| -rw-r--r-- | fr-fr/javascript-fr.html.markdown | 525 | ||||
| -rw-r--r-- | fr-fr/json-fr.html.markdown | 62 | ||||
| -rw-r--r-- | fr-fr/lua-fr.html.markdown | 2 | ||||
| -rw-r--r-- | fr-fr/markdown.html.markdown | 289 | ||||
| -rw-r--r-- | fr-fr/objective-c-fr.html.markdown | 2 | ||||
| -rw-r--r-- | fr-fr/r-fr.html.markdown | 746 | ||||
| -rw-r--r-- | fr-fr/ruby-fr.html.markdown | 6 | ||||
| -rw-r--r-- | fr-fr/scala.html.markdown | 5 | ||||
| -rw-r--r-- | fr-fr/typescript-fr.html.markdown | 174 | ||||
| -rw-r--r-- | fr-fr/xml-fr.html.markdown | 128 | ||||
| -rw-r--r-- | fr-fr/yaml-fr.html.markdown | 157 |
16 files changed, 3066 insertions, 9 deletions
diff --git a/fr-fr/bash-fr.html.markdown b/fr-fr/bash-fr.html.markdown new file mode 100644 index 00000000..0e764d7d --- /dev/null +++ b/fr-fr/bash-fr.html.markdown @@ -0,0 +1,230 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] + - ["Rahil Momin", "https://github.com/iamrahil"] + - ["Gregrory Kielian", "https://github.com/gskielian"] +translators: + - ["Baptiste Fontaine", "http://bfontaine.net"] +filename: LearnBash-fr.sh +lang: fr-fr +--- + +Bash est le nom du shell UNIX, qui était aussi distribué avec le système +d’exploitation GNU et est le shell par défaut sur Linux et Mac OS X. + +Presque tous les exemples ci-dessous peuvent être écrits dans un script shell +ou exécutés directement dans le terminal. + +[Plus d’informations ici.](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash +# La première ligne du script s’appelle le « shebang, » qui indique au système +# comment exécuter le script : http://fr.wikipedia.org/wiki/Shebang +# Comme vous pouvez le remarquer, les commentaires commencent par #. Le shebang +# est aussi un commentaire + +# Un exemple simple qui affiche « Hello world! » : +echo Hello world! + +# Chaque commande commence sur une nouvelle ligne ou après un point-virgule : +echo 'Ceci est la première ligne'; echo 'Ceci est la seconde ligne' + +# La déclaration d’une variable ressemble à ça : +VARIABLE="Du texte" + +# Mais pas comme ça : +VARIABLE = "Du texte" +# Bash va penser que VARIABLE est une commande qu’il doit exécuter et va +# afficher une erreur parce qu’elle est introuvable. + +# Utiliser une variable : +echo $VARIABLE +echo "$VARIABLE" +echo '$VARIABLE' +# Quand vous utilisez la variable en elle-même – en lui assignant une valeur, +# en l’exportant ou autre – vous écrivez son nom sans $. Si vous voulez +# utiliser sa valeur, vous devez utiliser $. +# Notez qu’entourer une variable de deux guillemets simples (') empêche +# l’expansion des variables ! + +# Substitution de chaîne de caractères dans une variable +echo ${VARIABLE/Some/A} +# Ceci va remplacer la première occurrence de « Some » par « A » + +# Sous-chaîne d’une variable +echo ${VARIABLE:0:7} +# Ceci va retourner seulement les 7 premiers caractères de la valeur + +# Valeur par défaut d’une variable +echo ${FOO:-"ValeurParDefautSiFOOestVideOuInexistant"} +# Ceci marche pour null (FOO=), la chaîne de caractères vide (FOO=""). Zéro +# (FOO=0) retourne 0 + +# Variables pré-remplies : +# Il y a quelques variables pré-remplies utiles, comme : +echo "La valeur de retour du dernier programme : $?" +echo "Le PID du script : $$" +echo "Nombre d’arguments : $#" +echo "Arguments du script : $@" +echo "Arguments du script séparés en plusieurs variables : $1 $2..." + +# Lire une valeur depuis l’entrée standard : +echo "Quel est votre nom ?" +read NAME # Notez que l’on n’a pas eu à déclarer une nouvelle variable +echo Bonjour, $NAME! + +# Nous avons l’habituelle structure « if » : +# Utilisez 'man test' pour plus d’informations à propos des conditions +if [ $NAME -ne $USER ] +then + echo "Votre nom n’est pas votre pseudo" +else + echo "Votre nom est votre pseudo" +fi + +# Il y a aussi l’exécution conditionnelle +echo "Toujours exécuté" || echo "Exécuté si la première commande ne réussit pas" +echo "Toujours exécuté" && echo "Exécuté si la première commande réussit" + +# Pour utiliser && et || avec des commandes « if, » vous devez utiliser +# plusieurs paires de crochets : +if [ $NAME == "Steve" ] && [ $AGE -eq 15 ] +then + echo "Ceci sera exécuté si $NAME est Steve ET $AGE est 15." +fi + +if [ $NAME == "Daniya" ] || [ $NAME == "Zach" ] +then + echo "Ceci sera exécuté si $NAME est Daniya OU Zach." +fi + +# Les expressions sont écrites dans le format suivant : +echo $(( 10 + 5 )) + +# Contrairement aux autres langages de programmation, Bash est un shell — il +# est donc exécuté dans le contexte du répertoire courant. Vous pouvez lister +# les fichiers et dossiers dans le répertoire courant avec la commande `ls` : +ls + +# Ces commandes ont des options qui contrôlent leur exécution : +ls -l # Liste tous les fichiers et répertoires sur des lignes séparées + +# Les résultat de la commande précédente peuvent être passés à la commande +# suivante en entrée. +# La commande grep filtre l’entrée avec les motifs donnés. On peut ainsi lister +# les fichiers .txt dans le répertoire courant : +ls -l | grep "\.txt" + +# Vous pouvez aussi rediriger l’entrée et les sorties standards et d’erreur +# d’une commande : +python2 hello.py < "entrée.in" +python2 hello.py > "sortie.out" +python2 hello.py 2> "erreur.err" +# Ceci va écraser le fichier s'il existe; si vous préférez écrire à la fin de +# celui-ci, utilisez >> à la place. + +# Les commandes peuvent se substituer à l’intérieur d’autres commandes en +# utilisant $( ) : +# La commande ci-dessous affiche le nombre de fichiers et répertoires dans le +# répertoire courant : +echo "Il y a $(ls | wc -l) choses ici." + +# On peut faire la même chose avec les accents graves `` mais on ne peut pas +# les imbriquer — la façon la plus courante est d’utiliser $( ). +echo "There are `ls | wc -l` items here." + +# Bash a une commande case qui marche de façon similaire au switch de Java et +# C++ : +case "$VARIABLE" in + #List patterns for the conditions you want to meet + 0) echo "There is a zero.";; + 1) echo "There is a one.";; + *) echo "It is not null.";; +esac + +# La boucle for itère autant de fois qu’elle a d’arguments : +# Le contenu de $VARIABLE est affiché trois fois. +for VARIABLE in {1..3} +do + echo "$VARIABLE" +done + +# Ou écrivez-la de façon « traditionnelle » : +for ((a=1; a <= 3; a++)) +do + echo $a +done + +# Elles peuvent aussi être utilisées pour agir sur des fichiers : +# Cette boucle va exécuter la commande 'cat' sur fichier1 et fichier2 +for VARIABLE in fichier1 fichier2 +do + cat "$VARIABLE" +done + +# …ou la sortie d’une commande : +# Ceci va afficher la sortie de ls. +for OUTPUT in $(ls) +do + cat "$OUTPUT" +done + +# Boucle while : +while [ true ] +do + echo "corps de la boucle ..." + break +done + +# Vous pouvez aussi définir des fonctions +# Définition : +function foo () +{ + echo "Les arguments fonctionnent comme les arguments de script : $@" + echo "Et : $1 $2..." + echo "Ceci est une fonction" + return 0 +} + +# Ou plus simplement : +bar () +{ + echo "Une autre façon de définir des fonctions !" + return 0 +} + +# Appeler votre fonction +foo "Mon nom est" $NAME + +# Il y a plein de commandes utiles que vous devriez apprendre : +# affiche les 10 dernières lignes de fichier.txt +tail -n 10 fichier.txt +# affiche les 10 premières lignes de fichier.txt +head -n 10 fichier.txt +# trie les lignes de fichier.txt +sort fichier.txt +# montre ou omet les lignes répétées, avec -d pour les montrer +uniq -d fichier.txt +# affiche uniquement la première colonne avant le caractère « , » +cut -d ',' -f 1 fichier.txt +# remplace chaque occurrence de 'okay' par 'super' dans fichier.txt +# (compatible avec les expression rationnelles) +sed -i 's/okay/super/g' fichier.txt +# affiche toutes les lignes de fichier.txt qui correspondent à une expression +# rationnelle, dans cet exemple les lignes qui commencent par « foo » et +# finissent par « bar » +grep "^foo.*bar$" fichier.txt +# ajoutez l’option « -c » pour afficher le nombre de lignes concernées +grep -c "^foo.*bar$" fichier.txt +# Si vous voulez vraiment chercher une chaîne de caractères, et non +# l’expression rationnelle, utilisez fgrep (ou grep -F) +fgrep "^foo.*bar$" fichier.txt +``` diff --git a/fr-fr/brainfuck-fr.html.markdown b/fr-fr/brainfuck-fr.html.markdown new file mode 100644 index 00000000..545e407e --- /dev/null +++ b/fr-fr/brainfuck-fr.html.markdown @@ -0,0 +1,87 @@ +--- +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. diff --git a/fr-fr/css-fr.html.markdown b/fr-fr/css-fr.html.markdown new file mode 100644 index 00000000..bdab9715 --- /dev/null +++ b/fr-fr/css-fr.html.markdown @@ -0,0 +1,221 @@ +--- +language: css +contributors: + - ["Mohammad Valipour", "https://github.com/mvalipour"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["@prrrnd", "https://github.com/prrrnd"] +lang: fr-fr +--- + +Au début du web, il n'y avait pas d'élements visuels, simplement du texte pure. Mais avec le dévelopement des navigateurs, +des pages avec du contenu visuel sont arrivées. +CSS est le langage standard qui existe et permet de garder une séparation entre +le contenu (HTML) et le style d'une page web. + +En résumé, CSS fournit une syntaxe qui vous permet de cibler des élements présents +sur une page HTML afin de leur donner des propriétés visuelles différentes. + +Comme tous les autres langages, CSS a plusieurs versions. Ici, nous allons parlons de CSS2.0 +qui n'est pas le plus récent, mais qui reste le plus utilisé et le plus compatible avec les différents navigateur. + +**NOTE :** Vous pouvez tester les effets visuels que vous ajoutez au fur et à mesure du tutoriel sur des sites comme [dabblet](http://dabblet.com/) afin de voir les résultats, comprendre, et vous familiariser avec le langage. +Cet article porte principalement sur la syntaxe et quelques astuces. + + +```css +/* Les commentaires sont entourés par slash-étoile, comme cette ligne! */ + +/* #################### + ## SÉLECTEURS + ####################*/ + +/* Généralement, la première déclaration en CSS est très simple */ +selecteur { propriete: valeur; /* autres proprietés...*/ } + +/* Le sélécteur sert à cibler un élément du HTML + +Vous pouvez cibler tous les éléments d'une page! */ +* { color:red; } + +/* +Voici un élément dans notre HTML : + +<div class='une-classe classe2' id='unId' attr='valeur' /> +*/ + +/* Vous pouvez le cibler par une classe */ +.une-classe { } + +/* ou par deux */ +.une-classe.classe2 { } + +/* ou par son type */ +div { } + +/* ou son id */ +#unId { } + +/* ou par le fait qu'il a un attribut */ +[attr] { font-size:smaller; } + +/* ou que l'attribut a une valeur spécifique */ +[attr='valeur'] { font-size:smaller; } + +/* commence avec une valeur */ +[attr^='val'] { font-size:smaller; } + +/* termine avec une valeur */ +[attr$='eur'] { font-size:smaller; } + +/* contient une valeur */ +[attr~='leu'] { font-size:smaller; } + + +/* Ce qu'il faut bien comprendre, c'est que vous pouvez combiner ceci -- Il ne doit pas y avoir +d'espaces entre. */ +div.une-classe[attr$='eu'] { } + +/* Vous pouvez aussi cibler un élément par son parent. */ + +/* Un élément qui est en enfant direct */ +div.un-parent > .enfant {} + +/* Cela cible aussi les .enfants plus profonds dans la structure HTML */ +div.un-parent .enfants {} + +/* Attention : le même sélecteur sans espace a un autre sens. */ +div.un-parent.classe {} + +/* Vous pouvez cibler un élément basé sur un enfant de même parent */ +.je-suis-avant + .cet-element { } + +/* ou n'importe quel enfant de même parent avec celui ci */ +.je-suis-tout-avant ~ .cet-element {} + +/* Il y a des pseudo-classes qui permettent de cibler un élément +basé sur le comportement, en plus de la structure de la page */ + +/* élément avec le curseur au-dessus */ +:hover {} + +/* lien visité */ +:visited {} + +/* lien non visité */ +:link {} + +/* élément avec le focus */ +:focus {} + + +/* #################### + ## PROPRIÉTÉS + ####################*/ + +selecteur { + + /* Units */ + width: 50%; /* pourcentage */ + font-size: 2em; /* taille de la police multipliée par X */ + width: 200px; /* pixels */ + font-size: 20pt; /* points */ + width: 5cm; /* centimetres */ + width: 50mm; /* millimetres */ + width: 5in; /* pouces */ + + /* Couleurs */ + background-color: #F6E; /* court hex */ + background-color: #F262E2; /* long hex */ + background-color: tomato; /* couleur nommée */ + background-color: rgb(255, 255, 255); /* rouge, vert, bleu */ + background-color: rgb(10%, 20%, 50%); /* rouge, vert, bleu en pourcent */ + background-color: rgba(255, 0, 0, 0.3); /* rouge, vert, bleu avec transparence */ + + /* Images */ + background-image: url(/chemin-vers-image/image.jpg); + + /* Polices */ + font-family: Arial; + font-family: "Courier New"; /* Si espace, entre guillemets */ + font-family: "Courier New", Trebuchet, Arial; /* Si la première n'est pas trouvée, la deuxième est utilisée, etc... */ +} + +``` + +## Utilisation + +Le CSS s'écrit dans des fichiers `.css`. + +```xml +<!-- Vous devez inclure le CSS dans la balise <head> : --> +<link rel='stylesheet' type='text/css' href='chemin/style.css' /> + +<!-- Vous pouvez inclure du CSS dans le HTML directement, mais ce n'est vraiment pas recommandé. --> +<style> + selecteur { propriete:valeur; } +</style> + +<!-- ou directement sur l'élément HTML. +PS : à ne pas faire. --> +<div style='propriete:valeur;'> +</div> + +``` + +## Priorités + +Comme on vient de le voir, un élément peut être ciblé par plus qu'un seul sélecteur +et une même propriété peut être définie plusieurs fois. +Dans ces cas, une des propriétés devient prioritaire. + +Voici du code CSS : + +```css +/*A*/ +p.classe1[attr='valeur'] + +/*B*/ +p.classe1 {} + +/*C*/ +p.classe2 {} + +/*D*/ +p {} + +/*E*/ +p { propriete: valeur !important; } + +``` + +et le code HTML: + +```xml +<p style='/*F*/ propriete:valeur;' class='classe1 classe2' attr='valeur'> +</p> +``` + +Les priorités de style sont : +Attention, les priorités s'appliquent aux **propriétés**, pas aux blocs entiers. + +* `E` a la priorité grâce à `!important`. +* `F` vient ensuite, car le code se trouve directement dans le HTML. +* `A` vient ensuite, car il est le plus spécifique. + plus spécifique veut dire, celui qui cible le plus l'élément +* `C` vient ensuite. Il est aussi spécifique que `B`, mais est écrit après. +* Puis `B` +* Et enfin `D`. + +## Compatibilité + +La plupart des fonctionnalités de CSS2 (et de plus en plus CSS3) sont compatibles +avec tous les navigateurs. Mais il est important de vérifier la compatibilité. + +[QuirksMode CSS](http://www.quirksmode.org/css/) est une très bonne source pour cela. + +## En savoir plus (en anglais) + +* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/) +* [QuirksMode CSS](http://www.quirksmode.org/css/) +* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context) diff --git a/fr-fr/go-fr.html.markdown b/fr-fr/go-fr.html.markdown new file mode 100644 index 00000000..16558e7e --- /dev/null +++ b/fr-fr/go-fr.html.markdown @@ -0,0 +1,439 @@ +--- +name: Go +category: language +language: Go +lang: fr-fr +filename: learngo.go +contributors: + - ["Sonia Keys", "https://github.com/soniakeys"] + - ["Christopher Bess", "https://github.com/cbess"] + - ["Jesse Johnson", "https://github.com/holocronweaver"] + - ["Quint Guvernator", "https://github.com/qguv"] + - ["Jose Donizetti", "https://github.com/josedonizetti"] + - ["Alexej Friesen", "https://github.com/heyalexej"] + - ["Jean-Philippe Monette", "http://blogue.jpmonette.net/"] +--- + +Go a été créé dans l'optique de développer de façon efficace. Ce n'est pas la +dernière tendance en ce qui est au développement, mais c'est la nouvelle façon +de régler des défis réels de façon rapide. + +Le langage possède des concepts familiers à la programmation impérative avec +typage. Il est rapide à compiler et exécuter, ajoute une concurrence facile à +comprendre, pour les processeurs multi coeurs d'aujourd'hui et apporte des +fonctionnalités facilitant le développement à grande échelle. + +Développer avec Go, c'est bénéficier d'une riche bibliothèque standard et d'une +communauté active. + +```go +// Commentaire ligne simple +/* Commentaire + multiligne */ + +// Un paquet débute avec une clause "package" +// "Main" est un nom spécial déclarant un paquet de type exécutable plutôt +// qu'une bibliothèque +package main + +// "Import" déclare les paquets référencés dans ce fichier. +import ( + "fmt" // Un paquet dans la bibliothèque standard. + "io/ioutil" // Implémente des fonctions utilitaires I/O. + m "math" // Bibliothèque mathématique utilisant un alias local "m". + "net/http" // Un serveur Web! + "strconv" // Bibliothèque pour convertir les chaînes de caractères. +) + +// Une définition de fonction. La fonction "main" est spéciale - c'est le point +// d'entrée du binaire. +func main() { + // Println retournera la valeur à la console. + // Associez la fonction avec son paquet respectif, fmt. + fmt.Println("Hello world!") + + // Appelez une fonction différente à partir de ce paquet. + beyondHello() +} + +// Les fonctions ont des paramètres entre parenthèses. +// Les parenthèses sont nécessaires avec ou sans paramètre. +func beyondHello() { + var x int // Déclaration de variable. Les variables doivent être déclarées + // avant leur utilisation. + x = 3 // Assignation de valeur. + // Les déclarations courtes utilisent := pour inférer le type, déclarer et + // assigner. + y := 4 + sum, prod := learnMultiple(x, y) // La fonction retourne deux valeurs. + fmt.Println("sum:", sum, "prod:", prod) // Affichage simple. + learnTypes() // < y minutes, en savoir plus! +} + +// Les fonctions peuvent avoir des paramètres et plusieurs valeurs retournées. +func learnMultiple(x, y int) (sum, prod int) { + return x + y, x * y // Deux valeurs retournées. +} + +// Quelques types inclus et littéraux. +func learnTypes() { + // Une déclaration courte infère généralement le type désiré. + str := "Learn Go!" // Type string. + + s2 := `Une chaîne de caractères peut contenir des +sauts de ligne.` // Chaîne de caractère. + + // Littéral non-ASCII. Les sources Go utilisent le charset UTF-8. + g := 'Σ' // type rune, un alias pour le type int32, contenant un caractère + // unicode. + + f := 3.14195 // float64, un nombre flottant IEEE-754 de 64-bit. + c := 3 + 4i // complex128, considéré comme deux float64 par le compilateur. + + // Syntaxe "var" avec une valeur d'initialisation. + var u uint = 7 // Non signé, mais la taille dépend selon l'entier. + var pi float32 = 22. / 7 + + // Conversion avec syntaxe courte. + n := byte('\n') // byte est un alias du type uint8. + + // Les tableaux ont une taille fixe déclarée à la compilation. + var a4 [4]int // Un tableau de 4 ints, tous initialisés à 0. + a3 := [...]int{3, 1, 5} // Un tableau initialisé avec une taille fixe de 3 + // éléments, contenant les valeurs 3, 1 et 5. + + // Les slices ont des tailles dynamiques. Les tableaux et slices ont chacun + // des avantages, mais les cas d'utilisation des slices sont plus fréquents. + s3 := []int{4, 5, 9} // Comparable à a3. + s4 := make([]int, 4) // Alloue un slice de 4 ints, initialisés à 0. + var d2 [][]float64 // Déclaration seulement, sans allocation de mémoire. + bs := []byte("a slice") // Conversion d'une chaîne en slice de bytes. + + // Parce qu'elles sont dynamiques, les slices peuvent être jointes sur + // demande. Pour joindre un élément à une slice, la fonction standard append() + // est utilisée. Le premier argument est la slice à utiliser. Habituellement, + // la variable tableau est mise à jour sur place, voir ci-bas. + s := []int{1, 2, 3} // Le résultat est une slice de taille 3. + s = append(s, 4, 5, 6) // Ajout de 3 valeurs. La taille est de 6. + fmt.Println(s) // La valeur est de [1 2 3 4 5 6] + + // Pour ajouter une slice à une autre, au lieu d'utiliser une liste de valeurs + // atomiques, il est possible de mettre en argument une référence de + // slice littérale grâce aux points de suspension. + s = append(s, []int{7, 8, 9}...) // Le deuxième argument est une slice + // littérale. + fmt.Println(s) // La slice contient [1 2 3 4 5 6 7 8 9] + + p, q := learnMemory() // Déclare p, q comme étant des pointeurs de type int. + fmt.Println(*p, *q) // * suit un pointeur. Ceci retourne deux ints. + + // Les maps sont des tableaux associatifs de taille dynamique, comme les + // hash ou les types dictionnaires de certains langages. + m := map[string]int{"trois": 3, "quatre": 4} + m["un"] = 1 + + // Les valeurs inutilisées sont considérées comme des erreurs en Go. + // Un tiret bas permet d'ignorer une valeur inutilisée, évitant une erreur. + _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs + + // Cependant, son affichage en console est considéré comme une utilisation, + // ce qui ne sera pas considéré comme une erreur à la compilation. + fmt.Println(s, c, a4, s3, d2, m) + + learnFlowControl() // De retour dans le flux. +} + +// Il est possible, à l'opposé de plusieurs autres langages, de retourner des +// variables par leur nom à partir de fonctions. +// Assigner un nom à un type retourné par une fonction permet de retrouver sa +// valeur ainsi que d'utiliser le mot-clé "return" uniquement, sans plus. +func learnNamedReturns(x, y int) (z int) { + z = x * y + return // z est implicite, car la variable a été définie précédemment. +} + +// La récupération de la mémoire est automatique en Go. Le langage possède des +// pointeurs, mais aucune arithmétique des pointeurs (*(a + b) en C). Vous +// pouvez produire une erreur avec un pointeur nil, mais pas en incrémentant un +// pointeur. +func learnMemory() (p, q *int) { + // Les valeurs retournées p et q auront le type pointeur int. + p = new(int) // Fonction standard "new" alloue la mémoire. + // Le int alloué est initialisé à 0, p n'est plus nil. + s := make([]int, 20) // Alloue 20 ints en un seul bloc de mémoire. + s[3] = 7 // Assigne l'un des entiers. + r := -2 // Déclare une autre variable locale. + return &s[3], &r // & retourne l'adresse d'un objet. +} + +func expensiveComputation() float64 { + return m.Exp(10) +} + +func learnFlowControl() { + // Bien que les "if" requièrent des accolades, les parenthèses ne sont pas + // nécessaires pour contenir le test booléen. + if true { + fmt.Println("voilà!") + } + // Le formatage du code est standardisé par la commande shell "go fmt." + if false { + // bing. + } else { + // bang. + } + // Utilisez "switch" au lieu des "if" en chaîne + x := 42.0 + switch x { + case 0: + case 1: + case 42: + // Les "case" n'ont pas besoin de "break;". + case 43: + // Non-exécuté. + } + // Comme les "if", les "for" n'utilisent pas de parenthèses. + // Les variables déclarées dans les "for" et les "if" sont locales à leur + // portée. + for x := 0; x < 3; x++ { // ++ est une incrémentation. + fmt.Println("itération ", x) + } + // x == 42 ici. + + // "For" est le seul type de boucle en Go, mais possède différentes formes. + for { // Boucle infinie + break // C'est une farce + continue // Non atteint. + } + + // Vous pouvez utiliser une "range" pour itérer dans un tableau, une slice, une + // chaîne, une map ou un canal. Les "range" retournent un canal ou deux + // valeurs (tableau, slice, chaîne et map). + for key, value := range map[string]int{"une": 1, "deux": 2, "trois": 3} { + // pour chaque pair dans une map, affichage de la valeur et clé + fmt.Printf("clé=%s, valeur=%d\n", key, value) + } + + // À l'opposé du "for", := dans un "if" signifie la déclaration et + // l'assignation y en premier, et ensuite y > x + if y := expensiveComputation(); y > x { + x = y + } + // Les fonctions littérales sont des fermetures. + xBig := func() bool { + return x > 10000 + } + fmt.Println("xBig:", xBig()) // true (la valeur e^10 a été assignée à x). + x = 1.3e3 // Ceci fait x == 1300 + fmt.Println("xBig:", xBig()) // Maintenant false. + + // De plus, les fonctions littérales peuvent être définies et appelées + // sur la même ligne, agissant comme argument à cette fonction, tant que: + // a) la fonction littérale est appelée suite à (), + // b) le résultat correspond au type de l'argument. + fmt.Println("Ajoute + multiplie deux nombres : ", + func(a, b int) int { + return (a + b) * 2 + }(10, 2)) // Appelle la fonction avec les arguments 10 et 2 + // => Ajoute + double deux nombres : 24 + + // Quand vous en aurez besoin, vous allez l'adorer. + goto love +love: + + learnFunctionFactory() // func retournant func correspondant à fun(3)(3). + learnDefer() // Un survol de cette instruction importante. + learnInterfaces() // Incontournable ! +} + +func learnFunctionFactory() { + // Les deux syntaxes sont identiques, bien que la seconde soit plus pratique. + fmt.Println(sentenceFactory("été")("Une matinée d'", "agréable!")) + + d := sentenceFactory("été") + fmt.Println(d("Une matinée d'", "agréable!")) + fmt.Println(d("Une soirée d'", "relaxante!")) +} + +// Le décorateur est un patron de conception commun dans d'autres langages. +// Il est possible de faire de même en Go avec des fonctions littérales +// acceptant des arguments. +func sentenceFactory(mystring string) func(before, after string) string { + return func(before, after string) string { + return fmt.Sprintf("%s %s %s", before, mystring, after) // nouvelle chaîne + } +} + +func learnDefer() (ok bool) { + // Les déclarations différées sont exécutées avant la sortie d'une fonction. + defer fmt.Println("les déclarations différées s'exécutent en ordre LIFO.") + defer fmt.Println("\nCette ligne est affichée en premier parce que") + // Les déclarations différées sont utilisées fréquemment pour fermer un + // fichier, afin que la fonction ferme le fichier en fin d'exécution. + return true +} + +// Défini Stringer comme étant une interface avec une méthode, String. +type Stringer interface { + String() string +} + +// Défini pair comme étant une structure contenant deux entiers, x et y. +type pair struct { + x, y int +} + +// Défini une méthode associée au type pair. Pair implémente maintenant Stringer +func (p pair) String() string { // p s'appelle le "destinataire" + // Sprintf est une autre fonction publique dans le paquet fmt. + // La syntaxe avec point permet de faire référence aux valeurs de p. + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func learnInterfaces() { + // La syntaxe avec accolade défini une "structure littérale". Celle-ci + // s'évalue comme étant une structure. La syntaxe := déclare et initialise p + // comme étant une instance. + p := pair{3, 4} + fmt.Println(p.String()) // Appelle la méthode String de p, de type pair. + var i Stringer // Déclare i instance de l'interface Stringer. + i = p // Valide, car pair implémente Stringer. + // Appelle la méthode String de i, de type Stringer. Retourne la même valeur + // que ci-haut. + fmt.Println(i.String()) + + // Les fonctions dans le paquet fmt appellent la méthode String, demandant + // aux objets d'afficher une représentation de leur structure. + fmt.Println(p) // Affiche la même chose que ci-haut. Println appelle la + // méthode String. + fmt.Println(i) // Affiche la même chose que ci-haut. + + learnVariadicParams("apprentissage", "génial", "ici!") +} + +// Les fonctions peuvent être définie de façon à accepter un ou plusieurs +// paramètres grâce aux points de suspension, offrant une flexibilité lors de +// son appel. +func learnVariadicParams(myStrings ...interface{}) { + // Itère chaque paramètre dans la range. + // Le tiret bas sert à ignorer l'index retourné du tableau. + for _, param := range myStrings { + fmt.Println("paramètre:", param) + } + + // Passe une valeur variadique comme paramètre variadique. + fmt.Println("paramètres:", fmt.Sprintln(myStrings...)) + + learnErrorHandling() +} + +func learnErrorHandling() { + // ", ok" idiome utilisée pour définir si l'opération s'est déroulée avec + // succès ou non + m := map[int]string{3: "trois", 4: "quatre"} + if x, ok := m[1]; !ok { // ok sera faux, car 1 n'est pas dans la map. + fmt.Println("inexistant") + } else { + fmt.Print(x) // x serait la valeur, si elle se trouvait dans la map. + } + // Une erreur ne retourne qu'un "ok", mais également plus d'information + // par rapport à un problème survenu. + if _, err := strconv.Atoi("non-int"); err != nil { // _ discarte la valeur + // retourne: 'strconv.ParseInt: parsing "non-int": invalid syntax' + fmt.Println(err) + } + // Nous réviserons les interfaces un peu plus tard. Pour l'instant, + learnConcurrency() +} + +// c est un canal, un objet permettant de communiquer en simultané de façon +// sécurisée. +func inc(i int, c chan int) { + c <- i + 1 // <- est l'opérateur "envoi" quand un canal apparaît à + // gauche. +} + +// Nous utiliserons inc pour incrémenter des nombres en même temps. +func learnConcurrency() { + // La fonction "make" utilisée précédemment pour générer un slice. Elle + // alloue et initialise les slices, maps et les canaux. + c := make(chan int) + // Démarrage de trois goroutines simultanées. Les nombres seront incrémentés + // simultanément, peut-être en paralèle si la machine le permet et configurée + // correctement. Les trois utilisent le même canal. + go inc(0, c) // go est une instruction démarrant une nouvelle goroutine. + go inc(10, c) + go inc(-805, c) + // Lis et affiche trois résultats du canal - impossible de savoir dans quel + // ordre ! + fmt.Println(<-c, <-c, <-c) // Canal à droite, <- est l'opérateur de + // "réception". + + cs := make(chan string) // Un autre canal, celui-ci gère des chaînes. + ccs := make(chan chan string) // Un canal de canaux de chaînes. + go func() { c <- 84 }() // Démarre une nouvelle goroutine, pour + // envoyer une valeur. + go func() { cs <- "wordy" }() // De nouveau, pour cs cette fois-ci. + // Select possède une syntaxe similaire au switch, mais chaque cas requiert + // une opération impliquant un canal. Il sélectionne un cas aléatoirement + // prêt à communiquer. + select { + case i := <-c: // La valeur reçue peut être assignée à une variable, + fmt.Printf("c'est un %T", i) + case <-cs: // ou la valeur reçue peut être ignorée. + fmt.Println("c'est une chaîne") + case <-ccs: // Un canal vide, indisponible à la communication. + fmt.Println("ne surviendra pas.") + } + // À ce point, une valeur a été prise de c ou cs. L'une des deux goroutines + // démarrée plus haut a complétée, la seconde restera bloquée. + + learnWebProgramming() // Go permet la programmation Web. +} + +// Une seule fonction du paquet http démarre un serveur Web. +func learnWebProgramming() { + + // Le premier paramètre de ListenAndServe est une adresse TCP à écouter. + // Le second est une interface, de type http.Handler. + go func() { + err := http.ListenAndServe(":8080", pair{}) + fmt.Println(err) // n'ignorez pas les erreurs ! + }() + + requestServer() +} + +// Implémente la méthode ServeHTTP de http.Handler à pair, la rendant compatible +// avec les opérations utilisant l'interface http.Handler. +func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // Répondez à une requête à l'aide de la méthode http.ResponseWriter. + w.Write([]byte("Vous avez appris Go en Y minutes!")) +} + +func requestServer() { + resp, err := http.Get("http://localhost:8080") + fmt.Println(err) + defer resp.Body.Close() + body, err := ioutil.ReadAll(resp.Body) + fmt.Printf("\nLe serveur Web a dit: `%s`", string(body)) +} +``` + +## En savoir plus + +La référence Go se trouve sur [le site officiel de Go](http://golang.org/). +Vous pourrez y suivre le tutoriel interactif et en apprendre beaucoup plus. + +Une lecture de la documentation du langage est grandement conseillée. C'est +facile à lire et très court (comparé aux autres langages). + +Vous pouvez exécuter et modifier le code sur [Go playground](https://play.golang.org/p/tnWMjr16Mm). Essayez de le modifier et de l'exécuter à partir de votre navigateur! Prennez en note que vous pouvez utiliser [https://play.golang.org](https://play.golang.org) comme un [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) pour tester et coder dans votre navigateur, sans même avoir à installer Go. + +Sur la liste de lecteur des étudiants de Go se trouve le [code source de la +librairie standard](http://golang.org/src/pkg/). Bien documentée, elle démontre +le meilleur de la clarté de Go, le style ainsi que ses expressions. Sinon, vous +pouvez cliquer sur le nom d'une fonction dans [la +documentation](http://golang.org/pkg/) et le code source apparaît! + +Une autre excellente ressource pour apprendre est [Go par l'exemple](https://gobyexample.com/). diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown index 989db1d5..d9d3151f 100644 --- a/fr-fr/haskell.html.markdown +++ b/fr-fr/haskell.html.markdown @@ -1,5 +1,5 @@ --- -language: haskell +language: Haskell contributors: - ["Adit Bhargava", "http://adit.io"] translators: diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown new file mode 100644 index 00000000..2e18d0be --- /dev/null +++ b/fr-fr/javascript-fr.html.markdown @@ -0,0 +1,525 @@ +--- +language: javascript +contributors: + - ['Adam Brenecki', 'http://adam.brenecki.id.au'] + - ['Ariel Krakowski', 'http://www.learneroo.com'] +filename: javascript-fr.js +translators: + - ['@nbrugneaux', 'https://nicolasbrugneaux.me'] +lang: fr-fr +--- + +JavaScript a été créé par Brendan Eich, travaillant alors a Netscape, en 1995. +Le langage avait à l'origine pour but d'être un langage de scripting simple +pour les sites web, complétant le Java (à ne pas confondre avec JavaScript) +pour des applications web complexes. Mais son intégration très proche et +simple des pages web, ainsi que le support natif des navigateurs a rendu +le JavaScript incontournable aujourd'hui tant bien dans le front-end que +dans le back-end. + +En effet, le JavaScript n'est plus uniquement limité aux navigateurs, grâce à +Node.JS, un projet qui offre un environnement indépendant dans lequel un +interpréteur Javascript, basé sur le célèbre moteur V8 de Google Chrome, +peut être utilisé directement côté serveur pour exécuter des programmes écrits +en JavaScript. + +```js +// Les commentaires sont comme en C. Les commentaires mono-ligne commencent par 2 slashs, +/* et les commentaires sur plusieurs lignes commencent avec slash-étoile + et finissent avec étoile-slash */ + +// Toutes les expressions peuvent finir par ; +doStuff(); + +// ... mais n'en n'ont pas forcément besoin, les point-virgules sont ajoutés +// lors de l’interprétation aux sauts de ligne, sauf exceptions +doStuff() + +// Parce que ces cas peuvent produire des effets inattendus, nous utiliserons +// des point-virgules dans ce guide. + + +/////////////////////////////////// +// 1. Nombres, Chaines de caractères et Opérateurs + +// JavaScript a un seul type de nombre (qui est un 64-bit IEEE 754 double (décimaux)) +// Comme avec le Lua, ne paniquez pas à cause du manque d'int (entiers) : les +// doubles ont un mantisse de 52 bits, ce qui est assez pour stocker des int jusqu'à +// 9 x 10¹⁵ exactement. +3; // = 3 +1.5; // = 1.5 + +// L'arithmétique de base fonctionne comme vous vous y attendriez +1 + 1; // = 2 +8 - 1; // = 7 +10 * 2; // = 20 +35 / 5; // = 7 + +// Ainsi que les divisions non-entières +5 / 2; // = 2.5 + +// Les opérations bits à bits fonctionnent aussi, quand vous effectuez une opération +// bits à bits, votre nombre décimal est converti en entier *jusqu'à* 32 bits. +1 << 2; // = 4 + +// Comme en mathématiques, la priorité est donnée aux parenthèses. +(1 + 3) * 2; // = 8 + +// Il existe 3 valeurs spéciales pour les nombres: +Infinity; // le résultat de 1/0 par exemple +-Infinity; // le résultat de -1/0 par exemple +NaN; // le résultat de 0/0 par exemple + +// Il existe également le type booléen. +true; // vrai +false; // faux + +// Les chaines de caractères (strings) sont créees avec " ou ' indifféremment, la seule +// raison de choisir l'un ou l'autre est la cohérence dans votre code. +"abc"; +'Hello, world'; + +// La négation utilise le symbole ! +!true; // = false +!false; // = true + +// L'égalité est === ou == +// === compare la valeur exacte 2 === '2' // = false +// == convertit la valeur pour comparer 2 === '2' // = true +// En général, il vaut mieux utiliser === pour ne pas faire d'erreur. +1 === 1; // = true +2 === 1; // = false + +// L'inégalité est !== ou !=, basé sur le même principe qu'avant. +1 !== 1; // = false +2 !== 1; // = true + +// Plus de comparaisons : +1 < 10; // = true +1 > 10; // = false +2 <= 2; // = true +2 >= 2; // = true + +// Les chaines de caractères se concatènent avec + +'Hello ' + 'world!'; // = 'Hello world!' + +// et peuvent être comparées alphabétiquement avec < et > +'a' < 'b'; // = true + +// Vous pouvez accéder les caractères dans une string avec charAt +'This is a string'.charAt(0); // = 'T' + +// ... ou utiliser substring pour avoir un plus gros morceau +'Hello world'.substring(0, 5); // = 'Hello' + +// la longueur, length, est une propriété, donc n'utilisez pas de () +'Hello'.length; // = 5 + +// Il y a également null et undefined +null; // utilisé pour une non-valeur +undefined; // utilisé pour une valeur actuellement non présente (cependant, + // undefined est aussi une valeur valide) + +// false, null, undefined, NaN, 0 and '' sont 'presque-faux' (falsy), tout le reste +// est 'presque-vrai' (truthy) +// Notez que 0 est falsy mais '0' est truthy, alors même que 0 == '0' (mais 0 !== '0') + + +/////////////////////////////////// +// 2. Variables, Tableaux et Objets + +// Les variables sont déclarées avec le mot clé var. Le typage en JavaScript est +// dynamique, donc pas besoin de spécifier le type. L'assignement utilise un seul =. +var someVar = 5; + +// si vous oubliez le mot clé var, vous n'aurez pas d'erreur (sauf en mode strict) +someOtherVar = 10; + +// ... mais la variable aura une portée globale (plus communément trouvé en tant +// que "global scope" en anglais), et non pas une portée limitée à la fonction +// dans laquelle vous l'aviez définie. + +// Les variables déclarées et non assignées sont undefined par défaut +var someThirdVar; +var someThirdVar = undefined; + +// ... sont deux déclarations identiques. + +// 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++; // = someVar += 1; +someVar--; // = someVar -= 1; + +// Les tableaux (Arrays) sont des listes ordonnées de valeurs, de tous types. +var myArray = ['Hello', 45, true]; + +// Leurs membres peuvent être accédés en utilisant les crochets +// Les indices commencent à 0. +myArray[1]; // = 45 + +// Les tableaux sont modifiables, ainsi que leurs longueurs +myArray.push( 'World' ); +myArray.length; // = 4 + +// Ajout/Modification à un index spécifique +myArray[3] = 'Hello'; + +// Les objets JavaScript sont appelés 'dictionnaires' ou 'maps' dans certains autres +// langages : ils sont une liste non-ordonnée de paires clé-valeur. +var myObj = {key1: 'Hello', key2: 'World'}; + +// Les clés sont des strings, mais les ' ou " sont optionels si elles sont des +// noms valides en JavaScript. Les valeurs peuvent être de n'importe quel type. +var myObj = {myKey: 'myValue', 'my other key': 4}; + +// Les attributs d'objets peuvent être accédés avec les crochets +myObj['my other key']; // = 4 + +// .. ou avec un point si la clé est un identifiant valide. +myObj.myKey; // = 'myValue' + +// Les objets sont eux aussi modifiables. +myObj.myThirdKey = true; + +// Si vous essayez d'accéder à une valeur non-définie, vous obtiendrez undefined +myObj.myFourthKey; // = undefined + + +/////////////////////////////////// +// 3. Logique et structures de contrôle + +// Les si (if) fonctionnent comme vous vous y attendez. +var count = 1; +if (count === 3) { + // seulement quand count est 3 +} +else if (count === 4) { + // uniquement quand count est 4 +} +else { + // le reste du temps, si ni 3, ni 4. +} + +// De même pour while. +while (true) { + // Une boucle infinie ! +} + +// Les boucles do-while sont pareilles, mais sont exécutées au moins une fois. +var input +do { + input = getInput(); +} while (!isValid(input)) + +// La boucle for est la même qu'en C ou en Java: +// initialisation; condition pour continuer; itération +for (var i = 0; i < 5; i++){ + // sera exécutée 5 fois +} + +// && est le "et" logique, || est le "ou" logique +if (house.size === 'big' && house.colour === 'blue'){ + house.contains = 'bear'; +} +if (colour === 'red' || colour === 'blue'){ + // colour est soit 'red' soit 'blue' +} + +// Les raccourcis && et || sont pratiques pour instancier des valeurs par defaut. +var name = otherName || 'default'; + +// Ceci est l'équivalent de +var name = otherName; +if (!name){ + name = 'default'; +} + +// Le switch vérifie les égalités avec === +// utilisez un "break" à la fin de chaque cas +// ou les cas suivants seront eux aussi exécutés +grade = 'B'; +switch (grade) { + case 'A': + console.log('Great job'); + break; + case 'B': + console.log('OK job'); + break; + case 'C': + console.log('You can do better'); + break; + default: + console.log('Oy vey'); + break; +} + + +/////////////////////////////////// +// 4. Fonctions, Scope (Environnement) et Closures + +// Les fonctions sont déclarées avec le mot clé function +function myFunction(thing){ + return thing.toUpperCase(); +} +myFunction('foo'); // = 'FOO' + +// Les fonctions JavaScript sont des objets de première classe, donc peuvent +// être réassignées à d'autres variables et passées en tant que paramètres pour +// d'autres fonctions +function myFunction(){ + // ce code s'exécutera dans 5 secondes +} +setTimeout(myFunction, 5000); +// Note: setTimeout ne fait pas parti du langage, mais les navigateurs ainsi +// que Node.js le rendent disponible + +// Les fonctions n'ont pas nécessairement besoin d'un nom, elles peuvent être +// anonymes +setTimeout(function(){ + // ce code s'exécutera dans 5 secondes +}, 5000); + +// Le Javascript crée uniquement un scope, une portée d'action limitée, pour +// les fonctions, et pas dans les autres blocs. +if (true){ + var i = 5; +} +i; // = 5 - et non undefined comme vous pourriez vous y attendre + +// Cela a mené à un style commun de fonctions anonymes immédiatement exécutée; +// ou "immediately-executing anonymous functions" +(function(){ + var temporary = 5; + // Nous pouvons accéder au scope global en assignant à l'objet global, + // qui dans les navigateurs est "window". Il est différent dans Node.js, + // le scope global sera en fait local au module dans lequel vous + // vous trouvez. http://nodejs.org/api/globals.html + window.permanent = 10; +})(); +// Cela permet de ne pas avoir de fuites de variables qui polluent +// l’environnement global. +temporary; // raises ReferenceError +permanent; // = 10 + +// Une des fonctionnalités les plus puissantes de Javascript est le système de +// closures. Si une fonction est définie dans une autre fonction, alors la +// fonction interne aura accès aux variables de la fonction parente, même si +// celle-ci a déjà finie son exécution. +function sayHelloInFiveSeconds(name){ + var prompt = 'Hello, ' + name + '!'; + // Fonction interne + function inner(){ + alert(prompt); + } + setTimeout(inner, 5000); + // setTimeout is asynchrone, donc la fonction sayHelloInFiveSeconds quittera + // immédiatement, et setTimeout appelera inner après. +} +sayHelloInFiveSeconds('Adam'); // ouvre un popup avec 'Hello, Adam!' dans 5sec + + +/////////////////////////////////// +// 5. Encore plus à propos des Objets; Constructeurs and Prototypes + +// Les objets peuvent contenir des fonctions. +var myObj = { + myFunc: function(){ + return 'Hello world!'; + } +}; +myObj.myFunc(); // = 'Hello world!' + +// Lorsqu'une fonction attachée à un objet est appelée, elle peut accéder à +// l'objet avec le mot clé this. +myObj = { + myString: 'Hello world!', + myFunc: function(){ + return this.myString; + } +}; +myObj.myFunc(); // = 'Hello world!' + +// La valeur de "this" change de par l'endroit où la fonction est appelée, et +// non de l'endroit où elle est définie. Donc elle ne fonctionnera pas si elle +// est appelée hors du contexte l'objet. +var myFunc = myObj.myFunc; +myFunc(); // = undefined + +// A l'inverse, une fonction peut être attachée à un objet et y gagner l'accès +// au travers de "this" +var myOtherFunc = function(){ + return this.myString.toUpperCase(); +} + +myObj.myOtherFunc = myOtherFunc; +myObj.myOtherFunc(); // = 'HELLO WORLD!' + +// Le contexte correspond à la valeur de "this". +// Nous pouvons aussi spécifier un contexte, forcer la valeur de "this, +// pour une fonction quand elle est appelée grâce à "call" ou "apply". +var anotherFunc = function(s){ + return this.myString + s; +} +anotherFunc.call(myObj, ' And Hello Moon!'); // = 'Hello World! And Hello Moon!' + +// 'apply' est presque identique, mais prend un tableau comme liste d’arguments. + +anotherFunc.apply(myObj, [' And Hello Sun!']); // = 'Hello World! And Hello Sun!' + +Math.min(42, 6, 27); // = 6 +Math.min([42, 6, 27]); // = NaN (uh-oh!) +Math.min.apply(Math, [42, 6, 27]); // = 6 + +// Mais, "call" and "apply" fonctionnenent uniquement au moment de l'appel de la +// fonction. Pour lier le contexte de façon permanente, nous pouvons utiliser +// "bind" pour garder une référence à la fonction avec ce "this". +var boundFunc = anotherFunc.bind(myObj); +boundFunc(' And Hello Saturn!'); // = 'Hello World! And Hello Saturn!' + +// "bind" peut aussi être utilisé pour créer une application partielle de la +// fonction (curry) +var product = function(a, b){ return a * b; } +var doubler = product.bind(this, 2); +doubler(8); // = 16 + +// Lorsque vous appelez une fonction avec le mot clé "new", un nouvel objet est +// crée et mis à disposition de la fonction via "this". Ces fonctions sont +// communément appelées constructeurs. +var MyConstructor = function(){ + this.myNumber = 5; +} +myNewObj = new MyConstructor(); // = {myNumber: 5} +myNewObj.myNumber; // = 5 + +// Chaque objet en Javascript a un "prototype". Quand vous essayez d'accéder à +// une propriété que l'objet n'a pas, l'interpréteur va regarder son prototype. + +// Quelques implémentations de JS vous laissent accéder au prototype avec la +// propriété "magique" __proto__. Ceci peut être utile, mais n'est pas standard +// et ne fonctionne pas dans certains des navigateurs actuels. +var myObj = { + myString: 'Hello world!' +}; +var myPrototype = { + meaningOfLife: 42, + myFunc: function(){ + return this.myString.toLowerCase() + } +}; + +myObj.__proto__ = myPrototype; +myObj.meaningOfLife; // = 42 +myObj.myFunc(); // = 'hello world!' + +myPrototype.__proto__ = { + myBoolean: true +}; +myObj.myBoolean; // = true + + +// Pour obtenir le prototype il existe également Object.getPrototypeOf +Object.getPrototypeOf( myObj ) // = {meaningOfLife: 42, myFunc: function} + +// Il n'y a pas de copie ici. Chacun des objets stocke une référence à son +// prototype. Cela veut dire que l'on peut le modifier et cela se répercutera +// partout. +myPrototype.meaningOfLife = 43; +myObj.meaningOfLife; // = 43 + +// L'inverse n'est cependant pas vrai. Changer la propriété d'un objet ne change +// pas la chaine prototypale. +myObj.meaningOfLife = 42; +myPrototype.meaningOfLife; // = 43 + +// Comme précédemment dit, __proto__ n'est pas standard et ne devrait pas être +// utilisé. Il y a deux autres moyen de créer un nouvel objet avec un prototype +// donné. + +// Le premier est Object.create, mais c'est assez récent et risque de ne pas +// fonctionner dans tous les navigateurs. +var myObj = Object.create(myPrototype); +myObj.meaningOfLife; // = 43 + +// Le deuxième moyen, qui marche partout, fonctionne avec les constructeurs. +// Les constructeurs ont un propriété appelée prototype. Ce n'est *pas* le +// prototype du constructeur de la fonction elle-même, c'est le prototype que +// les nouveaux objets crées grâce à ce constructeur avec "new" auront. +MyConstructor.prototype = { + myNumber: 5, + getMyNumber: function(){ + return this.myNumber; + } +}; +var myNewObj2 = new MyConstructor(); +myNewObj2.getMyNumber(); // = 5 +myNewObj2.myNumber = 6 +myNewObj2.getMyNumber(); // = 6 + +// Les types pré-définis tels que les strings ou nombres ont aussi des +// constructeurs +var myNumber = 12; +var myNumberObj = new Number(12); +myNumber == myNumberObj; // = true + +// ... mais ils ne sont pas exactement équivalent. +typeof myNumber; // = 'number' +typeof myNumberObj; // = 'object' +myNumber === myNumberObj; // = false +if (0){ + // 0 est falsy, le code ne fonctionnera pas. +} +if (Number(0)){ + // Parce que Number(0) est truthy, le code fonctionnera +} + +// Cependant, vous pouvez ajouter des fonctionnalités aux types de bases grâce à +// cette particularité. +String.prototype.firstCharacter = function(){ + return this.charAt(0); +} +'abc'.firstCharacter(); // = 'a' + +// C'est très souvent utilisé pour le "polyfilling", qui implémente des nouvelles +// fonctionnalités de JavaScript dans de plus anciens environnements, tels que +// les vieux navigateurs. + +//Par exemple, Object.create est assez récent, mais peut être implémenté grâce à +// ce polyfill +if (Object.create === undefined){ // pour ne pas reécrire si la fonction existe déjà + Object.create = function(proto){ + // on crée un constructeur temporaire avec le bon prototype + var Constructor = function(){}; + Constructor.prototype = proto; + // puis on utilise "new" pour créer un object avec ce même prototype + return new Constructor(); + } +} +``` + +## Pour aller plus loin (en anglais) + +The [Mozilla Developer +Network](https://developer.mozilla.org/fr-FR/docs/Web/JavaScript) expose une +excellente documentation pour le Javascript dans les navigateurs. Et contient +également un wiki pour s'entraider. + +MDN's [A re-introduction to +JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) +recouvre les principaux sujets vus ici. Le guide est délibérément uniquement +à propos du JavaScript, et ne parle pas des navigateurs; pour cela, dirigez vous +plutôt ici : +[Document Object +Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) + +[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) quelques challenges. + +[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) is an in-depth +un guide pour vous éviter les faux-amis dans le JavaScript. + +[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) un classique. A lire. + +En addition aux contributeurs de cet article, du contenu provient du +"Python tutorial" de Louie Dinh, et de [JS +Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) +sur le réseau Mozilla. diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown new file mode 100644 index 00000000..49c95820 --- /dev/null +++ b/fr-fr/json-fr.html.markdown @@ -0,0 +1,62 @@ +--- +language: json +filename: learnjson-fr.json +contributors: + - ["Anna Harren", "https://github.com/iirelu"] + - ["Marco Scannadinari", "https://github.com/marcoms"] +translators: + - ["Alois de Gouvello","https://github.com/aloisdg"] +lang: fr-fr +--- + +Comme JSON est un format d'échange de données extrêmement simple, ce Apprendre X en Y minutes +est susceptible d'être le plus simple jamais réalisé. + +JSON dans son état le plus pur n'a aucun commentaire, mais la majorité des parseurs accepterons +les commentaires du langage C (`//`, `/* */`). Pour les besoins de ce document, cependant, +tout sera du JSON 100% valide. Heureusement, il s'explique par lui-même. + + +```json +{ + "Clé": "valeur", + + "Clés": "devront toujours être entourées par des guillemets", + "nombres": 0, + "chaînes de caractères": "Hellø, wørld. Tous les caractères Unicode sont autorisés, accompagné d'un \"caractère d'échappement\".", + "a des booléens ?": true, + "rien": null, + + "grand nombre": 1.2e+100, + + "objets": { + "commentaire": "La majorité de votre strucutre sera des objets.", + + "tableau": [0, 1, 2, 3, "Les tableaux peuvent contenir n'importe quoi.", 5], + + "un autre objet": { + "commentaire": "Ces choses peuvent être imbriquées. C'est très utile." + } + }, + + "bêtises": [ + { + "sources de potassium": ["bananes"] + }, + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, "neo"], + [0, 0, 0, 1] + ] + ], + + "style alternatif": { + "commentaire": "regarde ça !" + , "position de la virgule": "n'a pas d'importance - aussi longtemps qu'elle est avant la valeur, alors elle est valide." + , "un autre commentaire": "comme c'est gentil" + }, + + "C'était court": "Et, vous avez terminé. Maintenant, vous savez tout ce que JSON a à offrir." +} +``` diff --git a/fr-fr/lua-fr.html.markdown b/fr-fr/lua-fr.html.markdown index 922d6ebc..b4e2a161 100644 --- a/fr-fr/lua-fr.html.markdown +++ b/fr-fr/lua-fr.html.markdown @@ -1,5 +1,5 @@ --- -language: lua +language: Lua filename: learnlua-fr.lua contributors: - ["Tyler Neylon", "http://tylerneylon.com/"] diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown new file mode 100644 index 00000000..29c0d65d --- /dev/null +++ b/fr-fr/markdown.html.markdown @@ -0,0 +1,289 @@ +--- +language: markdown +contributors: +- ["Andrei Curelaru", "http://www.infinidad.fr"] +filename: markdown.md +lang: fr-fr +--- + +Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe +facile à lire et à écrire, aisément convertible en HTML + (et beaucoup d'autres formats aussi à présent). + +Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" +et envoyer des pull request! + + +```markdown +<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML +est un document Markdown valide. Autrement dit, vous pouvez utiliser des +balises HTML dans un fichier Markdown, comme la balise commentaire dans +laquelle nous sommes à présent, car celle-ci ne sera pas affectée par +le parser( analyseur syntaxique ) Markdown. --> + +<!-- Toutefois, si vous voulez créer un élément HTML dans un fichier Markdown, + vous ne pourrez pas utiliser du Markdown à l'intérieur de ce dernier. --> + +<!-- Le Markdown est implémenté de différentes manières, selon le parser. +Ce guide va alors tenter de trier les fonctionnalités universelles de celles +spécifiques à un parser. --> + +<!-- Headers ( En-têtes ) --> +<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant + le texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six, + selon le niveau de titre souhaité. --> +# Ceci est un <h1> +## Ceci est un <h2> +### Ceci est un <h3> +#### Ceci est un <h4> +##### Ceci est un <h5> +###### Ceci est un <h6> + +<!-- +Markdown fournit également une façon alternative de marquer les h1 et h2 +--> + +Ceci est un h1 +============= + +Ceci est un h2 +------------- + +<!-- Styles basiques pour du texte --> +<!-- On peut facilement rendre un texte "gras" ou "italique" en Markdown --> + +*Ce texte est en italique.* +_Celui-ci aussi._ + +**Ce texte est en gras.** +__Celui-là aussi.__ + +***Ce texte a les deux styles.*** +**_Pareil ici_** +*__Et là!__* + +<!-- Dans le "Github Flavored Markdown", utilisé pour interpréter le Markdown +sur Github, on a également le strikethrough ( texte barré ) : --> + +~~Ce texte est barré avec strikethrough.~~ + +<!-- Les Paragraphes sont représentés par une ou plusieurs lignes de texte +séparées par une ou plusieurs lignes vides. --> + +Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non? + +Maintenant je suis dans le paragraphe 2. +Je suis toujours dans le paragraphe 2! + + +Puis là, eh oui, le paragraphe 3! + +<!-- +Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter +un ou plusieurs espaces à la fin de votre paragraphe, et en commencer +un nouveau. +--> + +J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). + +Bigre, il y a un <br /> au dessus de moi! + +<!-- Les 'Blocs de Citations' sont générés aisément, grâce au caractère > --> + +> Ceci est une superbe citation. Vous pouvez même +> revenir à la ligne quand ça vous chante, et placer un `>` +> devant chaque bout de ligne faisant partie +> de la citation. +> La taille ne compte pas^^ tant que chaque ligne commence par un `>`. + +> Vous pouvez aussi utiliser plus d'un niveau +>> d'imbrication! +> Classe et facile, pas vrai? + +<!-- les Listes --> +<!-- les Listes non ordonnées sont marquées par des asterisques, +signes plus ou signes moins. --> + +* Item +* Item +* Un autre item + +ou + ++ Item ++ Item ++ Encore un item + +ou + +- Item +- Item +- Un dernier item + +<!-- les Listes Ordonnées sont générées via un nombre suivi d'un point --> + +1. Item un +2. Item deux +3. Item trois + +<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera +les bons chiffres. Ceci dit, cette variante perd en clarté.--> + +1. Item un +1. Item deux +1. Item trois +<!-- ( cette liste sera interprétée de la même façon que celle au dessus ) --> + +<!-- Vous pouvez également utiliser des sous-listes --> + +1. Item un +2. Item deux +3. Item trois +* Sub-item +* Sub-item +4. Item quatre + +<!-- Il y a même des "listes de Taches". Elles génèrent des champs HTML +de type checkbox. --> + +Les [ ] ci dessous, n'ayant pas de [ x ], +deviendront des cases à cocher HTML non-cochées. + +- [ ] Première tache à réaliser. +- [ ] Une autre chose à faire. +La case suivante sera une case à cocher HTML cochée. +- [x] Ça ... c'est fait! + +<!-- les Blocs de Code --> +<!-- Pour marquer du texte comme étant du code, il suffit de commencer +chaque ligne en tapant 4 espaces (ou un Tab) --> + + echo "Ça, c'est du Code!"; + var Ça = "aussi !"; + +<!-- L'indentation par tab ou série de quatre espaces +fonctionne aussi à l'intérieur du bloc de code --> + + my_array.each do |item| + puts item + end + +<!-- Des bouts de code en mode 'inline' s'ajoutent en les entourant de ` --> + +La fonction `run()` ne vous oblige pas à aller courir! + +<!-- Via Github Flavored Markdown, vous pouvez utiliser +des syntaxes spécifiques --> + +\`\`\`ruby +<!-- mais enlevez les backslashes quand vous faites ça, +gardez juste ```ruby ( ou nom de la synatxe correspondant à votre code )--> +def foobar +puts "Hello world!" +end +\`\`\` <!-- pareil, pas de backslashes, juste ``` en guise de fin --> + +<-- 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 ``` --> + +<!-- Ligne Horizontale (<hr />) --> +<!-- Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets, +avec ou sans espaces entre chaque un. --> + +*** +--- +- - - +**************** + +<!-- Liens --> +<!-- Une des fonctionnalités sympathiques du Markdown est la facilité +d'ajouter des liens. Le texte du lien entre [ ], l'url entre ( ), +et voilà l'travail. +--> + +[Clic moi!](http://test.com/) + +<!-- +Pour ajouter un attribut Title, collez le entre guillemets, avec le lien. +--> + +[Clic moi!](http://test.com/ "Lien vers Test.com") + +<!-- les Liens Relatifs marchent aussi --> + +[En avant la musique](/music/). + +<!-- Les liens façon "références" sont eux aussi disponibles en Markdown --> + +[Cliquez ici][link1] pour plus d'information! +[Regardez aussi par ici][foobar] si vous voulez. + +[link1]: http://test.com/ "Cool!" +[foobar]: http://foobar.biz/ "Alright!" + +<!-- Le titre peut aussi être entouré de guillemets simples, +entre parenthèses ou absent. Les références peuvent être placées +un peu où vous voulez dans le document, et les identifiants +(link1, foobar, ...) quoi que ce soit tant qu'ils sont uniques --> + +<!-- Il y a également le "nommage implicite" qui transforme le texte du lien + en identifiant --> + +[Ceci][] est un lien. + +[ceci]: http://ceciestunlien.com/ + +<!-- mais ce n'est pas beaucoup utilisé. --> + +<!-- Images --> +<!-- Pour les images, la syntaxe est identique aux liens, sauf que précédée + d'un point d'exclamation! --> + + + +<!-- Là aussi, on peut utiliser le mode "références" --> + +![Ceci est l'attribut ALT de l'image][monimage] + +[monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici." + +<!-- Divers --> +<!-- Liens Automatiques --> + +<http://testwebsite.com/> est équivalent à : +[http://testwebsite.com/](http://testwebsite.com/) + +<!-- Liens Automatiques pour emails --> + +<foo@bar.com> + +<!-- Escaping --> +Il suffit de précéder les caractères spécifiques à ignorer par des backslash \ + +Pour taper *ce texte* entouré d'astérisques mais pas en italique : +Tapez \*ce texte\*. + +<!-- Tableaux --> +<!-- les Tableaux ne sont disponibles que dans le Github Flavored Markdown + et c'est ce n'est pas super agréable d'utilisation. + Mais si vous en avez besoin : + --> + +| Col1 | Col2 | Col3 | +| :----------- | :------: | ------------: | +| Alignement Gauche | Centé | Alignement Droite | +| bla | bla | bla | + +<!-- ou bien, pour un résultat équivalent : --> + +Col 1 | Col2 | Col3 +:-- | :-: | --: +Ough que c'est moche | svp | arrêtez + +<!-- Fin! --> + +``` + +Pour plus d'information : + consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, + et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard. diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown index b98d161e..69f4d8f9 100644 --- a/fr-fr/objective-c-fr.html.markdown +++ b/fr-fr/objective-c-fr.html.markdown @@ -14,7 +14,7 @@ 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. -```cpp +```objective_c // Les commentaires sur une seule ligne commencent par // /* diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown new file mode 100644 index 00000000..3f225a0f --- /dev/null +++ b/fr-fr/r-fr.html.markdown @@ -0,0 +1,746 @@ +--- +language: R +contributors: + - ["e99n09", "http://github.com/e99n09"] + - ["isomorphismes", "http://twitter.com/isomorphisms"] +translators: + - ["Anne-Catherine Dehier", "https://github.com/spellart"] +filename: learnr-fr.r +--- + +R est un langage de programmation statistique. Il dispose de nombreuses +bibliothèques pour le téléchargement et le nettoyage d'ensembles de données, +l'exécution de procédures statistiques, et la réalisation de graphiques. +On peut également exécuter des commmandes `R` au sein d'un document LaTeX. + + +```r + +# Les commentaires commencent avec des symboles numériques. + +# Il n'est pas possible de faire des commentaires multilignes, +# mais on peut placer plusieurs commentaires les uns en dessous +# des autres comme ceci. + +# Sur Mac, taper COMMAND-ENTER pour exécuter une ligne +# et sur Windows taper CTRL-ENTER + + + +######################################################################## +# Les choses que vous pouvez faire sans rien comprendre +# à la programmation +######################################################################## + +# Dans cette section, nous vous montrons quelques trucs cools que vous +# pouvez faire avec R sans rien comprendre à la programmation. +# Ne vous inquiétez pas si vous ne comprenez pas tout ce que le code fait. +# Profitez simplement ! + +data() # parcours les ensembles de données préchargées +data(rivers) # récupère ceci : "Lengths of Major North American Rivers" +ls() # notez que "rivers" apparaît maintenant dans votre espace de travail +head(rivers) # donne un aperçu des données +# 735 320 325 392 524 450 + +length(rivers) # Combien de rivers ont été mesurées ? +# 141 +summary(rivers) # Quelles sont les principales données statistiques ? +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 135.0 310.0 425.0 591.2 680.0 3710.0 + +# Fait un diagramme à tiges et à feuilles (visualisation de données de +# types histogramme) +stem(rivers) + + +# Le point décimal est de 2 chiffres à droite du | +# +# 0 | 4 +# 2 | 011223334555566667778888899900001111223333344455555666688888999 +# 4 | 111222333445566779001233344567 +# 6 | 000112233578012234468 +# 8 | 045790018 +# 10 | 04507 +# 12 | 1471 +# 14 | 56 +# 16 | 7 +# 18 | 9 +# 20 | +# 22 | 25 +# 24 | 3 +# 26 | +# 28 | +# 30 | +# 32 | +# 34 | +# 36 | 1 + +stem(log(rivers)) # Notez que les données ne sont ni normales +# ni lognormales ! +# Prenez-ça, la courbe en cloche + +# Le point décimal est à 1 chiffre à gauche du | +# +# 48 | 1 +# 50 | +# 52 | 15578 +# 54 | 44571222466689 +# 56 | 023334677000124455789 +# 58 | 00122366666999933445777 +# 60 | 122445567800133459 +# 62 | 112666799035 +# 64 | 00011334581257889 +# 66 | 003683579 +# 68 | 0019156 +# 70 | 079357 +# 72 | 89 +# 74 | 84 +# 76 | 56 +# 78 | 4 +# 80 | +# 82 | 2 + +# Fait un histogramme : +hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces paramètres +hist(log(rivers), col="#333333", border="white", breaks=25) # vous ferez plus de tracés plus tard + +# Ici d'autres données qui viennent préchargées. R en a des tonnes. +data(discoveries) +plot(discoveries, col="#333333", lwd=3, xlab="Year", + main="Number of important discoveries per year") +plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year", + main="Number of important discoveries per year") + +# Plutôt que de laisser l'ordre par défaut (par année) +# Nous pourrions aussi trier pour voir ce qu'il y a de typique +sort(discoveries) +# [1] 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 +# [26] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 +# [51] 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 +# [76] 4 4 4 4 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 8 9 10 12 + +stem(discoveries, scale=2) +# +# Le point décimale est à la | +# +# 0 | 000000000 +# 1 | 000000000000 +# 2 | 00000000000000000000000000 +# 3 | 00000000000000000000 +# 4 | 000000000000 +# 5 | 0000000 +# 6 | 000000 +# 7 | 0000 +# 8 | 0 +# 9 | 0 +# 10 | 0 +# 11 | +# 12 | 0 + +max(discoveries) +# 12 +summary(discoveries) +# Min. 1st Qu. Median Mean 3rd Qu. Max. +# 0.0 2.0 3.0 3.1 4.0 12.0 + +# Lance un dé plusieurs fois +round(runif(7, min=.5, max=6.5)) +# 1 4 6 1 4 6 4 +# Vos numéros diffèreront des miens à moins que nous mettions +# le même random.seed(31337) + +# Dessine à partir d'une normale Gaussienne 9 fois +rnorm(9) +# [1] 0.07528471 1.03499859 1.34809556 -0.82356087 0.61638975 -1.88757271 +# [7] -0.59975593 0.57629164 1.08455362 + + + +############################################################## +# les types de données et l'arithmétique de base +############################################################## + +# Maintenant pour la partie orientée programmation du tutoriel. +# Dans cette section vous rencontrerez les types de données importants de R : +# les entiers, les numériques, les caractères, les logiques, et les facteurs. + +# LES ENTIERS +# Les entiers de type long sont écrits avec L +5L # 5 +class(5L) # "integer" +# (Essayez ?class pour plus d'informations sur la fonction class().) +# Avec R, chaque valeur seule, comme 5L, est considérée comme +# un vecteur de longueur 1 +length(5L) # 1 +# On peut avoir un vecteur d'entiers avec une longueur > 1 : +c(4L, 5L, 8L, 3L) # 4 5 8 3 +length(c(4L, 5L, 8L, 3L)) # 4 +class(c(4L, 5L, 8L, 3L)) # "integer" + +# LES NUMÉRIQUES +# Un "numeric" est un nombre à virgule flottante d'une précision double +5 # 5 +class(5) # "numeric" +# Encore une fois, tout dans R est un vecteur ; +# Vous pouvez faire un vecteur numérique avec plus d'un élément +c(3,3,3,2,2,1) # 3 3 3 2 2 1 +# Vous pouvez aussi utiliser la notation scientifique +5e4 # 50000 +6.02e23 # nombre d'Avogadro +1.6e-35 # longueur de Planck +# Vous pouvez également avoir des nombres infiniments grands ou petits +class(Inf) # "numeric" +class(-Inf) # "numeric" +# Vous pouvez utiliser "Inf", par exemple, dans integrate(dnorm, 3, Inf); +# Ça permet d'éviter de réaliser une table de la loi normale. + +# ARITHMÉTIQUES DE BASE +# Vous pouvez faire de l'arithmétique avec des nombres +# Faire des opérations arithmétiques en mixant des entiers +# et des numériques +# donne un autre numérique +10L + 66L # 76 # un entier plus un entier donne un entier +53.2 - 4 # 49.2 # un numérique moins un numérique donne un numérique +2.0 * 2L # 4 # un numérique multiplié par un entier donne un numérique +3L / 4 # 0.75 # un entier sur un numérique donne un numérique +3 %% 2 # 1 # le reste de deux numériques est un autre numérique +# Les opérations arithmétiques illégales donnent un "Not A Number" : +0 / 0 # NaN +class(NaN) # "numeric" +# Vous pouvez faire des opérations arithmétiques avec deux vecteurs d'une +# longueur plus grande que 1, à condition que la longueur du plus grand +# vecteur soit un multiple entier du plus petit +c(1,2,3) + c(1,2,3) # 2 4 6 + +# LES CARACTÈRES +# Il n'y a pas de différences entre les chaînes de caractères et +# les caractères en R +"Horatio" # "Horatio" +class("Horatio") # "character" +class('H') # "character" +# Ceux-ci sont tous les deux des vecteurs de longueur 1 +# Ici un plus long : +c('alef', 'bet', 'gimmel', 'dalet', 'he') +# => +# "alef" "bet" "gimmel" "dalet" "he" +length(c("Call","me","Ishmael")) # 3 +# Vous pouvez utiliser des expressions rationnelles sur les vecteurs de caractères : +substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis " +gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis." +# R possède plusieurs vecteurs de caractères préconstruits : +letters +# => +# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" +# [20] "t" "u" "v" "w" "x" "y" "z" +month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec" + +# LES TYPES BOOLÉENS +# En R, un "logical" est un booléen +class(TRUE) # "logical" +class(FALSE) # "logical" +# Leur comportement est normal +TRUE == TRUE # TRUE +TRUE == FALSE # FALSE +FALSE != FALSE # FALSE +FALSE != TRUE # TRUE +# Les données manquantes (NA) sont logiques également +class(NA) # "logical" +# On utilise | et & pour les operations logiques. +# OR +TRUE | FALSE # TRUE +# AND +TRUE & FALSE # FALSE +# Vous pouvez tester si x est TRUE +isTRUE(TRUE) # TRUE +# Ici nous avons un vecteur de type logique avec plusieurs éléments : +c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE +c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE + +# LES FACTEURS +# Les facteurs sont généralement utilisés pour y stocker des +# variables qualitatives (catégorielles). +# Les facteurs peuvent être ordonnés (comme le niveau scolaire +# des enfants) ou non ordonnés (comme le sexe) +factor(c("female", "female", "male", NA, "female")) +# female female male <NA> female +# Les niveaux : female male +# Les facteurs possèdent un attribut appelé niveau ("level"). +# Les niveaux sont des vecteurs contenant toutes les valeurs +# que peuvent prendre les données catégorielles. +# Notez que les données manquantes n'entrent pas dans le niveau +levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male" +# Si le vecteur de facteurs a une longueur 1, ses niveaux seront +# de longueur 1 également +length(factor("male")) # 1 +length(levels(factor("male"))) # 1 +# On rencontre communément des facteurs dans des "data frame", +# un type de données que nous couvrirons plus tard +data(infert) # "Infertility after Spontaneous and Induced Abortion" +levels(infert$education) # "0-5yrs" "6-11yrs" "12+ yrs" + +# NULL +# "NULL" est bizarre ; on l'utilise pour effacer un vecteur +class(NULL) # NULL +parakeet = c("beak", "feathers", "wings", "eyes") +parakeet +# => +# [1] "beak" "feathers" "wings" "eyes" +parakeet <- NULL +parakeet +# => +# NULL + +# LES CONVERSIONS DE TYPES +# Les conversions de types servent à forcer une valeur à prendre +# un type différent +as.character(c(6, 8)) # "6" "8" +as.logical(c(1,0,1,1)) # TRUE FALSE TRUE TRUE +# Si vous mettez des éléments de différents types dans un vecteur, +# des coercitions bizarres se produisent : +c(TRUE, 4) # 1 4 +c("dog", TRUE, 4) # "dog" "TRUE" "4" +as.numeric("Bilbo") +# => +# [1] NA +# Message d'avertissement : +# NAs est introduit par coercition + +# Notez également : ce n'étaient que des types de données basiques +# Il y a beaucoup d'autres types de données, comme les dates, +# les séries temporelles, etc ... + + + +####################################### +# Variables, boucles , if/else +####################################### + +# Une variable est comme une boîte dans laquelle on garde une valeur +# pour l'utiliser plus tard. +# Nous appellons ça "assigner" une valeur à une variable. +# Avoir des variables nous permet d'écrire des boucles, des fonctions, et +# des instructions conditionnelles (if/else) + +# LES VARIABLES +# Beaucoup de façons d'assigner des choses : +x = 5 # c'est correct +y <- "1" # c'est préféré +TRUE -> z # ça marche mais c'est bizarre + +# LES BOUCLES +# Il y a les boucles for : +for (i in 1:4) { + print(i) +} +# Il y a les boucles while : +a <- 10 +while (a > 4) { + cat(a, "...", sep = "") + a <- a - 1 +} +# Gardez à l'esprit que les boucles for et while s'exécutent lentement +# en R. +# Des opérations sur la totalité d'un vecteur (ex une ligne entière, +# une colonne entière), +# ou les fonctions de type apply() (nous en parlerons plus tard), +# sont préférées. + +# IF/ELSE +# Encore une fois assez standard +if (4 > 3) { + print("4 is greater than 3") +} else { + print("4 is not greater than 3") +} +# => +# [1] "4 is greater than 3" + +# LES FONCTIONS +# se définissent comme ceci : +jiggle <- function(x) { + x = x + rnorm(1, sd=.1) # ajoute un peu de bruit (contrôlé) + return(x) +} +# Appelées comme n'importe quelles autres fonction R : +jiggle(5) # 5±ε. After set.seed(2716057), jiggle(5)==5.005043 + + + +########################################################################## +# Les structures de données : les vecteurs, les matrices, +# les data frames et les tableaux +########################################################################## + +# À UNE DIMENSION + +# Commençons par le tout début, et avec quelque chose que +# vous connaissez déjà : les vecteurs. +vec <- c(8, 9, 10, 11) +vec # 8 9 10 11 +# Nous demandons des éléments spécifiques en les mettant entre crochets +# (Notez que R commence à compter à partir de 1) +vec[1] # 8 +letters[18] # "r" +LETTERS[13] # "M" +month.name[9] # "September" +c(6, 8, 7, 5, 3, 0, 9)[3] # 7 +# Nous pouvons également rechercher des indices de composants spécifiques, +which(vec %% 2 == 0) # 1 3 +# Récupèrer seulement les premières ou dernières entrées du vecteur, +head(vec, 1) # 8 +tail(vec, 2) # 10 11 +# ou vérifier si un certaine valeur est dans le vecteur +any(vec == 10) # TRUE +# Si un index "dépasse" vous obtiendrez NA : +vec[6] # NA +# Vous pouvez trouver la longueur de votre vecteur avec length() +length(vec) # 4 +# Vous pouvez réaliser des opérations sur des vecteurs entiers ou des +# sous-ensembles de vecteurs +vec * 4 # 16 20 24 28 +vec[2:3] * 5 # 25 30 +any(vec[2:3] == 8) # FALSE +# Et R a beaucoup de méthodes statistiques pré-construites pour les vecteurs : +mean(vec) # 9.5 +var(vec) # 1.666667 +sd(vec) # 1.290994 +max(vec) # 11 +min(vec) # 8 +sum(vec) # 38 +# Quelques fonctions préconstruites sympas supplémentaires : +5:15 # 5 6 7 8 9 10 11 12 13 14 15 +seq(from=0, to=31337, by=1337) +# => +# [1] 0 1337 2674 4011 5348 6685 8022 9359 10696 12033 13370 14707 +# [13] 16044 17381 18718 20055 21392 22729 24066 25403 26740 28077 29414 30751 + +# À DEUX DIMENSIONS (TOUT DANS UNE CLASSE) + +# Vous pouvez créer une matrice à partir d'entrées du même type comme ceci : +mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6)) +mat +# => +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [3,] 3 6 +# Différemment du vecteur, la classe d'une matrice est "matrix", +# peut importe ce qu'elle contient +class(mat) # => "matrix" +# Récupérer la première ligne +mat[1,] # 1 4 +# Réaliser une opération sur la première colonne +3 * mat[,1] # 3 6 9 +# Demander une cellule spécifique +mat[3,2] # 6 + +# Transposer la matrice entière +t(mat) +# => +# [,1] [,2] [,3] +# [1,] 1 2 3 +# [2,] 4 5 6 + +# La multiplication de matrices +mat %*% t(mat) +# => +# [,1] [,2] [,3] +# [1,] 17 22 27 +# [2,] 22 29 36 +# [3,] 27 36 45 + +# cbind() colle des vecteurs ensemble en colonne pour faire une matrice +mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog")) +mat2 +# => +# [,1] [,2] +# [1,] "1" "dog" +# [2,] "2" "cat" +# [3,] "3" "bird" +# [4,] "4" "dog" +class(mat2) # matrix +# Encore une fois regardez ce qui se passe ! +# Parce que les matrices peuvent contenir des entrées de toutes sortes de +# classes, tout sera converti en classe caractère +c(class(mat2[,1]), class(mat2[,2])) + +# rbind() colle des vecteurs ensemble par lignes pour faire une matrice +mat3 <- rbind(c(1,2,4,5), c(6,7,0,4)) +mat3 +# => +# [,1] [,2] [,3] [,4] +# [1,] 1 2 4 5 +# [2,] 6 7 0 4 +# Ah, tout de la même classe. Pas de coercitions. Beaucoup mieux. + +# À DEUX DIMENSIONS (DE CLASSES DIFFÉRENTES) + +# Pour des colonnes de différents types, utiliser une data frame +# Cette structure de données est si utile pour la programmation statistique, +# qu'une version a été ajoutée à Python dans le paquet "pandas". + +students <- data.frame(c("Cedric","Fred","George","Cho","Draco","Ginny"), + c(3,2,2,1,0,-1), + c("H", "G", "G", "R", "S", "G")) +names(students) <- c("name", "year", "house") # name the columns +class(students) # "data.frame" +students +# => +# name year house +# 1 Cedric 3 H +# 2 Fred 2 G +# 3 George 2 G +# 4 Cho 1 R +# 5 Draco 0 S +# 6 Ginny -1 G +class(students$year) # "numeric" +class(students[,3]) # "factor" +# Trouver les dimensions +nrow(students) # 6 +ncol(students) # 3 +dim(students) # 6 3 +# La fonction data.frame() convertit les vecteurs caractères en vecteurs de +# facteurs par défaut; désactiver cette fonction en règlant +# stringsAsFactors = FALSE quand vous créer la data.frame +?data.frame + +# Il y a plusieurs façons de subdiviser les data frames, +# toutes subtilement différentes +students$year # 3 2 2 1 0 -1 +students[,2] # 3 2 2 1 0 -1 +students[,"year"] # 3 2 2 1 0 -1 + +# Une version améliorée de la structure data.frame est data.table. +# Si vous travaillez avec des données volumineuses ou des panels, ou avez +# besoin de fusionner quelques ensembles de données, data.table peut être +# un bon choix. Ici un tour éclair : +install.packages("data.table") # télécharge le paquet depuis CRAN +require(data.table) # le charge +students <- as.data.table(students) +students # regardez la différence à l'impression +# => +# name year house +# 1: Cedric 3 H +# 2: Fred 2 G +# 3: George 2 G +# 4: Cho 1 R +# 5: Draco 0 S +# 6: Ginny -1 G +students[name=="Ginny"] # obtiens les lignes avec name == "Ginny" +# => +# name year house +# 1: Ginny -1 G +students[year==2] # obtiens les lignes avec year == 2 +# => +# name year house +# 1: Fred 2 G +# 2: George 2 G +# data.table facilite la fusion entre deux ensembles de données +# Faisons une autre data.table pour fusionner students +founders <- data.table(house=c("G","H","R","S"), + founder=c("Godric","Helga","Rowena","Salazar")) +founders +# => +# house founder +# 1: G Godric +# 2: H Helga +# 3: R Rowena +# 4: S Salazar +setkey(students, house) +setkey(founders, house) +students <- founders[students] # merge les deux ensembles de données qui matchent "house" +setnames(students, c("house","houseFounderName","studentName","year")) +students[,order(c("name","year","house","houseFounderName")), with=F] +# => +# studentName year house houseFounderName +# 1: Fred 2 G Godric +# 2: George 2 G Godric +# 3: Ginny -1 G Godric +# 4: Cedric 3 H Helga +# 5: Cho 1 R Rowena +# 6: Draco 0 S Salazar + +# data.table facilite le résumé des tableaux +students[,sum(year),by=house] +# => +# house V1 +# 1: G 3 +# 2: H 3 +# 3: R 1 +# 4: S 0 + +# Pour supprimer une colonne d'une data.frame ou data.table, +# assignez-lui la valeur NULL +students$houseFounderName <- NULL +students +# => +# studentName year house +# 1: Fred 2 G +# 2: George 2 G +# 3: Ginny -1 G +# 4: Cedric 3 H +# 5: Cho 1 R +# 6: Draco 0 S + +# Supprimer une ligne en subdivisant +# En utilisant data.table : +students[studentName != "Draco"] +# => +# house studentName year +# 1: G Fred 2 +# 2: G George 2 +# 3: G Ginny -1 +# 4: H Cedric 3 +# 5: R Cho 1 +# En utilisant data.frame : +students <- as.data.frame(students) +students[students$house != "G",] +# => +# house houseFounderName studentName year +# 4 H Helga Cedric 3 +# 5 R Rowena Cho 1 +# 6 S Salazar Draco 0 + +# MULTI-DIMENSIONNELLE (TOUS ÉLÉMENTS D'UN TYPE) + +# Les arrays créent des tableaux de n dimensions. +# Tous les éléments doivent être du même type. +# Vous pouvez faire un tableau à 2 dimensions (une sorte de matrice) +array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4)) +# => +# [,1] [,2] [,3] [,4] +# [1,] 1 4 8 3 +# [2,] 2 5 9 6 +# Vous pouvez aussi utiliser array pour faire des matrices à 3 dimensions : +array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2)) +# => +# , , 1 +# +# [,1] [,2] +# [1,] 2 8 +# [2,] 300 9 +# [3,] 4 0 +# +# , , 2 +# +# [,1] [,2] +# [1,] 5 66 +# [2,] 60 7 +# [3,] 0 847 + +# LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES, +# DE DIFFÉRENTS TYPES) + +# Enfin, R a des listes (de vecteurs) +list1 <- list(time = 1:40) +list1$price = c(rnorm(40,.5*list1$time,4)) # random +list1 +# Vous pouvez obtenir des éléments de la liste comme ceci +list1$time # une façon +list1[["time"]] # une autre façon +list1[[1]] # encore une façon différente +# => +# [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 +# [34] 34 35 36 37 38 39 40 +# Vous pouvez subdiviser les éléments d'une liste comme n'importe quel vecteur +list1$price[4] + +# Les listes ne sont pas les structures de données les plus efficaces +# à utiliser avec R ; +# À moins d'avoir une très bonne raison, vous devriez utiliser data.frames +# Les listes sont souvent retournées par des fonctions qui effectuent +# des régressions linéaires. + +########################################## +# La famille de fonction apply() +########################################## + +# Vous vous rappelez mat ? +mat +# => +# [,1] [,2] +# [1,] 1 4 +# [2,] 2 5 +# [3,] 3 6 +# Utilisez apply(X, MARGIN, FUN) pour appliquer la fonction FUN à la matrice X +# sur les lignes (MAR = 1) ou les colonnes (MAR = 2) +# R exécute FUN à chaque lignes (ou colonnes) de X, beaucoup plus rapidement +# que le ferait une boucle for ou while +apply(mat, MAR = 2, jiggle) +# => +# [,1] [,2] +# [1,] 3 15 +# [2,] 7 19 +# [3,] 11 23 +# D'autres fonctions : ?lapply, ?sapply + +# Ne soyez pas trop intimidé ; tout le monde reconnaît que c'est un peu déroutant + +# Le paquet plyr vise à remplacer (et améliorer !) la famille *apply(). +install.packages("plyr") +require(plyr) +?plyr + + + +############################ +# Charger des données +############################ + +# "pets.csv" est un fichier sur internet +# (mais il pourrait être tout aussi facilement sur votre ordinateur) +pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv") +pets +head(pets, 2) # first two rows +tail(pets, 1) # last row + +# Pour sauvegarder une data frame ou une matrice en fichier .csv +write.csv(pets, "pets2.csv") # to make a new .csv file +# définir le répertoire de travail avec setwd(), le récupérer avec getwd() + +# Essayez ?read.csv et ?write.csv pour plus d'informations + + + +################ +# Les tracés +################ + +# LES FONCTIONS DE TRACÉ PRÉCONSTRUITES +# Les diagrammes de dispersion ! +plot(list1$time, list1$price, main = "fake data") +# Les régressions ! +linearModel <- lm(price ~ time, data = list1) +linearModel # sort le résultat de la régression +# Tracer une ligne de regression sur une tracé existant +abline(linearModel, col = "red") +# Obtenir une variété de diagnostiques sympas +plot(linearModel) +# Les histogrammes ! +hist(rpois(n = 10000, lambda = 5), col = "thistle") +# Les diagrammes en bâtons ! +barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow")) + +# GGPLOT2 +# Mais ceux-ci ne sont même pas les plus jolis tracés de R +# Essayez le paquet ggplot2 pour d'avantages de graphiques +install.packages("ggplot2") +require(ggplot2) +?ggplot2 +pp <- ggplot(students, aes(x=house)) +pp + geom_histogram() +ll <- as.data.table(list1) +pp <- ggplot(ll, aes(x=time,price)) +pp + geom_point() +# ggplot2 a une documentation excellente +#(disponible sur http://docs.ggplot2.org/current/) + + + +``` + +## Comment obtenir R ? + +* Obtiens R et R GUI depuis [http://www.r-project.org/](http://www.r-project.org/) +* [RStudio](http://www.rstudio.com/ide/) est un autre GUI diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown index 3060bd75..1564d2b6 100644 --- a/fr-fr/ruby-fr.html.markdown +++ b/fr-fr/ruby-fr.html.markdown @@ -268,7 +268,7 @@ end # implicitement la valeur de la dernière instruction évaluée double(2) #=> 4 -# Les paranthèses sont facultative +# Les parenthèses sont facultatives # lorsqu'il n'y a pas d'ambiguïté sur le résultat double 3 #=> 6 @@ -336,8 +336,8 @@ class Humain puts "#{msg}" end - def species - @@species + def espece + @@espece end end diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown index da562138..a43edf16 100644 --- a/fr-fr/scala.html.markdown +++ b/fr-fr/scala.html.markdown @@ -1,12 +1,11 @@ --- language: Scala -filename: learnscala.scala contributors: - ["George Petrov", "http://github.com/petrovg"] - ["Dominic Bou-Samra", "http://dbousamra.github.com"] translators: - - ["Anne-Catherine Dehier", "https://github.com/spellart"] -filename: learn.scala + - ["Anne-Catherine Dehier", "https://github.com/spellart"] +filename: learnscala-fr.scala lang: fr-fr --- diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown new file mode 100644 index 00000000..b8807104 --- /dev/null +++ b/fr-fr/typescript-fr.html.markdown @@ -0,0 +1,174 @@ +--- +language: TypeScript +contributors: + - ["Philippe Vlérick", "https://github.com/pvlerick"] +translators: + - ["Alois de Gouvello", "https://github.com/aloisdg"] +filename: learntypescript-fr.ts +lang: fr-fr +--- + +TypeScript est un langage visant à faciliter le développement d'applications larges et scalables, écrites en JavaScript. +TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionnel) à JavaScript. +C'est une surcouche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur. + +Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/). + +Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et accéder directement au rendu JavaScript. + +```js +// Il y a 3 types basiques en TypeScript +var isDone: boolean = false; +var lines: number = 42; +var name: string = "Anders"; + +// Si nous ne pouvons pas déterminer le type, on utilise `Any` +var notSure: any = 4; +notSure = "maybe a string instead"; +notSure = false; // ok, définitivement un booléen + +// Pour les collections, il y a les tableaux typés et les tableaux génériques +var list: number[] = [1, 2, 3]; // Un tableaux typé +var list: Array<number> = [1, 2, 3]; // un tableau générique + +// Pour les énumeration +enum Color { Red, Green, Blue }; +var c: Color = Color.Green; + +// Enfin, `void` est utilisé dans le cas spécifique +// d'une fonction ne retournant rien +function bigHorribleAlert(): void { + alert("Je suis une petite boîte ennuyeuse !"); +} + +// Les fonctions sont des entités de première classe. Le langage supporte +// les expressions lambda et utilise l'inférence de type + +// Les fonctions ci-dessous sont équivalentes, une signature identique +// sera inférée par le compilateur, et le même JavaScript sera généré +var f1 = function(i: number): number { return i * i; } +// Retourne un type inféré +var f2 = function(i: number) { return i * i; } +var f3 = (i: number): number => { return i * i; } +// Retourne un type inféré +var f4 = (i: number) => { return i * i; } +// Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire +var f5 = (i: number) => i * i; + +// Les interfaces sont structurées, tout les objets qui ont ces propriétés +// sont compatible avec l'interface +interface Person { + name: string; + // Les propriétés optionnelles sont identifiées avec un "?" + age?: number; + // Et bien sûr, les fonctions + move(): void; +} + +// Un objet implémentant l'interface "Person" peut être traité comme +// une Person car il a les propriétés "name" et "move" +var p: Person = { name: "Bobby", move: () => {} }; +// Des objets implémentants la propriété optionnelle : +// valide car "age" est un nombre +var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; +// invalide car "age" n'est pas un nombre +var invalidPerson: Person = { name: "Bobby", age: true }; + +// Les interfaces peuvent aussi décrire un type de fonction +interface SearchFunc { + (source: string, subString: string): boolean; +} + +// Seul les types des paramètres sont importants. Les noms ne le sont pas. +var mySearch: SearchFunc; +mySearch = function(src: string, sub: string) { + return src.search(sub) != -1; +} + +// Les membres des classes sont publiques par défaut. +class Point { + // Propriétés + x: number; + + // Constructeur - Les mots clés "public" et "private" dans ce contexte + // génèrent le code de la propriété et son initialisation dans le + // constructeur. Ici, "y" sera défini de la même façon que "x", + // mais avec moins de code. Les valeurs par défaut sont supportées. + constructor(x: number, public y: number = 0) { + this.x = x; + } + + // Fonctions + dist() { return Math.sqrt(this.x * this.x + this.y * this.y); } + + // Membres statiques + static origin = new Point(0, 0); +} + +var p1 = new Point(10 ,20); +var p2 = new Point(25); // y sera 0 + +// Héritage +class Point3D extends Point { + constructor(x: number, y: number, public z: number = 0) { + // Un appel explicite au constructeur de la super classe + // est obligatoire. + super(x, y); + } + + // Redéfinition + dist() { + var d = super.dist(); + return Math.sqrt(d * d + this.z * this.z); + } +} + +// Modules, "." peut être utilisé comme un séparateur de sous modules. +module Geometry { + export class Square { + constructor(public sideLength: number = 0) { + } + area() { + return Math.pow(this.sideLength, 2); + } + } +} + +var s1 = new Geometry.Square(5); + +// Alias local pour référencer un module +import G = Geometry; + +var s2 = new G.Square(10); + +// Génériques +// Classes +class Tuple<T1, T2> { + constructor(public item1: T1, public item2: T2) { + } +} + +// Interfaces +interface Pair<T> { + item1: T; + item2: T; +} + +// Et fonctions +var pairToTuple = function<T>(p: Pair<T>) { + return new Tuple(p.item1, p.item2); +}; + +var tuple = pairToTuple({ item1:"hello", item2:"world"}); + +// Inclure des références à un fichier : +/// <reference path="jquery.d.ts" /> + +``` + +## Lectures complémentaires + * [Site officiel de TypeScript] (http://www.typescriptlang.org/) + * [Spécification du langage TypeScript (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238) + * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript) + * [Code source sur GitHub] (https://github.com/Microsoft/TypeScript) + * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/) diff --git a/fr-fr/xml-fr.html.markdown b/fr-fr/xml-fr.html.markdown new file mode 100644 index 00000000..ed5f55ff --- /dev/null +++ b/fr-fr/xml-fr.html.markdown @@ -0,0 +1,128 @@ +--- +language: xml +contributors: + - ["João Farias", "https://github.com/JoaoGFarias"] +translators: + - ["Geoffrey Liu", "https://github.com/g-liu"] +filename: learnxml-fr.xml +lang: fr-fr +--- + +XML est un langage de balisage conçu pour stocker et transporter les informations. + +Contrairement à HTML, XML ne spécifie pas comment afficher ou formater les informations, juste comment les porter. + +* La syntaxe XML + +```xml +<!-- Les commentaires en XML ressemblent ceci --> + +<?xml version="1.0" encoding="UTF-8"?> +<librairie> + <livre categorie="CUISINE"> + <titre lang="en">Everyday Italian</titre> + <auteur>Giada De Laurentiis</auteur> + <an>2005</an> + <prix>30.00</prix> + </livre> + <livre categorie="ENFANTS"> + <titre lang="en">Harry Potter</titre> + <auteur>J. K. Rowling</auteur> + <an>2005</an> + <prix>29.99</prix> + </livre> + <livre categorie="WEB"> + <titre lang="en">Learning XML</titre> + <auteur>Erik T. Ray</auteur> + <an>2003</an> + <prix>39.95</prix> + </livre> +</librairie> + +<!-- Ce qui suit est un fichier XML typique. + Il commence par une déclaration, qui informe certaines métadonnées (en option). + +XML utilise une structure arborescente. Ci-dessus, le nœud racine est «librairie», qui a + trois nœuds enfants, qui sont appelés «livres». Ces nœuds ont plus de nœuds enfants, et ainsi de suite ... + +On crée les nœuds avec des balises d'ouverture / fermeture, et les enfants sont les nœuds juste entre + les balises d'ouverture et de fermeture. --> + + +<!-- XML porte deux types d'informations: + 1 - Les attributs -> les métadonnées sur un nœud. + Habituellement, l'analyseur XML utilise cette information pour bien stocker les données. + 2 - Les éléments -> les informations pures. + C'est ce que l'analyseur retrouvera du fichier XML. + Les éléments apparaissent entre les balises d'ouverture et de fermeture, sans parenthèses. --> + + +<!-- Ci-dessous, un élément avec deux attributs --> +<fichier type="gif" id="4293">ordinateur.gif</fichier> + + +``` + +* Un document bien formaté & le validation + +Un document XML est bien formaté s'il est syntaxiquement correct. +Cependant, il est possible d'injecter plus de contraintes dans le document, +en utilisant les définitions de documents, tels que les schémas DTD et XML. + +Un document XML qui suit une définition de document est dit valide, +en ce qui concerne ce document. + +Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique de l'application. + +```xml + +<!-- Ci-dessous, vous pouvez voir une version simplifiée du document de librairie, + avec l'addition de définition DTD. --> + +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE note SYSTEM "Librairie.dtd"> +<librairie> + <livre categorie="CUISINE"> + <titre>Everyday Italian</titre> + <prix>30.00</prix> + </livre> +</librairie> + +<!-- Cette DTD pourrait être quelque chose comme: --> + +<!DOCTYPE note +[ +<!ELEMENT librairie (livre+)> +<!ELEMENT livre (titre,prix)> +<!ATTLIST livre categorie CDATA "Littérature"> +<!ELEMENT titre (#PCDATA)> +<!ELEMENT prix (#PCDATA)> +]> + +<!-- La DTD commence par une déclaration. + Après, le nœud racine est déclaré, qui exige un ou plusieurs nœuds enfants. + Chaque «livre» doit contenir exactement un «titre» et «prix» et un attribut + appelé «catégorie», avec «littérature» comme valeur par défaut. + Les nœuds de «titre» et «prix» contiennent des informations de caractère analysés + (Anglais: «parsed character data») --> + +<!-- La DTD pourrait être déclarée dans le fichier XML lui-même --> + +<?xml version="1.0" encoding="UTF-8"?> + +<!DOCTYPE note +[ +<!ELEMENT librairie (livre+)> +<!ELEMENT livre (titre,prix)> +<!ATTLIST livre categorie CDATA "Littérature"> +<!ELEMENT titre (#PCDATA)> +<!ELEMENT prix (#PCDATA)> +]> + +<librairie> + <livre categorie="CUISINE"> + <titre>Everyday Italian</titre> + <prix>30.00</prix> + </livre> +</librairie> +``` diff --git a/fr-fr/yaml-fr.html.markdown b/fr-fr/yaml-fr.html.markdown new file mode 100644 index 00000000..43b1df54 --- /dev/null +++ b/fr-fr/yaml-fr.html.markdown @@ -0,0 +1,157 @@ +--- +language: yaml +filename: learnyaml.yaml +contributors: + - ["Andrei Curelaru", "http://www.infinidad.fr"] +lang: fr-fr +--- + +Proposé à l'origine par Clark Evans en Mai 2001, YAML est un un format de +représentation de données par sérialisation, conçu pour être aisément +éditable et lisible par nous même, les humains. + +YAML est plus concis que le XML auquel il est parfois comparé par ceux qui le découvre, plus lisible et clair que le CSV, et emprunte beaucoup au JSON dont il est un parent naturel. Toutefois, YAML emprunte également des idées et concepts de chez Python, et s'intègre bien avec bon nombre de langages. + + +```yaml +# les Commentaires sont précédés d'un signe "#", comme cette ligne. + +############# +# SCALAIRES # +############# + +# Les scalaires sont l'ensemble des types YAML qui ne sont pas des collections +# ( listes ou tableaux associatifs ). + +# Notre objet root ( racine ), sera une map ( carte ) et englobera +# l'intégralité du document. Cette map est l'équivalent d'un dictionnaire, +# hash ou objet dans d'autres langages. +clé: valeur +aurtre_clé: une autre valeur +valeur_numérique: 100 +notation_scientifique: 1e+12 +boolean: true +valeur_null: null +clé avec espaces: valeur +# Bien qu'il ne soit pas nécessaire d'enfermer les chaînes de caractères +# entre guillemets, cela reste possible, et parfois utile. +toutefois: "Une chaîne, peut être contenue entre guillemets." +"Une clé entre guillemets.": "Utile si on veut utiliser ':' dans la clé." + +# Les chaînes couvrant plusieurs lignes, peuvent être écrites au choix, +# comme un 'bloc littéral' ( avec | ) ou bien 'bloc replié' avec ( > ). +bloc_littéral: | + Tout ce bloc de texte sera la valeur de la clé 'bloc_littéral', + avec préservation des retours à la ligne. ( chaque ligne vide à + l'intérieur du même bloc, sera remplacée par "\n\n" ) + + Le littéral continue jusqu'à ce que l'indentation soit annulée. + + Toutes lignes qui serait "d'avantage indentées" conservent leur + indentation, constituée de 4 espaces. +bloc_replié: > + Tout ce bloc de texte sera la valeur de la clé 'bloc_replié', mais + cette fois ci, toutes les nouvelles lignes deviendront un simple espace. + + Les lignes vides, comme ci-dessus, seront converties en caractère "\n". + + Les lignes 'plus-indentées' gardent leurs retours à la ligne - + ce texte apparaîtra sur deux lignes. + +############### +# COLLECTIONS # +############### + +# l'Imbrication est créée par indentation. +une_map_imbriquée: + clé: valeur + autre_clé: autre valeur + autre_map_imbriquée: + bonjour: bonjour + +# les Clés des Maps ne sont pas nécessairement des chaînes de caractères. +0.25: une clé de type float + +# les Clés peuvent également être des objets s'étendant sur plusieurs lignes, +# en utilisant le signe "?" pour indiquer le début de la clé. +? | + ceci est une Clé + sur de multiples lignes +: et ceci est sa Valeur + +# YAML autorise aussi l'usage des collections à l'intérieur des clés, +# mais certains langages de programmation ne le tolère pas si bien. + +# les Séquences (équivalent des listes ou tableaux) ressemblent à cela: +une_séquence: + - Item 1 + - Item 2 + - 0.5 # les séquences peuvent contenir des types variés. + - Item 4 + - clé: valeur + autre_clé: autre_valeur + - + - Ceci est une séquence + - dans une autre séquence + +# YAML étant un proche parent de JSON, vous pouvez écrire directement +# des maps et séquences façon JSON +json_map: {"clé": "valeur"} +json_seq: [1, 2, 3, "soleil"] + +################################# +# AUTRES FONCTIONNALITÉES YAML # +################################# + +# YAML possède une fonctionnalité fort utile nommée 'ancres'. Celle-ci +# vous permet de dupliquer aisément du contenu au sein de votre document. + +# Les deux clés suivantes auront la même valeur: +contenu_ancré: &nom_ancre Cette chaîne sera la valeur des deux clés. +autre_ancre: *nom_ancre + +# Avec les Tags YAML, vous pouvez explicitement déclarer des types de données. +chaine_explicite: !!str 0.5 + +# Certains parsers implémentent des tags spécifiques à d'autres langages, +# comme par exemple le "complex number" de Python. +python_complex_number: !!python/complex 1+2j + +##################### +# AUTRES TYPES YAML # +##################### + +# YAML interprète également les données formatées ISO de type date et datetime, +# pas seulement les chaînes et nombres. +datetime: 2001-12-15T02:59:43.1Z +datetime_avec_espaces: 2001-12-14 21:59:43.10 -5 +date: 2002-12-14 + +# Le tag !!binary indique que la chaîne à suivre est la représentation binaire +# d'un blob encodé en base64. En clair ? Une image ! +fichier_gif: !!binary | + R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5 + OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+ + +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC + AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs= + +# YAML a de même un type "set", qui ressemble à cela: +set: + ? item1 + ? item2 + ? item3 + +# Comme dans Python, les sets ne sont que des maps contenant des valeurs null ; +# le set précédent est l'équivalent du suivant: +set2: + item1: null + item2: null + item3: null + +``` + +Quelques références et outils : + +- Doc officielle [YAML 1.2](http://www.yaml.org/spec/1.2/spec.html) *anglais*, +- Une [Introduction à YAML](http://sweetohm.net/html/introduction-yaml.html) très bien construite et claire, +- Un outil pour tester [live](http://yaml-online-parser.appspot.com/) la syntaxe YAML, avec des exemples. |