mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 09:41:36 +00:00
[livescript/fr] initial commit
This commit is contained in:
Morgan
parent
6e34ebf88f
commit
6066176a9f
351
fr-fr/livescript-fr.html.markdown
Normal file
351
fr-fr/livescript-fr.html.markdown
Normal file
@ -0,0 +1,351 @@
|
||||
---
|
||||
language: LiveScript
|
||||
filename: learnLivescript-fr.ls
|
||||
contributors:
|
||||
- ["Christina Whyte", "http://github.com/kurisuwhyte/"]
|
||||
- ["Morgan Bohn", "https://github.com/morganbohn"]
|
||||
lang: fr-fr
|
||||
---
|
||||
|
||||
LiveScript est un langage qui se compile en JavaScript. Il a un rapport direct
|
||||
avec JavaScript, et vous permet d'écrire du JavaScript de façon considérables
|
||||
sans répétitivité. LiveScript ajoute non seulement des fonctionnalités pour
|
||||
écrire du code fonctionnel, mais possède aussi nombre d'améliorations pour la
|
||||
programmation orientée objet et la programmation impérative.
|
||||
|
||||
LiveScript est un descendant indirect de [CoffeeScript][], direct de [Coco][]
|
||||
avec beaucoup plus de compatibilité.
|
||||
|
||||
[Coco]: http://satyr.github.io/coco/
|
||||
[CoffeeScript]: http://coffeescript.org/
|
||||
|
||||
Vous pouvez contacter l'auteur du guide original en anglais ici :
|
||||
[@kurisuwhyte](https://twitter.com/kurisuwhyte)
|
||||
|
||||
|
||||
```coffeescript
|
||||
# Comme son cousin CoffeeScript, LiveScript utilise le symbole dièse pour les
|
||||
# commentaires sur une ligne.
|
||||
|
||||
/*
|
||||
Les commentaires sur plusieurs lignes utilisent la syntaxe du C. Utilisez-les
|
||||
si vous voulez préserver les commentaires dans la sortie JavaScript.
|
||||
*/
|
||||
```
|
||||
```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.
|
||||
|
||||
|
||||
########################################################################
|
||||
## 1. Valeurs basiques
|
||||
########################################################################
|
||||
|
||||
# Les valeurs non définies sont représentées par le mot clé `void` à la place de
|
||||
# `undefined`
|
||||
void # comme `undefined` mais plus sûr (ne peut pas être redéfini)
|
||||
|
||||
# Une valeur non valide est représentée par Null.
|
||||
null
|
||||
|
||||
|
||||
# Les booléens se déclarent de la façon suivante:
|
||||
true
|
||||
false
|
||||
|
||||
# Et il existe divers alias les représentant également:
|
||||
on; off
|
||||
yes; no
|
||||
|
||||
|
||||
# Puis viennent les nombres entiers et décimaux.
|
||||
10
|
||||
0.4 # Notez que le `0` est requis
|
||||
|
||||
# Dans un souci de lisibilité, vous pouvez utiliser les tirets bas et les
|
||||
# suffixes sur les nombres. Il seront ignorés à la compilation.
|
||||
12_344km
|
||||
|
||||
|
||||
# Les chaînes sont des séquences immutables de caractères, comme en JS:
|
||||
"Christina" # Les apostrophes fonctionnent également!
|
||||
"""Multi-line
|
||||
strings
|
||||
are
|
||||
okay
|
||||
too."""
|
||||
|
||||
# De temps à autre, vous voulez encoder un mot clé; la notation en backslash
|
||||
# rend cela facile:
|
||||
\keyword # => 'keyword'
|
||||
|
||||
|
||||
# Les tableaux sont des collections ordonnées de valeurs.
|
||||
fruits =
|
||||
* \apple
|
||||
* \orange
|
||||
* \pear
|
||||
|
||||
# Il peuvent être écrits de manière plus consises à l'aide des crochets:
|
||||
fruits = [ \apple, \orange, \pear ]
|
||||
|
||||
# Vous pouvez également utiliser la syntaxe suivante, à l'aide d'espaces, pour
|
||||
# créer votre liste de valeurs:
|
||||
fruits = <[ apple orange pear ]>
|
||||
|
||||
# Vous pouvez récupérer une entrée à l'aide de son index:
|
||||
fruits[0] # => "apple"
|
||||
|
||||
# Les objets sont une collection non ordonnées de paires clé/valeur, et
|
||||
# d'autres choses (que nous verrons plus tard).
|
||||
person =
|
||||
name: "Christina"
|
||||
likes:
|
||||
* "kittens"
|
||||
* "and other cute stuff"
|
||||
|
||||
# A nouveau, vous pouvez utiliser une expression plus consise à l'aide des
|
||||
# accolades:
|
||||
person = {name: "Christina", likes: ["kittens", "and other cute stuff"]}
|
||||
|
||||
# Vous pouvez récupérer une entrée via sa clé:
|
||||
person.name # => "Christina"
|
||||
person["name"] # => "Christina"
|
||||
|
||||
|
||||
# Les expressions régulières utilisent la même syntaxe que JavaScript:
|
||||
trailing-space = /\s$/ # les mots-composés deviennent motscomposés
|
||||
|
||||
# A l'exception que vous pouvez pouvez utiliser des expressions sur plusieurs
|
||||
# lignes!
|
||||
# (les commentaires et les espaces seront ignorés)
|
||||
funRE = //
|
||||
function\s+(.+) # nom
|
||||
\s* \((.*)\) \s* # arguments
|
||||
{ (.*) } # corps
|
||||
//
|
||||
|
||||
|
||||
########################################################################
|
||||
## 2. Les opérations basiques
|
||||
########################################################################
|
||||
|
||||
# Les opérateurs arithmétiques sont les mêmes que pour JavaScript:
|
||||
1 + 2 # => 3
|
||||
2 - 1 # => 1
|
||||
2 * 3 # => 6
|
||||
4 / 2 # => 2
|
||||
3 % 2 # => 1
|
||||
|
||||
|
||||
# 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
|
||||
2 == 2 # => true
|
||||
2 == "2" # => false
|
||||
2 ~= "2" # => true
|
||||
2 === "2" # => false
|
||||
|
||||
[1,2,3] == [1,2,3] # => false
|
||||
[1,2,3] === [1,2,3] # => true
|
||||
|
||||
+0 == -0 # => true
|
||||
+0 === -0 # => false
|
||||
|
||||
# Les opérateurs suivants sont également disponibles: <, <=, > et >=
|
||||
|
||||
# Les valeurs logiques peuvent être combinéees grâce aux opérateurs logiques
|
||||
# `or`, `and` et `not`
|
||||
true and false # => false
|
||||
false or true # => true
|
||||
not false # => true
|
||||
|
||||
|
||||
# Les collections ont également des opérateurs additionnels
|
||||
[1, 2] ++ [3, 4] # => [1, 2, 3, 4]
|
||||
'a' in <[ a b c ]> # => true
|
||||
'name' of { name: 'Chris' } # => true
|
||||
|
||||
|
||||
########################################################################
|
||||
## 3. Fonctions
|
||||
########################################################################
|
||||
|
||||
# Puisque LiveScript est fonctionnel, vous vous attendez à une bonne prise en
|
||||
# charge des fonctions. En LiveScript, il est encore plus évident que les
|
||||
# fonctions sont de premier ordre:
|
||||
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!
|
||||
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.
|
||||
|
||||
# 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
|
||||
# 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.
|
||||
foo = (a = 1, b = 2) -> a + b
|
||||
foo! # => 3
|
||||
|
||||
# You pouvez utiliser cela pour cloner un argument en particulier pour éviter
|
||||
# les effets secondaires. Par exemple:
|
||||
copy = (^^target, source) ->
|
||||
for k,v of source => target[k] = v
|
||||
target
|
||||
a = { a: 1 }
|
||||
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
|
||||
# d'une courte:
|
||||
add = (left, right) --> left + right
|
||||
add1 = add 1
|
||||
add1 2 # => 3
|
||||
|
||||
# Les fonctions ont un argument `it` implicite si vous n'en déclarez pas:
|
||||
identity = -> it
|
||||
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 (+)
|
||||
|
||||
# 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.
|
||||
double-minus-one = (* 2) >> (- 1)
|
||||
double-minus-one = (- 1) << (* 2)
|
||||
|
||||
|
||||
# Pour appliquer une valeur à une fonction, vous pouvez utiliser les opérateurs
|
||||
# `|>` et `<|`:
|
||||
map = (f, xs) --> xs.map f
|
||||
[1 2 3] |> map (* 2) # => [2 4 6]
|
||||
|
||||
# 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,
|
||||
# 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
|
||||
# (mais vous devriez essayer des approches plus fonctionnelles, comme
|
||||
# Promises):
|
||||
readFile = (name, f) -> f name
|
||||
a <- readFile 'foo'
|
||||
b <- readFile 'bar'
|
||||
console.log a + b
|
||||
|
||||
# Equivalent à:
|
||||
readFile 'foo', (a) -> readFile 'bar', (b) -> console.log a + b
|
||||
|
||||
|
||||
########################################################################
|
||||
## 4. Conditionnalités
|
||||
########################################################################
|
||||
|
||||
# Vous pouvez faire de la conditionnalité à l'aide de l'expression `if...else`:
|
||||
x = if n > 0 then \positive else \negative
|
||||
|
||||
# A la place de `then`, vous pouvez utiliser `=>`
|
||||
x = if n > 0 => \positive
|
||||
else \negative
|
||||
|
||||
# Pour les conditions complexes, il vaut mieux utiliser l'expresssion `switch`:
|
||||
y = {}
|
||||
x = switch
|
||||
| (typeof y) is \number => \number
|
||||
| (typeof y) is \string => \string
|
||||
| 'length' of y => \array
|
||||
| otherwise => \object # `otherwise` et `_` correspondent.
|
||||
|
||||
# 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
|
||||
|
||||
|
||||
########################################################################
|
||||
## 5. Compréhensions
|
||||
########################################################################
|
||||
|
||||
# Comme en python, vous allez pouvoir utiliser les listes en compréhension,
|
||||
# ce qui permet de générer rapidement et de manière élégante une liste de
|
||||
# valeurs:
|
||||
oneToTwenty = [1 to 20]
|
||||
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:
|
||||
copy = { [k, v] for k, v of source }
|
||||
|
||||
|
||||
########################################################################
|
||||
## 4. Programmation orientée objet
|
||||
########################################################################
|
||||
|
||||
# Bien que LiveScript soit un langage fonctionnel, il dispose d'intéressants
|
||||
# outils pour la programmation objet. La syntaxe de déclaration d'une classe
|
||||
# est héritée de CoffeeScript:
|
||||
class Animal
|
||||
(@name, kind) ->
|
||||
@kind = kind
|
||||
action: (what) -> "*#{@name} (a #{@kind}) #{what}*"
|
||||
|
||||
class Cat extends Animal
|
||||
(@name) -> super @name, 'cat'
|
||||
purr: -> @action 'purrs'
|
||||
|
||||
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:
|
||||
Huggable =
|
||||
hug: -> @action 'is hugged'
|
||||
|
||||
class SnugglyCat extends Cat implements Huggable
|
||||
|
||||
kitten = new SnugglyCat 'Purr'
|
||||
kitten.hug! # => "*Mei (a cat) is hugged*"
|
||||
```
|
||||
|
||||
## Lectures complémentaires
|
||||
|
||||
Il y a beaucoup plus de choses à dire sur LiveScript, mais ce guide devrait
|
||||
suffire pour démarrer l'écriture de petites fonctionnalités.
|
||||
Le [site officiel](http://livescript.net/) dispose de beaucoup d'information,
|
||||
ainsi que d'un compilateur en ligne vous permettant de tester le langage!
|
||||
|
||||
Jetez également un coup d'oeil à [prelude.ls](http://gkz.github.io/prelude-ls/),
|
||||
et consultez le channel `#livescript` sur le réseau Freenode.
|
||||
Loading…
Reference in New Issue
Block a user