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

Triche pour les expressions régulières PERL

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 motifs permettant de trouver des combinaisons de caractères spécifiées dans des chaînes de texte et de les remplacer par d'autres combinaisons de symboles (ces opérations sont respectivement appelées correspondance de motif et substitution ). L'expression régulière dans PERL ressemble à

  / pattern / modificateurs 

Ici, pattern 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 correspond à 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", "for cat ", " cut ". Cependant, la véritable force des expressions régulières PERL permet d'utiliser des métacaractères spéciaux.

Tableau 6.9. Métacaractères dans les expressions régulières
Symbole Description
\ Pour les caractères qui sont généralement traités littéralement, cela signifie que le caractère suivant est un métacaractère. Par exemple, / n / correspond à la lettre n et / \ n / correspond au caractère de nouvelle ligne.
Pour les métacaractères, un symbole doit être compris littéralement. Par exemple, / ^ / indique le début de la ligne, et / \ ^ / correspond simplement au caractère ^. / \\ / correspond à la barre oblique inverse \.
^ Correspond au début de la ligne (modificateur de comparaison m ).
$ Correspond à la fin de la ligne (comparez le modificateur m ).
. Correspond à n'importe quel caractère à l'exception d'un saut de ligne (modificateur de comparaison s ).
* Correspond à répéter le caractère précédent zéro ou plusieurs fois.
+ Correspond à répéter le caractère 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 de motif et se souvient du match trouvé .
x | y Correspond à 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. Correspond à n occurrences ou plus 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 pas à plus de m occurrences du caractère précédent. / x {0,1} / est équivalent à / x? /.
[ xyz ] Correspond à n'importe quel caractère des crochets entre crochets.
[^ xyz ] Correspond à n'importe quel caractère sauf ceux entre crochets.
[ a - z ] Correspond à n'importe quel caractère dans la plage spécifiée.
[^ a - z ] Correspond à tout caractère autre que ceux compris dans la plage spécifiée.
\ a Correspond au symbole de la cloche (BEL).
\ A Correspond uniquement au début de la ligne, même avec le modificateur m .
\ b Elle correspond à la frontière de mot, c'est-à-dire la position entre \ w et \ W dans n'importe quel ordre.
\ B Correspond à n'importe quelle position autre que la limite de mot.
à partir de X Correspond au caractère Ctrl + X. Par exemple, / \ cI / est équivalent à / \ t /.
\ C Cela correspond à un octet, même avec l' utilisation de la directive utf8 .
\ d Correspond à la figure. C'est équivalent à [0-9].
\ D Correspond à un caractère non numérique. C'est é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 traduction de format (FF).
\ G Correspond à la position dans la ligne égale à pos () .
\ l Convertit le caractère suivant en minuscules.
\ L Convertit les caractères en minuscules avant \ E.
\ n Correspond aux sauts de ligne.
Propriété \ p Correspond aux caractères Unicode qui ont la propriété de propriété . Si la propriété est spécifiée par plusieurs caractères, utilisez la syntaxe \ p { property } .
Propriété \ P Correspond aux caractères Unicode qui n'ont pas la propriété de propriété . Si la propriété est spécifiée par plusieurs caractères, utilisez la syntaxe \ P { propriété } .
\ Q Ajoute le caractère "\" avant les métacaractères à \ E.
\ r Correspond à un caractère de retour chariot (CR).
\ s Correspond au caractère d'espace. Équivalent à / [\ f \ n \ r \ t] /.
\ S Correspond à n'importe quel caractère non-espace. Equivalent à / [^ \ f \ n \ r \ t] /.
\ t Correspond au caractère de tabulation (HT).
\ u Convertit le caractère suivant en majuscules.
\ U Convertit les caractères en majuscules en \ E.
\ w Correspond à la lettre latine, le nombre ou le trait de soulignement. Équivalent à / [A-Za-z0-9_] /.
\ W Correspond à n'importe quel caractère à l'exception d'une lettre, d'un nombre ou d'un trait de soulignement. Équivalent à / [^ A-Za-z0-9_] /.
\ X Correspond à une séquence de caractères Unicode du personnage principal et un ensemble d'icônes diacritiques. Équivalent à l'expression / C <(?: \ PM \ pM *)> /.
\ z Correspond uniquement à la fin de la ligne, même avec le modificateur m .
\ Z Correspond uniquement à la fin de la ligne ou au saut de ligne à la fin de la ligne, même avec le modificateur m .
\ n n est un nombre positif. Correspond à la nième sous-chaîne stockée . Si la parenthèse de gauche avant ce caractère est inférieure à n , et n > 9, alors elle est équivalente à \ 0 n .
\ 0 n n est un nombre octal non supérieur à 377. Il correspond à un caractère avec un code octal n . Par exemple, / \ 011 / est équivalent à / \ t /.
\ x n n est un nombre hexadécimal composé de deux chiffres. Correspond à un 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 à un caractère Unicode avec n hexadécimal. 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 spécifier l'opération à effectuer. Cependant, les quatre modificateurs ont un but général.

