This page has been robot translated, sorry for typos if any. Original content here.

PERL Aide-mémoire Expressions régulières

Par sujet:


Chapitre 6.4. Expressions régulières

6.4.1. Syntaxe d'expression régulière

Les expressions régulières sont des modèles permettant de rechercher des combinaisons spécifiques de caractères dans des chaînes de texte et de les remplacer par d'autres combinaisons de caractères (ces opérations sont respectivement appelées correspondance et substitution de modèle ). L'expression régulière de PERL est

  / pattern / modificateurs 

Ici, modèle est une chaîne qui spécifie une expression régulière et les modificateurs sont des modificateurs facultatifs à une lettre qui spécifient les règles d'utilisation de cette expression régulière.

Une expression régulière peut être composée de caractères ordinaires; dans ce cas, il s'agira de la combinaison de caractères spécifiée dans la chaîne. Par exemple, l'expression / cat / correspond aux sous-chaînes sélectionnées dans les lignes suivantes: " cat ok", "pour chat ", "dans le chat ". Cependant, le réel pouvoir des expressions régulières PERL vient de la possibilité d’utiliser des métacaractères spéciaux.

Tableau 6.9. Méta-caractères de regex
Symbole Description
\ Pour les caractères qui sont généralement interprétés littéralement, signifie que le caractère suivant est un métacaractère. Par exemple, / n / correspond à la lettre n et / \ n / à un caractère de nouvelle ligne.
Pour les métacaractères, signifie que le caractère doit être compris littéralement. Par exemple, / ^ / signifie le début de la ligne et / \ ^ / correspond simplement au symbole ^. / \\ / correspond à la barre oblique inverse \.
^ Il correspond au début de la ligne (cf. modificateur m ).
$ Correspond à la fin de la ligne (cf. modificateur m ).
. Correspond à n'importe quel caractère sauf un saut de ligne (cf. modificateur s ).
* Faites correspondre le caractère précédent zéro ou plusieurs fois.
+ Faites correspondre le personnage précédent une ou plusieurs fois.
? Correspond à la répétition du caractère précédent zéro ou une fois.
( motif ) Correspond à la ligne du motif et se souvient de la correspondance trouvée .
x | y Allumettes x ou y .
{ n } n est un nombre non négatif. Correspond exactement à n occurrences du caractère précédent.
{ n ,} n est un nombre non négatif. Faites correspondre n ou plus d'occurrences du caractère précédent. / x {1,} / est équivalent à / x + /. / x {0,} / est équivalent à / x * /.
{ n , m } n et m sont des nombres non négatifs. Correspond à au moins n et au plus m occurrences du caractère précédent. / x {0,1} / est équivalent à / x? /.
[ xyz ] Correspond à n'importe quel caractère entre crochets.
[^ xyz ] Correspond à tout caractère sauf entre crochets.
[ a - z ] Correspond à n'importe quel caractère de la plage spécifiée.
[^ a - z ] Correspond à n'importe quel caractère sauf ceux de la plage spécifiée.
\ a Correspond au symbole de la cloche (BEL).
\ A Ne correspond qu'au début de la ligne, même avec le modificateur m .
\ b Faites correspondre la limite de mots, c'est-à-dire la position entre \ w et \ W dans n'importe quel ordre.
\ B Correspond à toute position autre que la limite de mot.
\ s X Correspond au caractère Ctrl + X. Par exemple, / \ cI / est équivalent à / \ t /.
\ C Correspond à un octet, même avec la directive use utf8 .
\ d Correspond au numéro. Équivalent à [0-9].
\ D Correspond à un caractère non numérique. Équivalent à [^ 0-9].
\ e Correspond au caractère d'échappement (esc).
\ E La fin des transformations \ L , \ Q , \ U.
\ f Correspond au caractère de transfert de format (FF).
\ G Correspond à la position dans la ligne égale à pos () .
\ l Convertit le caractère suivant en minuscule.
\ L Convertit les caractères en minuscules avant \ E.
\ n Correspond aux sauts de ligne.
\ p propriété Correspond aux caractères Unicode avec la propriété property . Si une propriété est spécifiée avec plusieurs caractères, utilisez la syntaxe \ p { propriété } .
\ P propriété Correspond aux caractères Unicode n'ayant pas de propriété . Si une propriété est spécifiée avec plusieurs caractères, utilisez la syntaxe \ P { propriété } .
\ Q Ajoute un caractère "\" devant les métacaractères avant \ E.
\ r Correspond au symbole de retour chariot (CR).
\ s Correspond à un caractère d'espace. Équivalent à / [\ f \ n \ r \ t] /.
\ S Correspond à n'importe quel caractère non-blanc. Équivalent à / [^ \ f \ n \ r \ t] /.
\ t Correspond au caractère de tabulation (HT).
\ u Convertit le caractère suivant en majuscule.
\ U Convertit les caractères en majuscules avant \ E.
\ w Correspond à la lettre latine, au chiffre ou au trait de soulignement. Équivalent à / [A-Za-z0-9_] /.
\ W Correspond à n'importe quel caractère sauf la lettre latine, les chiffres ou les traits de soulignement. Équivalent à / [^ A-Za-z0-9_] /.
\ X Correspond à une séquence de caractères Unicode du personnage principal et à un ensemble d’accents. Équivalent à / C <(?: \ PM \ pM *)> /.
\ z Correspond seulement à la fin de la ligne, même avec le modificateur m .
\ Z Correspond seulement à la fin d'une ligne ou à un saut de ligne à la fin d'une ligne, même avec le modificateur m .
\ n n est un nombre positif. Correspond à la nième sous-chaîne mémorisée . Si la parenthèse gauche précédant ce caractère est inférieure à n et n > 9, elle est équivalente à \ 0 n .
\ 0 n n est un nombre octal non supérieur à 377. Correspond au symbole avec le code octal n . Par exemple, / \ 011 / est équivalent à / \ t /.
\ x n n est un nombre hexadécimal composé de deux chiffres. Correspond au caractère avec le code hexadécimal n . Par exemple, / \ x31 / est équivalent à / 1 /.
\ x { n } n est un nombre hexadécimal composé de quatre chiffres. Correspond au caractère Unicode avec un code hexadécimal n . Par exemple, / \ x {2663} / est équivalent à / ♣ /.

