cvs: phpdoc /fr/functions pcre.xml

From: Date: Tue, 30 Jan 2001 09:06:55 +0000
Subject: cvs: phpdoc /fr/functions pcre.xml
Groups: php.doc 
Request: Send a blank email to phpdoc+get-969334058@lists.php.net to get a copy of this message
dams Tue Jan 30 01:06:55 2001 EDT Modified files: /phpdoc/fr/functions pcre.xml Log: Updating translation to fit en tree.

Index: phpdoc/fr/functions/pcre.xml diff -u phpdoc/fr/functions/pcre.xml:1.11 phpdoc/fr/functions/pcre.xml:1.12 --- phpdoc/fr/functions/pcre.xml:1.11 Fri Jan 26 06:44:21 2001 +++ phpdoc/fr/functions/pcre.xml Tue Jan 30 01:06:54 2001 @@ -964,7 +964,7 @@ </refsect1> <refsect1 id="regexp.reference"> <title>D&eacute;tails sur les expressions r&eacute;guli&egrave;res</title> - <para> + <literallayout> La syntaxe et la s&eacute;mantique des expressions r&eacute;guli&egrave;re support&eacute;es par PCRE sont d&eacute;crites ci-dessous. Les expressions r&eacute;guli&egrave;res sont aussi d&eacute;crites dans la documentation @@ -973,10 +973,6 @@ chez O'Reilly (ISBN 1-56592-257-3), les d&eacute;crits en profondeur. Cette description est organis&eacute;e comme une documentation de r&eacute;f&eacute;rence. - </para> - <refsect2 id="regexp.reference.intro"> - <title>Just a title</title> - <para> Une expression r&eacute;guli&egrave;re est un masque, qui est appliqu&eacute; sur une cha&icirc;ne sujet, de gauche &agrave; droite. La plus part des caract&egrave;res se repr&eacute;sentent eux-m&ecirc;mes. Un exemple trivial : un masque qui serait @@ -987,11 +983,6 @@ dans le masque par des <emphasis>meta</emphasis>-<emphasis>characters</emphasis>, qui ne repr&eacute;sentent pas ce qu'ils sont, mais sont interpr&eacute;t&eacute;s d'une certaine mani&egrave;re. - </para> - </refsect2> - <refsect2 id="regexp.reference.meta"> - <title>Just a title</title> - <para> Il y a deux sortes de m&eacute;ta-caract&egrave;res : ceux qui sont reconnus n'importe o&uacute; dans un masque, hormis entre crochets, et ceux qui sont reconnus entre crochets. A l'ext&eacute;rieur des crochets, les m&eacute;ta caract&egrave;res sont : @@ -1018,11 +1009,6 @@ - indique un intervalle de caract&egrave;res ] termine la classe de caract&egrave;res La section suivante d&eacute;crit l'utilisation de chaque m&eacute;ta caract&egrave;res : - </para> - </refsect2> - <refsect2 id="regexp.reference.backslash"> - <title>Just a title</title> - <para> ANTISLASH Le caract&egrave;re antislash a de nombreuses utilisations. En premier lieu, s'il est suivi d'un caract&egrave;re non alpha num&eacute;rique, @@ -1143,11 +1129,6 @@ La diff&eacute;rence entre \Z et \z tient au fait que \Z recherche les positions avant les nouvelles lignes et &agrave; la fin de la cha&icirc;ne sujet, tandis que \z ne recherche que la fin de la cha&icirc;ne. - </para> - </refsect2> - <refsect2 id="regexp.reference.circudollar"> - <title>Just a title</title> - <para> CIRCUMFLEX et DOLLAR En dehors d'une classe de caract&egrave;re, avec les options par d&eacute;faut, ^ est une assertion qui n'est vraie que si elle est plac&eacute;e tout au d&eacute;but de la @@ -1180,11 +1161,6 @@ Notez que les m&eacute;ta caract&egrave;res \A, \Z, et \z peuvent servir &agrave; r&eacute;p&eacute;rer le d&eacute;but et la fin du sujet, et toutes les parties du masque qui commenceront par \A seront toujours ancr&eacute;es, avec l'option PCRE_MULTILINE ou non. - </para> - </refsect2> - <refsect2 id="regexp.reference.dot"> - <title>Just a title</title> - <para> FULL STOP (PERIOD, DOT) En dehors d'une classe de caract&egrave;res, un point remplace n'importe quel caract&egrave;re, m&ecirc;me invisible et &agrave; l'exception du caract&egrave;re de nouvelle ligne. Avec l'option @@ -1193,11 +1169,6 @@ Le seul point commun est que les deux ont un comportement particulier vis &agrave; vis des caract&egrave;re de nouvelle ligne. Le point n'a pas de comportement particulier dans une classe de caract&egrave;res. - </para> - </refsect2> - <refsect2 id="regexp.reference.squarebrackets"> - <title>Just a title</title> - <para> SQUARE BRACKETS Un crochet ouvrant introduit une classe de caract&egrave;re, et le crochet fermant la conclut. Le crochet fermant n'a pas de signification en lui m&ecirc;me. Si le crochet @@ -1248,11 +1219,6 @@ Tous les caract&egrave;res non alphanum&eacute;riques autres que \, -, ^ (plac&eacute; en d&eacute;but de cha&icirc;ne) et ] n'ont pas de significations particuli&egrave;re, mais ils ne perdront rien &agrave; &ecirc;tre &eacute;chapp&eacute;s. - </para> - </refsect2> - <refsect2 id="regexp.reference.verticalbar"> - <title>Just a title</title> - <para> VERTICAL BAR La barre verticale sert &agrave; s&eacute;parer des alternatives. Par exemple, dans le masque dupont|martin @@ -1261,11 +1227,6 @@ toutes les alternatives sont essay&eacute;es, de gauche &agrave; droit, et la premi&egrave;re qui est accept&eacute;e, est utilis&eacute;e. Si les alternatives sont dans un sous-masque, elle ne r&eacute;ussiront que si le masque principal r&eacute;ussi aussi. - </para> - </refsect2> - <refsect2 id="regexp.reference.internal_options"> - <title>Just a title</title> - <para> INTERNAL OPTION SETTING Les options PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, et PCRE_EXTENDED peuvent &ecirc;tre chang&eacute;e depuis le masque lui-m&ecirc;me, avec des s&eacute;quences mises "(?" et ")". @@ -1310,12 +1271,7 @@ U et X. L'option (?X) est particuli&egrave;re, car elle doit toujours intervenir avant toutes les autres options, m&ecirc;me au niveau du masque entier. Il vaut mieux la mettre au d&eacute;but du masque. - </para> - </refsect2> - <refsect2 id="regexp.reference.subpatterns"> - <title>Just a title</title> - <para> -SUBPATTERNS +sous-masques Les sous-masques sont d&eacute;limit&eacute;s par des parenth&egrave;ses, et peuvent &ecirc;tre imbriqu&eacute;es. Ajouter des sous-masques a deux utilit&eacute;s : 1. D&eacute;limiter des alternatives. Par exemple, le masque @@ -1347,11 +1303,6 @@ (?:(?i) samedi | dimanche) De plus, comme les s&eacute;quences d'options sont valables sur toute une alternative, le masque ci dessus acceptera aussi "DIMANCHE" que "Dimanche". - </para> - </refsect2> - <refsect2 id="regexp.reference.repetitions"> - <title>Just a title</title> - <para> REPETITION les R&eacute;p&eacute;titions sont sp&eacute;cifi&eacute;es avec des quantificateurs, qui peuvent &ecirc;tre plac&eacute;s &agrave; la suite des caract&egrave;res suivants : @@ -1438,11 +1389,6 @@ correspondante peut l'avoir &eacute;t&eacute; lors des pr&eacute;c&eacute;dentes it&eacute;rations. Par exemple : /(a|(b))+/ accepte "aba" et la deuxi&egrave;me valeur captur&eacute;e est - </para> - </refsect2> - <refsect2 id="regexp.reference.back_references"> - <title>Just a title</title> - <para> R&eacute;f&eacute;rences arri&egrave;res (back references) En dehors des classes de caract&egrave;res, un antislash suivi d'un nombre plus grand que 0 (et possiblement plusieurs chiffres) est une r&eacute;f&eacute;rence arri&egrave;re (c'est &agrave; @@ -1484,11 +1430,6 @@ fonctionne, il faut que la premi&egrave;re it&eacute;ration n'ai pas besoin d'utiliser la r&eacute;f&eacute;rence arri&egrave;re. Cela arrive avec les alternatives, comme dans l'exemple ci dessus, ou avec un quantificateur de minimum 0. - </para> - </refsect2> - <refsect2 id="regexp.reference.assertions"> - <title>Just a title</title> - <para> Les assertions Une assertion est un test sur les caract&egrave;res suivants ou pr&eacute;c&eacute;dent celui qui est en cours d'&eacute;tude. Ce test ne consomme par de caract&egrave;re (ie, on ne d&eacute;place pas le @@ -1536,11 +1477,25 @@ Plusieurs assertions peuvent intervenir successivement. Par exemple (?&lt;=\d{3})(?&lt;!999)foo recherche les cha&icirc;nes "foo" pr&eacute;c&eacute;d&eacute;e par trois chiffres qui ne sont pas "999". + Notez que chaque assertions est appliqu&eacute;es ind&eacute;pendemment, au m&ecirc;me point + de la cha&icirc;ne &agrave; traiter. Tout d'abord, il est v&eacute;rifi&eacute; que les trois premiers + caract&egrave;res ont tous des chiffres, puis on s'assure que ces trois caract&egrave;res + ne sont pas "999". Le masque pr&eacute;c&eacute;dant n'accepte pas "foo" pr&eacute;c&eacute;d&eacute; de 6 + caract&egrave;res, les trois premiers &eacute;tant des chiffres et les trois suivant + &eacute;tant diff&eacute;rents de "999". Par exemple, ce masque n'acceptera pas la cha&icirc;ne + "123abcfoo". Pour ce faire, il faut utiliser : + (?&lt;=\d{3}...)(?&lt;!999)foo + Dans ce masque, la premi&egrave;re assertion v&eacute;rifie les six premiers caract&egrave;res, + s'assure que les trois premiers sont des entiers, et la deuxi&egrave;me assertion + s'assure que les trois derniers caract&egrave;res ne sont pas "999". De plus, les assertions peuvent &ecirc;tre imbriqu&eacute;es : (?&lt;=(?&lt;!foo)bar)baz recherche les occurrences de "baz" qui sont pr&eacute;c&eacute;d&eacute;es par "bar", qui, &agrave; son tour, - n'est pas pr&eacute;c&eacute;d&eacute; par "foo". - Les assertions ne sont pas capturantes, et ne peuvent pas &ecirc;tre r&eacute;p&eacute;t&eacute;es. Si une + n'est pas pr&eacute;c&eacute;d&eacute; par "foo". Au contraire, + (?&lt;=\d{3}(?!999)...)foo + est un autre masque, qui recherche les caract&egrave;res "foo", pr&eacute;c&eacute;d&eacute;s par + trois chiffres, suivis trois autres caract&egrave;res qui ne forment pas "999". + Les assertions ne sont pas capturantes, et ne peuvent pas &ecirc;tre r&eacute;p&eacute;t&eacute;es. Si une assertion contient des sous-masques capturants en son sein, ils seront compris dans le nombre de sous-masques capturants du masque entier. La capture est r&eacute;alis&eacute;e pour les assertions positives, mais cela n'a pas de sens pour les @@ -1607,11 +1562,29 @@ va alors faire un test sur les 4 derniers caract&egrave;res. Si elle &eacute;choue, la recherche est imm&eacute;diatement interrompue. Pour les cha&icirc;nes tr&egrave;s longues, cette approche fait la diff&eacute;rence en terme de performance et de temps de recherche. - </para> - </refsect2> - <refsect2 id="regexp.reference.conditional"> - <title>Just a title</title> - <para> + Lorsqu'un masque contient une r&eacute;p&eacute;tition illimit&eacute;e dans un sous-masque, + qui contient lui-m&ecirc;me un nombre illimit&eacute; de r&eacute;p&eacute;titeur, l'utilisation des + sous-masques &agrave; utilisation unique sont la seule fa&ccedil;on d'&eacute;viter l'&eacute;chec + de la recherche &agrave; cause d'un temps de calcul trop long. + Le masque + (\D+|&lt;\d+&gt;)*[!?] + recherche un nombre illimit&eacute; de sous-cha&icirc;nes, qui contiennent + soit des non-chiffres, ou alors des chiffres inclus dans + &lt;&gt;, suivi soit par ! ou par ?. Lorsqu'il trouve une solution, + ce masque va tr&egrave;s vite. Mais, lorsqu'il est appliqu&eacute; &agrave; une cha&icirc;ne + telle que : + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + Il lui faut beaucoup de temps pour annoncer un &eacute;chec. Cela est + du au fait que la chaine peut &ecirc;tre divis&eacute;e en deux sous-cha&icirc;nes + d'un grand nombre de fa&ccedil;ons, et qu'elles ont toutes &eacute;t&eacute; essay&eacute;es. + (Cet exemple utilisait [!?] plutot qu'un caract&egrave;re simple, car + PCRE et PHP utilise une optimisation qui permet de detecter rapidement + l'&eacute;chec lorsqu'un caract&egrave;re unique est trouv&eacute;. Il se souvient + du dernier caract&egrave;re qui est attendu, et s'apercoit rapidement + qu'il n'y a pas ce caract&egrave;re.). Si le masque utilis&eacute; est + ((?&gt;\D+)|&;lt;\d+&gt;)*[!?] + les s&eacute;quences de chiffres ne peuvent pas &ecirc;tre trouv&eacute;es, et l'&eacute;chec + intervient rapidement. Les sous-masques conditionnels (CONDITIONAL SUBPATTERNS) Il est possible de lier un sous-masque &agrave; un une condition, ou de choisir entre deux sous-masques alternatifs, en fonction du r&eacute;sultat d'une assertion, ou @@ -1648,11 +1621,6 @@ poursuit avec la premi&egrave;re alternative, et sinon, avec la seconde. Ce masque recherche des cha&icirc;nes de la forme dd-aaa-dd ou dd-dd-dd, avec aaa qui sont des lettres, et dd qui sont des chiffres - </para> - </refsect2> - <refsect2 id="regexp.reference.comments"> - <title>Just a title</title> - <para> COMMENTS La s&eacute;quence (?# marque le d&eacute;but des commentaires, qui se termine &agrave; la procha&icirc;ne parenth&egrave;se fermante. Les parenth&egrave;ses imbriqu&eacute;es ne sont pas autoris&eacute;es. @@ -1661,11 +1629,50 @@ Si l'option PCRE_EXTENDED est mise, les caract&egrave;res di&egrave;ses # non &eacute;chapp&eacute;s en dehors d'une classe de caract&egrave;res introduisent un commentaire qui continuera jusqu'&agrave; la procha&icirc;ne ligne dans le masque. - </para> - </refsect2> - <refsect2 id="regexp.reference.performances"> - <title>Just a title</title> - <para> +Masques r&eacute;cursifs + Consid&eacute;rons le cas o&ugrave; il faut recherche dans une cha&icirc;ne, avec un + niveau d'imbrication infini de parenth&egrave;ses. Sans l'aide de la r&eacute;cursivit&eacute;, le + mieux que nous puissions obtenir est de cr&eacute;er un masque avec un + niveau fix&eacute; de profondeur d'imbrication. Il n'est pas possible + de traiter des masques &agrave; niveau d'imbrications variable. PCRE fournit + un nouvel outil exp&eacute;rimental qui permet d'utiliser la r&eacute;cursivit&eacute; + dans les masques (entre autre). L'option (?R) est fournie pour servir + la cause de la r&eacute;cursivit&eacute;. Le masque suivant r&eacute;soud le probl&egrave;me des + parenth&egrave;ses (en utilisant l'option PCRE_EXTENDED est utilis&eacute;e pour + ignorer les espaces) : + \( ( (?&gt;[^()]+) | (?R) )* \) + Tout d'abord, le masque recherche une parenth&egrave;se ouvrante. Puis, + il recherche n'importe quel nombre de sous-cha&icirc;nes qui sont soit + des s&eacute;quences de caract&egrave;res non-parenth&egrave;ses, ou bien une recherche + r&eacute;cursive avec le m&ecirc;me masque (i.e. une cha&icirc;ne correctement + inclus entre parenth&egrave;ses). Finalement, il recherche une + parenth&egrave;se fermante. + Cet exemple particulier contient un nombre illimit&eacute; de r&eacute;p&eacute;titions + imbriqu&eacute;es, ce qui fait que l'utilisation de sous-cha&icirc;nes &agrave; + utilisation unique pour rechercher les s&eacute;quence de caract&egrave;res + non-parenth&egrave;ses est important, lorsqu'il s'applique &agrave; une cha&icirc;ne + qui n'est pas valide. Par exemple, si on l'applique &agrave; + (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa() + la r&eacute;ponse arrive rapidement. Sinon, si les sous-cha&icirc;nes &agrave; utilisation + unique ne sont pas utilis&eacute;es, la recherche peut prendre un tr&egrave;s long + temps, car il existe de tr&egrave;s nombreuses combinaisons de + + et * &agrave; tester avant de conclure &agrave; l'&eacute;chec. + Les valeurs utilis&eacute;es pour capturer les sous-masques sont celles + utilis&eacute;es par les niveaux les plus hauts de r&eacute;cursivit&eacute;s, auquel + la valeur est fix&eacute;e. Si le masque pr&eacute;c&eacute;dent est utilis&eacute; avec + (ab(cd)ef) + la valeur de la parenth&egrave;se capturante est "ef", qui est la derni&egrave;re + valeur lue au niveau sup&eacute;rieur. Si de nouvelles parenth&egrave;ses sont + ajout&eacute;es, par exemple : + \( ( ( (?&gt;[^()]+) | (?R) )* ) \) + ^ ^ + ^ ^ + alors la cha&icirc;ne captur&eacute;e est "ab(cd)ef", c'est &agrave; dire le contenu de la + parenth&egrave;ses capturant de plus haut niveau. S'il y a plus de 15 parenth&egrave;ses + capturantes dans une cha&icirc;ne, PCRE doit utiliser plus de m&eacute;moire pour + stocker ces donn&eacute;es. S'il ne peut obtenir cette m&eacute;moire suppl&eacute;mentaire, + il ne fait que sauver les 15 premi&egrave;res, car il n'y a pas moyen de g&eacute;n&eacute;rer + une erreur de m&eacute;moire lors d'une r&eacute;cursion. PERFORMANCE Certaines s&eacute;quences de recherches sont plus efficaces que d'autres. Ainsi, il est plus efficace d'utiliser une classe de caract&egrave;res telle que [aeiou] plut&ocirc;t @@ -1689,8 +1696,30 @@ avec l'option PCRE_DOTALL, ou en ancrant le masque avec ^.*. Cela &eacute;vite &agrave; PCRE de scanner toute la cha&icirc;ne pour rechercher un caract&egrave;re de nouvelle ligne et recommencer la recherche. - </para> - </refsect2> + Attention aux masques qui contiennent des quantificateurs infinis + imbriqu&eacute;s. Ils peuvent demander un temps de calcul tr&egrave;s long, lorsqu'appliqu&eacute;s + &agrave; une cha&icirc;ne qui n'accepte pas ce masque. Par exemple, + (a+)* + peut accepter "aaaa" de 33 mani&egrave;res diff&eacute;rentes, et ce nombre + croit rapidement avec la taille de la cha&icirc;ne (le quantificateur + * peut prendre les valeurs de 0, 1, 2, 3, ou 4, et pour chaque cas + non nul, le quantificateur + peut prendre diff&eacute;rentes valeurs). + Lorsque le reste de la cha&icirc;ne est tel que l'on s'achemine vers un + &eacute;chec, PCRE doit en principe v&eacute;rifier toutes les possibilit&eacute;s, et cela + prend un temps extr&ecirc;mement long. + Un optmiseur rep&egrave;re les cas les plus simples, tel que + (a+)*b + o&ugrave; un caract&egrave;re simple suit les quantificateurs. Avant de partir + dans les proc&eacute;dures standard de recherche, PCRE s'assure qu'il y a + au moins un "b" dans la cha&icirc;ne, et si ce n'est pas le cas, l'&eacute;chec + est annonc&eacute; imm&eacute;diatement. Sinon, il n'y a pas d'optimisation dans + la recherche. Vous pouvez voir la diff&eacute;rence de comportement + avec le masque suivant : + (a+)*\d + Le premier retourne un &eacute;chec quasi imm&eacute;diatement, s'il est appliqu&eacute; + &agrave; une ligne de "a", alors que le second masque prend un temps + significatif pour une cha&icirc;ne de plus de 20 caract&egrave;res. + </literallayout> </refsect1> </refentry> </reference>
« previous php.doc (#969334058) next »