SELFHTML: JavaScript / Référence objet JavaScript / RegExp

SELFHTML/Quickbar JavaScript Référence objet

RegExp

RegExp: généralités sur l'utilisation

Propriétés:

$[1..9] (sous-expressions entre parenthèses)

Méthodes:

exec() (utiliser une expression régulière)

test() (utiliser une expression régulière pour essayer)

RegExp: généralités sur l'utilisation

Les expressions régulières servent à formuler des critères de recherche pour des recherches dans des chaînes de caractères et pour remplacer les occurrences par d'autres.

Vous pouvez utiliser des expressions régulières en JavaScript directement dans les méthodes correspondantes de l'objet string, à savoir dans les méthodes:
match()
replace()
search().
Là est décrit comment et où vous pouvez utiliser exactement des expressions régulières pour parcourir des chaînes de caractères et en remplacer des parties.

En revanche, vous n'avez besoin de l'objet RegExp de JavaScript que si vous voulez créer et modifier de façon dynamique des expressions régulières pendant l'exécution du script. Pour cela, il vous faut définir une instance de l'objet RegExp. Vous pouvez ensuite utiliser sur cette instance les propriétés et méthodes de l'objet RegExp qui sont décrites ici.

Exemple:

<html><head><title>Test</title>
<script language="JavaScript">
function sortie(valeur)
{
 var expression = /(\w.+)\s(\w.+)/;
 expression.exec(valeur);
 alert(RegExp.$2 + ", " + RegExp.$1);
}
</script>
</head><body>
<form>
<input name="User" value="prénom nom">
<input type=button value="sortie" onClick="sortie(this.form.User.value)">
</form>
</body></html>

Explication:

L'exemple montre comment un nom sous la forme "prénom nom" se laisse transformer en "nom, prénom" en utilisant une expression régulière.

L'exemple contient un formulaire avec un champ de saisie et un bouton. Dans le champ de saisie, l'utilisateur doit entrer son nom sous la forme "prénom nom". Le champ est déjà prédéfini à cet effet. En cliquant sur le bouton, la fonction sortie(), définie dans l'entête de fichier, est appelée. La fonction reçoit comme paramètre le contenu du champ de saisie.

Dans la fonction est définie une expression régulière (expression de recherche), qui est sauvegardée dans la variable expression. De telles expressions régulières sont incluses dans des barres obliques simples /.../. L'expression régulière de l'exemple ci-dessus est à lire ainsi: Recherche un nombre de lettres contiguës sans chiffre ni signe de paragraphe et retiens le résultat = (\w.+). Recherche ensuite un espace distinct = \s. Recherche ensuite encore une fois un nombre de lettres contiguës et retiens le résultat = (\w.+). De cette façon, le schéma "prénom nom" a été trouvé. Les parenthèses autour de (\w.+) ont pour conséquence que les deux suites de lettres contiguës soient distinguées en interne comme parties distinctes. Plus tard, ces parties distinctes sont adressables séparément.

La commande suivante de l'exemple emploie une méthode importante de l'objet RegExp sur l'expression régulière définie auparavant, à savoir la méthode exec(). Elle permet d' "exécuter" l'expression et de l'affecter à l'objet RegExpr. Dans l'exemple, on accède avec RegExp.$2 directement à la deuxième partie entre parenthèses, distinguée auparavant en interne, et avec RegExp.$1 à la première de ces expressions. De par leur alignement avec une virgule entre les deux est obtenu que la suite entrée "prénom nom" s'affiche ensuite selon l'autre schéma "nom, prénom".

Syntaxe d'expressions régulières

Le tableau suivant montre de quelles composantes vous pouvez former une expression régulière.

Composante	Exemple	Description
	`/par/`	trouve "par", à savoir dans "par", "départ", "parlement" et "répartie".
