Programação de expressão regular

Você pode usar expressões regulares no JScript para procurar por padrões em uma seqüência de caracteres, substitua o texto e extraia substrings.

A pesquisa

O seguinte JScript exemplo localiza todas as ocorrências da palavra.

A instrução que cria a expressão regular é

var re = /\w+/g;

O /\w+/ padrão especifica para coincidir com um ou mais dos seguintes caracteres: A-Z, a-z, 0-9 e o caractere de sublinhado. O g sinalizador (global) que segue o padrão especifica que a pesquisa deve localizar todas as ocorrências do padrão em vez de apenas a primeira ocorrência.

Você também pode usar a seguinte alternativa JScript sintaxe.

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

Para recuperar cada correspondência, o Método de EXEC mantém pesquisa, começando na posição de lastIndex, até null é retornado.

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
}

O exemplo a seguir localiza a primeira correspondência. Porque o modelo global (g) sinalizador não estiver definido, a pesquisa começa a partir do início da string de pesquisa.

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
}

Substituindo

No exemplo a seguir, as ocorrências de "a" são substituídas por "a". A instância do "The" não é substituído, porque o i (ignorar maiúsculas e minúsculas) sinalizador não está incluída na expressão regular sinalizadores.

O exemplo usa o o método replace.

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.
}

Extraindo Substrings

Colocar parênteses em um padrão de expressão regular cria um submatch que pode ser armazenado para uso posterior.

No exemplo a seguir, o padrão inclui três subcorrespondentes. As seqüências de caracteres submatch exibem junto com cada correspondência.

Uma matriz é retornada pelo Método de EXEC. Zero de elemento da matriz contém a correspondência completa e os elementos 1 através de n conter subcorrespondentes.

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
}

Sinalizadores

No JScript expressão regular /abc/gim, o g Especifica o sinalizador global, o i Especifica o sinalizador de ignorar ocorrência e o m Especifica o sinalizador de várias linhas.

A tabela a seguir mostra os sinalizadores permitidos.

JScriptSinalizador	Se houver um sinalizador
g	Localize todas as ocorrências do padrão na seqüência de caracteres pesquisada, em vez da primeira ocorrência.
i	A pesquisa não diferencia maiúsculas de minúsculas.
m	^posições de correspondências seguindo um \n ou \r, e $corresponde a posições antes de \n ou \r. Se o sinalizador estiver presente, ^ corresponde à posição no início da cadeia de caracteres pesquisada, e $ corresponde à posição final da seqüência de caracteres pesquisada.

Recursos adicionais

Os seguintes recursos de programação adicionais estão disponíveis.

Característica	Descrição
compilar o método (Visual Studio - JScript)	Compile uma expressão regular em um formato interno para execução mais rápida.
Método de teste.	Teste se ocorre um padrão em uma seqüência de caracteres pesquisada.
Método de pesquisa.	Retorne a posição da primeira correspondência.

Consulte também

Referência

Objeto de expressão regular

Conceitos

Criando uma expressão Regular

Sintaxe de expressão regular