Please note, this is a STATIC archive of website developer.mozilla.org from 03 Nov 2016, cach3.com does not collect or store any user information, there is no "phishing" involved.
Los resultados de tu búsqueda

    RegExp

    Sumario

    Crea un objeto 'expresión regular' para encontrar texto de acuerdo a un patrón.

    Sintaxis

    RegExp(patrón [, flags])
    /patrón/flags

    Parametros

    patrón
    El texto de la expresión regular.
    flags

    Si se especifica, los flags puenden ser una combinación de los siguientes valores:

    g
    busqueda global (global match)
    i
    ignorar mayúsculas o minúsculas
    m
    Tratar caracteres de inicio y fin (^ y $) como multiples líneas de texto(por ejemplo: encontrar el inicio o fin de cada línea delimitada por \n o \r, no sólo al inicio o fin de toda la entrada de texto)
    y

    sticky; matches only from the index indicated by the lastIndex property of this regular expression in the target string (and does not attempt to match from any later indexes). This allows the match-only-at-start capabilities of the character "^" to effectively be used at any location in a string by changing the value of the lastIndex property.

    Descripción

    Cuando se usa la función constructor, la cadena de escape de reglas normal (precedida del caracter especial \ cuando incluye un string) es necesaria. Por ejemplo, lo siguiente es equivalente:

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

    Hay que remarcar que los parámetros en formato literal no usan comillas para indicar strings, mientras que los parámetros para la funcion constructor usan comillas. Así la siguiente expresión crea la misma expresión regular:

    /ab+c/i;
