From a55b575e8089ee6cab7c5c262a7e6db55d0e34d6 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:46:50 +0100 Subject: unslug es: move --- .../global_objects/regexp/compile/index.html | 93 ++++++++ .../global_objects/regexp/exec/index.html | 238 +++++++++++++++++++ .../global_objects/regexp/ignorecase/index.html | 142 +++++++++++ .../reference/global_objects/regexp/index.html | 264 +++++++++++++++++++++ .../global_objects/regexp/regexp/index.html | 114 +++++++++ .../global_objects/regexp/rightcontext/index.html | 54 +++++ .../global_objects/regexp/test/index.html | 152 ++++++++++++ .../global_objects/regexp/tostring/index.html | 171 +++++++++++++ 8 files changed, 1228 insertions(+) create mode 100644 files/es/web/javascript/reference/global_objects/regexp/compile/index.html create mode 100644 files/es/web/javascript/reference/global_objects/regexp/exec/index.html create mode 100644 files/es/web/javascript/reference/global_objects/regexp/ignorecase/index.html create mode 100644 files/es/web/javascript/reference/global_objects/regexp/index.html create mode 100644 files/es/web/javascript/reference/global_objects/regexp/regexp/index.html create mode 100644 files/es/web/javascript/reference/global_objects/regexp/rightcontext/index.html create mode 100644 files/es/web/javascript/reference/global_objects/regexp/test/index.html create mode 100644 files/es/web/javascript/reference/global_objects/regexp/tostring/index.html (limited to 'files/es/web/javascript/reference/global_objects/regexp') diff --git a/files/es/web/javascript/reference/global_objects/regexp/compile/index.html b/files/es/web/javascript/reference/global_objects/regexp/compile/index.html new file mode 100644 index 0000000000..0bce81a56d --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/regexp/compile/index.html @@ -0,0 +1,93 @@ +--- +title: RegExp.prototype.compile() +slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/compile +tags: + - Desaprovado + - Expresion Regular + - JavaScript + - Obsoleto + - Prototype + - Referencia + - RegExp + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/compile +--- +
{{JSRef}} {{deprecated_header}}
+ +

El método obsoleto compile() es usado para (re-)compilar una expresión regular durante la ejecución del script. Es básicamente lo mismo que el constructor RegExp.

+ +

Sintaxis

+ +
regexObj.compile(patrón, flags)
+ +

Parámetros

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

Si es especificado, las flags pueden tener cualquier combinación de los siguientes valores:

+ +
+
g
+
búsqueda 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; busca solamente desde el índice indicado por la propiedad lastIndex de esta expresión regular en la cadena objetivo (y no intenta buscar desde ningún índice posterior).
+
+
+
+ +

Descripción

+ +

 El método compile es obsoleto. Puedes simplemente utilizar el constructor RegExp para lograr el mismo efecto.

+ +

Ejemplos

+ +

Usando compile()

+ +

El siguiente ejemplo muestra como recompilar una expresión regultar con un nuevo patrón y nuevas flags.

