Partager via


Alternative et sous-expressions

Dans une expression régulière, une alternative vous permet de regrouper des choix entre au moins deux possibilités. Cela consiste essentiellement à spécifier« ceci OU cela » dans un modèle.

Les sous-expressions vous permettent d'établir une correspondre avec un modèle dans un texte recherché et de décomposer cette correspondance en sous-correspondances. Les sous-correspondances qui en résultent peuvent être récupérées par le programme. Les sous-expressions vous permettent également de remettre en forme le texte, comme indiqué dans Backreferences dans JScript.

Pour plus d'informations sur les expressions régulières, consultez Création d'une expression régulière et Syntaxe d'une expression régulière.

Alternative

Vous pouvez utiliser le signe (|) pour spécifier un choix entre au moins deux possibilités. Ce concept est appelé alternative. Une correspondance est établie avec la plus grande expression possible d'un côté ou de l'autre du signe (|). Vous pouvez penser que l'expression JScript suivante établit une correspondance avec « Chapter » ou « Section » suivi d'un ou deux chiffres.

/Chapter|Section [1-9][0-9]{0,1}/

Mais cette expression régulière établit en fait une correspondance avec le mot « Chapter » ou le mot « Section », et ce quels que soient les chiffres qui suivent. Si la chaîne recherchée est « Section 22 », l'expression établit une correspondance avec « Section 22 ». Mais, si la chaîne recherchée est « Chapter 22 », l'expression établit une correspondance avec le mot « Chapter » au lieu d'établir une correspondance avec « Chapter 22 ».

Alternative avec parenthèses

Vous pouvez utiliser des parenthèses pour limiter la portée d'une alternative et vous assurer qu'elle ne s'applique qu'aux deux mots « Chapter » et « Section ». En ajoutant des parenthèses, vous pouvez faire en sorte que l'expression régulière établisse une correspondance avec « Chapter 1 » ou « Section 3 ».

Les parenthèses permettent toutefois également de créer une sous-expression. La sous-correspondance résultante peut être récupérée par le programme.

Les parenthèses utilisées dans l'expression régulière JScript suivante regroupent « Chapter » et « Section ». Les correspondances possibles incluront donc « Chapter » suivi de chiffres.

/(Chapter|Section) [1-9][0-9]{0,1}/

Les parenthèses qui entourent Chapter|Section permettent également d'enregistrer l'un ou l'autre des deux mots correspondants pour un usage ultérieur.

L'exemple suivant indique comment récupérer des correspondances et des sous-correspondances dans le code. Comme l'expression ne comporte qu'une seule paire de parenthèses, une seule sous-correspondance est enregistrée.

var re = /(Chapter|Section) [1-9][0-9]{0,1}/g
var src = "Chapter 50  Section 85"
ShowMatches(src, re);

// Output:
//  Chapter 50
//  submatch 1: Chapter

//  Section 85
//  submatch 1: Section

// Perform a search on a string by using a regular expression,
// and display the matches and submatches.
function ShowMatches(src, re)
{
    var result;

    // Get the first match.
    result = re.exec(src);
    
    while (result != null)
    {
        // Show the entire match.
        print();
        print(result[0]);

        // Show the submatches.
        for (var index=1; index<result.length; index++)
            {
                print("submatch " + index + ": " + result[index]);
            }

        // Get the next match.
        result = re.exec(src);
    }
}

Alternative sans sous-correspondance enregistrée

Dans l'exemple précédent, vous avez utilisé des parenthèses pour regrouper un choix entre les mots « Chapter » et « Section ».

Pour empêcher la sous-correspondance d'être enregistrée pour un usage ultérieur, vous pouvez spécifier la sous-expression (?:pattern). L'exemple suivant accomplit les mêmes tâches que dans l'exemple précédent, mais sans enregistrer la sous-correspondance.

var re = /(?:Chapter|Section) [1-9][0-9]{0,1}/g
var src = "Chapter 50  Section 85"
ShowMatches(src, re);
// Output:
//  Chapter 50
//  Section 85

Sous-expressions

La présence de parenthèses dans une expression régulière crée une sous-expression. La sous-correspondance résultante peut être récupérée par le programme.

Dans l'exemple suivant, l'expression régulière contient trois sous-expressions. Les chaînes de sous-correspondance s'affichent avec chaque correspondance.

