Updating French translation

Thanks vendethiel for all the suggestions!
This commit is contained in:
Jean-Philippe Monette 2015-03-17 23:17:50 +00:00
parent 290c0956d0
commit 9922336a9d

View File

@ -2,7 +2,7 @@
name: Go name: Go
category: language category: language
language: Go language: Go
filename: learngo-fr.go filename: learngo.go
contributors: contributors:
- ["Sonia Keys", "https://github.com/soniakeys"] - ["Sonia Keys", "https://github.com/soniakeys"]
- ["Christopher Bess", "https://github.com/cbess"] - ["Christopher Bess", "https://github.com/cbess"]
@ -10,21 +10,19 @@ contributors:
- ["Quint Guvernator", "https://github.com/qguv"] - ["Quint Guvernator", "https://github.com/qguv"]
- ["Jose Donizetti", "https://github.com/josedonizetti"] - ["Jose Donizetti", "https://github.com/josedonizetti"]
- ["Alexej Friesen", "https://github.com/heyalexej"] - ["Alexej Friesen", "https://github.com/heyalexej"]
translators:
- ["Jean-Philippe Monette", "http://blogue.jpmonette.net/"] - ["Jean-Philippe Monette", "http://blogue.jpmonette.net/"]
lang: fr-fr
--- ---
Go a été créé dans l'optique de déveloper de façcon efficace. Ce n'est pas la 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 au développement, mais c'est la nouvelle façon de dernière tendance en ce qui est au développement, mais c'est la nouvelle façon
régler des défis réels de façcon rapide. de régler des défis réels de façon rapide.
Le langage possède des concepts familiers à la programmation impérative avec Le langage possède des concepts familiers à la programmation impérative avec
typage. Il est rapide à compiler et exécuter, ajoute une concurrence facile à typage. Il est rapide à compiler et exécuter, ajoute une concurrence facile à
comprendre pour les processeurs multi coeurs d'aujourd'hui et apporte des comprendre, pour les processeurs multi coeurs d'aujourd'hui et apporte des
fonctionnalités facilitant le développement à grande échelle. fonctionnalités facilitant le développement à grande échelle.
Développer avec Go, c'est bénéficier d'une riche librairie standard et d'une Développer avec Go, c'est bénéficier d'une riche bibliothèque standard et d'une
communauté active. communauté active.
```go ```go
@ -34,22 +32,22 @@ communauté active.
// Un paquet débute avec une clause "package" // Un paquet débute avec une clause "package"
// "Main" est un nom spécial déclarant un paquet de type exécutable plutôt // "Main" est un nom spécial déclarant un paquet de type exécutable plutôt
// qu'une librairie // qu'une bibliothèque
package main package main
// "Import" déclare les paquets référencés dans ce fichier. // "Import" déclare les paquets référencés dans ce fichier.
import ( import (
"fmt" // Un paquet dans la librairie standard. "fmt" // Un paquet dans la bibliothèque standard.
"io/ioutil" // Implémente des fonctions utilitaires I/O. "io/ioutil" // Implémente des fonctions utilitaires I/O.
m "math" // Librairie mathématique utilisant un alias local "m". m "math" // Bibliothèque mathématique utilisant un alias local "m".
"net/http" // Un serveur Web! "net/http" // Un serveur Web!
"strconv" // Librairie pour convertir les chaînes de caractères. "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 // Une définition de fonction. La fonction "main" est spéciale - c'est le point
// d'entrée du binaire. Celle-ci est encapsulée par des accolades. // d'entrée du binaire.
func main() { func main() {
// Println retourne une ligne à stdout. // Println retournera la valeur à la console.
// Associez la fonction avec son paquet respectif, fmt. // Associez la fonction avec son paquet respectif, fmt.
fmt.Println("Hello world!") fmt.Println("Hello world!")
@ -78,7 +76,7 @@ func learnMultiple(x, y int) (sum, prod int) {
// Quelques types inclus et littéraux. // Quelques types inclus et littéraux.
func learnTypes() { func learnTypes() {
// Déclaration courte produit généralement le type désiré. // Une déclaration courte infère généralement le type désiré.
str := "Learn Go!" // Type string. str := "Learn Go!" // Type string.
s2 := `Une chaîne de caractères peut contenir des s2 := `Une chaîne de caractères peut contenir des
@ -89,7 +87,7 @@ sauts de ligne.` // Chaîne de caractère.
// unicode. // unicode.
f := 3.14195 // float64, un nombre flottant IEEE-754 de 64-bit. f := 3.14195 // float64, un nombre flottant IEEE-754 de 64-bit.
c := 3 + 4i // complex128, représenté à l'interne par deux float64. c := 3 + 4i // complex128, considéré comme deux float64 par le compilateur.
// Syntaxe "var" avec une valeur d'initialisation. // Syntaxe "var" avec une valeur d'initialisation.
var u uint = 7 // Non signé, mais la taille dépend selon l'entier. var u uint = 7 // Non signé, mais la taille dépend selon l'entier.
@ -98,13 +96,13 @@ sauts de ligne.` // Chaîne de caractère.
// Conversion avec syntaxe courte. // Conversion avec syntaxe courte.
n := byte('\n') // byte est un alias du type uint8. n := byte('\n') // byte est un alias du type uint8.
// Les tableaux ont des tailles fixes à la compilation. // Les tableaux ont une taille fixe déclarée à la compilation.
var a4 [4]int // Un tableau de 4 ints, tous initialisés à 0. 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 a3 := [...]int{3, 1, 5} // Un tableau initialisé avec une taille fixe de 3
// éléments, contenant les valeurs 3, 1 et 5. // éléments, contenant les valeurs 3, 1 et 5.
// Les slices ont des tailles dynamiques. Les tableaux et slices ont chacun // Les slices ont des tailles dynamiques. Les tableaux et slices ont chacun
// des avantages, mais les usages des slices sont plus communs. // des avantages, mais les cas d'utilisation des slices sont plus fréquents.
s3 := []int{4, 5, 9} // Comparable à a3. s3 := []int{4, 5, 9} // Comparable à a3.
s4 := make([]int, 4) // Alloue un slice de 4 ints, initialisés à 0. s4 := make([]int, 4) // Alloue un slice de 4 ints, initialisés à 0.
var d2 [][]float64 // Déclaration seulement, sans allocation de mémoire. var d2 [][]float64 // Déclaration seulement, sans allocation de mémoire.
@ -116,11 +114,11 @@ sauts de ligne.` // Chaîne de caractère.
// la variable tableau est mise à jour sur place, voir ci-bas. // 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 := []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. s = append(s, 4, 5, 6) // Ajout de 3 valeurs. La taille est de 6.
fmt.Println(s) // La valeur est maintenant de [1 2 3 4 5 6] fmt.Println(s) // La valeur est de [1 2 3 4 5 6]
// Pour ajouter une autre slice, au lieu d'utiliser une liste de valeurs
// 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 // atomiques, il est possible de mettre en argument une référence de
// slice littérale de cette façon, avec des points de suspension, signifiant // slice littérale grâce aux points de suspension.
// qu'il faut prendre les éléments de la slice et les ajouter à la slice s.
s = append(s, []int{7, 8, 9}...) // Le deuxième argument est une slice s = append(s, []int{7, 8, 9}...) // Le deuxième argument est une slice
// littérale. // littérale.
fmt.Println(s) // La slice contient [1 2 3 4 5 6 7 8 9] fmt.Println(s) // La slice contient [1 2 3 4 5 6 7 8 9]
@ -133,17 +131,19 @@ sauts de ligne.` // Chaîne de caractère.
m := map[string]int{"trois": 3, "quatre": 4} m := map[string]int{"trois": 3, "quatre": 4}
m["un"] = 1 m["un"] = 1
// Les valeurs inutilisées sont des erreurs en Go. // Les valeurs inutilisées sont considérées comme des erreurs en Go.
// Un tiret bas permet d'utiliser une variable, mais d'en jeter la valeur. // Un tiret bas permet d'ignorer une valeur inutilisée, évitant une erreur.
_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
// L'affichage est considéré comme une utilisation de la variable.
// 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) fmt.Println(s, c, a4, s3, d2, m)
learnFlowControl() // De retour dans le flux. learnFlowControl() // De retour dans le flux.
} }
// Il est possible, à l'opposée de plusieurs autres langages, à des fonctions // Il est possible, à l'opposé de plusieurs autres langages, de retourner des
// en go d'avoir des valeurs retournées avec nom. // variables par leur nom à partir de fonctions.
// Assigner un nom à un type retourné par une fonction permet de retrouver sa // 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. // valeur ainsi que d'utiliser le mot-clé "return" uniquement, sans plus.
func learnNamedReturns(x, y int) (z int) { func learnNamedReturns(x, y int) (z int) {
@ -152,10 +152,11 @@ func learnNamedReturns(x, y int) (z int) {
} }
// La récupération de la mémoire est automatique en Go. Le langage possède des // La récupération de la mémoire est automatique en Go. Le langage possède des
// pointeurs, mais aucun pointeur arithmétique. Vous pouvez faire une erreur // pointeurs, mais aucune arithmétique des pointeurs (*(a + b) en C). Vous
// avec un pointeur nil, mais pas en incrémentant un pointeur. // pouvez produire une erreur avec un pointeur nil, mais pas en incrémentant un
// pointeur.
func learnMemory() (p, q *int) { func learnMemory() (p, q *int) {
// Les valeurs retournées définies p et q ont le type pointeur int. // Les valeurs retournées p et q auront le type pointeur int.
p = new(int) // Fonction standard "new" alloue la mémoire. p = new(int) // Fonction standard "new" alloue la mémoire.
// Le int alloué est initialisé à 0, p n'est plus nil. // 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 := make([]int, 20) // Alloue 20 ints en un seul bloc de mémoire.
@ -169,11 +170,12 @@ func expensiveComputation() float64 {
} }
func learnFlowControl() { func learnFlowControl() {
// Bien que les "if" requiert des accolades, les parenthèses ne le sont pas. // Bien que les "if" requièrent des accolades, les parenthèses ne sont pas
// nécessaires pour contenir le test booléen.
if true { if true {
fmt.Println("voilà!") fmt.Println("voilà!")
} }
// Le formate est standardisé par la commande shell "go fmt." // Le formatage du code est standardisé par la commande shell "go fmt."
if false { if false {
// bing. // bing.
} else { } else {
@ -189,8 +191,9 @@ func learnFlowControl() {
case 43: case 43:
// Non-exécuté. // Non-exécuté.
} }
// Comme les "if", "for" n'utilise pas de parenthèses. // Comme les "if", les "for" n'utilisent pas de parenthèses.
// Les variables déclarées dans "for" et "if" sont locales à leur portée. // 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. for x := 0; x < 3; x++ { // ++ est une incrémentation.
fmt.Println("itération ", x) fmt.Println("itération ", x)
} }
@ -202,8 +205,8 @@ func learnFlowControl() {
continue // Non atteint. continue // Non atteint.
} }
// Vous pouvez utiliser un "range" pour itérer dans un tableau, une slice, une // Vous pouvez utiliser une "range" pour itérer dans un tableau, une slice, une
// chaîne, une map ou un channel. Les "range" retournent un canal ou deux // chaîne, une map ou un canal. Les "range" retournent un canal ou deux
// valeurs (tableau, slice, chaîne et map). // valeurs (tableau, slice, chaîne et map).
for key, value := range map[string]int{"une": 1, "deux": 2, "trois": 3} { 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é // pour chaque pair dans une map, affichage de la valeur et clé
@ -215,35 +218,35 @@ func learnFlowControl() {
if y := expensiveComputation(); y > x { if y := expensiveComputation(); y > x {
x = y x = y
} }
// Les fonctions littérales est une fermeture (closure). // Les fonctions littérales sont des fermetures.
xBig := func() bool { xBig := func() bool {
return x > 10000 // Réfère à la variable x déclarée en haut du "switch". return x > 10000
} }
fmt.Println("xBig:", xBig()) // true (la valeur e^10 a été assignée à x). fmt.Println("xBig:", xBig()) // true (la valeur e^10 a été assignée à x).
x = 1.3e3 // Ceci fait x == 1300 x = 1.3e3 // Ceci fait x == 1300
fmt.Println("xBig:", xBig()) // Maintenant false. fmt.Println("xBig:", xBig()) // Maintenant false.
// De plus, les fonctions littérales peuvent être définies et appelée // De plus, les fonctions littérales peuvent être définies et appelées
// sur la même ligne, agissant comme argument de fonctions, tant que: // sur la même ligne, agissant comme argument à cette fonction, tant que:
// a) la fonction littérale est appelée suite à (), // a) la fonction littérale est appelée suite à (),
// b) le résultat correspond au type de l'argument. // b) le résultat correspond au type de l'argument.
fmt.Println("Ajoute + multiplie deux nombres : ", fmt.Println("Ajoute + multiplie deux nombres : ",
func(a, b int) int { func(a, b int) int {
return (a + b) * 2 return (a + b) * 2
}(10, 2)) // Appelé avec les arguments 10 et 2 }(10, 2)) // Appelle la fonction avec les arguments 10 et 2
// => Ajoute + double deux nombres : 24 // => Ajoute + double deux nombres : 24
// Quand vous en aurez besoin, vous allez l'adorer. // Quand vous en aurez besoin, vous allez l'adorer.
goto love goto love
love: love:
learnFunctionFactory() // func retournant func correspond à fun(3)(3). learnFunctionFactory() // func retournant func correspondant à fun(3)(3).
learnDefer() // Un survol de cette instruction important. learnDefer() // Un survol de cette instruction importante.
learnInterfaces() // Incontournable ! learnInterfaces() // Incontournable !
} }
func learnFunctionFactory() { func learnFunctionFactory() {
// Les deux syntaxes sont identiques, bien que la seconde est plus pratique. // Les deux syntaxes sont identiques, bien que la seconde soit plus pratique.
fmt.Println(sentenceFactory("été")("Une matinée d'", "agréable!")) fmt.Println(sentenceFactory("été")("Une matinée d'", "agréable!"))
d := sentenceFactory("été") d := sentenceFactory("été")
@ -287,12 +290,12 @@ func (p pair) String() string { // p s'appelle le "destinataire"
} }
func learnInterfaces() { func learnInterfaces() {
// La syntaxe avec accolade défini une "structure littérale". Ceci s'évalue // La syntaxe avec accolade défini une "structure littérale". Celle-ci
// comme étant une strucutre. La syntaxe := déclare et initialise p comme // s'évalue comme étant une structure. La syntaxe := déclare et initialise p
// étant cette structure. // comme étant une instance.
p := pair{3, 4} p := pair{3, 4}
fmt.Println(p.String()) // Appelle la méthode String de p, de type pair. fmt.Println(p.String()) // Appelle la méthode String de p, de type pair.
var i Stringer // Déclare i de l'interface de type Stringer. var i Stringer // Déclare i instance de l'interface Stringer.
i = p // Valide, car pair implémente Stringer. i = p // Valide, car pair implémente Stringer.
// Appelle la méthode String de i, de type Stringer. Retourne la même valeur // Appelle la méthode String de i, de type Stringer. Retourne la même valeur
// que ci-haut. // que ci-haut.
@ -307,9 +310,11 @@ func learnInterfaces() {
learnVariadicParams("apprentissage", "génial", "ici!") learnVariadicParams("apprentissage", "génial", "ici!")
} }
// Les fonctions peuvent avoir des paramètres variables. // 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{}) { func learnVariadicParams(myStrings ...interface{}) {
// Itère chaque valeur du paramètre variable. // Itère chaque paramètre dans la range.
// Le tiret bas sert à ignorer l'index retourné du tableau. // Le tiret bas sert à ignorer l'index retourné du tableau.
for _, param := range myStrings { for _, param := range myStrings {
fmt.Println("paramètre:", param) fmt.Println("paramètre:", param)
@ -322,8 +327,8 @@ func learnVariadicParams(myStrings ...interface{}) {
} }
func learnErrorHandling() { func learnErrorHandling() {
// ", ok" expression utilisée pour définir si quelque chose a fonctionné ou // ", ok" idiome utilisée pour définir si l'opération s'est déroulée avec
// non. // succès ou non
m := map[int]string{3: "trois", 4: "quatre"} 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. if x, ok := m[1]; !ok { // ok sera faux, car 1 n'est pas dans la map.
fmt.Println("inexistant") fmt.Println("inexistant")
@ -336,14 +341,14 @@ func learnErrorHandling() {
// retourne: 'strconv.ParseInt: parsing "non-int": invalid syntax' // retourne: 'strconv.ParseInt: parsing "non-int": invalid syntax'
fmt.Println(err) fmt.Println(err)
} }
// Nous réviserons les interfaces un peu plus tard. Maintenant, // Nous réviserons les interfaces un peu plus tard. Pour l'instant,
learnConcurrency() learnConcurrency()
} }
// c est un canal, un objet permettant de communiquer en simultané de façon // c est un canal, un objet permettant de communiquer en simultané de façon
// sécuritaire. // sécurie.
func inc(i int, c chan int) { func inc(i int, c chan int) {
c <- i + 1 // <- est l'opérateur "destination" quand un canal apparaît à c <- i + 1 // <- est l'opérateur "envoi" quand un canal apparaît à
// gauche. // gauche.
} }
@ -355,7 +360,7 @@ func learnConcurrency() {
// Démarrage de trois goroutines simultanées. Les nombres seront incrémentés // 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 // simultanément, peut-être en paralèle si la machine le permet et configurée
// correctement. Les trois utilisent le même canal. // correctement. Les trois utilisent le même canal.
go inc(0, c) // go est une déclaration démarrant une nouvelle goroutine. go inc(0, c) // go est une instruction démarrant une nouvelle goroutine.
go inc(10, c) go inc(10, c)
go inc(-805, c) go inc(-805, c)
// Lis et affiche trois résultats du canal - impossible de savoir dans quel // Lis et affiche trois résultats du canal - impossible de savoir dans quel
@ -374,13 +379,13 @@ func learnConcurrency() {
select { select {
case i := <-c: // La valeur reçue peut être assignée à une variable, case i := <-c: // La valeur reçue peut être assignée à une variable,
fmt.Printf("c'est un %T", i) fmt.Printf("c'est un %T", i)
case <-cs: // ou la valeur reçue peut être discartée. case <-cs: // ou la valeur reçue peut être ignorée.
fmt.Println("c'est une chaîne") fmt.Println("c'est une chaîne")
case <-ccs: // Un canal vide, indisponible à la communication. case <-ccs: // Un canal vide, indisponible à la communication.
fmt.Println("ne surviendra pas.") fmt.Println("ne surviendra pas.")
} }
// À ce point, une valeur a été prise de c ou cs. L'une des deux goroutines // À ce point, une valeur a été prise de c ou cs. L'une des deux goroutines
// démarrée plus haut a complété, la seconde restera bloquée. // démarrée plus haut a complétée, la seconde restera bloquée.
learnWebProgramming() // Go permet la programmation Web. learnWebProgramming() // Go permet la programmation Web.
} }
@ -388,7 +393,7 @@ func learnConcurrency() {
// Une seule fonction du paquet http démarre un serveur Web. // Une seule fonction du paquet http démarre un serveur Web.
func learnWebProgramming() { func learnWebProgramming() {
// Le premier paramètre de ListenAndServe is une adresse TCP à écouter. // Le premier paramètre de ListenAndServe est une adresse TCP à écouter.
// Le second est une interface, de type http.Handler. // Le second est une interface, de type http.Handler.
go func() { go func() {
err := http.ListenAndServe(":8080", pair{}) err := http.ListenAndServe(":8080", pair{})
@ -398,7 +403,8 @@ func learnWebProgramming() {
requestServer() requestServer()
} }
// Fait de pair un http.Handler en implémentant sa seule méthode: ServeHTTP. // 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) { func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Répondez à une requête à l'aide de la méthode http.ResponseWriter. // Répondez à une requête à l'aide de la méthode http.ResponseWriter.
w.Write([]byte("Vous avez appris Go en Y minutes!")) w.Write([]byte("Vous avez appris Go en Y minutes!"))
@ -421,7 +427,7 @@ 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 Une lecture de la documentation du langage est grandement conseillée. C'est
facile à lire et très court (comparé aux autres langages). facile à lire et très court (comparé aux autres langages).
Vous pouvez exécuter 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. 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 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 librairie standard](http://golang.org/src/pkg/). Bien documentée, elle démontre