je
Ignore le cas des caractères lors de la correspondance avec un motif. Lors de l' utilisation de la directive locale locale , la conversion des caractères en un registre est effectuée en tenant compte du paramètre national.
m
Considère la chaîne source comme un tampon de plusieurs lignes de texte séparées par des sauts de ligne. Cela signifie que les méta-caractères ^ et $ correspondent non seulement au début et à la fin de la chaîne entière, mais aussi au début et à la fin de la ligne de texte délimitée par des sauts de ligne.
s
Considère la chaîne source comme une seule ligne de texte, en ignorant les sauts de ligne. Cela signifie que le métacaractère . correspond à n'importe quel caractère, y compris un saut de ligne.
x
Permet l'utilisation d'espaces et de commentaires. Les espaces qui n'ont pas de caractère précédent \ et ne sont pas inclus dans [] sont ignorés. Le symbole # 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

  [: class:] 

class spécifie le nom de la classe de symboles POSIX, c'est-à-dire la norme mobile pour le langage C. Si vous utilisez la directive utf8 , au lieu de la classe POSIX, vous pouvez utiliser les classes de caractères Unicode dans la construction

  \ p {class} 

Le tableau suivant résume toutes les classes de caractères POSIX, les classes de caractères Unicode correspondantes et les métacaractères, le cas échéant.

Tableau 6.10. Classes de caractères
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
digit IsDigit \ d Figures
graphe IsGraph Lettres, chiffres et ponctuation
plus bas IsLower Lettres minuscules
imprimer IsPrint Lettres, chiffres, ponctuation et espace
punct IsPunct Ponctuation
espace IsSpace \ s Symboles d'espacement
supérieur IsUpper Lettres majuscules
mot IsWord \ w Lettres, chiffres et traits de soulignement
xdigit IsXDigit Chiffres hexadécimaux

Par exemple, vous pouvez spécifier un nombre décimal de l'une des trois manières suivantes:

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

Pour indiquer que le symbole n'appartient pas à une classe donnée, les constructions sont utilisées

  [: ^ classe:]
 \ P {class}

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

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

6.4.4. Mémorisation des sous-chaînes

L'utilisation de parenthèses dans une expression régulière entraîne le stockage de la sous-chaîne correspondant au motif entre crochets dans un tampon spécial. Pour accéder à la nième sous-chaîne stockée dans l'expression régulière, utilisez la construction \ n , et en dehors de $ n , où n peut prendre toutes les valeurs commençant à 1. Cependant, souvenez-vous que PERL utilise les expressions \ 10 , \ 11 et t etc. comme synonymes pour les codes octaux des caractères \ 010 , \ 011 , etc. L'ambiguïté ici est résolue comme suit. Le caractère \ 10 est considéré comme une référence à la 10ème sous-chaîne stockée, s'il y a au moins dix parenthèses fermées devant lui dans l'expression régulière; sinon, il s'agit d'un caractère avec un code octal 10. Les métacaractères \ 1 , ... \ 9 sont toujours considérés comme des références aux sous-chaînes stockées. Exemples:

  if (/(.)\1/) {# recherche le premier caractère répétitif
  print "'$ 1' est le premier caractère répétitif \ n";
 }
 si (/ Heure: (..) :( ..) :( ..) /) {# extrait les composants de temps
  $ heures = 1 $;
  $ minutes = 2 $;
  $ secondes = 3 $;
 } 

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

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