new RegExp("ab+c", "i");

    Caracteres especiales en expresiones regulares

    Carácter Significado
    \

    Para los caracteres que generalmente son tratados literalmente, indica que el siguiente carácter es especial y no debe interpretarse literalmente.

    Por ejemplo, /b/ encuentra el carácter 'b'. Al colocar una barra invertida delante de b, de la forma /\b/, el carácter se convierte en especial al significar la busqueda de un límite de palabra(word boundary).

    o

    Para los caracteres que normalmente se tratan de forma especial, indica que el siguiente carácter no es especial y debe ser interpretado literalmente.

    Por ejemplo, * es un carácter especial que significa que 0 o más ocurrencias del carácter precedente deberían ser encontradas; por ejemplo, /a*/ significa 0 o mas "aes". Para encontrar * literalmente, debe precederle la barra invertida; por ejemplo, /a\*/ encuentra 'a*'.
    ^

    Encuentra el principio de la entrada. Si el flag multilínea aparece como verdadero, también coincide con el carácter inmediatamente después de un carácter de salto de línea.

    Por ejemplo, /^A/ no encuentra la 'A' en "an A", pero si encuentra la primera 'A' en "An A."
    $

    Encuentra el final de la entrada. Si el flag multilínea es puesto a verdadero, también encuentra el carácter inmediatamente después al carácter de salto de linea.

    Por ejemplo, /t$/ no encuentra la 't' en "eater", pero la encuentra en "eat".
    *

    Encuentra el elemento anterior 0 o más veces.

    Por ejemplo, /bo*/ encuentra 'boooo' en "A ghost booooed" y 'b' en "A bird warbled", pero no encuentra nada en "A goat grunted".
    +

    Encuentra el elemento precedente 1 o mas veces. Es equivalente a {1,}.

    Por ejemplo, /a+/ encuentra la 'a' en "candy" y todas las aes en "caaaaaaandy".
    ?

    Encuentra el elemento precedente 0 o una vez.

    Por ejemplo, /e?le?/ encuentra el 'el' en "angel" y el 'le' en "angle."

    Si es usado inmediantamente despues de cualquier cuantificador *, +, ?, o {}, hace al cuantificador no expansivo (encontrando el mínimo número de veces), en comparación con el valor por defecto, el cual es expansivo (encuentra el máximo número de veces).

    También usado en las afirmaciones posteriores, descritas bajo (?=), (?!), y (?:) en esta tabla.
    .

    (El punto decimal) encuentra cualquier carácter excepto los caracteres de nueva linea: \n \r \u2028 o \u2029. ([\s\S] puede ser usado para encontrar cualquier carácter incluyendo nuevas lineas.)

    Por ejemplo, /.n/ encuentra 'an' y 'on' en "nay, an apple is on the tree", pero no 'nay'.
    (x)

    Encuentra x y recuerda la busqueda. Se llaman paréntesis de captura.

    Por ejemplo, /(foo)/ encuentra y recuerda 'foo' en "foo bar." El substring encontrado puede ser vuelto a llamar desde el array de elementos resultante [1], ..., [n] o desde las propiedades predefinidas del objeto RegExp $1, ..., $9.
    (?:x)

    Encuentra x pero no recuerda la búsqueda. Estos son llamados los paréntesis de no-captura. El substring encontrado no puede ser re-llamado desde el array de elementos resultante [1], ..., [n] o desde las propiedades predefinidas del objeto RegExp $1, ..., $9.
    x(?=y)

    Encuentra x solo si x es seguido de y. Por ejemplo, /Jack(?=Sprat)/ encuentra 'Jack' solo si está seguido de 'Sprat'. /Jack(?=Sprat|Frost)/ encuentra 'Jack' solo si este es seguido de 'Sprat' o 'Frost'. Sin embargo, ni 'Sprat' ni 'Frost' forman parte del resultado encontrado.
    x(?!y)

    Encuentra x solo si x no va seguido de y. Por ejemplo, /\d+(?!\.)/ encuentra un numero si esto no va seguido de un punto decimal.

    /\d+(?!\.)/.exec("3.141") encuentra 141 pero no 3.141.
    x|y

    Coincide con x o y.

    Por ejemplo, /green|red/ encuentra 'green' en "green apple" y 'red' en "red apple."
    {n}

    Cuando n es un entero positivo. Encuentra exactamente n ocurrencias del elemento precedente.

    Por ejemplo, /a{2}/ no encuentra la 'a' en "candy," pero encuentra todas las aes en "caandy," y la primeras dos aes en "caaandy."
    {n,}

    Donde n es un entero positivo. Encuentra al menos n occurrencias del elemento predecesor.

    Por ejemplo, /a{2,}/ no encuentra la 'a' en "candy", pero encuentra todas las aes en "caandy" y en "caaaaaaandy."
    {n,m}

    Donde n y m son enteros positivos. Encuentra al menos n y como máximo m occurrencias del elemento precedente.

    Por ejemplo, /a{1,3}/ no encuentra nada en "cndy", la 'a' en "candy," las dos aes en "caandy," y las tres primeras aes en "caaaaaaandy". Hay que mencionar que cuando se busca en "caaaaaaandy", lo encontrado es "aaa", a pesar de que el string original tiene mas aes en el.
    [xyz]

    Un set de caracteres. Encuentra cualquiera de ellos. Puedes espedificar el rango de caracteres usando un guion (-).

    Por ejemplo, [abcd] encuentra lo mismo que [a-d]. Los dos encuentran la 'b' en "brisket" y la 'c' en "chop".
    [^xyz]

    A negated or complemented character set. That is, it matches anything that is not enclosed in the brackets. You can specify a range of characters by using a hyphen.

    For example, [^abc] is the same as [^a-c]. They initially match 'r' in "brisket" and 'h' in "chop."
    [\b]

    Matches a backspace. (Not to be confused with \b.)
    \b

    Matches a word boundary, such as a space. (Not to be confused with [\b].)

    For example, /\bn\w/ matches the 'no' in "noonday"; /\wy\b/ matches the 'ly' in "possibly yesterday."
    \B

    Matches a non-word boundary.

    For example, /\w\Bn/ matches 'on' in "noonday", and /y\B\w/ matches 'ye' in "possibly yesterday."
    \cX

    Where X is a letter from A - Z. Matches a control character in a string.

    For example, /\cM/ matches control-M in a string.
    \d

    Matches a digit character in the basic Latin alphabet. Equivalent to [0-9].

    Note: In Firefox 2 and earlier, matches a digit character from any alphabet. (bug 378738)

    For example, /\d/ or /[0-9]/ matches '2' in "B2 is the suite number."
    \D

    Matches any non-digit character in the basic Latin alphabet. Equivalent to [^0-9].

    Note: In Firefox 2 and earlier, all alphabet. (bug 378738)

    For example, /\D/ or /[^0-9]/ matches 'B' in "B2 is the suite number."
    \f

    Matches a form-feed.
    \n

    Matches a linefeed.
    \r

    Matches a carriage return.
    \s

    Matches a single white space character, including space, tab, form feed, line feed and other unicode spaces.[equivalent_s]

    For example, /\s\w*/ matches ' bar' in "foo bar."
    \S

    Matches a single character other than white space.[equivalent_S]

    For example, /\S\w*/ matches 'foo' in "foo bar."
    \t

    Matches a tab.
    \v

    Matches a vertical tab.
    \w

    Matches any alphanumeric character from the basic Latin alphabet, including the underscore. Equivalent to [A-Za-z0-9_].

    For example, /\w/ matches 'a' in "apple," '5' in "$5.28," and '3' in "3D."
    \W

    Matches any character that is not a word character from the basic Latin alphabet. Equivalent to [^A-Za-z0-9_].

    For example, /\W/ or /[^A-Za-z0-9_]/ matches '%' in "50%."
    \n

    Where n is a positive integer. A back reference to the last substring matching the n parenthetical in the regular expression (counting left parentheses).

    For example, /apple(,)\sorange\1/ matches 'apple, orange,' in "apple, orange, cherry, peach." A more complete example follows this table.
    \0

    Matches a NUL character. Do not follow this with another digit.
    \xhh

    Matches the character with the code hh (two hexadecimal digits)
    \uhhhh

    Matches the character with the Unicode value hhhh (four hexadecimal digits).

    The literal notation provides compilation of the regular expression when the expression is evaluated. Use literal notation when the regular expression will remain constant. For example, if you use literal notation to construct a regular expression used in a loop, the regular expression won't be recompiled on each iteration.

    The constructor of the regular expression object, for example, new RegExp("ab+c"), provides runtime compilation of the regular expression. Use the constructor function when you know the regular expression pattern will be changing, or you don't know the pattern and are getting it from another source, such as user input.

    1. ^Equivalent to:

    [\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]

    1. ^Equivalent to:

    [^\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]

    Properties

    For properties available on RegExp instances, see Properties of RegExp instances.

    prototype
    Allows the addition of properties to all objects.

    Properties inherited from Function:

    Methods

    For methods available on RegExp instances, see Methods of RegExp instances.

    The global RegExp object has no methods of its own, however, it does inherit some methods through the prototype chain.

    Methods inherited from Function:

    Properties

    See also deprecated RegExp properties.

    Note that several of the RegExp properties have both long and short (Perl-like) names. Both names always refer to the same value. Perl is the programming language from which JavaScript modeled its regular expressions.

    RegExp.prototype.constructor
    Specifies the function that creates an object's prototype.
    RegExp.prototype.flags
    A string that contains the flags of the RegExp object.
    RegExp.prototype.global
    Whether to test the regular expression against all possible matches in a string, or only against the first.
    RegExp.prototype.ignoreCase
    Whether to ignore case while attempting a match in a string.
    RegExp.prototype.multiline
    Whether or not to search in strings across multiple lines.
    RegExp.prototype.source
    The text of the pattern.
    RegExp.prototype.sticky
    Whether or not the search is sticky.
    RegExp.prototype.unicode
    Whether or not Unicode features are enabled.

    Methods

    RegExp.prototype.compile()
    (Re-)compiles a regular expression during execution of a script.
    RegExp.prototype.exec()
    Executes a search for a match in its string parameter.
    RegExp.prototype.test()
    Tests for a match in its string parameter.
    RegExp.prototype.toSource()
    Returns an object literal representing the specified object; you can use this value to create a new object. Overrides the Object.prototype.toSource() method.
    RegExp.prototype.toString()
    Returns a string representing the specified object. Overrides the Object.prototype.toString() method.

    Properties

    See also deprecated RegExp properties.

    Note that several of the RegExp properties have both long and short (Perl-like) names. Both names always refer to the same value. Perl is the programming language from which JavaScript modeled its regular expressions.

    RegExp.prototype.constructor
    Specifies the function that creates an object's prototype.
    RegExp.prototype.flags
    A string that contains the flags of the RegExp object.
    RegExp.prototype.global
    Whether to test the regular expression against all possible matches in a string, or only against the first.
    RegExp.prototype.ignoreCase
    Whether to ignore case while attempting a match in a string.
    RegExp.prototype.multiline
    Whether or not to search in strings across multiple lines.
    RegExp.prototype.source
    The text of the pattern.
    RegExp.prototype.sticky
    Whether or not the search is sticky.
    RegExp.prototype.unicode
    Whether or not Unicode features are enabled.

    Methods

    RegExp.prototype.compile()
    (Re-)compiles a regular expression during execution of a script.
    RegExp.prototype.exec()
    Executes a search for a match in its string parameter.
    RegExp.prototype.test()
    Tests for a match in its string parameter.
    RegExp.prototype.toSource()
    Returns an object literal representing the specified object; you can use this value to create a new object. Overrides the Object.prototype.toSource() method.
    RegExp.prototype.toString()
    Returns a string representing the specified object. Overrides the Object.prototype.toString() method.

    Examples

    Example: Using a regular expression to change data format

    The following script uses the replace method inherited by the String instance to match a name in the format first last and output it in the format last, first. In the replacement text, the script uses $1 and $2 to indicate the results of the corresponding matching parentheses in the regular expression pattern.

    var re = /(\w+)\s(\w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
print(newstr);

    This displays "Smith, John".

    Example: Using a regular expression with the "sticky" flag

    This example demonstrates how one could use the sticky flag on regular expressions to match individual lines of multiline input.

    var text = "First line\nsecond line";
var regex = /(\S+) line\n?/y;

var match = regex.exec(text);
print(match[1]);  // prints "First"
print(regex.lastIndex); // prints 11

var match2 = regex.exec(text);
print(match2[1]); // prints "Second"
print(regex.lastIndex); // prints "22"

var match3 = regex.exec(text);
print(match3 === null); // prints "true"

    One can test at run-time whether the sticky flag is supported, using try { … } catch { … }. For this, either an eval(…) expression or the RegExp(regex-string, flags-string) syntax must be used (since the /regex/flags notation is processed at compile-time, so throws an exception before the catch block is encountered). For example:

    var supports_sticky;
try { RegExp('','y'); supports_sticky = true; }
catch(e) { supports_sticky = false; }
alert(supports_sticky); // alerts "false" in Firefox 2, "true" in Firefox 3+

    See also

    Etiquetas y colaboradores del documento

    Etiquetas: 
     Colaboradores en esta página: teoli, fmvilas, Sole, marcoslhc, lmorchard, Scipion, Sheppy
     Última actualización por: teoli,