var re = /(\w+)@(\w+)\.(\w+)/g
var src = "Please send mail to george@contoso.com and someone@example.com. Thanks!"
ShowMatches(src, re);
// The ShowMatches function is provided earlier.

// Output:
//  george@contoso.com
//  submatch 1: george
//  submatch 2: contoso
//  submatch 3: com

//  someone@example.com
//  submatch 1: someone
//  submatch 2: example
//  submatch 3: com

L'exemple suivant décompose un URI (Universal Resource Indicator).

La première sous-expression entre parenthèses enregistre la partie relative au protocole de l'adresse Web. Elle établit une correspondance avec tout mot précédant les deux-points et deux barres obliques. La deuxième sous-expression entre parenthèses enregistre la partie relative au domaine de l'adresse. Elle établit une correspondance avec toute séquence de caractères ne comportant ni barre oblique (/) ni deux-points (:). La troisième sous-expression entre parenthèses enregistre le numéro de port du site Web, si celui-ci est spécifié. Elle établit une correspondance avec les chiffres (zéro, un ou plusieurs chiffres) qui suivent les deux-points. La quatrième sous-expression entre parenthèses enregistre les informations sur le chemin d'accès et/ou la page spécifiées par l'adresse Web. Elle établit une correspondance avec les caractères (zéro, un ou plusieurs caractères) autres que le signe dièse (#) ou l'espace.

var re = /(\w+):\/\/([^\/:]+)(:\d*)?([^# ]*)/gi;
var src = "https://msdn.microsoft.com:80/scripting/default.htm";
ShowMatches(src, re);

// Output:
//  https://msdn.microsoft.com:80/scripting/default.htm
//  submatch 1: http
//  submatch 2: msdn.microsoft.com
//  submatch 3: :80
//  submatch 4: /scripting/default.htm

Préanalyses positives et négatives

Une préanalyse positive est une recherche qui présente la particularité suivante : une fois une correspondance établie, la recherche de la correspondance suivante commence avant le texte mis en correspondance. La correspondance n'est pas enregistrée pour une utilisation ultérieure. Pour spécifier une analyse positive, utilisez la syntaxe (?=pattern).

Dans l'exemple suivant, une recherche est lancée pour déterminer si un mot de passe comporte de 4 à 8 caractères et s'il contient au moins un chiffre.

Dans l'expression régulière, .*\d recherche tous les caractères suivis d'un chiffre. Pour la chaîne recherchée "abc3qr", le résultat correspondant est "abc3". En commençant avant (et non après) cette correspondance, .{4,8} établit une correspondance avec une chaîne de 4 à 8 caractères. Cela correspond à "abc3qr".

^ et $ spécifient les positions au début et à la fin de la chaîne recherchée. Cela permet d'empêcher une correspondance si la chaîne recherchée contient des caractères en dehors des caractères mis en correspondance.

var re = /^(?=.*\d).{4,8}$/gi
var src = "abc3qr"
ShowMatches(src, re);
// The ShowMatches function is provided earlier.
// Output:
//  abc3qr

Une préanalyse négative recherche une chaîne de recherche qui ne correspond pas au modèle dans une expression de préanalyse négative. Une fois une correspondance établie, la recherche de la correspondance suivante commence avant le texte mis en correspondance. La correspondance n'est pas enregistrée pour une utilisation ultérieure. Pour spécifier une préanalyse négative, utilisez la syntaxe (?!pattern).

L'exemple suivant établit une correspondance avec les mots qui ne commencent pas par « th ».

Dans l'expression régulière, \b établit une correspondance avec une limite de mot. Pour la chaîne recherchée " quick" , une correspondance est établie avec le premier espace. (?!th) correspond à une chaîne qui n'est pas "th". Cela correspond à "qu". En commençant avant cette correspondance, \w+ établit une correspondance avec un mot. Cela correspond à "quick".

var re = /\b(?!th)\w+\b/gi
var src = "The quick brown fox jumps over the lazy dog."
ShowMatches(src, re);
// Output:
//  quick
//  brown
//  fox
//  jumps
//  over
//  lazy
//  dog

Voir aussi

Concepts

Backreferences dans JScript

Autres ressources

Introduction aux expressions régulières