Donnons un exemple:

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

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

6.4.5. Échantillons avancés

PERL contient plusieurs constructions supplémentaires qui peuvent être utilisées dans les expressions régulières pour étendre leurs capacités. Toutes ces constructions sont entourées de parenthèses et commencent par un symbole ? , ce qui les distingue des sous-chaînes de mémorisation.

(? # texte )
Commentaire Toute la construction est ignorée.
(? modificateurs - modificateurs )
Active ou désactive les modificateurs spécifiés. Modificateurs, debout avant le symbole - , sont inclus, debout après elle - sont éteints. Exemple:
  if (/ aaa /) {...} # correspond à la casse
 if (/ (i) aaa /) {...} # comparaison non sensible à la casse 
(?: motif )
(? modificateurs - modificateurs : modèle )
Vous permet de regrouper les sous-expressions d'une expression régulière sans se souvenir de la correspondance trouvée. La deuxième forme active ou désactive les modificateurs spécifiés. Par exemple, l'expression /ко(?:т|шка)/ est une courte entrée de l'expression /кот|кошка/ .
(? = motif )
Correspondant à l'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 dans la ligne "Windows 3.1". Après la mise en correspondance, la recherche continue à partir de la position suivant la correspondance trouvée, sans tenir compte du regard avant.
(?! motif )
Mismatch avec regarder en avant sans se souvenir du match trouvé. Par exemple, l'expression /Windows (?!95|98|NT|2000)/ correspond à "Windows" dans la chaîne "Windows 3.1", mais ne correspond pas dans la chaîne "Windows 98". Après la mise en correspondance, la recherche continue à partir de la position suivant la correspondance trouvée, sans tenir compte du regard avant.
(? <= motif )
Correspondant avec un regard en arrière sans mémoriser le match trouvé. 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 $ & . Un fragment correspondant à une rétrospective devrait avoir une largeur fixe.
(? <! pattern )
Incohérence à regarder en arrière sans se souvenir du match trouvé. Par exemple, l'expression /(?<!\t)\w+/ correspond à un mot devant lequel il n'y a pas de caractère de tabulation. Un fragment correspondant à une rétrospective devrait avoir une largeur fixe.

6.4.6. Opérations avec des expressions régulières

Jusqu'à présent, nous avons inclus des expressions régulières dans les symboles // . En fait, les symboles d'expressions régulières sont définis par l' opération q , que nous leur appliquons. Cette section décrit en détail toutes les opérations de PERL avec des expressions régulières.

6.4.6.1. Comparaison avec l'échantillon

  Syntaxe : / pattern / modificateurs m / pattern / modificateurs
 

Cette opération mappe la chaîne spécifiée sur le modèle de modèle et renvoie true ou false, en fonction du résultat du mappage. La chaîne correspondante 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, le contenu de la variable spéciale $ _ est comparé. En particulier, l'exemple précédent peut être réécrit comme suit:

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

En plus de la norme, vous pouvez utiliser les modificateurs suivants:

Modificateur Description
c Ne réinitialisez pas la position de recherche si la correspondance est infructueuse (uniquement avec le modificateur g ).
g Correspondance globale, c'est-à-dire recherche de toutes les occurrences d'un motif.
o Compilez l'expression régulière une seule fois.

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

  • Si les délimiteurs sont '' , alors le motif n'est pas interpolé. Dans d'autres cas, l'échantillon interpole et s'il contient des variables, chaque compilation effectue sa compilation. Pour éviter cela, utilisez le modificateur o (bien sûr, si vous êtes sûr que les valeurs des variables entrant dans le pattern restent inchangées).
  • Si les limiteurs sont des caractères ?? , alors la règle de correspondance unique s'applique.

Si pattern est une chaîne vide, la dernière expression régulière avec succès est utilisée à la place.

Si le modificateur g n'est pas défini 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 le motif. Si elles ne sont pas présentes, la liste (1) est renvoyée. Sinon, une liste est renvoyée qui comprend les valeurs des variables $ 1, $ 2, etc., c'est-à-dire une liste de toutes les sous-chaînes stockées. L'exemple suivant

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

met le premier mot de la chaîne $ x dans la variable $ w1 , le second mot dans la variable $ w2 , et le reste de cette ligne dans la variable $ rest .

Le modificateur g active la correspondance globale avec le modèle, c'est-à-dire la recherche de toutes les correspondances dans la chaîne. Son comportement dépend du contexte. Si le résultat du mappage 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, la liste de toutes les correspondances à l'échantillon est renvoyée, comme si elle était entièrement entre parenthèses. L'exemple suivant

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

affiche les lignes 12 , 23 et 45 .

Dans un contexte scalaire, la correspondance avec le modificateur g chaque fois qu'il recherche la correspondance suivante au modèle et renvoie true ou false, en fonction du résultat de la recherche. La position dans la ligne 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 . La modification de la ligne entraîne également la réinitialisation de la position de recherche.

Le métacaractère \ G offre des possibilités supplémentaires, ce qui n'a de sens qu'avec le modificateur g . Ce méta-caractère correspond à la position de recherche actuelle dans la chaîne. L'utilisation de la construction m / \ G ... / gc est pratique, en particulier, pour écrire des analyseurs lexicaux effectuant diverses actions pour les jetons rencontrés dans le texte analysé. L'exemple suivant

  $ _ = 'Mot1, mot2 et 12345.';
 BOUCLE:
  {
  print ("nombre"), refait LOOP si /\G\d+\b[,.]?\s*/gc;
  print ("mot"), refait LOOP si / \ G [A-Za-z0-9] + \ b [,.]]? \ s * / gc;
  print ("unknown"), refait LOOP si / \ G [^ A-Za-z0-9] + / gc;
  } 

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

