summaryrefslogtreecommitdiffhomepage
path: root/fr-fr
diff options
context:
space:
mode:
Diffstat (limited to 'fr-fr')
-rw-r--r--fr-fr/awk-fr.html.markdown376
1 files changed, 376 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..750703f4
--- /dev/null
+++ b/fr-fr/awk-fr.html.markdown
@@ -0,0 +1,376 @@
+---
+language: 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)