Provided by: manpages-fr_4.13-4_all bug

NOM

       regex – Expressions rationnelles POSIX.2

DESCRIPTION

       Les  expressions  rationnelles  (« ER »), définies par POSIX.2 existent sous deux formes :
       les ER modernes (en gros celles de  egrep que  POSIX.2  appelle  expressions  rationnelles
       « étendues »)  et  les  ER  obsolètes  (en gros celles de ed(1) — les ER « basiques » pour
       POSIX.2) (N.d.T. : le terme « officiel » pour la traduction de « regular expression »  est
       « expression    rationnelle »    et    c'est    celui    employé   ici,   mais   consultez
       https://fr.wikipedia.org/wiki/Expression_régulières). Les ER obsolètes existent surtout  à
       titre  de  compatibilité  avec  d'anciens  programmes et  elles  seront abordées à la fin.
       POSIX.2 laisse de côté certains aspects syntaxiques  et  sémantiques  des  ER ;  un  signe
       « (!) »  indique  une interprétation qui peut ne pas être totalement portable sur d'autres
       implémentations de POSIX.2.

       Une ER (moderne) est une(!) ou plusieurs branches non vides(!), séparées par  « | ».  Elle
       correspond à tout ce qui correspond à l'une des branches.

       Une  branche  est  une(!)  ou  plusieurs  pièces  concaténées.  Elle  correspond  à ce qui
       correspond à la première pièce, suivi de ce qui correspond  à  la  seconde,  et  ainsi  de
       suite.

       Une  pièce  est  un  atome suivi éventuellement d'un unique(!) « * », « + », « ? » ou d'un
       encadrement. Un atome suivi de « * » correspond  à  une  séquence  de  zéro  ou  plusieurs
       correspondances pour l'atome. Un atome suivi d'un « + » correspond à une séquence d’une ou
       plusieurs correspondances pour l'atome.  Un  atome  suivi  d'un  « ? »  correspond  à  une
       séquence de zéro ou une correspondance pour l'atome.

       Un  encadrement  est  un  « { »  suivi d'un entier décimal non signé, suivi éventuellement
       d'une virgule, suivie éventuellement d'un autre entier décimal non signé, toujours  suivis
       d'un  « } ». Les entiers doivent être entre 0 et RE_DUP_MAX (255(!)) compris et, s'il y en
       a deux, le second ne doit pas être  plus  petit  que  le  premier.  Un  atome  suivi  d'un
       encadrement  contenant  un  entier  i  et  pas  de  virgule correspond à une séquence de i
       correspondances pour l'atome exactement. Un atome  suivi  d'un  encadrement  contenant  un
       entier  i  et  une  virgule  correspond  à  une séquence d'au moins i correspondances pour
       l'atome. Un atome suivi d'un encadrement contenant deux entiers i et j  correspond  à  une
       séquence de i à j (compris) correspondances pour l'atome.

       Un  atome  est  une  ER  encadrée par des parenthèses (correspondant à ce qui correspond à
       l’ER), un ensemble vide « () » (correspondant à la chaîne vide)(!), une  expression  entre
       crochets  (voir  plus  bas), un point « . » (correspondant à n'importe quel caractère), un
       accent « ^ » (correspondant à une chaîne vide en début de ligne), « $ »  (correspondant  à
       une  chaîne  vide  en  fin  de ligne), un « \ » suivi d'un des caractères « ^.[$()|*+?{\ »
       (correspondant à ce caractère considéré comme un caractère ordinaire), un « \ »  suivi  de
       n'importe  quel  autre caractère(!) (correspondant au caractère pris sous forme littérale,
       comme si le « \ » était absent(!)), ou un caractère simple sans signification particulière
       (correspondant  à  ce  caractère).  Un  « { » suivi d'un caractère autre qu'un chiffre est
       considéré sous sa forme littérale, non pas comme le  début  d’un  encadrement(!).  Il  est
       illégal de terminer une ER avec un « \ ».

       Une  expression  entre  crochets  est  une  liste  de caractères encadrés par « [] ». Elle
       correspond normalement à n'importe quel caractère de la liste (mais voir ci-après). Si  la
       liste  débute  par « ^ », elle correspond à n'importe quel caractère sauf ceux de la liste
       (mais voir ci-après). Si deux caractères de la  liste  sont  séparés  par  un  « - »,  ils
       représentent tout l'intervalle de caractères entre eux (compris). Par exemple « [0-9] » en
       ASCII représente n'importe quel chiffre décimal. Il  est  illégal(!)  d'utiliser  la  même
       limite  dans  deux  intervalles,  comme  « a-c-e ».  Les intervalles dépendent beaucoup de
       l'ordre de classement des caractères et les programmes portables  doivent  éviter  de  les
       utiliser.

       Pour  insérer  un « ] » littéral dans la liste, il faut le mettre en première position (ou
       après un éventuel « ^ »). Pour inclure un « - » littéral, il faut le placer en première ou
       en dernière position, ou comme seconde borne d'un intervalle. Pour utiliser un « - » comme
       première borne d'intervalle, encadrez-le entre « [. » et « .] » pour en faire  un  élément
       de  classement  (voir plus bas). À l'exception de ces éléments et de quelques combinaisons
       avec des crochets (voir plus bas), tous les  autres  caractères  spéciaux,  y  compris  le
       « \ », perdent leurs significations spéciales dans une expression entre crochets.

       Dans  une  expression  entre  crochets, un élément de classement (un seul caractère ou une
       séquence de caractères qui se comporte comme un seul, ou un nom de séquence de  classement
       pour  l’un  ou  l’autre) entre « [. » et « .] » correspond à la séquence des caractères de
       cet élément de classement. Une séquence est un seul  élément  de  la  liste  d'expressions
       entre  crochets.  Une  expression  entre  crochets  contenant  un  élément  de  classement
       multicaractère peut donc correspondre à plus d'un caractère. Par exemple, si  la  séquence
       inclut  un  élément  de  classement  « ch », alors l'ER « [[.ch.]]*c » correspond aux cinq
       premiers caractères de « chchcc ».

       Dans une expression entre crochets, un élément de classement encadré par « [= » et  « =] »
       est  une  classe  d'équivalence,  représentant  les  séquences  de  caractères de tous les
       éléments de classement équivalents à celui-ci, y compris lui-même (s'il n'y a pas d'autres
       éléments  de  classement  équivalents,  le fonctionnement est le même que si l'encadrement
       était « [. » et « .] »). Par exemple, si o et ^ sont les membres d'une classe équivalence,
       alors  « [[=o=]] »,  « [[=o^=]] » et « [oo^] » sont tous synonymes. Une classe d'équivalence
       ne doit(!) pas être une borne d'intervalle.

       Dans une expression entre crochets, le nom d'une classe de caractères encadré  par  « [: »
       et  « :] » correspond à la liste de tous les caractères de la classe. Les noms des classes
       standard sont :

              alnum   digit   punct
              alpha   graph   space
              blank   lower   upper
              cntrl   print   xdigit

       Ces  classes  correspondent  aux  classes  de  caractères  définies  pour  wctype(3).  Une
       localisation  peut en fournir d'autres. Une classe de caractères ne doit pas être utilisée
       comme borne d'intervalle.

       Dans le cas où une ER peut correspondre à plusieurs sous-chaînes d'une chaîne donnée, elle
       correspond  à  celle  qui commence le plus tôt dans la chaîne. Si l'ER peut correspondre à
       plusieurs  sous-chaînes  débutant  au  même  point,  elle  correspond  à  la  plus  longue
       sous-chaîne.  Les  sous-expressions  correspondent  aussi  à  la  plus  longue sous-chaîne
       possible, à condition que la correspondance complète soit la plus  longue  possible,  avec
       les  sous-expressions  débutant  le  plus tôt dans l'ER ayant priorité sur celles débutant
       plus loin. Notez que les sous-expressions  de  haut  niveau  ont  donc  priorité  sur  les
       sous-expressions de bas niveau les composant.

       La  longueur des correspondances est mesurée en caractères, pas en éléments de classement.
       Une chaîne vide est considérée comme plus longue  qu'aucune  correspondance.  Par  exemple
       « bb* »     correspond     aux     trois    caractères    du    milieu    de    « abbbc »,
       « (wee|week)(knights|nights) » correspond aux  dix  caractères  de  « weeknights »,  quand
       « (.*).* »  est  mis  en correspondance avec « abc », la sous-expression entre parenthèses
       correspond aux trois caractères, et si « (a*)* » est mis en  correspondance  avec  « bc »,
       l'ER  entière  et  la  sous-ER  entre parenthèses correspondent toutes deux avec la chaîne
       vide.

       Si une correspondance sans distinction de casse est demandée, toutes les différences entre
       capitales  et  minuscules  disparaissent  de  l'alphabet.  Quand  un  symbole alphabétique
       existant dans les deux casses apparait  hors  d'une  expression  entre  crochets,  il  est
       remplacé  par  une  expression  contenant  les  deux  casses  (par  exemple  « x » devient
       « [xX] »). Lorsqu'il apparaît dans une expression entre  crochets,  tous  ses  équivalents
       sont ajoutés (« [x] » devient « [xX] » et « [^x] » devient « [^xX] »).

       Aucune  limite  particulière  n'est  imposée  sur  la  longueur  des ER(!). Les programmes
       destinés à être portables devraient limiter leurs ER à 256 octets, car une  implémentation
       peut refuser les expressions plus longues pour demeurer compatible avec POSIX.

       Les  expressions  rationnelles  obsolètes  (« basiques »)  diffèrent sur plusieurs points.
       « | », « + » et « ? » sont des caractères normaux et n’ont pas  d’équivalents  pour  leurs
       fonctionnalités.  Les  délimiteurs d'encadrement sont « \{ » et « \} », car « { » et « } »
       sont des caractères ordinaires. Les parenthèses pour les sous-expressions sont  « \( »  et
       « \) »,  « ( »  et  « ) »  étant  par  eux-mêmes  des  caractères ordinaires. « ^ » est un
       caractère ordinaire sauf au début d'une ER ou(!)  au  début  d'une  sous-expression  entre
       parenthèses,  « $ » est un caractère ordinaire sauf à la fin d'une ER ou(!) à la fin d'une
       sous-expression entre parenthèses, et « * » est un caractère ordinaire  s'il  apparaît  au
       début  d'une  ER  ou  au  début d'une sous-expression entre parenthèses (après un éventuel
       « ^ » au début).

       Enfin, il existe un nouveau type d'atome, la référence arrière : « \ » suivi d'un  chiffre
       décimal  non  nul  n  qui  correspond  à  la  même  séquence de caractères que ceux mis en
       correspondance avec la n-ième sous-expression entre parenthèses (les sous-expressions sont
       numérotées  par  leurs  parenthèses  ouvrantes,  de gauche à droite), ainsi « \([bc]\)\1 »
       correspond à « bb » ou « cc » mais pas à « bc ».

BOGUES

       Utiliser deux sortes d'ER est une ineptie.

       La norme POSIX.2 actuelle dit que « ) » est un caractère  ordinaire  en  l'absence  de  la
       « ( »   correspondante.   C'est   dû  à  une  erreur  d'interprétation  et  cela  changera
       probablement. Évitez d'en tenir compte.

       Les références arrières sont une terrible ineptie et posent de  gros  problèmes  pour  une
       implémentation   efficace.   Elles   sont   de   plus   assez  mal  définies  (est-ce  que
       « a\(\(b\)*\2\)*d » correspond à « abbbd » ?). Évitez-les.

       Les spécifications de POSIX.2 sur les correspondances sans distinction de casse sont assez
       vagues.  La  définition  « une  casse implique toutes les casses » donnée plus haut est le
       consensus actuel parmi les implémentations comme étant la bonne interprétation.

AUTEUR

       Cette page est tirée du paquet regex de Henry Spencer.

VOIR AUSSI

       grep(1), regex(3)

       POSIX.2, section 2.8 (Regular Expression Notation).

COLOPHON

       Cette page fait partie de la publication 5.10 du projet man-pages Linux.  Une  description
       du  projet et des instructions pour signaler des anomalies et la dernière version de cette
       page peuvent être trouvées à l'adresse https://www.kernel.org/doc/man-pages/.

TRADUCTION

       La traduction française de cette  page  de  manuel  a  été  créée  par  Christophe  Blaess
       <https://www.blaess.fr/christophe/>,  Stéphan  Rafin  <stephan.rafin@laposte.net>, Thierry
       Vignaud <tvignaud@mandriva.com>, François Micaux, Alain  Portal  <aportal@univ-montp2.fr>,
       Jean-Philippe    Guérard   <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)   <jean-
       luc.coulon@wanadoo.fr>,   Julien    Cristau    <jcristau@debian.org>,    Thomas    Huriaux
       <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
       Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>,  Denis
       Barbier   <barbier@debian.org>,   David   Prévot  <david@tilapin.org>,  Frédéric  Hantrais
       <fhantrais@gmail.com> et Jean-Paul Guillonneau <guillonneau.jeanpaul@free.fr>

       Cette traduction est une documentation libre ; veuillez vous reporter  à  la  GNU  General
       Public   License   version 3  ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩  concernant  les
       conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
       message à debian-l10n-french@lists.debian.org ⟨⟩.

                                           13 août 2020                                  REGEX(7)