6.4.6.2. La seule comparaison avec l'échantillon

  Syntaxe:?
  motif ?
  m?  motif ? 

Cette construction est complètement analogue à la construction m / pattern / , avec la seule différence: une correspondance réussie avec le pattern est effectuée une seule fois entre les appels à la fonction reset () . Cela est pratique, par exemple, lorsque nous avons seulement besoin de trouver la première occurrence d'un motif dans chaque fichier de l'ensemble en cours de visualisation, par exemple:

  while (<>) {
  if (? ^ $?) {
  ... # traite la première ligne vide du fichier
  }
 } continuer {
  réinitialiser si eof;  # réinitialiser l'état ??  pour le fichier suivant
 } 

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

  Syntaxe : qr / string / modificateurs
 

Cette construction crée une expression régulière avec le texte de la chaîne et les modificateurs et la compile. Si les délimiteurs sont '' , l'interpolation de la chaîne n'est pas effectuée. Dans d'autres cas, l'échantillon interpole et s'il contient des variables, chaque compilation effectue sa compilation. Pour éviter cela, utilisez le modificateur o (bien sûr, si vous êtes sûr que les valeurs des variables entrant dans le pattern restent inchangées).

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

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

 $ re = qr / $ en-tête / est;
 s / $ re / text /;  # identique à s / $ header / text / is 

6.4.6.4. Substitution

  Syntaxe : s / pattern / string / modificateurs
 

Cette opération mappe la chaîne spécifiée sur le modèle de modèle et remplace les fragments trouvés par une chaîne . Il renvoie le nombre de remplacements effectués ou faux (plus précisément, une chaîne vide) si la correspondance échoue. La chaîne correspondante est spécifiée par l'opérande gauche de l'opération = ~ ou ! ~ . Il doit s'agir d'une variable scalaire, d'un élément de tableau ou d'un élément d'un tableau associatif, par exemple:

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