+ +
var regexObj = new RegExp('foo', 'gi');
+regexObj.compile('new foo', 'g');
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoCommentario
{{SpecName('ES6', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}{{Spec2('ES6')}}Definición inicial. Definido en la (norma) Annex B ECMAScript para Características Adicionales para Navegadores Web.
{{SpecName('ESDraft', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}{{Spec2('ESDraft')}}Definido en la (norma) Annex B ECMAScript para Características Adicionales para Navegadores Web.
+ +

Compatiblidad con navegadores

+ +
+ + +

{{Compat("javascript.builtins.RegExp.compile")}}

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/regexp/exec/index.html b/files/es/web/javascript/reference/global_objects/regexp/exec/index.html new file mode 100644 index 0000000000..1925e63b67 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/regexp/exec/index.html @@ -0,0 +1,238 @@ +--- +title: RegExp.prototype.exec() +slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/exec +tags: + - Expresiones Regulares + - JavaScript + - Prototipo + - Referencia + - RegExp + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/exec +--- +
{{JSRef}}
+ +

El método exec() ejecuta una busqueda sobre las coincidencias de una expresión regular en una cadena especifica. Devuelve el resultado como array, o {{jsxref("null")}}.

+ +

Si está ejecutando una expresión regular solo para buscar si algo se cumple o no, usa el método {{jsxref("RegExp.prototype.test()")}} o el método {{jsxref("String.prototype.search()")}}.

+ +

Sintaxis

+ +
regexObj.exec(cadena)
+ +

Parametros

+ +
+
cadena
+
Cadena sobre la cual se quiere aplicar la expresión regular
+
+ +

Valor devuelto

+ +

Si se encuentran coincidencial, el método exec() devuelve un array y actualiza las propiedades del objecto de la expresión regular. El array devuelto contiene los elementos encontrados en su primer elemento, y un elemento por cada parte de la expresión regular que se encuentra entre parentesis y se encuentra dentro del texto que fué capturado.

+ +

Si la busqueda falla, el método exec() devuelve {{jsxref("null")}}.

+ +

Descripción

+ +

Considerando el siguiente ejemplo:

+ +
// Busca "quick brown" seguido de "jumps", ignorando los caracteres que se
+// encuentren entre medias.
+// Recuerda "brown" y "jumps"
+// Ignora mayusculas y minusculas
+var re = /quick\s(brown).+?(jumps)/ig;
+var result = re.exec('The Quick Brown Fox Jumps Over The Lazy Dog');
+
+ +

La siguiente tabla muestra el resultado de este script:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ObjetoPropiedad/ÍndiceDescripciónEjemplo
result[0]Todas las partes de la cadena que cumplen la expresión regularQuick Brown Fox Jumps
[1],...[n] +

Las subcadenas entre parentesis que han sido encontradas, si hay alguna. El número de subcadenas encontradas es ilimitado

+ 		[1] = Brown
+ [2] = Jumps
indexEl índice de base-0 del elemento encontrado en la cadena.4
inputLa cadena original.The Quick Brown Fox Jumps Over The Lazy Dog
relastIndexEl índice sobre el cual empieza la siguiente busqueda. Cuando no se usa g (busqueda global), esto va a ser siempre 0.25
ignoreCaseIndica si la bandera "i" ha sido usada para ignorar mayusculas y minusculas.true
globalIndica si la bandera "g" fue usada para hacer una busqueda global.true
multilineIndica si la bandera "m" fue usada para buscar en cadenas sobre multiples lineasfalse
sourceEl texto del patrón de busquedaquick\s(brown).+?(jumps)
+ +

Ejemplos

+ +

Encontrando coincidencias sucesivas

+ +

Si tu expresión regular contiene la bandera "g", puedes usar el método exec() varias veces para encontrar coincidencias sucesivas en la misma cadena. Cuando lo haces, la busqueda empieza en la subcadena str especificada por la propiedad {{jsxref("RegExp.lastIndex", "lastIndex")}} de la expresión regular ({{jsxref("RegExp.prototype.test()", "test()")}} también movera hacia adelante el indice de la propiedad {{jsxref("RegExp.lastIndex", "lastIndex")}}). Por ejemplo, asumiendo que tienes este script:

+ +
var myRe = /ab*/g;
+var str = 'abbcdefabh';
+var myArray;
+while ((myArray = myRe.exec(str)) !== null) {
+  var msg = 'Se ha encontrado ' + myArray[0] + '. ';
+  msg += 'La siguiente coincidencia empieza en el indice ' + myRe.lastIndex;
+  console.log(msg);
+}
+
+ +

Este script muestra el siguiente texto:

+ +
Se ha encontrado abb. La siguiente coincidencia empieza en el indice 3
+Se ha encontrado ab. La siguiente coincidencia empieza en el indice 9
+
+ +

Nota: No uses la expresión regular literalmente (o el constructor {{jsxref("RegExp")}}) dentro de la condición del bucle while o se creará un bucle infinito si hay una coincidencia, por culpa de que la propiedad {{jsxref("RegExp.lastIndex", "lastIndex")}} va a ser reiniciada por cada iteración del bucle. Además asegurate de que has usado la bandera de busqueda global "g" o se creará un bucle también.

+ +

Usando exec() con RegExp literales

+ +

También se puede usar exec() sin crear un objeto de  {{jsxref("RegExp")}}:

+ +
var matches = /(hola \S+)/.exec('Esto es un hola mundo!');
+console.log(matches[1]);
+
+ +

Esto logueará un mensaje que contiene 'hola mundo!'.

+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónStatusComment
{{SpecName('ES3')}}{{Spec2('ES3')}}Definición inicial. Implementado en JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.10.6.21', 'RegExp.exec')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-regexp.prototype.exec', 'RegExp.exec')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-regexp.prototype.exec', 'RegExp.exec')}}{{Spec2('ESDraft')}} 
+ +

Compatiblidad con navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FuncionalidadChromeEdgeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
FuncionalidadAndroidChrome for AndroidEdgeFirefox Móvil (Gecko)IE MóvilOpera MóvilSafari Móvil
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/regexp/ignorecase/index.html b/files/es/web/javascript/reference/global_objects/regexp/ignorecase/index.html new file mode 100644 index 0000000000..9073d631d1 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/regexp/ignorecase/index.html @@ -0,0 +1,142 @@ +--- +title: RegExp.prototype.ignoreCase +slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/ignoreCase +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase +--- +
{{JSRef}}
+ +

La propiedad ignoreCase indica si la expresión regular está usando la bandera "i". ignoreCase es una propiedad de sólo lectura de una instancia de expresión regular.

+ +
{{js_property_attributes(0, 0, 1)}}
+ +

Descripción

+ +

El valor de ignoreCase es un {{jsxref("Boolean")}} y true si la bandera "i" fue usada. De otra manera es false. La bandera "i" indica que el se debe ignorar la capitalización al tratar de encontrar los equivalentes en un texto.

+ +

No se puede cambiar esta propiedad directamente.

+ +

Ejemplos

+ +

Usando ignoreCase

+ +
var regex = new RegExp('foo', 'i');
+
+console.log(regex.ignoreCase); // true
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstatusComentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Definición inicial. Implementado en JavaScript 1.2. JavaScript 1.5: ignoreCase es una propiedad de la instancia  {{jsxref("RegExp")}}, y no del objecto {{jsxref("RegExp")}}.
{{SpecName('ES5.1', '#sec-15.10.7.3', 'RegExp.prototype.ignoreCase')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-get-regexp.prototype.ignorecase', 'RegExp.prototype.ignoreCase')}}{{Spec2('ES6')}}ignoreCase es ahora una propiedad accesora del prototipo en lugar de una propiedad de dato de una instancia.
{{SpecName('ESDraft', '#sec-get-regexp.prototype.ignorecase', 'RegExp.prototype.ignoreCase')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad de navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeEdgeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Propiedad accesor del Prototipo{{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoDesktop(38)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome para AndroidEdgeFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Propiedad accesor del Prototipo{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoMobile(38)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/regexp/index.html b/files/es/web/javascript/reference/global_objects/regexp/index.html new file mode 100644 index 0000000000..9a26edead0 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/regexp/index.html @@ -0,0 +1,264 @@ +--- +title: RegExp +slug: Web/JavaScript/Referencia/Objetos_globales/RegExp +tags: + - Clase + - Expresiones Regulares + - JavaScript + - Referencia + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp +--- +
{{JSRef}}
+ +

El objeto RegExp se utiliza para hacer coincidir texto con un patrón.

+ +

Para obtener una introducción a las expresiones regulares, lee el {{JSxRef("../Guide/Regular_Expressions", "capítulo sobre expresiones regulares")}} en la {{JSxRef("../Guide/Regular_Expressions", "Guía de JavaScript")}}.

+ +

Descripción

+ +

Notación literal y constructor

+ +

Hay dos formas de crear un objeto RegExp: una notación literal y un constructor.

+ + + +

Las siguientes tres expresiones crean el mismo objeto de expresión regular:

+ +
let er = /ab+c/i; // notación literal
+let er = new RegExp('ab+c', 'i') // constructor con patrón de cadena como primer argumento
+let er = new RegExp(/ab+c/, 'i') // constructor con expresión regular literal como primer argumento (a partir de ECMAScript 6)
+
+ +

La notación literal da como resultado la compilación de la expresión regular cuando se evalúa la expresión. Utiliza la notación literal cuando la expresión regular permanecerá constante. Por ejemplo, si usas notación literal para construir una expresión regular usada en un bucle, la expresión regular no se volverá a compilar en cada iteración.

+ +

El constructor del objeto de expresión regular, por ejemplo, new RegExp('ab+c'), da como resultado la compilación en tiempo de ejecución de la expresión regular. Utiliza la función constructora cuando sepas que el patrón de expresión regular cambiará, o no conozcas el patrón y lo obtienes de otra fuente, tal como la entrada del usuario.

+ +

Banderas en el constructor

+ +

A partir de ECMAScript 6, new RegExp(/ab+c/, 'i') ya no arroja un {{JSxRef("TypeError")}} ("no puedes proporcionar banderas cuando construyes una expresión regular a partir de otra") cuando el primer argumento es una RegExp y el segundo argumento flags está presente. En su lugar, se crea una nueva RegExp a partir de los argumentos.

+ +

Cuando se utiliza la función constructora, las reglas de escape de cadenas normales (antes de los caracteres especiales con \ cuando se incluyen en una cadena) son necesarias.

+ +

Por ejemplo, los siguientes son equivalentes:

+ +
let er = /\w+/
+let er = new RegExp('\\w+')
+
+ +

Propiedades de expresiones regulares similares a Perl

+ +

Ten en cuenta que varias de las propiedades de {{JSxRef("RegExp")}} tienen nombres largos y cortos (tipo Perl). Ambos nombres siempre se refieren al mismo valor. (Perl es el lenguaje de programación a partir del cual JavaScript modeló sus expresiones regulares). Consulta también las propiedades {{JSxRef("Características_Desaprobadas", "en desuso de RegExp", "#Propiedades_de_RegExp")}}

+ +

Constructor

+ +
+
{{JSxRef("Objetos_globales/RegExp/RegExp", "RegExp()")}}
+
Crea un nuevo objeto RegExp.
+
+ +

Propiedades estáticas

+ +
+
{{JSxRef("RegExp.@@species", "get RegExp[@@species]")}}
+
La función constructora utilizada para crear objetos derivados.
+
{{JSxRef("RegExp.lastIndex")}}
+
El índice en el que comenzará la siguiente búsqueda.
+
+ +

Propiedades de la instancia

+ +
+
{{JSxRef("RegExp.prototype.flags")}}
+
Una cadena que contiene las banderas del objeto RegExp.
+
{{JSxRef("RegExp.prototype.dotAll")}}
+
Si el "." coincide con nuevas líneas o no.
+
{{JSxRef("RegExp.prototype.global")}}
+
Si se debe probar o no la expresión regular con todas las posibles ocurrencias en una cadena, o solo con la primera.
+
{{JSxRef("RegExp.prototype.ignoreCase")}}
+
Si se deben o no ignorar las mayúsculas/minúsculas al buscar en una cadena.
+
{{JSxRef("RegExp.prototype.multiline")}}
+
Si buscar o no en cadenas multilínea.
+
{{JSxRef("RegExp.prototype.source")}}
+
El texto del patrón.
+
{{JSxRef("RegExp.prototype.sticky")}}
+
Si la búsqueda es pegajosa o no.
+
{{JSxRef("RegExp.prototype.unicode")}}
+
Si las funciones Unicode están habilitadas o no.
+
+ +

Métodos de instancia

+ +
+
{{JSxRef("RegExp.prototype.compile()")}}
+
(Re)compila una expresión regular durante la ejecución de un script.
+
{{JSxRef("RegExp.prototype.exec()")}}
+
Ejecuta una búsqueda de una coincidencia en su parámetro de cadena.
+
{{JSxRef("RegExp.prototype.test()")}}
+
Prueba una coincidencia en su parámetro de cadena.
+
{{JSxRef("RegExp.prototype.toString()")}}
+
Devuelve una cadena que representa el objeto especificado. Redefine el método {{JSxRef("Object.prototype.toString()")}}.
+
{{JSxRef("RegExp.prototype.@@match()", "RegExp.prototype[@@match]()")}}
+
Realiza la coincidencia con la cadena dada y devuelve el resultado de la coincidencia.
+
{{JSxRef("RegExp.prototype.@@matchAll()", "RegExp.prototype[@@matchAll]()")}}
+
Devuelve todas las coincidencias de la expresión regular con una cadena.
+
{{JSxRef("RegExp.prototype.@@replace()", "RegExp.prototype[@@replace]()")}}
+
Reemplaza las coincidencias en una cadena dada con una nueva subcadena.
+
{{JSxRef("RegExp.prototype.@@search()", "RegExp.prototype[@@search]()")}}
+
Busca la coincidencia en la cadena dada y devuelve el índice del patrón encontrado en la cadena.
+
{{JSxRef("RegExp.prototype.@@split()", "RegExp.prototype[@@split]()")}}
+
Divide la cadena dada en un arreglo separando la cadena en subcadenas.
+
+ +

Ejemplos

+ +

Usar una expresión regular para cambiar el formato de los datos

+ +

El siguiente script usa el método {{JSxRef("String.prototype.replace()", "replace()")}} de la instancia {{JSxRef("Objetos_globales/String", "String")}} para hacer coincidir una nombre en el formato primero último y enviarlo en el formato último, primero.

+ +

En el texto de reemplazo, el script usa $1 y $2 para indicar los resultados de los correspondientes paréntesis coincidentes en el patrón de expresión regular.

+ +
let er = /(\w+)\s(\w+)/
+let str = 'John Smith'
+let newstr = str.replace(er, '$2, $1')
+console.log(newstr)
+
+ +

Esto muestra "Smith, John".

+ +

Uso de expresiones regulares para dividir líneas con diferentes finales de línea/saltos de línea

+ +

El final de línea predeterminado varía según la plataforma (Unix, Windows, etc.). La división de líneas proporcionada en este ejemplo funciona en todas las plataformas.

+ +
let texto = 'Un poco de texto\ny un poco más\r\ny aún\reste es el final'
+let lineas = texto.split(/\r\n|\r|\n/)
+console.log(lineas) // logs [ 'Un poco de texto', 'y un poco más', 'y aún', 'este es el final' ]
+
+ +

Ten en cuenta que el orden de los patrones en la expresión regular es importante.

+ +

Usar expresiones regulares en varias líneas

+ +
let s = '¡Por favor, sí\nhazme el día!'
+
+s.match(/sí.*día/);
+// Devuelve null
+
+s.match(/sí[^]*día/);
+// Devuelve ["sí\nhazme el día"]
+
+ +

Usar una expresión regular con la bandera pegajosa

+ +

La bandera {{JSxRef("Objetos_globales/RegExp/sticky", "sticky")}} indica que la expresión regular realiza una coincidencia permanente en la cadena de destino al intentar hacer coincidir a partir de {{JSxRef("RegExp.prototype.lastIndex")}}.

+ +
let str = '#foo#'
+let regex = /foo/y
+
+regex.lastIndex = 1
+regex.test(str)      // true
+regex.lastIndex = 5
+regex.test(str)      // false (lastIndex se tiene en cuenta con una bandera pegajosa)
+regex.lastIndex      // 0 (restablecer después de un error de coincidencia)
+ +

La diferencia entre la bandera pegajosa y la bandera global

+ +

Con la bandera pegajosa y, la siguiente coincidencia tiene que ocurrir en la posición lastIndex, mientras que con la bandera global g, la coincidencia puede ocurrir en la posición lastIndex o posterior:

+ +
er = /\d/y;
+while (r = re.exec("123 456")) console.log(r, "Y er.lastIndex", er.lastIndex);
+
+// [ '1', index: 0, input: '123 456', groups: undefined ] AND er.lastIndex 1
+// [ '2', index: 1, input: '123 456', groups: undefined ] AND er.lastIndex 2
+// [ '3', index: 2, input: '123 456', groups: undefined ] AND er.lastIndex 3
+//   ... y no más coincidencias.
+ +

Con la bandera global g, coincidirían los 6 dígitos, no solo 3.

+ +

Expresión regular y caracteres Unicode

+ +

\w y \W solo coincide con caracteres basados en ASCII; por ejemplo, a a z, A a Z, 0 a 9 y _.

+ +

Para hacer coincidir caracteres de otros idiomas como Cirílico o Hebreo, usa \uhhhh, donde hhhh es el Valor Unicode en hexadecimal.

+ +

Este ejemplo demuestra cómo se pueden separar los caracteres Unicode de una palabra.

+ +
let texto = 'Образец texto на русском языке'
+let regex = /[\u0400-\u04FF]+/g
+
+let match = regex.exec(text)
+console.log(match[0])        // registra 'Образец'
+console.log(regex.lastIndex) // registra '7'
+
+let match2 = regex.exec(texto)
+console.log(match2[0])       // registra 'на' [no registró 'texto']
+console.log(regex.lastIndex) // registra '15'
+
+// y así sucesivamente
+
+ +

La función {{JSxRef("../Guide/Regular_Expressions/Unicode_Property_Escapes", "Escapes de propiedad Unicode")}} presenta una solución, al permitir una declaración tan simple como \p{scx=Cyrl}.

+ +

Extraer el nombre de subdominio de la URL

+ +
let url = 'http://xxx.dominio.com'
+console.log(/[^.]+/.exec(url)[0].substr(7)) // registra 'xxx'
+
+ +
+

En lugar de utilizar expresiones regulares para analizar las URL, normalmente es mejor utilizar el analizador de URL integrado en los navegadores mediante la API URL.

+
+ +

Especificaciones

+ + + + + + + + + + + + +
Especificación
{{SpecName('ESDraft', '#sec-regexp-regular-expression-objects', 'RegExp')}}
+ +

Compatibilidad del navegador

+ +
+ + +

{{Compat("javascript.builtins.RegExp")}}

+
+ +

Notas específicas de Firefox

+ +

A partir de Firefox 34, en el caso de un grupo de captura con cuantificadores que impiden su ejercicio, el texto coincidente para un grupo de captura ahora es undefined en lugar de una cadena vacía:

+ +
// Firefox 33 o anterior
+'x'.replace(/x(.)?/g, function(m, group) {
+  console.log("'grupo: " + group + "'");
+});
+// 'grupo: '
+
+// Firefox 34 o más reciente
+'x'.replace(/x(.)?/g, function(m, group) {
+  console.log("'grupo: " + group + "'");
+});
+// 'grupo: undefined'
+
+ +

Ten en cuenta que, debido a la compatibilidad web, RegExp.$N seguirá devolviendo una cadena vacía en lugar de undefined ({{bug(1053944)}}).

+ +

Ve también

+ + diff --git a/files/es/web/javascript/reference/global_objects/regexp/regexp/index.html b/files/es/web/javascript/reference/global_objects/regexp/regexp/index.html new file mode 100644 index 0000000000..ad3a8c90e9 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/regexp/regexp/index.html @@ -0,0 +1,114 @@ +--- +title: Constructor RegExp() +slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/RegExp +tags: + - Constructor + - JavaScript + - Referencia + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/RegExp +--- +
{{JSRef}}
+ +

El constructor RegExp crea un objeto de expresión regular para hacer coincidir el texto con un patrón.

+ +

Para ver la introducción a las expresiones regulares, lee el {{JSxRef("../Guide/Regular_Expressions", "capítulo sobre expresiones regulares")}} en la {{JSxRef("../Guide", "Guía de JavaScript")}}.

+ +
{{EmbedInteractiveExample("pages/js/regexp-constructor.html")}}
+ + + +

Sintaxis

+ +

Son posibles las notaciones literal, constructor y de fábrica:

+ +
/patrón/banderas
+new RegExp(patrón[, banderas])
+RegExp(patrón[, banderas])
+
+ +

Parámetros

+ +
+
patrón
+
El texto de la expresión regular.
+
A partir de ES5, también puede ser otro objeto o RegExp literal (solo para las dos notaciones del constructor RegExp). Los patrones pueden incluir {{JSxRef("../Guide/Regular_Expressions", "caracteres especiales", "#Usar_caracteres_especiales")}} para que coincidan con un rango de valores más amplio que el de una cadena literal.
+
banderas
+
+

Si se especifica, banderas es una cadena que contiene las banderas para agregar.

+ +

Alternativamente, si se proporciona un objeto para el patrón, la cadena banderas reemplazará cualquiera de las banderas de ese objeto (y lastIndex se restablecerá a 0) (a partir de ES2015).

+ +

Si no se especifica banderas y se proporciona un objeto de expresiones regulares, las banderas de ese objeto (y el valor de lastIndex) se copiarán.

+ +

banderas puede contener cualquier combinación de los siguientes caracteres:

+ +
+
g (coincidencia global)
+
Encuentra todas las coincidencias en lugar de detenerse después de la primera.
+
i (ignorar mayúsculas y minúsculas)
+
Si el indicador u también está habilitado, utiliza el plegado de mayúsculas y minúsculas Unicode.
+
m (multilínea)
+
Trata los caracteres iniciales y finales (^ y $) como si estuvieran trabajando en varias líneas. En otras palabras, hace coincidir el principio o el final de cada línea (delimitada por \n o \r), no solo al principio o final de toda la cadena de entrada.
+
s («dotAll» o punto para todo)
+
Permite que el punto (. coincida con nuevas líneas o no.
+
u (unicode)
+
Trata el patrón como una secuencia de puntos de código Unicode. (Consulta también Cadenas binarias).
+
y (sticky)
+
Coincide solo con el índice indicado por la propiedad lastIndex de esta expresión regular en la cadena destino. No intenta coincidir con índices posteriores.
+
+
+
+ +

Ejemplos

+ +

Notación literal y constructor

+ +

Hay dos formas de crear un objeto RegExp: una notación literal y un constructor.

+ + + +

Las siguientes tres expresiones crean la misma expresión regular:

+ +
/ab+c/i
+new RegExp(/ab+c/, 'i') // notación literal
+new RegExp('ab+c', 'i') // constructor
+
+ +

La notación literal da como resultado la compilación de la expresión regular cuando se evalúa la expresión. Utiliza la notación literal cuando la expresión regular permanecerá constante. Por ejemplo, si usas notación literal para construir una expresión regular usada en un bucle, la expresión regular no se volverá a compilar en cada iteración.

+ +

El constructor del objeto de expresión regular, por ejemplo, new RegExp('ab+c'), da como resultado la compilación en tiempo de ejecución de la expresión regular. Usa la función constructora cuando sepas que el patrón de la expresión regular cambiará, o no conoces el patrón y lo obtienes de otra fuente, como la entrada del usuario.

+ +

Especificaciones

+ + + + + + + + + + + + +
Especificación
{{SpecName('ESDraft', '#sec-regexp-constructor', 'RegExp constructor')}}
+ +

Compatibilidad del navegador

+ +
+ + +

{{Compat("javascript.builtins.RegExp.RegExp")}}

+
+ +

Ve también

+ + diff --git a/files/es/web/javascript/reference/global_objects/regexp/rightcontext/index.html b/files/es/web/javascript/reference/global_objects/regexp/rightcontext/index.html new file mode 100644 index 0000000000..39530ee1b5 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/regexp/rightcontext/index.html @@ -0,0 +1,54 @@ +--- +title: RegExp.rightContext ($') +slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/rightContext +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/rightContext +--- +
{{JSRef}} {{non-standard_header}}
+ +

La propiedad rightContext (No es estándar) es una propiedad estática y de solo lectura de expresiones regulares que contiene la subcadena que sigue a la coincidencia más reciente. el alias para esta propiedad es RegExp.$'.

+ +

Sintaxis

+ +
RegExp.rightContext
+RegExp["$'"]
+
+ +

Descripción

+ +

La propiedad rightContext es estática, no es una propiedad de un objeto de expresión regular individual. Debe usarse como RegExp.rightContext o RegExp["$'"].

+ +

El valor de la propiedad rightContext es de solo lectura y se modifica cada que hay una coincidencia exitosa.

+ +

Tenga presente que no puede usar la abreviatura (RegExp.$'), porque el analizador espera una cadena de inicio, si lo hace optendra un error de sintaxis {{jsxref("SyntaxError")}} , para este caso, usted debe usar corchetes. consulte notación de paréntesis para acceso a la propiedad.

+ +

Ejemplos

+ +

Usando rightContext y $'

+ +
var re = /hola/g;
+re.test('hola mundo!');
+RegExp.rightContext; // " mundo!"
+RegExp["$'"];       // " mundo!"
+
+ +

Especificaciones

+ +

No estándar. No forma parte de ninguna especificación actual.

+ + + +
+ + +

{{Compat("javascript.builtins.RegExp.rightContext")}}

+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/regexp/test/index.html b/files/es/web/javascript/reference/global_objects/regexp/test/index.html new file mode 100644 index 0000000000..4507b57c97 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/regexp/test/index.html @@ -0,0 +1,152 @@ +--- +title: RegExp.prototype.test() +slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/test +tags: + - Expresion Regular + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test +--- +
{{JSRef}}
+ +

El método test() ejecuta la búsqueda de una ocurrencia entre una expresión regular y una cadena especificada. Devuelve true o false.

+ +

Sintaxis

+ +
regexObj.test(cadena)
+ +

Parámetros

+ +
+
cadena
+
La cadena a comparar contra la expresión regular.
+
+ +

Valor de Retorno

+ +

Retorna true si existe una coincidencia entre la expresión regular y la cadena especificada; de lo contrario retorna false.

+ +

Descripción

+ +

Use test() cuando desee saber si existe la ocurrencia de un patrón en una cadena (similar al método {{jsxref("String.prototype.search()")}}, la diferencia es que test() devuelve un booleano, mientras que search() devuelve el índice de la coincidencia (si la encuentra) o -1 si no la encuentra).

+ +

Si requiere más información (a coste de una ejecución más lenta) utilice el método {{jsxref("RegExp.prototype.exec()", "exec()")}}. Al igual que este último, multiples llamadas a test() sobre la misma instancia global de una expresión regular avanzará desde de la ocurrencia anterior.

+ +

Ejemplos

+ +

Usando test()

+ +

Ejemplo simple que prueba si "hello" está contenido al principio de una cadena y devuelve un valor booleano.

+ +
var cadena = "hello world!";
+var result = /^hello/.test(cadena);
+console.log(result); // true
+
+ +

El siguiente ejemplo registra un mensaje que depende del éxito de la prueba:

+ +
function probarEntrada(regexp, cadena){
+  var subcadena;
+  if (regexp.test(cadena)) {
+    subcadena = ' contiene ';
+  } else {
+    subcadena = ' no contiene ';
+  }
+  console.log(cadena + subcadena + regexp.source);
+}
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Definition inicial. Implementado en JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.10.6.3', 'RegExp.test')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-regexp.prototype.test', 'RegExp.test')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-regexp.prototype.test', 'RegExp.test')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad en Navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Notas específicas para Gecko

+ +

Antes de Gecko 8.0 {{geckoRelease("8.0")}}, test() estaba incorrectamente implementado; cuando era llamado sin parámetros, buscaba emparejar contra el valor de la entrada anterior (la propiedad RegExp.input) en lugar de hacerlo contra la cadena "undefined". Esto ha sido corregido; ahora /undefined/.test() resulta correctamente en true, en lugar de un error.

+ +

Vea también

+ + diff --git a/files/es/web/javascript/reference/global_objects/regexp/tostring/index.html b/files/es/web/javascript/reference/global_objects/regexp/tostring/index.html new file mode 100644 index 0000000000..50c10d2bb2 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/regexp/tostring/index.html @@ -0,0 +1,171 @@ +--- +title: RegExp.prototype.toString() +slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/toString +tags: + - Expresion Regular + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/toString +--- +
{{JSRef}}
+ +

El método toString() devuelve una cadena que representa el patrón de la expresión regular.

+ +

Sintaxis

+ +
regexObj.toString();
+ +

Valor de Retorno

+ +

Una cadena que representa el objeto dado.

+ +

Descripción

+ +

El objeto {{jsxref("RegExp")}} reemplaza el método toString() del objeto {{jsxref("Object")}}; no hereda de {{jsxref("Object.prototype.toString()")}}. Para objetos {{jsxref("RegExp")}}, el método toString() retorna una cadena que representa el patrón de la expresión regular.

+ +

Ejemplos

+ +

Usando toString()

+ +

El siguiente ejemplo muestra la cadena de representación de un objeto {{jsxref("RegExp")}}:

+ +
var myExp = new RegExp('a+b+c');
+console.log(myExp.toString());  // '/a+b+c/'
+
+var foo = new RegExp('bar', 'g');
+console.log(foo.toString());    // '/bar/g'
+
+ +

Expresiones regulares vacías y escapado

+ +

A partir de ECMAScript 5, una expresión regular vacía devuelve la cadena "/(?:)/" y los terminadores de línea tales como "\n" son escapados:

+ +
new RegExp().toString(); // "/(?:)/"
+
+new RegExp('\n').toString() === "/\n/";  // true, antes de ES5
+new RegExp('\n').toString() === "/\\n/"; // true, desde ES5
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Definición inicial. Implementado en JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.9.5.2', 'RegExp.prototype.toString')}}{{Spec2('ES5.1')}}Agregado de la definición para escapado de caracteres especiales y "(?:)" para expresiones regulares vacías.
{{SpecName('ES6', '#sec-regexp.prototype.tostring', 'RegExp.prototype.toString')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-regexp.prototype.tostring', 'RegExp.prototype.toString')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad en Navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Escaping{{CompatVersionUnknown}}{{CompatGeckoDesktop(38)}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Generic function{{CompatUnknown}}{{CompatGeckoDesktop(39)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Escaping{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile(38)}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Generic function{{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoMobile(39)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +

Vea también

+ + -- cgit v1.2.3-54-g00ecf