Drapeau Signification c Au cas où une erreur survient ne pas réinitialiser la position de la recherche. g rechercher globalement, c'est à dire trouver toutes les occurrences. i ignorer la casse m les chaînes de caractères peuvent comprendre plusieurs lignes o n'appliquer le modèle de recherche qu'une seule fois s considérer la chaîne de caractères comme une ligne distincte x utiliser la syntaxe étendue ----------------------------------------------------------- Avec ls seul Avec ls et grep Commence par «a» et dont la deuxième lettre est «s» ou «t» ls a[st]* ls | grep '^a[st].*' Contient «un» et se termine par «t» ls *un*t ls | grep '.*un.*t$' Contient «gre» ou «st» ls *(gre|st)* ls | grep '\(gre\|st\)' Contient exactement deux lettres «m» ls | grep '[^m]*m[^m]*m[^m]*' Contient au moins deux lettres «m» ls | grep '.*m.*m.*' Contient au moins quatre caractères et aucun chiffre ls | grep '^[^0-9]\{4,\}$' Est constitué de deux lettres exactement ls ?? ls | grep '^..$' Commence et finit par un chiffre ls [0-9]*[0-9] ls | grep '^[0-9].*[0-9]$' ---------------------------------------------------------- le motif présent exemple mots matchés * 0 fois ou plus m/a*/ mot vide, a, aa, aaa ... + 1 fois ou plus m/a+/ a, aa, aaa ... ? 0 ou 1 fois m/a?/ mot vide ou a {n} n fois exactement m/a{4}/ aaaa {n,} au moins n fois m/a{2,}/ aa, aaa, aaaa ... {,n} au plus n fois m/a{,3}/ mot vide, a, aa ou aaa {n,m} entre m et n fois m/a{2,5}/ aa, aaa, aaaa ou aaaaa On remarquera que * est un raccourci pour {0,} ainsi que + pour {1,}, de même que ? pour {0,1}. ------------------------------------------------------ \d : un chiffre, équivalent à [0-9] (d comme digit, chiffre en anglais) \D : un non-numérique, équivalent à [^0-9] \w : un alphanumérique, équivalent à [0-9a-zA-Z_] (w comme word, c'est un caractère d'un mot) \W : un non-alphanumérique, équivalent à [^0-9a-zA-Z_] \s : un espacement, équivalent à [ \n\t\r\f] (s comme space) \S : un non-espacement, équivalent à [^ \n\t\r\f] ---------------------------------------------------- Extraire de $v les deux premiers mots. ($prem,$deux) = ( $v =~ m/^(.)(.)/ ); --------------------------------------------- my $v = "aatobbtbvvtczz"; while( $v =~ m/t./g ) { print "$&\n"; } L'affichage effectué est le suivant : to tb tc ---------------------------------------------- Opérateurs de comparaison numériques : < <= > >= : plus petit, plus petit ou égal, plus grand, plus grand ou égal == != : égal, différent Opérateurs de comparaison pour les chaînes de caractères : lt le gt ge : plus petit, plus petit ou égal, plus grand, plus grand ou égal eq ne : égal, différent =~ !~ : teste si une chaîne de caractères correspond à une expression régulière. ------------------------------------------------ Pour tester si une chaîne commence par la lettre 'a', on peut faire : if (/^a/) ... Pour tester si une chaîne se termine par 'z' : if (/z$/) ... ------------------------------------------ $test = "toto"; $$test = 144; # affecte 144 à $toto ${$test} = 12; # affecte 12 à $toto $test->[1] = 12; # affecte 12 à $toto[1] @$test = (1,2,3); # affecte le tableau @toto Cela peut aller beaucoup plus loin, car vous pouvez mettre une chaîne de caractères entre les accolades : ${$test x 2} = 12; # affecte 12 à $totototo $titi = 2; ${"$toto$titi"} = 2; # affecte 2 à $toto2 --------------------------------------------- # convertit la liste des nombre de @nums dans les caractères correspondants. @chars = map(chr, @nums); ---------------------------------------------------- \d est un chiffre et est équivalent à [0-9] \s est un blanc et est équivalent à [\ \t\r\n\f] \w est caractère mot (alphanumérique ou _) et est équivalent à [0-9a-zA-Z_] \D est la négation de \d; il représente tout autre caractère qu'un chiffre [^0-9] \S est la négation de \s [^\s] \W est la négation de \w [^\w] Le point '.' reconnaît n'importe quel caractère sauf ``\n''. Les abréviations \d\s\w\D\S\W peuvent être utilisées à l'extérieur ou à l'intérieur d'une classe de caractères. Quelques exemples : /\d\d:\d\d:\d\d/; # reconnaît une heure au format hh:mm:ss /[\d\s]/; # reconnaît un chiffre ou un blanc /\w\W\w/; # reconnaît un caractère mot suivi d'un caractère # non mot, suivi d'un caractère mot /..rt/; # reconnaît deux caractères quelconques suivis de 'rt' /fin\./; # reconnaît 'fin.' /fin[.]/; # idem, reconnaît 'fin.' --------------------------------------------------------- a? : reconnaît 'a' zéro ou une fois. a* : reconnaît 'a' zéro fois ou plus. a+ : reconnaît 'a' au moins une fois. a{n,m} : reconnaît 'a' au moins n fois, mais pas plus de m fois. a{n,} : reconnaît 'a' au moins n fois. a{n} : reconnaît 'a' exactement n fois. Voici quelques exemples : /[a-z]+\s+\d*/; # reconnaît un mot en minuscules suivi d'au moins un blanc # et éventuellement d'un certain nombre de chiffres /(\w+)\s+\1/; # reconnaît la répétition d'un mot de longueur quelconque $annee =~ /\d{2,4}/; # s'assure que l'année contient au moins 2 chiffres et # pas plus de 4 chiffres $annee =~ /\d{4}|\d{2}/; # meilleure reconnaissance; exclut le cas de 3 chiffres --------------------------------------------------------------- $motif = 'Seuss'; while (<>) { print if /$motif/; } -------------------------------------------------- $x = "chien chat maison"; # 3 mots while ($x =~ /(\w+)/g) { print "le mot $1 se termine en ", pos $x, "\n"; } affiche le mot chien se termine en 5 le mot chat se termine en 10 le mot maison se termine en 17 ------------------------------------------------------ * Reconnaît 0 fois ou plus + Reconnaît 1 fois ou plus ? Reconnaît 0 ou 1 fois {n} Reconnaît n fois exactement {n,} Reconnaît au moins n fois {n,m} Reconnaît au moins n fois mais pas plus de m fois ----------------------------------------------------------------- @tab = (1..6); # @tab reçoit les valeurs : 1 2 3 4 5 et 6 $var = "3"; @tab = (-1..$var); # @tab reçoit les valeurs : -1 0 1 2 et 3 ------------------------------------------------------------- $val = "probleme avec les espaces"; $val =~ s/ +/ /g; # on obtient maintenant "probleme avec les espaces"; $val =~ s/^/Plus de /g; # on obtient maintenant "Plus de probleme avec les espaces"; ----------------------------------------------------- Le but est de lister toutes les commandes que l'on peut lancer (toutes celles présentes dans la variable PATH) : #!/usr/local/bin/perl for (split(/:/, $ENV{'PATH'})) { opendir(DIR, $_) or die "can't opendir $_: $!"; grep {!/^\./ && print "$_\n" } readdir(DIR); closedir DIR; } --------------------------------------------------------------- Nous allons utiliser chaque mot comme une clef de la table et nous allons ajouter 1 à la valeur de cette clef : my @texte = qw( bonjour vous bonjour ); my %comptage = (); foreach my $mot ( @texte ) { $comptage{$mot}++; } while( my ($k,$v) = each(%comptage) ) { print "Le mot '$k' est présent $v fois\n"; } Ce qui donne l'affichage suivant : Le mot 'vous' est présent 1 fois Le mot 'bonjour' est présent 2 fois ---------------------------------------------------------- # Voici mes deux ensembles # Je mets les éléments dans des tableaux my @ensA = (1, 3, 5, 6, 7, 8); my @ensB = (2, 3, 5, 7, 9); # Voici mon union et mon intersection, # les éléments des ensembles en seront les clefs my %union = (); my %inter = (); # Je mets tous les éléments de A dans l'union : foreach my $e (@ensA) { $union{$e} = 1; } # Pour tous les éléments de B : foreach my $e (@ensB) { # S'il est déjà dans l'union, c'est qu'il est # dans A : je le mets donc dans l'intersection : $inter{$e} = 1 if ( exists( $union{$e} ) ); # Je le mets dans l'union $union{$e} = 1; } # Tous les éléments présents dans A ou B # sont des clefs de la table union. # Tous les éléments présents dans A et B # sont des clefs de la table inter. # Je reconstitue des tableaux à partir des tables de hachage #(en les triant pour l'affichage) my @union = sort( {$a<=>$b} keys(%union) ); my @inter = sort( {$a<=>$b} keys(%inter) ); print("@union\n"); # affiche : 1 2 3 5 6 7 8 9 print("@inter\n"); # affiche : 3 5 7 ######################################### Pour le même problème, voici une solution n'utilisant qu'une seule table de hachage, je vous laisse le soin d'en apprécier le principe : my @ensA = (1, 3, 5, 6, 7, 8); my @ensB = (2, 3, 5, 7, 9); my %hash = (); # Qu'une seule table ... foreach my $e (@ensA) { $hash{$e}++; } foreach my $e (@ensB) { $hash{$e}++; } my @union = sort( {$a<=>$b} keys(%hash) ); my @inter = sort( {$a<=>$b} ( grep { $hash{$_}==2 } keys(%hash) ) ); print("@union\n"); # affiche : 1 2 3 5 6 7 8 9 print("@inter\n"); # affiche : 3 5 7 --------------------------------------------------------------- Quelques options de la commande grep: -c pour avoir uniquement le nombre de lignes satisfaisantes -i pour ne pas différencier minuscules et majuscules -n pour afficher les numéros de ligne -v pour obtenir les lignes où le motif n'existe pas ------------------------------------------------------------ #syntaxe pas sure: $var2=` awk '\$2 ~ /1/ {print \$1" no list"}' hash3.txt && awk '\$2 ~ /2/ {print \$1" ok"}' hash3.txt`; print $var2; #cette syntaxe est la meilleure: $var3=` awk '{if (\$2 == "1") print \$1" no list" else if (\$2 == "2") print \$1" ok"}' hash3.txt`; print $var3; -------------------------------------- #!/usr/bin/perl; @ARGV = ("Entree.txt"); while (<>) { if (/aaa/) { print "$_"; } } ------------------------------------- \d Chiffres [0-9] \D Tout sauf un chiffre [^0-9] \w Caractères faisant partie de la construction des mots [a_zA-Z0-9_] \W Tout sauf les caractères faisant partie de la construction des mots (les séparateurs) [a_zA-Z0-9_] \s Les séparateurs? [\t\n\f\r] \S Tout sauf un séparateur [^\t\n\f\r] Exemple : /\W\d*\dA\d\W/ Est le modèle qui va permettre de chercher. \W Un caractère ne faisant pas partie de ceux composant les mots (séparateur ou signe de ponctuation. \d* Suivi d'un nombre de chiffres compris entre 0 et n. \d Suivi d'un chiffre. En résumé, au moins un chiffre. A Suivi du caractère "A" (en majuscule). \d Suivi d'un chiffre. \W Et se terminant par un caractère ne faisant pas partie de ceux composant les mots (séparateur ou signe de ponctuation. ----------------------------------------------------- changer le délimiteur identifiant l'expression régulière afin que ce dernier ne soit plus le "/". Ce changement de délimiteur est spécifié par la lettre "m" (pour modify). #!/usr/bin/perl; $path = ; if ($path =~ m*^/etc/passwd*) { # le delimiteur est maintenant * print ("Chaine reconnue"); } else { print ("Chaine inconnue"); } ----------------------------------------------- Il existe par ailleurs trois variables spécifiques prédéfinies. Nom Contenu. $& Chaine qui couvre le modèle. $` Partie qui précède le modèle. $' Partie qui suit le modèle #!/usr/bin/perl; $cible = "AA-aaa-BB-bbb-C-C-ccc-DD"; $cible =~ /(b+)/; print ("Chaine reperee : $&\n"); print ("Chaine qui precede : $`\n"); print ("Chaine qui suit : $'\n"); Chaine reperee : bbb Chaine qui precede : AA-aaa-BB- Chaine qui suit : -C-C-ccc-DD ---------------------------------------------- #!/usr/bin/perl; $cible = "AA-aaa-BB-bbb-C-C-ccc-DD"; print ("Avant : $cible\n"); $cible =~ s/(\w+)(\W+)/<$1>/g; print "$cible\n"; Avant : AA-aaa-BB-bbb-C-C-ccc-DD Apres :
On mémorise chaque mot et son séparateur (\w+)(\W+), on replace le mot mémorisé entre <> <$1> et on ne tient pas compte du séparateur. Cette opération est effectuée pour l'ensemble des éléments de la cible (option g). ---------------------------------------------- commander la suppression d'un fichier: system("rm nom_fichier.txt"); --------------------------------------------- $message = "À l'endroit : 'camel'.\n"; print $message; $message =~ s/endroit/envers/; $message =~ s/('\w+')/reverse($1)/e; print $message; exit 0 et sa sortie à l'écran : À l'endroit : 'camel'. À l'envers : 'lemac'. --------------------------------------------- La transformation d'un tableau en une chaine de caractères utilise la fonction join : $chaine = join($separateur,@tableau) Et la transformation (inverse) d'une chaine de caractères en un tableau utilise la fonction split : @tableau = split($separateur,$chaine) --------------------------------------------------- ($tvar[$nbve],$tval[$nbve]) = split(/=/,$ligne) ; réalise une affectation multiple : la première variable (qui est en fait un élément de tableau) reçoit la partie de la variable $ligne qui est avant le caractère "=" et la deuxième variable ce qui est après. --------------------------------------------------- #capture verticale : 1 colonne dans une variable avec 'split': open(F3, ">hash1d.txt"); open(F2, ">hash1c.txt"); open(F, "; foreach $ligne (@DATA) { ($var1,$var2) = split(/ /,$ligne) ; print "$var1\n"; print F2 "$var1\n"; print F3 $var2; } -------------------------------------------- $count = 0; $pos = 0; while ( ($pos = index($string, "binky", $pos) != -1) { $count++; $pos++; } ------------------------------------------- @a = (1, 2, 3); ## original array $aRef = \@a; ## reference to the array print "a: @a\n"; ## prints "a: 1 2 3" print "a: @$aRef\n"; ## exactly the same ----------------------------------------------- @a = (1, 2, 3); @b = (4, 5, 6); @root = (\@a, \@b); print "a: @a\n"; ## a: (1 2 3) print "a: @{$root[0]}\n"; ## a: (1 2 3) print "b: @{$root[1]}\n"; ## b: (4 5 6) scalar(@root) ## root len == 2 scalar(@{$root[0]}) ## a len: == 3 For arrays of arrays, the [ ] operations can stack together so the syntax is more C like... $root[1][0] ## this is 4 -------------------------------------- compter nb lignes d'une liste @data + 0; # implicitly force @days into a scalar context (voir pas utile) print scalar(@data); # explicitly force @days into a scalar context ----------------------------------------- . Match any character \w Match "word" character (alphanumeric plus "_") \W Match non-word character \s Match whitespace character \S Match non-whitespace character \d Match digit character \D Match non-digit character \t Match tab \n Match newline \r Match return \f Match formfeed \a Match alarm (bell, beep, etc) \e Match escape --------------------------------------------- * Match 0 or more times + Match 1 or more times ? Match 1 or 0 times {n} Match exactly n times {n,} Match at least n times {n,m} Match at least n but not more than m times Now for some examples: $string =~ m/\s*rem/i; #true if the first printable text is rem or REM ---------------------------------------------------- my($text) = "mississippi"; $text =~ m/(i.*s)/; print $1 . "\n"; Run the preceding code, and here's what you get: ississ ------------------------------------- my($text) = "mississippi"; $text =~ m/(i.*?s)/; print $1 . "\n"; Now look what the code produces: is -------------------------------------- #compter les occurrences des mots d'un texte: my @texte = qw( bonjour vous bonjour ); my %comptage = (); foreach my $mot ( @texte ) { $comptage{$mot}++; } while( my ($k,$v) = each(%comptage) ) { print "Le mot '$k' est présent $v fois\n"; } Ce qui donne l'affichage suivant : Le mot 'vous' est présent 1 fois Le mot 'bonjour' est présent 2 fois -------------------------------------------------- @s = sort( {$a cmp $b} @t ); La liste @s a pour valeur la liste @t triée selon l'ordre lexical. @s = sort( @t ); Le fonctionnement est identique à l'exemple précédent. @s = sort( {$a <=> $b} @t ); Le critère de tri est ici numérique. ------------------------------------------------ @s = map( { substr($_,0,2) } @t ); Le tableau @s aura pour valeurs les deux premiers caractères des valeurs de @t. ------------------------------------------------- #copie d'un fichier (manière peu élégante: system("cat fichier.txt>fichier2.txt"); ----------------------------------------------- remplacer espaces doubles, triples.... par des espaces simples: while($line = ) { $line =~ s/[ ]+/ /g; } -------------------------------------------------- autre façon d'imprimer à l'écran les entiers pairs de 0 à 20 : my $i = -1; while( 1 ) # 1 est vrai { $i++; last if( $i > 20 ); next if( $i%2 != 0 ); print "$i\n"; } ---------------------------------------------------- Depuis la version 5.6 de Perl, l'instruction exists (que l'on retrouvera pour les tables de hachage) permet de tester l'existence d'un élément d'un tableau : if( exists( $t[100] ) ) { ... } Ce test sera vrai si l'élément d'indice 100 du tableau @t existe. Ce qui est différent du test suivant : if( defined( $t[100] ) ) { ... } Car on teste ici si l'expression $t[100] vaut undef ou non, ce qui peut être vrai dans deux cas : soit l'élément existe et vaut undef, soit l'élément n'existe pas ... ------------------------------------------------------------ aplatissement des listes: @t = (1,2,"age"); @t2 = (10,@t,20); @t2 = (10,1,2,"age",20); --------------------------------------------- Absorption d'une liste par un tableau La syntaxe suivante est intéressante à connaître : ($a,@t) = @s; -------------------------------------------------- Il est aussi possible de ne pas utiliser explicitement de variable de boucle ; dans ce cas c'est la variable spéciale $_ qui sera automatiquement utilisée : foreach (@t) { print "$_\n"; } -------------------------------------------------- Voici un petit exemple d'utilisation de foreach affichant des tables de multiplication : #!/usr/bin/perl -w use strict; die("Usage: $0 \n") if( !defined( $ARGV[1] ) ); foreach my $i (1..$ARGV[0]) { foreach my $j (1..$ARGV[1]) { printf( "%4d", $i*$j ); } print "\n"; } Et le voici à l'oeuvre : ./mult.pl Usage: ./mult.pl ./mult.pl 5 3 1 2 3 2 4 6 3 6 9 4 8 12 5 10 15 ---------------------------------------------- unshift(@t,5,6); @t vaut alors la liste (5,6,1,2,3,4). ------------------------------------------- $v = shift(@t); $v vaut alors 1 et @t la liste (2,3,4). -------------------------------------------- push(@t,5,6); @t vaut alors la liste (1,2,3,4,5,6). ----------------------------------------- La fonction pop prend un tableau en argument ; elle supprime son dernier élément et renvoie cet élément : $v = pop(@t); $v vaut alors 4 et @t la liste (1,2,3). ------------------------------------------- @s = reverse(@t); @s vaut alors la liste (4,3,2,1) et @t n'est pas modifiée. ------------------------------------------ #fichier 'w52.txt' : #('28','Sep','google','imprimer-dossier','phpbb','editeurjavascript', #'wamp5','mysql-formation','regscrubxp','ace-translator','phpres','tutorial-in-Perl')"; open(F1, ") { @data = split(/,/, $line); #supprimer les 2 premières lignes: ($line1, $line2, @reste) = @data; foreach $reste (@reste) { #supprimer les signes entre crochets: $reste =~ s/['()";]//g; print "$reste\n"; } } close(F1); #résultat: #google #imprimer-dossier #phpbb #....etc ------------------------------------------- Afficher son adresse IP: renvoie le nom du navigateur du client : #!/usr/bin/perl use CGI; $co = new CGI; $test = $co->param('test'); #on recupere les variables postées ou transmises par l'url print "Content-type: text/html\n\n"; print "
test = ".$test."
"; print "
votre ip:".$ENV{'REMOTE_ADDR'}."
"; #on affiche l'adresse ip sans le module CGI use CGI; $co = new CGI; $test = $co->param('test'); #on recupere les variables postées ou transmises par l'url print "
test = ".$test."
"; print "
le nom du navigateur:".$ENV{'HTTP_USER_AGENT'}."
"; #renvoie le nom du navigateur du client ----------------------------------------- Variable d'environnement : $ENV{'CONTENT_LENGTH'} taille des données, peut servir a déterminer la taille des données envoyées lors d'une requete http, peut determiner par exemple la taille d'un fichier uploader $ENV{'CONTENT_TYPE'} type des données , peut servir également dans le cas d'un upload, si on veut s'assurer que le client uploade un fichier de tel type ex: html,jpg,etc... $ENV{'HTTP_COOKIE'} renvoie le contenu des cookies du client $ENV{'HTTP_REFERER'} renvoie l'url d'ou vient le client. $ENV{'HTTP_REQUEST_METHOD'} renvoie le type de la méthode post ou get par exemple. $ENV{'HTTP_USER_AGENT'} renvoie le nom du navigateur du client ... $ENV{'QUERY_STRING'} contient les données de l'url. $ENV{'REMOTE_ADDR'} contient l'adresse ip du client ------------------------------------ \n caractère de fin de ligne \r retour à la ligne (retour chariot) \t tabulation \s espacement (« », « . », « , ») \S tout ce qui n’est pas un espacement \d n’importe quel chiffre \D tout ce qui n’est pas un chiffre \w n’importe quelle lettre \W tout ce qui n’est pas une lettre --------------------------------------------- Fonction de recherche: Une expression régulière s’applique à une variable. Par défaut, il s’agit de la variable $_. Pour le traitement de toute autre variable, on utilise l’opérateur =~, ainsi : $variable =~ /[a-z] ; compare le contenu de $variable au motif [a-z], à savoir les caractères alphabétiques en minuscules. Comme il s’agit d’une comparaison, la valeur renvoyée sera VRAI si $variable comprend au moins un caractère alphabétique en minuscule, FAUX dans le cas contraire. ------------------------------------ Opérations de substitution: $chaine =~ s/a/b/; signifie: remplacer, dans $chaine, le premier caractère « a » par le caractère « b ». ------------------------------------- Opérations de translation: $chaine =~ tr/liste1/liste2/options; transpose chaque caractère de liste1 en le caractère correspondant de liste2. Trois options sont possibles : c complète liste1 par les caractères en trop de liste2 d supprime les caractères de liste1 qui n’ont pas d’équivalent dans liste2 s « compresse » les caractères en double ----------------------------------------------- $chaine =~ s/\n//g; remplace tous les caractères de fin de ligne par une chaine vide. $chaine =~ s/([a-zA-Z]){2}/$1/g; élimine tous les « doublons » (« aa », « bb »…) d’une chaine, en les « compressant » (« aa » donne « a », « bb » donne « b »…). ------------------------------------------------ #compter les occurrences des mots d'un fichier #fichier 'in.txt' : #R_SEGOU_OK94_136P.17.list: DATASETS PROCESSED 1 CONTAINING 686784 #R_SEGOU_OK94_137R.18.list: DATASETS PROCESSED 2 CONTAINING 686799 #R_SEGOU_OK94_138S.19.list: DATASETS PROCESSED 3 CONTAINING 686807 open(F2, ">out.txt"); open(F, " ) ) { $line =~ s/[_.:]/ /g; # W est tout sauf un mot = signe de ponctuation @words = split( /\s+/, $line ); foreach $word (@words) { $total{$word}++; } } close(F); foreach $word (sort keys %total) { printf "%30s","$word trouvé $total{$word} fois.\n"; printf F2 "%30s","$word trouvé $total{$word} fois.\n"; } close(F2); #trier sur la colonne 3 en descendant: $var1=` cat out.txt|sort -k3 -r>out2.txt`; print $var1; #résultat: # CONTAINING trouvé 3 fois. # PROCESSED trouvé 3 fois. # DATASETS trouvé 3 fois. # SEGOU trouvé 3 fois. # list trouvé 3 fois. # OK94 trouvé 3 fois. # R trouvé 3 fois. # 686807 trouvé 1 fois. # 686799 trouvé 1 fois. # 686784 trouvé 1 fois. # 138S trouvé 1 fois. # 137R trouvé 1 fois. # 136P trouvé 1 fois. # 19 trouvé 1 fois. # 18 trouvé 1 fois. # 17 trouvé 1 fois. # 3 trouvé 1 fois. # 2 trouvé 1 fois. # 1 trouvé 1 fois. ------------------------------------------ sort @amies = ("Christine","Martine","Ludivine","Pauline","Justine","Sabine"); @ordre = sort(@amies); for(@ordre) { print $_, "\n"; } ------------------------------- ecrit le 1er mot de chaque ligne #!/usr/bin/perl open(F1, "; @first_word = map { /(\S+)/ } @phrases; foreach $word (@first_word) { print "$word\n"; } ---------------------------------- ecrit la 1ère lettre de chaque mot en majuscule #!/usr/bin/perl open(F1, ") { $title = join ' ', map { ucfirst lc } split / /, $name; } ----------------------------------