Programación con expresiones regulares

Es posible usar expresiones regulares en JScript para buscar modelos en una cadena, reemplazar texto y extraer subcadenas.

Buscar

En el siguiente ejemplo de JScript se buscan todas las apariciones de una palabra.

La instrucción que crea la expresión regular es

var re = /\w+/g;

El modelo /\w+/ especifica que se deben buscar coincidencias con uno o más de los caracteres siguientes: A-Z, a-z, 0-9 y el carácter de subrayado. Cuando se usa, la marca g (global) que va después del modelo especifica que, en una búsqueda, se deben encontrar todas las repeticiones del modelo y no sólo la primera aparición.

También se puede usar la siguiente sintaxis alternativa de JScript.

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

Para recuperar cada coincidencia, exec (Método) sigue buscando, desde la posición de lastIndex, hasta que se devuelve null.

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
}

En el ejemplo siguiente se busca únicamente la primera coincidencia. Dado que no se establece la marca global (g), la búsqueda comienza desde el principio de la cadena de búsqueda.

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
}

Sustitución

En el ejemplo siguiente, los casos de "the" se reemplazan con "a". El caso de "The" no se reemplaza, porque la marca i (no distinguir entre mayúsculas y minúsculas) no está incluida en la expresión regular.

En el ejemplo se usa replace (Método).

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

Extraer subcadenas

Al usar paréntesis en un modelo de expresión regular, se crea una subcoincidencia que se puede almacenar para su posterior uso.

En el ejemplo siguiente, el modelo incluye tres subcoincidencias. Las cadenas de subcoincidencia se muestran con cada coincidencia.

exec (Método) devuelve una matriz. El elemento cero de la matriz contiene la coincidencia completa y los elementos de 1 a n contienen subcoincidencias.

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
}

Marcadores

En la expresión regular de JScript /abc/gim, g especifica la marca global, i especifica la marca para no distinguir entre mayúsculas y minúsculas, y m especifica la marca multilínea.

En la tabla siguiente se muestran las marcas permitidas.

Características adicionales

Existen las siguientes características de programación adicionales.

Vea también

Referencia

Regular Expression (Objeto)

Conceptos

Crear expresiones regulares

Sintaxis de expresiones regulares