6.4.2. Modificateurs

Différentes opérations avec des expressions régulières utilisent différents modificateurs pour affiner l'opération en cours. Cependant, les quatre modificateurs ont un objectif général.

je
Ignorer la casse des caractères lors de la recherche de motif. Lors de l' utilisation de la directive use locale , la conversion des caractères dans un registre est effectuée en fonction du paramètre national.
m
Traite la ligne source comme un tampon de plusieurs lignes de texte séparées par des sauts de ligne. Cela signifie que les métacaractères ^ et $ correspondent non seulement au début et à la fin de la ligne entière, mais également au début et à la fin d'une ligne de texte délimitée par des sauts de ligne.
s
Considère la ligne source comme une seule ligne de texte, en ignorant les sauts de ligne. Cela signifie le métacaractère . correspond à n'importe quel caractère, y compris les sauts de ligne.
x
Permet l'utilisation d'espaces et de commentaires. Les espaces qui n'ont pas de caractère \ précédent et qui ne sont pas entre [] sont ignorés. Le caractère # commence un commentaire, qui est également ignoré.

6.4.3. Classes de caractères Unicode et POSIX

Nous pouvons utiliser la syntaxe dans les expressions régulières

  [: classe:] 

classe spécifie le nom de la classe de caractères POSIX, c'est-à-dire le standard mobile du langage C. Lorsque vous utilisez la directive utf8 , les classes de caractères Unicode peuvent être utilisées dans la construction à la place des classes POSIX.

  \ p {classe} 

