[livescript/fr] corrections

This commit is contained in:
Morgan 2015-07-08 13:41:15 +02:00
parent 93486c8e7a
commit 71cdcb3443

View File

@ -36,8 +36,8 @@ Vous pouvez contacter l'auteur du guide original en anglais ici :
```
```coffeescript
# LiveScript utilise l'indentation pour délimiter les blocs de code plutôt que
# les accolades, et les espaces pour appliquer les fonctions, plutôt que les
# parenthèses.
# les accolades, et les espaces pour appliquer les fonctions (bien que les
# parenthèses soient utilisables).
########################################################################
@ -52,7 +52,7 @@ void # comme `undefined` mais plus sûr (ne peut pas être redéfini)
null
# Les booléens se déclarent de la façon suivante:
# Les booléens s'utilisent de la façon suivante:
true
false
@ -144,6 +144,7 @@ funRE = //
# Les comparaisons sont presque identiques, à l'exception que `==` équivaut au
# `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la
# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes
# (sans conversion de type)
2 == 2 # => true
2 == "2" # => false
2 ~= "2" # => true
@ -180,27 +181,28 @@ not false # => true
add = (left, right) -> left + right
add 1, 2 # => 3
# Les fonctions qui ne prennent pas d'arguments sont appelées avec un point
# d'exclamation!
# Les fonctions qui ne prennent pas d'arguments peuvent être appelées avec un
# point d'exclamation!
two = -> 2
two!
# LiveScript utilise l'environnement de la fonction, comme JavaScript.
# A l'inverse de JavaScript, le `=` fonctionne comme un opérateur de
# déclaration, et il déclarera toujours la variable située à gauche.
# déclaration, et il déclarera toujours la variable située à gauche (sauf si
# la variable a été déclarée dans l'environnement parent).
# L'opérateur `:=` est disponible pour réutiliser un nom provenant de
# l'environnement parent.
# Vous pouvez "déballer" les arguments d'une fonction pour récupérer
# Vous pouvez extraire les arguments d'une fonction pour récupérer
# rapidement les valeurs qui vous intéressent dans une structure de données
# complexe:
tail = ([head, ...rest]) -> rest
tail [1, 2, 3] # => [2, 3]
# Vous pouvez également transformer les arguments en utilisant les opérateurs
# binaires. Définir des arguments par défaut est aussi possible.
# binaires et unaires. Définir des arguments par défaut est aussi possible.
foo = (a = 1, b = 2) -> a + b
foo! # => 3
@ -214,7 +216,7 @@ copy a, { b: 2 } # => { a: 1, b: 2 }
a # => { a: 1 }
# Une fonction peut être réduite en utilisant une longue flèche à la place
# Une fonction peut être curryfiée en utilisant une longue flèche à la place
# d'une courte:
add = (left, right) --> left + right
add1 = add 1
@ -227,14 +229,14 @@ identity 1 # => 1
# Les opérateurs ne sont pas des fonctions en LiveScript, mais vous pouvez
# facilement les transformer en fonction:
divide-by-two = (/ 2)
[2, 4, 8, 16].map(divide-by-two) .reduce (+)
[2, 4, 8, 16].map(divide-by-two).reduce (+)
# Comme dans tout bon langage fonctionnel, vous pouvez créer des fonctions
# composées d'autres fonctions:
double-minus-one = (- 1) . (* 2)
# En plus de la formule mathématique `f . g`, vous avez les opérateurs `>>`
# et `<<`, qui décrivent l'ordre d'application des fonctions.
# et `<<`, qui décrivent l'ordre d'application des fonctions composées.
double-minus-one = (* 2) >> (- 1)
double-minus-one = (- 1) << (* 2)
@ -244,22 +246,27 @@ double-minus-one = (- 1) << (* 2)
map = (f, xs) --> xs.map f
[1 2 3] |> map (* 2) # => [2 4 6]
# La version sans pipe correspont à:
((map (* 2)) [1, 2, 3])
# You pouvez aussi choisir où vous voulez que la valeur soit placée, en
# marquant la position avec un tiret bas (_):
reduce = (f, xs, initial) --> xs.reduce f, initial
[1 2 3] |> reduce (+), _, 0 # => 6
# Le tiret bas est également utilisé pour l'application régulière partielle,
# Le tiret bas est également utilisé pour l'application partielle,
# que vous pouvez utiliser pour toute fonction:
div = (left, right) -> left / right
div-by-two = div _, 2
div-by-two 4 # => 2
# Pour conclure, LiveScript vous permet d'utiliser les fonctions de rappel
# Pour conclure, LiveScript vous permet d'utiliser les fonctions de rappel.
# (mais vous devriez essayer des approches plus fonctionnelles, comme
# Promises):
# Promises).
# Un fonction de rappel est une fonction qui est passée en argument à une autre
# fonction:
readFile = (name, f) -> f name
a <- readFile 'foo'
b <- readFile 'bar'
@ -291,8 +298,8 @@ x = switch
# Le corps des fonctions, les déclarations et les assignements disposent d'un
# `switch` implicite, donc vous n'avez pas besoin de le réécrire:
take = (n, [x, ...xs]) -->
| n == 0 => []
| _ => [x] ++ take (n - 1), xs
| n == 0 => []
| _ => [x] ++ take (n - 1), xs
########################################################################
@ -307,8 +314,8 @@ evens = [x for x in oneToTwenty when x % 2 == 0]
# `when` et `unless` peuvent être utilisés comme des filtres.
# Cette technique fonctionne sur les objets de la même manière, via la syntaxe
# suivante:
# Cette technique fonctionne sur les objets de la même manière. Vous allez
# pouvoir générer l'ensemble de paires clé/valeur via la syntaxe suivante:
copy = { [k, v] for k, v of source }
@ -332,7 +339,7 @@ kitten = new Cat 'Mei'
kitten.purr! # => "*Mei (a cat) purrs*"
# En plus de l'héritage classique, vous pouvez utiliser autant de mixins
# que vous voulez pour votre classe. Les mixins sont justes des objets:
# que vous voulez pour votre classe. Les mixins sont juste des objets:
Huggable =
hug: -> @action 'is hugged'