Programmation des expressions régulières

Vous pouvez utiliser des expressions régulières en JScript pour rechercher des modèles dans une chaîne, remplacer du texte et extraire des sous-chaînes.

Recherche

L'exemple JScript suivant recherche toutes les occurrences d'un mot.

L'instruction qui crée l'expression régulière est la suivante :

var re = /\w+/g;

Le modèle /\w+/ spécifie qu'il faut établir une correspondance avec un ou plusieurs des caractères suivants : A-Z, a-z, 0-9 et le trait de soulignement. L'indicateur g (global) placé à la suite du modèle spécifie que la recherche doit trouver toutes les occurrences du modèle et non la première occurrence uniquement.

Vous pouvez également utiliser la syntaxe de remplacement JScript suivante.

var re = new RegExp("\\w+", "g");

Pour récupérer chaque correspondance, la exec, méthode continue la recherche, à partir de la position de lastIndex, jusqu'à ce que la valeur null soit retournée.

function SearchGlobal()
{
    var src = "The quick brown fox jumps over the lazy dog.";

    // Create a regular expression pattern that has a global flag.
    var re = /\w+/g;

    var result;

    // Get the first match.
    result = re.exec(src);
    while (result != null)
    {
        print (result.index + "-" + result.lastIndex + "\t" + result[0]);

        // Get the next match.
        // Because the global flag is set, the search starts at the
        // position of lastIndex.
        result = re.exec(src);
    }

    // Output:
    //  0-3 The
    //  4-9 quick
    //  10-15 brown
    //  16-19 fox
    //  20-25 jumps
    //  26-30 over
    //  31-34 the
    //  35-39 lazy
    //  40-43 dog
}

L'exemple suivant recherche juste la première correspondance. Étant donné que l'indicateur global (g) n'est pas défini, la recherche démarre au début de la chaîne recherchée.

function SearchNonGlobal()
{
    var src = "The quick brown fox jumps over the lazy dog.";

    // Create a regular expression that does not have
    // a global flag.
    var re = /\w+/;

    // Get the first match.
    // Because the global flag is not set, the search starts
    // from the beginning of the string.
    var result = re.exec(src);

    if (result == null)
        print ("not found");
    else
        {   
        print (result.index + "-" + result.lastIndex + "\t" + result[0]);
        }

    // Output:
    //  0-3 The
}

Remplacement

Dans l'exemple suivant, les occurrences de "the" sont remplacées par "a". L'instance de "the" n'est pas remplacée, car l'indicateur i (ignorer la casse) n'est pas inclus dans les indicateurs d'expression régulière.

L'exemple utilise la replace, méthode.

function ReplaceGlobal()
{
    var src = "The batter hit the ball with the bat ";
    src += "and the fielder caught the ball with the glove.";

    // Replace "the" with "a".
    var re = /the/g;
    var result = src.replace(re, "a");

    print(result);

    // Output:
    //  The batter hit a ball with a bat and a fielder caught a ball with a glove.
}

Extraction de sous-chaînes

Le placement de parenthèses dans un modèle d'expression régulière crée une sous-correspondance qui peut être stockée pour une utilisation ultérieure.

Dans l'exemple suivant, le modèle inclut trois sous-correspondances. Les chaînes de sous-correspondance s'affichent avec chaque correspondance.

Un tableau est retourné par la exec, méthode. L'élément zéro du tableau contient la correspondance complète, les éléments 1 à n contiennent les sous-correspondances.

function SearchWithSubmatches()
{
    var result;

    var src = "Please send mail to george@contoso.com and someone@example.com. Thanks!";

    // Create a regular expression to search for an e-mail address.
    // Include the global flag.
    // (More sophisticated RegExp patterns are available for
    // matching an e-mail address.)
    var re = /(\w+)@(\w+)\.(\w+)/g;

    // Get the first match.
    result = re.exec(src);
    while (result != null)
    {
        print ("e-mail address: " + result[0]);

        // Get the submatched parts of the address.
        print ("user name: " + result[1]);
        print ("host name: " + result[2]);
        print ("top-level domain: " + result[3]);
        print ("");

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

    // Output:
    //  e-mail address: george@contoso.com
    //  user name: george
    //  host name: contoso
    //  top-level domain: com

    //  e-mail address: someone@example.com
    //  user name: someone
    //  host name: example
    //  top-level domain: com
}

Flags

Dans l'expression régulière JScript /abc/gim, g spécifie l'indicateur global, i spécifie l'indicateur de non-respect de la casse et m spécifie l'indicateur de lignes multiples.

Le tableau suivant montre les indicateurs autorisés.

Indicateur JScript	Si l'indicateur est présent
g	Trouve toutes les occurrences du modèle dans la chaîne recherchée au lieu de la première occurrence uniquement.
i	La recherche ne respecte pas la casse.
m	^ correspond aux positions après \n ou \r, et $ correspond aux positions avant \n ou \r. Que l'indicateur soit présent ou non, ^ correspond à la position de début dans la chaîne recherchée, alors que $ correspond à la position de fin dans la chaîne recherchée.

Fonctionnalités supplémentaires

Les fonctionnalités de programmation supplémentaires suivantes sont disponibles.

Fonctionnalité	Description
Méthode compile (Visual Studio - JScript)	Compile une expression régulière en un format interne en vue d'une exécution plus rapide.
test, méthode	Teste si un modèle existe dans une chaîne recherchée.
search, méthode	Retourne la position de la première correspondance.

Voir aussi

Référence

Regular Expression, objet

Concepts

Création d'une expression régulière

Syntaxe d'une expression régulière