`^`	`/^par/`	trouve "par" au début de la valeur à rechercher, à savoir dans "par" et "parlement", à condition que l'un de ces mots apparaisse en premier dans la valeur.
`$`	`/par$/`	trouve "par" à la fin de la valeur à rechercher, à savoir dans "par" et "Épar ", à condition que l'un de ces mots apparaisse en dernier dans la valeur.
`*`	`/par*/`	trouve "par", "parr" et "parrrrrr", donc le dernier signe avant l'étoile est répété 0 ou un nombre quelconque de fois.
`+`	`/par+/`	trouve "parr" et "parrrrrr", donc le dernier signe avant l'étoile est répété au moins une ou un nombre quelconque de fois.
`.`	`/.par/`	trouve "épar" et "Spar", donc un signe quelconque à un endroit déterminé.
`.+`	`/.+par/`	trouve "épar" und "hépar", donc une suite de signes quelconque à un endroit déterminé. Résumé de lettres quelconques et nombre quelconque.
`\b`	`/\bpar\b/`	trouve "par" en tant que mot distinct. \b signifie une extrémité de mot.
`\B`	`/\Bpar\B/`	trouve"par" uniquement à l'intérieur de mots, par exemple dans "départir" ou "impartir". \B signifie pas d'extrémité de mot .
`\d`	`/\d.+\B/`	trouve un chiffre entier quelconque. \d signifie un chiffre (0 à 9)
`\D`	`/\D.+/`	trouve" ex." dans "3 ex.", donc pas de chiffres.
`\f`	`/\f/`	trouve un signe de saut de page.
`\n`	`/\n/`	trouve un signe d'avance d'une ligne (LF).
`\r`	`/\r/`	trouve un signe de retour chariot (CR).
`\t`	`/\t/`	trouve un signe de tabulation.
`\v`	`/\v/`	trouve un signe de tabulation verticale.
`\s`	`/\s/`	trouve toute sorte d'espace blanc donc \f\n\t\v et des espaces.
`\S`	`/\S.+/`	trouve un caractère quelconque distinct qui ne soit ni espace blanc donc pas \f\n\t\v ni un espace.
`\w`	`/\w.+/`	trouve tous les signes alphanumériques et le tiret de soulignement (condition typique par exemple pour des noms attribués soi-même pour qu'ils soient conformes aux langages de programmation).
`\W`	`/\W/`	trouve un signe qui ne soit ni alphanumérique ni tiret de soulignement (typique pour rechercher des signes non permis dans des noms attribués soi-même pour qu'ils soient conformes aux langages de programmation).
`\()`	`/(par)/`	trouve "par" et en prend note en interne. Jusqu'à 9 parenthèses de ce genre (endroits marqués) sont permises dans une expression régulière.
`/.../g`	`/par/g`	trouve "par" aussi souvent qu'il apparaît dans le passage à rechercher. Les occurrences sont sauvegardées en interne dans un array.
`/.../i`	`/par/i`	trouve "par", "Par" et "PAR", donc sans respecter la casse.

Vous pouvez trouvez d'autres informations éventuellement plus complètes sur les expressions régulières dans cette documentation à la page expressions régulières en Perl.

$[1..9]

Sauvegarde les parties constituantes marquées d'une expression régulière, donc les parties entre parenthèses.

Exemple:

<html><head><title>Test</title>
</head><body>
<script language="JavaScript">
 versioncomp = /(\d)/;
 versioncomp.exec(navigator.userAgent);
 document.write("numéro de version complet de votre navigateur: " + RegExp.$1);
</script>
</body></html>

Explication:

L'exemple définit une expression régulière nommée versioncomp, qui recherche la première apparition d'un chiffre et se note l'occurrence par une parenthèse = (\d). Cette expression régulière est alors utilisée sur la propriété d'objet navigator.userAgent, qui sauvegarde les mentions sur le navigateur de l'utilisateur. Comme cette valeur suit un certain schéma, il est clair que le premier chiffre qu'elle contient représente la version complète (à condition que le chiffre n'ait qu'une position). Dans l'exemple, le numéro de version trouvé est écrit dans le fichier de façon dynamique. Pour ce faire, il est accédé directement par l'objet RegExp à la propriété $1. C'est la première expression partielle distinguée entre parenthèses de l'expression régulière actuelle, dans l'exemple donc le numéro de version.

exec()

Applique une expression régulière à une chaîne de caractères.

Exemple:

<html><head><title>Test</title>
</head><body>
<script language="JavaScript">
 phrase = "Sur le mur";
 cherche = /(ur)/g;
 resultat = cherche.exec(phrase);
 document.write(resultat.length + " occurrences");
</script>
</body></html>

Explication:

L'exemple démontre la relation: une expression régulière est définie - dans l'exemple: une expression régulière nommée cherche. Avec une instruction comme cherche.exec(), vous pouvez ensuite commencer la recherche. Comme paramètre, c'est généralement l'expression dans laquelle il faut chercher qui est transmise à la méthode. La méthode retourne les occurrences trouvées. La variable dans laquelle est sauvegardée la valeur retournée (dans l'exemple la variable resultat) se transforme automatiquement en array si plus d'une occurrence est trouvée. Dans l'exemple, deux occurrences ont été trouvées. C'est pourquoi la propriété d'array length peut s'appliquer à la variable resultat.

test()

Teste à l'avance si une expression régulière trouvera des occurrences ou non. Renvoie true, si quelque chose a été trouvé et false dans le cas contraire.

Exemple:

<html><head><title>Test</title>
</head><body>
<script language="JavaScript">
 phrase = "Sur le mur";
 cherche = /(quelquechose)/g;
 resultat = cherche.test(phrase);
 if(resultat == false)
 document.write("rien n'a été trouvé");
</script>
</body></html>

Explication:

L'exemple définit une expression régulière nommée cherche et l'applique avec la méthode test() sur la variable phrase. La valeur retournée est sauvegardée dans la variable resultat. Si aucune occurrence n'a été trouvée, un avis correspondant est écrit. Dans l'exemple, c'est le cas.


après:	screen
avant:	Number

SELFHTML/Quickbar JavaScript Référence objet