Merge pull request #1 from adambard/master

Merging from master.

1 files changed, 377 insertions, 0 deletions

diff --git a/fr-fr/awk-fr.html.markdown b/fr-fr/awk-fr.html.markdown
new file mode 100644
index 00000000..75c48811
--- /dev/null
+++ b/fr-fr/awk-fr.html.markdown
@@ -0,0 +1,377 @@
+---
+category: tool
+tool: awk
+filename: learnawk-fr.awk
+contributors:
+     - ["Marshall Mason", "http://github.com/marshallmason"]
+translators:
+    - ["GannonTdW", "https://github.com/GannonTdW"]
+lang: fr-fr
+
+---
+
+AWK est un outil standard présent dans chaque système UNIX conforme aux normes POSIX.
+C’est un outil en ligne de commande qui ressemble au Perl et qui est excellent dans les tâches de traitement de fichiers texte.
+Vous pouvez l’appeler à partir d’un script shell, ou l’utiliser comme un langage de script autonome.
+
+Pourquoi utiliser AWK au lieu du langage Perl ?
+Principalement, car AWK fait partie d'UNIX et est donc présent par défaut sur une très grande partie des systèmes d'exploitation UNIX et Linux. 
+AWK est aussi plus facile à lire que le langage Perl ; et est l'outil idéal pour ce qui concerne le traitement de texte simple. Notamment le traitement de ceux qui necéssitent de lire des fichiers ligne par ligne ; chaque ligne comportant des champs séparés par des délimiteur.
+
+
+```awk
+#!/usr/bin/awk -f
+
+# Les commentaires commencent par un #
+
+
+# les programmes AWK consistent en une collection de règles et d'actions
+règle1 { action; }
+règle2 { action; }
+
+# AWK lit et analyse automatiquement chaque ligne de chaque fichier fourni.
+# Chaque ligne est divisée par un délimiteur FS qui est par défaut l'espace (plusieurs espaces ou une tabulation comptent pour un espace). Ce délimiteur peut être changer grâce à l'option -F ou être renseigné au début d'un bloc (exemple: FS = " ").
+
+# BEGIN est une règle spécifique exécutée au début du programme. C'est à cet endroit que vous mettrez tout le code à exécuter avant de traiter les fichiers texte. Si vous ne disposez pas de fichiers texte, considérez BEGIN comme le point d’entrée principal du script.
+# A l'opposé de BEGIN, il existe la règle END. Cette règle est présente après chaque fin de fichier (EOF : End Of File).
+
+BEGIN {
+
+    # Les variables sont globales. Pas besoin de les déclarer.
+    count = 0;
+
+    # les opérateurs sont identiques au langage C et aux langages similaires (exemple: C#, C++)
+    a = count + 1; # addition
+    b = count - 1; # soustraction
+    c = count * 1; # multiplication
+    d = count / 1; # division entière
+    e = count % 1; # modulo, reste de la division entière
+    f = count ^ 1; # exponentiel
+
+    a += 1;
+    b -= 1;
+    c *= 1;
+    d /= 1;
+    e %= 1;
+    f ^= 1;
+
+    # Incrémenter et décrémenter par un
+    a++;
+    b--;
+
+    # En tant qu'opérateur préfixé, c'est la valeur incrémentée qui est retournée
+    ++a;
+    --b;
+
+    # Instruction de contrôle
+    if (conteur == 0)
+        print "Nombre de départ 0";
+    else
+        print "Hein?";
+
+    # Vous pouvez aussi utiliser l'opérateur ternaire
+    print (compteur == 0) ? "Nombre de départ 0" : "Hein?";
+
+    # Les blocs sont composés d'une multitude de lignes entre accolades
+    while (a < 10) {
+        print "La concaténation de chaînes de caractères" " se fait avec des séries de chaînes "    " séparées par des espaces";
+        print a;
+
+        a++;
+    }
+
+    for (i = 0; i < 10; i++)
+        print "le bon vieux for pour les boucles";
+
+    # Les opérateurs de comparaison sont standard
+    # a < b   # plus petit que
+    # a <= b  # plus petit ou égale à
+    # a != b  # non égale
+    # a == b  # égale
+    # a > b   # Plus grand que
+    # a >= b  # Plus grand ou égale à
+
+    # Les opérateurs logiques sont
+    # a && b  # ET
+    # a || b  # OU
+
+    # En plus, il y a les expressions régulières
+    if ("foo" ~ "^fo+$")
+        print "Fooey!";
+    if ("boo" !~ "^fo+$")
+        print "Boo!";
+
+    # Les Tableaux
+    arr[0] = "foo";
+    arr[1] = "bar";
+
+    # Vous pouvez aussi initialiser un tableau avec la fonction split()
+
+    n = split("foo:bar:baz", arr, ":");
+
+    # Il y a aussi les tableaux associatifs
+    assoc["foo"] = "bar";
+    assoc["bar"] = "baz";
+
+    # et les tableaux multi-dimentions, avec certaines limitations que l'on ne mentionnera pas ici
+    multidim[0,0] = "foo";
+    multidim[0,1] = "bar";
+    multidim[1,0] = "baz";
+    multidim[1,1] = "boo";
+
+    # Vous pouvez tester l'appartenance à un tableau
+    if ("foo" in assoc)
+        print "Fooey!";
+
+    # Vous pouvez aussi utilisez l'opérateur 'in' pour parcourir les clés d'un tableau
+    for (key in assoc)
+        print assoc[key];
+
+    # La ligne de commande est dans un tableau spécifique appelé ARGV
+    for (argnum in ARGV)
+        print ARGV[argnum];
+
+    # Vous pouvez supprimer des éléments d'un tableau
+    # C'est utile pour empêcher AWK de supposer que certains arguments soient des fichiers à traiter.
+    delete ARGV[1];
+
+    # Le nombre d'arguments de la ligne de commande est dans une variable appellée ARGC
+    print ARGC;
+
+    # AWK inclue trois catégories de fonction.
+    # On les examinera plus tard
+
+    return_value = arithmetic_functions(a, b, c);
+    string_functions();
+    io_functions();
+}
+
+# Voici comment définir une fonction
+function arithmetic_functions(a, b, c,     d) {
+
+    # La partie la plus ennuieuse de AWK est probablement l’absence de variables locales.
+    # Tout est global. Pour les scripts courts, c'est très utile, mais pour les scripts plus longs,
+    # cela peut poser problème.
+
+    # Il y a cepandant une solution de contournement (enfin ... une bidouille).
+    # Les arguments d'une fonction sont locaux à cette fonction.
+    # Et AWK vous permet de définir plus d'arguments à la fonction que nécessaire.
+    # Il suffit donc de mettre une variable locale dans la déclaration de fonction,
+    # comme ci-dessus. La convention veut que vous mettiez quelques espaces supplémentaires
+    # pour faire la distinction entre les paramètres réels et les variables locales.
+    # Dans cet exemple, a, b et c sont des paramètres réels,
+    # alors que d est simplement une variable locale.
+
+    # Maintenant, les fonctions arithmétiques
+
+    # La plupart des implémentations de AWK ont des fonctions trigonométriques standards
+    localvar = sin(a);
+    localvar = cos(a);
+    localvar = atan2(b, a); # arc tangente de b / a
+
+    # Les exponentiels et logarithmes décimaux sont aussi là
+    localvar = exp(a);
+    localvar = log(a);
+
+    # Les racines carrées
+    localvar = sqrt(a);
+
+    # Tronquer un nombre décimal en nombre entier
+    localvar = int(5.34); # localvar => 5
+
+    # Les nombres aléatoires
+    srand(); 
+    # L'argument de la fonction srand() est la valeur de départ pour générer
+    # les nombres aléatoires . Par défaut, il utilise l'heure du système
+    
+    localvar = rand(); # Nombre aléatoire entre 0 et 1.
+
+    # Maintenant on retourne la valeur
+    return localvar;
+}
+
+function string_functions(    localvar, arr) {
+
+    # AWK a plusieurs fonctions pour le traitement des chaînes de caractères,
+    # dont beaucoup reposent sur des expressions régulières.
+
+    # Chercher et remplacer, la première occurence (sub) ou toutes les occurences (gsub)
+    # Les deux renvoient le nombre de correspondances remplacées
+    localvar = "fooooobar";
+    sub("fo+", "Meet me at the ", localvar); # localvar => "Meet me at the bar"
+    gsub("e+", ".", localvar); # localvar => "m..t m. at th. bar"
+
+    # Rechercher une chaîne de caractères qui correspond à une expression régulière
+    # index() fait la même chose, mais n'autorise pas les expressions régulières
+    match(localvar, "t"); # => 4, puisque 't' est le quatrième caractère
+
+    # Séparer par un délimiteur
+    n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
+
+    # Autre astuces utiles
+    sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
+    substr("foobar", 2, 3); # => "oob"
+    substr("foobar", 4); # => "bar"
+    length("foo"); # => 3
+    tolower("FOO"); # => "foo"
+    toupper("foo"); # => "FOO"
+}
+
+function io_functions(    localvar) {
+
+    # Vous avez déjà vu print
+    print "Hello world";
+
+    # Mais il y a aussi printf
+    printf("%s %d %d %d\n", "Testing", 1, 2, 3);
+
+    # AWK n'a pas de descripteur de fichier en soi. Il ouvrira automatiquement
+    # un descripteur de fichier lorsque vous utilisez quelque chose qui en a besoin.
+    # La chaîne de caractères que vous avez utilisée pour cela peut être traitée
+    # comme un descripteur de fichier à des fins d'entrée / sortie.
+
+    outfile = "/tmp/foobar.txt";
+
+    print "foobar" > outfile;
+
+    # Maintenant, la chaîne de caractères "outfile" est un descripteur de fichier.
+    # Vous pouvez le fermer
+    close(outfile);
+
+    # Voici comment exécuter quelque chose dans le shell
+    system("echo foobar"); # => affiche foobar
+
+    # Lire quelque chose depuis l'entrée standard et la stocker dans une variable locale
+    getline localvar;
+
+    # Lire quelque chose à partir d'un pipe (encore une fois, utilisez une chaine de caractère
+    # que vous fermerez proprement)
+    "echo foobar" | getline localvar # localvar => "foobar"
+    close("echo foobar")
+
+    # Lire une ligne d'un fichier et la stocker dans une variable locale
+    infile = "/tmp/foobar.txt";
+    getline localvar < infile;
+    close(infile);
+}
+
+# Comme dit au début, AWK consiste en une collection de règles et d'actions.
+# Vous connaissez déjà les règles BEGIN et END. Les autres règles ne sont utilisées que si vous traitez 
+# des lignes à partir de fichiers ou l'entrée standard (stdin).
+# Quand vous passez des arguments à AWK, ils sont considérés comme des noms de fichiers à traiter.
+# AWK les traitera tous dans l'ordre. Voyez les comme dans à une boucle implicite,
+# parcourant les lignes de ces fichiers.
+# Ces règles et ces actions ressemblent à des instructions switch dans la boucle.
+
+/^fo+bar$/ {
+
+    # Cette action sera exécutée pour chaque ligne qui correspond à l'expression régulière,
+    # /^fo+bar$/, et sera ignorée pour toute ligne qui n'y correspond pas.
+    # Imprimons simplement la ligne:
+
+    print;
+
+    # Pas d'argument ! C'est parce que print a un défaut : $0.
+    # $0 est le nom de la ligne en cours de traitement. Il est créé automatiquement.
+
+    # Vous devinez probablement qu'il existe d'autres variables $.
+    # Chaque ligne est divisée implicitement avant que chaque action soit exécutée, comme
+    # le fait le shell. Et, comme le shell, chaque champ est accessible avec un signe dollar
+
+     # Ceci affichera les deuxième et quatrième champs de la ligne.
+    print $2, $4;
+
+    # AWK défini automatiquement beaucoup d'autres variables qui peuvent vous aider
+    # à inspecter et traiter chaque ligne. La plus importante est NF
+
+    # Affiche le nombre de champs de la ligne
+    print NF;
+
+    # Afficher le dernier champ de la ligne
+    print $NF;
+}
+
+# Chaque règle est en réalité un test conditionel. 
+
+a > 0 {
+    # Ceci s’exécutera une fois pour chaque ligne, tant que le test est positif
+}
+
+# Les expressions régulières sont également des tests conditionels.
+#Si le test de l'expression régulières n'est pas vrais alors le bloc n'est pas executé
+$0 /^fobar/ { 
+   print "la ligne commance par fobar"  
+}
+
+# Dans le cas où vous voulez tester votre chaine de caractères sur la ligne en cours de traitement
+# $0 est optionnelle.
+
+/^[a-zA-Z0-9]$/ {
+    print "La ligne courante ne contient que des caractères alphanumériques.";
+}
+
+
+# AWK peut parcourir un fichier texte ligne par ligne et exécuter des actions en fonction de règles établies
+# Cela est si courant sous UNIX qu'AWK est un langage de script.
+
+# Ce qui suit est un exemple rapide d'un petit script, pour lequel AWK est parfait.
+# Le script lit un nom à partir de l'entrée standard, puis affiche l'âge moyen de toutes les
+# personnes portant ce prénom.
+# Supposons que vous fournissiez comme argument le nom d'un fichier comportant ces données:
+#
+# Bob Jones 32
+# Jane Doe 22
+# Steve Stevens 83
+# Bob Smith 29
+# Bob Barker 72
+#
+# Le script est le suivant :
+
+BEGIN {
+
+    # Premièrement, on demande à l'utilisateur le prénom voulu
+    print "Pour quel prénom vouldriez vous savoir l'age moyen ?";
+
+    # On récupère la ligne à partir de l'entrée standard, pas de la ligne de commande
+    getline name < "/dev/stdin";
+}
+
+# Maintenant, pour chaque ligne dont le premier champ est le prénom donné
+$1 == name {
+
+    # Ici, nous avons accès à un certain nombre de variables utiles déjà préchargées :
+    # $0 est la ligne entière
+    # $3 est le troisième champ. Ici il correspond à l'age qui nous intéresse
+    # NF est le nombre de champs et vaut 3
+    # NR est le nombre d'enregistrements (lignes) vus jusqu'à présent
+    # FILENAME est le nom du fichier en cours de traitement
+    # FS est séparateur de champs, ici c'est " " (un espace)
+    # ...etc. Et beaucoup d'autre que vous pouvez connaître dans le manuel de man.
+    # Pour cela exécutez "man awk" dans votre terminal
+
+    # Garder une trace du total accumulé et du nombre de lignes correspondant.
+    sum += $3;
+    nlines++;
+}
+
+# Un autre motif spécial est END. Il fonctionnera après le traitement de tous
+# les fichiers texte. Contrairement à BEGIN, il ne fonctionne que si vous lui
+# donnez une entrée à traiter. Il sera exécuté une fois que tous les fichiers
+# auront été lus et traités conformément aux règles et aux actions que vous
+# avez fournies. Le but est généralement de produire un rapport final
+# ou de faire quelque chose avec l'ensemble des données que vous avez
+# accumulées au cours du script.
+
+
+END {
+    if (nlines)
+        print "L'age moyen pour le prénom " name " est " sum / nlines;
+}
+
+```
+Pour plus d'informations :
+
+* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
+* [Awk man page](https://linux.die.net/man/1/awk)
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk est dans la majorité des systèmes Linux.
+* [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html)