Le tableau suivant récapitule toutes les classes de caractères POSIX, les classes de caractères Unicode correspondantes et les métacaractères éventuels.

Tableau 6.10. Cours de caractère
Posix Unicode Métacaractère Description
alpha IsAlpha Lettres
alnum IsAlnum Lettres et chiffres
Ascii IsAscii Caractères ASCII
cntrl IsCntrl Caractères de contrôle
chiffre IsDigit \ d Numéros
graphique IsGraph Lettres, chiffres et signes de ponctuation
plus bas Est inférieur Lettres minuscules
imprimer Impression Lettres, chiffres, ponctuation et espace
ponctuer IsPunct Signes de ponctuation
espace IsSpace \ s Caractères de l'espace
supérieur Isupper Lettres majuscules
mot Isward \ w Lettres, chiffres et tirets bas
xdigit IsXdigit Nombres hexadécimaux

Par exemple, un nombre décimal peut être spécifié de l'une des trois manières suivantes:

  / \ d + /
 / [: digit:] + /
 / \ p {IsDigit} + / # use utf8 

Pour indiquer qu'un caractère n'appartient pas à une classe donnée, des constructions sont utilisées.

 [: ^ classe:] \ P {classe} 

Par exemple, les expressions suivantes ont la même signification:

  [: ^ digit:] \ D \ P {IsDigit}
 [: ^ space:] \ S \ P {IsSpace}
 [: ^ mot:] \ W \ P {IsWord} 

6.4.4. Mémorisation de sous-chaînes

L'utilisation de parenthèses dans une expression régulière conduit au fait que la sous-chaîne correspondant au motif entre parenthèses est mémorisée dans un tampon spécial. Pour accéder à la nième sous-chaîne mémorisée dans une expression rationnelle, la construction \ n est utilisée. $ N , où n peut prendre toutes les valeurs à partir de 1. Cependant, rappelez-vous que PERL utilise les expressions \ 10 , \ 11 et t d. comme synonymes des codes de caractères octaux \ 010 , \ 011 , etc. L’ambiguïté est ici résolue comme suit. Le symbole \ 10 est considéré comme la référence à la dixième sous-chaîne mémorisée s’il comporte au moins dix parenthèses gauches devant lui dans une expression régulière; sinon, il s'agit d'un caractère de code octal 10. Les métacaractères \ 1 , ... \ 9 sont toujours considérés comme des références à des sous-chaînes mémorisées. Exemples:

  if (/(.)\1/) {# cherche le premier caractère récurrent
  print "'$ 1' - le premier caractère récurrent \ n";
 }
 si (/ Time: (..) :( ..) :( ..) /) {# extrait les composants temporels
  $ heures = 1 $;
  $ minutes = 2 $;
  $ secondes = 3 $;
 } 

En plus des variables $ 1 , $ 2 , ..., il existe plusieurs variables spéciales dans lesquelles les résultats de la dernière opération avec une expression régulière sont stockés, à savoir:

Variable Description
$ & La dernière sous-chaîne trouvée.
$ ` La sous-chaîne avant la dernière sous-chaîne trouvée.
$ ' La sous-chaîne après la dernière sous-chaîne trouvée.
$ + Dernière sous-chaîne stockée.

Donnons un exemple:

  'AAA111BBB222' = ~ / (\ d +) /;
 print "$` \ n ";  # AAA
 print "$ & \ n";  # 111
 print "$ '\ n";  # BBB222
 print "$ + \ n";  # 111 

Toutes ces variables spéciales conservent leurs valeurs jusqu'à la fin du bloc englobant ou jusqu'à la prochaine correspondance de motif réussie.

6.4.5. Échantillons étendus

PERL contient plusieurs constructions supplémentaires pouvant être utilisées dans les expressions régulières pour développer leurs capacités. Toutes ces constructions sont entre parenthèses et commencent par le symbole ? cela les distingue de la mémorisation des sous-chaînes.