Si la chaîne n'est pas spécifiée, l'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, vous pouvez utiliser les modificateurs suivants:

Modificateur Description
e Chaîne de processus en tant qu'expression PERL.
g Substitution globale, c'est-à-dire remplacement de toutes les occurrences de l'échantillon.
o Compilez l'expression régulière une seule fois.

Nous pouvons utiliser n'importe quel caractère valide dans q-operations au lieu de // . Si le modèle est entre parenthèses, la chaîne doit avoir sa propre paire de délimiteurs, par exemple s(foo)[bar] ou s<foo>/bar/ .

Si les délimiteurs sont '' , alors le motif n'est pas interpolé. Dans d'autres cas, l'échantillon interpole et s'il contient des variables, chaque compilation effectue sa compilation. Pour éviter cela, utilisez le modificateur o (bien sûr, si vous êtes sûr que les valeurs des variables entrant dans le pattern restent inchangées).

Si pattern est une chaîne vide, la dernière expression régulière avec succès est utilisée à la place.

Par défaut, seul le premier échantillon trouvé est remplacé. Pour remplacer toutes les occurrences d'un motif dans une chaîne, vous devez utiliser 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 / par exemple;  # même chose 

Voici d'autres exemples typiques d'utilisation d'une opération de substitution. Suppression des commentaires du formulaire / * ... * / du texte d'un programme Java ou C:

  $ programme = ~ s {
  / \ * # Début du commentaire
  . *?  # Le nombre minimum de caractères
  \ * / # Fin du commentaire
 } [] gsx; 

Supprimez les espaces de début et de fin dans la ligne $ var :

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

Permutation des deux premiers champs dans $ _ . Notez que la ligne de remplacement utilise les variables $ 1 et $ 2 , pas les métacaractères \ 1 et \ 2 :

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

Remplacer les onglets par des espaces alignés sur des colonnes qui sont des multiples de huit:

  1 tout en 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 la liste list1 par les caractères correspondants de la liste list2 . Renvoie le nombre de caractères remplacés ou supprimés. Les listes doivent comporter des caractères séparés et / ou des plages de la forme az . La chaîne à convertir est donnée par l'opérande gauche de l'opération = ~ ou ! ~ . Il doit s'agir d'une variable scalaire, d'un élément de tableau ou d'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, l'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 n'importe quel caractère valide dans q-operations au lieu de // . Si list1 est entre parenthèses, list2 doit avoir sa propre paire de délimiteurs, par exemple tr(AZ)[az] ou tr<AZ>/az/ .

Habituellement, cette opération est appelée tr . Le synonyme y est introduit pour les fanatiques de l'éditeur sed et n'est utilisé que par eux. La translittération prend en charge les modificateurs suivants:

Modificateur Description
c Remplacer les caractères non inclus dans list1 .
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 / depuis l'encodage UTF-8.
C Convertir vers / depuis un encodage à un octet.

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

Par défaut, si list2 est plus court que list1 , il est mis à jour avec son dernier caractère, et s'il est vide, il est supposé être égal à list1 (c'est pratique pour compter le nombre de caractères d'une certaine classe dans une chaîne). Le modificateur d modifie ces règles: tous les caractères de list1 qui ne correspondent pas 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 caractères latins.

Le modificateur s supprime les doublons: si plusieurs caractères sont remplacés successivement par le même caractère, une seule occurrence de ce symbole sera conservée. Par exemple, l'opération tr/ / /s supprime les espaces répétés dans la chaîne.

Les modificateurs C et U sont conçus pour la conversion de caractères du codage du système en UTF-8 et vice versa. Le premier pointe vers l'encodage original, et le second vers l'encodage du résultat. Par exemple, tr/\0-\xFF//CU recodera la chaîne du codage système en UTF-8, et tr/\0-\xFF//UC effectuera le transcodage inverse.

La translittération se fait sans interpolation des listes de symboles, donc pour utiliser les variables, vous devez appeler la fonction eval () , par exemple:

  eval "tr / $ oldlist / $ nouvelle liste /";