(? # texte )
Commentaire Toute la construction est ignorée.
(? modificateurs - modificateurs )
Active ou désactive les modificateurs spécifiés. Les modificateurs situés devant le symbole - sont activés, ceux qui le suivent sont désactivés. Exemple:
  if (/ aaa /) {...} # mappage sensible à la casse
 if (/ (? i) aaa /) {...} # mappage insensible à la casse 
(?: motif )
(? modificateurs - modificateurs : modèle )
Vous permet de regrouper des sous-expressions d'expressions régulières sans mémoriser la correspondance trouvée. La deuxième forme active ou désactive en outre les modificateurs spécifiés. Par exemple, l'expression /ко(?:т|шка)/ est un bref enregistrement de l'expression /кот|кошка/ .
(? = motif )
Associer à regarder en avant sans mémoriser le match trouvé. Par exemple, l'expression /Windows (?=95|98|NT|2000)/ correspond à "Windows" dans la chaîne "Windows 98", mais ne correspond pas à la chaîne "Windows 3.1". Après la mise en correspondance, la recherche continue à partir de la position suivant la correspondance trouvée, sans regarder vers l’avant.
(?! pattern )
Décalage avec regarder devant sans mémoriser le match trouvé. Par exemple, l'expression /Windows (?!95|98|NT|2000)/ correspond à "Windows" dans la chaîne "Windows 3.1", mais ne correspond pas à la chaîne "Windows 98". Après la mise en correspondance, la recherche continue à partir de la position suivant la correspondance trouvée, sans regarder vers l’avant.
(? <= motif )
Faire correspondre avec regarder en arrière sans mémoriser la correspondance trouvée. Par exemple, l'expression /(?<=\t)\w+/ correspond au mot qui suit le caractère de tabulation et le caractère de tabulation n'est pas inclus dans $ & . Le fragment correspondant à regarder en arrière doit avoir une largeur fixe.
(? <! pattern )
La différence avec regarder en arrière sans mémoriser la correspondance trouvée. Par exemple, l'expression /(?<!\t)\w+/ correspond à un mot avant lequel il n'y a pas de caractère de tabulation. Le fragment correspondant à regarder en arrière doit avoir une largeur fixe.

6.4.6. Opérations d'expression régulière

Jusqu'à présent, nous avons inclus des expressions régulières dans // caractères. En fait, les caractères limites d'une expression régulière sont déterminés par la q-opération que nous leur appliquons. Cette section décrit en détail toutes les opérations PERL avec des expressions régulières.

6.4.6.1. Correspondance de modèle

  Syntaxe : / pattern / modifiers m / pattern / modifiers
 

Cette opération correspond à la chaîne spécifiée avec le modèle de motif et renvoie true ou false en fonction du résultat correspondant. La chaîne mappée est spécifiée par l'opérande gauche de l'opération = ~ ou ! ~ , Par exemple:

  $ mynumber = '12345';
 if ($ mynumber = ~ / ^ \ d + $ /) {# si la chaîne $ mynumber est composée de chiffres décimaux, alors ...
  ...
 } 

Si la chaîne n'est pas spécifiée, une comparaison est faite avec le contenu de la variable spéciale $ _ . En particulier, l'exemple précédent peut être réécrit comme suit:

  $ _ = '12345';
 si (/ ^ \ d + $ /) {
  ...
 } 

En plus de la norme, les modificateurs suivants peuvent être utilisés ici:

Modificateur Description
c Ne réinitialisez pas la position de recherche en cas d’échec de la correspondance (uniquement avec le modificateur g ).
g Correspondance globale, c’est-à-dire rechercher toutes les occurrences de l’échantillon.
o Compilez une expression régulière une seule fois.

Si l'expression régulière est incluse dans // , alors le m initial est facultatif. La construction avec m initial permet d'utiliser tous les caractères autorisés dans q-opérations comme limiteurs d'une expression régulière. Cas spéciaux utiles:

  • Si les délimiteurs sont les caractères '' , la chaîne de modèle n'est pas interpolée. Dans d'autres cas, l'échantillon est interpolé et s'il contient des variables, il est ensuite compilé à chaque correspondance. Pour éviter cela, utilisez le modificateur o (bien sûr, si vous êtes sûr que les valeurs des variables incluses dans l’échantillon restent inchangées).
  • Si les délimiteurs sont des caractères ?? alors la règle de correspondance unique s'applique.

Si motif est une chaîne vide, la dernière expression régulière trouvée est utilisée à la place.

Si le modificateur g n'est pas spécifié et que le résultat du mappage est affecté à la liste, une liste vide est renvoyée si le mappage échoue. Le résultat d'une correspondance réussie dépend de la présence de parenthèses dans l'échantillon. Sinon, la liste est renvoyée (1) . Sinon, il retourne une liste composée des valeurs des variables $ 1, $ 2, etc., c'est-à-dire une liste de toutes les sous-chaînes stockées. Exemple suivant

  ($ w1, $ w2, $ reste) = ($ x = ~ / ^ (\ S +) \ s + (\ S +) \ s ** (. *) /); 

place le premier mot de la chaîne $ x dans la variable $ w1 , son deuxième mot dans la variable $ w2 et le reste de la chaîne dans la variable $ rest .

Le modificateur g comprend un modèle de correspondance de modèle global, c’est-à-dire une recherche de toutes les correspondances d’une chaîne. Son comportement dépend du contexte. Si le résultat de la correspondance est affecté à la liste, une liste de toutes les sous-chaînes stockées est renvoyée. Si l'échantillon ne contient pas de parenthèses, une liste de toutes les correspondances avec l'échantillon est renvoyée, comme si elle était entièrement entre parenthèses. Exemple suivant

  $ _ = "12:23:45";
 @result = / \ d + / g;
 foreach $ elem (@result) {
  print "$ elem \ n";
 } 

affichera les lignes 12 , 23 et 45 .

Dans un contexte scalaire, le mappage avec le modificateur g à chaque fois recherche la correspondance suivante pour le modèle et renvoie true ou false en fonction du résultat de la recherche. La position dans la chaîne après la dernière correspondance peut être lue ou modifiée par la fonction pos () . Une recherche infructueuse réinitialise généralement la position de recherche à zéro, mais nous pouvons éviter cela en ajoutant le modificateur c . Changer une chaîne réinitialise également la position de recherche qu'il contient.

Des fonctionnalités supplémentaires sont fournies par le métacaractère \ G , ce qui n'a de sens qu'en combinaison avec le modificateur g . Ce métacaractère correspond à la position de recherche actuelle dans la chaîne. Utiliser la construction m / \ G ... / gc est particulièrement pratique pour écrire des analyseurs lexicaux effectuant diverses actions pour les lexèmes trouvés dans le texte analysé. Exemple suivant

  $ _ = 'Word1, word2 et 12345.';
 BOUCLE:
  {
  print ("number"), refaire LOOP si / \ G d + b b ,, ;; ?? s * / gc;
  print ("word"), refaire LOOP if / \ GAA-Za-z0-9 ++ b, ;;; ?? s * / gc;
  print ("unknown"), refaire LOOP si / \ G [^ A-Za-z0-9] + / gc;
  } 

affichera le mot chaîne numéro numéro mot .

6.4.6.2. Le seul motif correspondant

  Syntaxe:?
  motif ?
  m?  motif ? 

Cette construction est complètement similaire à la construction m / pattern / avec la seule différence: une correspondance de motif réussie est effectuée une seule fois entre les appels à la fonction reset () . Ceci est pratique, par exemple, lorsque nous devons rechercher uniquement la première occurrence de l'échantillon dans chaque fichier de l'ensemble en cours de visualisation, par exemple:

  tandis que (<>) {
  si (? ^ $?) {
  ... # traite la première ligne vide du fichier
  }
 } continuer {
  réinitialiser si eof;  # réinitialiser le statut ??  pour le prochain fichier
 } 

6.4.6.3. Créer une expression régulière

  Syntaxe : qr / string / modifiers
 

Cette construction crée une expression régulière avec du texte chaîne et des modificateurs, puis la compile. Si les délimiteurs sont des caractères, aucune interpolation de chaîne n'est effectuée. Dans d'autres cas, l'échantillon est interpolé et s'il contient des variables, il est ensuite compilé à chaque correspondance. Pour éviter cela, utilisez le modificateur o (bien sûr, si vous êtes sûr que les valeurs des variables incluses dans l’échantillon restent inchangées).

Une fois qu'une expression régulière est créée, elle peut être utilisée à la fois indépendamment et en tant que fragment d'autres expressions régulières. Exemples:

  $ re = qr / \ d + /;
 $ string = ~ / \ s * $ {re} \ s * /;  # inclusion dans une autre expression régulière
 $ string = ~ $ re;  # utilisation indépendante
 $ string = ~ / $ re /;  # même

 $ re = qr / $ header / is;
 s / $ re / text /;  # idem que s / $ header / text / is 

6.4.6.4. La substitution

  Syntaxe : s / pattern / string / modifiers
 

Cette opération correspond à la chaîne spécifiée avec le modèle de motif et remplace les fragments trouvés par la chaîne . Il renvoie le nombre de remplacements effectués ou false (plus précisément, une chaîne vide) si la correspondance a échoué. La chaîne mappée est spécifiée par l'opérande gauche de l'opération = ~ ou ! ~ . Ce doit être une variable scalaire, un élément d'un tableau ou un élément d'un tableau associatif, par exemple:

  $ path = '/ usr / bin / perl';
 $ path = ~ s | / usr / bin | / usr / local / bin |; 

Si la chaîne n'est pas spécifiée, une opération de substitution est effectuée sur la variable spéciale $ _ . En particulier, l'exemple précédent peut être réécrit comme suit:

  $ _ = '/ usr / bin / perl';
 s | / usr / bin | / usr / local / bin |; 

En plus de la norme, les modificateurs suivants peuvent être utilisés ici:

Modificateur Description
e Traiter la chaîne comme une expression PERL.
g Substitution globale, c’est-à-dire remplacement de toutes les occurrences de l’échantillon.
o Compilez une expression régulière une seule fois.

Nous pouvons utiliser à la place de // tout caractère autorisé dans les q-opérations. Si le motif est placé entre crochets, la chaîne doit avoir sa propre paire de terminaisons, par exemple s(foo)[bar] ou s<foo>/bar/ .

Si les délimiteurs sont les caractères '' , la chaîne de modèle n'est pas interpolée. Dans d'autres cas, l'échantillon est interpolé et s'il contient des variables, il est ensuite compilé à chaque correspondance. Pour éviter cela, utilisez le modificateur o (bien sûr, si vous êtes sûr que les valeurs des variables incluses dans l’échantillon restent inchangées).

Si motif est une chaîne vide, la dernière expression régulière trouvée est utilisée à la place.

Par défaut, seul le premier motif trouvé est remplacé. Pour remplacer toutes les occurrences d'un échantillon dans une chaîne, utilisez le modificateur g .

Le modificateur e indique que la chaîne est une expression. Dans ce cas, la fonction eval () est d'abord appliquée à la chaîne , puis la substitution est effectuée. Exemple:

  $ _ = '123';
 s / \ d + / $ & * 2 / e;  # $ _ = '246'
 s / \ d / $ & * 2 / eg;  # même 

Donnons quelques exemples plus typiques d'utilisation de l'opération de substitution. Supprimez les commentaires tels que / * ... * / de Java ou du texte du programme C:

  $ programme = ~ s {
  / \ * # Commence le commentaire
  . *?  # Nombre minimum de caractères
  \ * / # Fin du commentaire
 } [] gsx; 

Supprimez les espaces de début et de fin dans la chaîne $ var :

  pour ($ var) {
  s / ^ \ s + //;
  s / \ s + $ //;
 } 

Réorganisez les deux premiers champs de $ _ . Veuillez noter que la chaîne de remplacement utilise les variables $ 1 et $ 2 , et non les métacaractères \ 1 et \ 2 :

  s / ([^] *) * ([^] *) / $ 2 $ 1 /; 

Remplacement d'onglets par des espaces avec alignement sur des colonnes multiples de huit:

  1 tant que s / \ t + / '' x (longueur ($ &) * 8 - longueur ($ `)% 8) / e; 

6.4.6.5. Translittération

  Syntaxe : tr / list1 / list2 / modificateurs y / list1 / list2 / modificateurs
 

La translittération consiste à remplacer tous les caractères de list1 par les caractères correspondants de list2 . Il retourne le nombre de caractères remplacés ou supprimés. Les listes doivent être composées de caractères individuels et / ou de plages de la forme az . La chaîne à convertir est spécifiée par l'opérande gauche de l'opération = ~ ou ! ~ . Ce doit être une variable scalaire, un élément d'un tableau ou un élément d'un tableau associatif, par exemple:

  $ test = 'ABCDEabcde';
 $ test = ~ tr / AZ / az /;  # remplacer les lettres minuscules par des majuscules 

Si la chaîne n'est pas spécifiée, une opération de substitution est effectuée sur la variable spéciale $ _ . En particulier, l'exemple précédent peut être réécrit comme suit:

  $ _ = 'ABCDEabcde';
 tr / AZ / az /; 

Nous pouvons utiliser à la place de // tout caractère autorisé dans les q-opérations. Si list1 est placé entre crochets, alors list2 doit avoir sa propre paire de terminaisons, par exemple, tr(AZ)[az] ou tr<AZ>/az/ .

Cette opération s'appelle généralement tr . Le synonyme y est introduit pour les fanatiques de sed et n’est utilisé que par eux. La translittération prend en charge les modificateurs suivants:

Modificateur Description
c Remplace les caractères qui ne sont pas dans la liste1 .
d Supprimer les caractères pour lesquels il n'y a pas de remplacement.
s Supprimer les caractères en double lors du remplacement.
U Convertir vers / à partir du codage UTF-8.
C Convertir vers / à partir d'un codage sur un octet.

Le modificateur c provoque la translittération de tous les caractères non inclus dans la liste list1 . Par exemple, l'opération tr/a-zA-Z/ /c remplacera tous les caractères qui ne sont pas des lettres latines par des espaces.

Par défaut, si list2 est plus court que list1 , il est complété avec son dernier caractère et s'il est vide, il est considéré comme list1 (c'est pratique pour compter le nombre de caractères d'une classe particulière dans une ligne). Le modificateur d change ces règles: tous les caractères de list1 qui n'ont pas de correspondance dans list2 sont supprimés de la chaîne. Par exemple, l'opération tr/a-zA-Z//cd supprimera de la chaîne tous les caractères qui ne sont pas des lettres latines.

Le modificateur s supprime les doublons: si plusieurs caractères sont remplacés par un seul et même caractère dans une ligne, il ne restera plus qu'une occurrence de ce caractère. Par exemple, l'opération tr/ / /s supprime les espaces répétés d'une chaîne.

Les modificateurs C et U sont utilisés pour traduire les caractères du codage du système en UTF-8 et inversement. Le premier pointe sur le codage d'origine et le second sur le résultat. Par exemple, tr/\0-\xFF//CU recode une chaîne du codage du système en UTF-8 et tr/\0-\xFF//UC effectue le transcodage inverse.

La translittération est effectuée sans interpoler les listes de caractères. Pour utiliser des variables, vous devez donc appeler la fonction eval () , par exemple:

  eval "tr / $ oldlist / $ newlist /";