Merge pull request #53 from fiji-flo/unslugging-es

Unslugging es

8 files changed, 1236 insertions, 0 deletions

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..9f23a0b47f
--- /dev/null
+++ b/files/es/web/javascript/reference/global_objects/regexp/compile/index.html
@@ -0,0 +1,94 @@
+---
+title: RegExp.prototype.compile()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/compile
+tags:
+  - Desaprovado
+  - Expresion Regular
+  - JavaScript
+  - Obsoleto
+  - Prototype
+  - Referencia
+  - RegExp
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/compile
+original_slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/compile
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>El método obsoleto <code><strong>compile</strong></code><strong><code>()</code></strong> es usado para (re-)compilar una expresión regular durante la ejecución del script. Es básicamente lo mismo que el constructor <code>RegExp</code>.</p>
+
+<h2 id="Sintaxis">Sintaxis</h2>
+
+<pre class="syntaxbox"><code><var>regexObj</var>.compile(<var>patrón, flags</var>)</code></pre>
+
+<h3 id="Parámetros">Parámetros</h3>
+
+<dl>
+ <dt><code>patrón</code></dt>
+ <dd>El texto de la expresión regular.</dd>
+ <dt><code>flags</code></dt>
+ <dd>
+ <p>Si es especificado, las flags pueden tener cualquier combinación de los siguientes valores:</p>
+
+ <dl>
+  <dt><code>g</code></dt>
+  <dd>búsqueda global (global match)</dd>
+  <dt><code>i</code></dt>
+  <dd>ignorar mayúsculas o minúsculas</dd>
+  <dt><code>m</code></dt>
+  <dd>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)</dd>
+  <dt><code>y</code></dt>
+  <dd>sticky; busca solamente desde el índice indicado por la propiedad <code>lastIndex</code> de esta expresión regular en la cadena objetivo (y no intenta buscar desde ningún índice posterior).</dd>
+ </dl>
+ </dd>
+</dl>
+
+<h2 id="Descripción">Descripción</h2>
+
+<p> El método <code>compile</code> es obsoleto. Puedes simplemente utilizar el constructor <code>RegExp</code> para lograr el mismo efecto.</p>
+
+<h2 id="Ejemplos">Ejemplos</h2>
+
+<h3 id="Usando_compile">Usando <code>compile()</code></h3>
+
+<p>El siguiente ejemplo muestra como recompilar una expresión regultar con un nuevo patrón y nuevas flags.</p>
+
+<pre class="brush: js">var regexObj = new RegExp('foo', 'gi');
+regexObj.compile('new foo', 'g');
+</pre>
+
+<h2 id="Especificaciones">Especificaciones</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificación</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Commentario</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definición inicial. Definido en la (norma) Annex B ECMAScript para Características Adicionales para Navegadores Web.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Definido en la (norma) Annex B ECMAScript para Características Adicionales para Navegadores Web.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatiblidad_con_navegadores">Compatiblidad con navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.RegExp.compile")}}</p>
+</div>
+
+<h2 id="Ver_también">Ver también</h2>
+
+<ul>
+ <li>{{jsxref("RegExp")}}</li>
+</ul>
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..a285f13a40
--- /dev/null
+++ b/files/es/web/javascript/reference/global_objects/regexp/exec/index.html
@@ -0,0 +1,239 @@
+---
+title: RegExp.prototype.exec()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/exec
+tags:
+  - Expresiones Regulares
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - RegExp
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/exec
+original_slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/exec
+---
+<div>{{JSRef}}</div>
+
+<p>El método <strong><code>exec()</code></strong> ejecuta una busqueda sobre las coincidencias de una expresión regular en una cadena especifica. Devuelve el resultado como array, o {{jsxref("null")}}.</p>
+
+<p>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()")}}.</p>
+
+<h2 id="Sintaxis">Sintaxis</h2>
+
+<pre class="syntaxbox"><var>regexObj</var>.exec(<em>cadena</em>)</pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt><code>cadena</code></dt>
+ <dd>Cadena sobre la cual se quiere aplicar la expresión regular</dd>
+</dl>
+
+<h3 id="Valor_devuelto">Valor devuelto</h3>
+
+<p>Si se encuentran coincidencial, el método <code>exec()</code> 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.</p>
+
+<p>Si la busqueda falla, el método <code>exec()</code> devuelve {{jsxref("null")}}.</p>
+
+<h2 id="Descripción">Descripción</h2>
+
+<p>Considerando el siguiente ejemplo:</p>
+
+<pre class="brush: js">// 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');
+</pre>
+
+<p>La siguiente tabla muestra el resultado de este script:</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <td class="header">Objeto</td>
+   <td class="header">Propiedad/Índice</td>
+   <td class="header">Descripción</td>
+   <td class="header">Ejemplo</td>
+  </tr>
+  <tr>
+   <td rowspan="4"><code>result</code></td>
+   <td><code>[0]</code></td>
+   <td>Todas las partes de la cadena que cumplen la expresión regular</td>
+   <td><code>Quick Brown Fox Jumps</code></td>
+  </tr>
+  <tr>
+   <td><code>[1],...[<em>n</em>]</code></td>
+   <td>
+    <p>Las subcadenas entre parentesis que han sido encontradas, si hay alguna. El número de subcadenas encontradas es ilimitado</p>
+   </td>
+   <td><code>[1] = Brown<br>
+    [2] = Jumps</code></td>
+  </tr>
+  <tr>
+   <td><code>index</code></td>
+   <td>El índice de base-0 del elemento encontrado en la cadena.</td>
+   <td><code>4</code></td>
+  </tr>
+  <tr>
+   <td><code>input</code></td>
+   <td>La cadena original.</td>
+   <td><code>The Quick Brown Fox Jumps Over The Lazy Dog</code></td>
+  </tr>
+  <tr>
+   <td rowspan="5"><code>re</code></td>
+   <td><code>lastIndex</code></td>
+   <td>El índice sobre el cual empieza la siguiente busqueda. Cuando no se usa g (busqueda global), esto va a ser siempre 0.</td>
+   <td><code>25</code></td>
+  </tr>
+  <tr>
+   <td><code>ignoreCase</code></td>
+   <td>Indica si la bandera "<code>i</code>" ha sido usada para ignorar mayusculas y minusculas.</td>
+   <td><code>true</code></td>
+  </tr>
+  <tr>
+   <td><code>global</code></td>
+   <td>Indica si la bandera "<code>g</code>" fue usada para hacer una busqueda global.</td>
+   <td><code>true</code></td>
+  </tr>
+  <tr>
+   <td><code>multiline</code></td>
+   <td>Indica si la bandera "<code>m"</code> fue usada para buscar en cadenas sobre multiples lineas</td>
+   <td><code>false</code></td>
+  </tr>
+  <tr>
+   <td><code>source</code></td>
+   <td>El texto del patrón de busqueda</td>
+   <td><code>quick\s(brown).+?(jumps)</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Ejemplos">Ejemplos</h2>
+
+<h3 id="Encontrando_coincidencias_sucesivas">Encontrando coincidencias sucesivas</h3>
+
+<p>Si tu expresión regular contiene la bandera "<code>g</code>", puedes usar el método <code>exec()</code> varias veces para encontrar coincidencias sucesivas en la misma cadena. Cuando lo haces, la busqueda empieza en la subcadena <code>str</code> 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:</p>
+
+<pre class="brush: js">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);
+}
+</pre>
+
+<p>Este script muestra el siguiente texto:</p>
+
+<pre>Se ha encontrado abb. La siguiente coincidencia empieza en el indice 3
+Se ha encontrado ab. La siguiente coincidencia empieza en el indice 9
+</pre>
+
+<p>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.</p>
+
+<h3 id="Usando_exec()_con_RegExp_literales">Usando <code>exec()</code> con <code>RegExp</code> literales</h3>
+
+<p>También se puede usar <code>exec() sin crear un objeto de </code> {{jsxref("RegExp")}}:</p>
+
+<pre class="brush: js">var matches = /(hola \S+)/.exec('Esto es un hola mundo!');
+console.log(matches[1]);
+</pre>
+
+<p>Esto logueará un mensaje que contiene 'hola mundo!'.</p>
+
+<h2 id="Especificaciones">Especificaciones</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificación</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definición inicial. Implementado en JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.10.6.21', 'RegExp.exec')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-regexp.prototype.exec', 'RegExp.exec')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-regexp.prototype.exec', 'RegExp.exec')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatiblidad_con_navegadores">Compatiblidad con navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidad</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Soporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidad</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Móvil (Gecko)</th>
+   <th>IE Móvil</th>
+   <th>Opera Móvil</th>
+   <th>Safari Móvil</th>
+  </tr>
+  <tr>
+   <td>Soporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_también">Ver también</h2>
+
+<ul>
+ <li>Capítulo de <a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Expresiones Regulares</a> en la <a href="/en-US/docs/Web/JavaScript/Guide">Guía de Javascript</a></li>
+ <li>{{jsxref("RegExp")}}</li>
+</ul>
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..24e70a06ac
--- /dev/null
+++ b/files/es/web/javascript/reference/global_objects/regexp/ignorecase/index.html
@@ -0,0 +1,143 @@
+---
+title: RegExp.prototype.ignoreCase
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase
+original_slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/ignoreCase
+---
+<div>{{JSRef}}</div>
+
+<p>La propiedad <strong><code>ignoreCase</code></strong> indica si la expresión regular está usando la bandera "i". <code>ignoreCase</code> es una propiedad de <em>sólo lectura </em>de una instancia de expresión regular.</p>
+
+<div>{{js_property_attributes(0, 0, 1)}}</div>
+
+<h2 id="Descripción">Descripción</h2>
+
+<p>El valor de <code>ignoreCase es un </code>{{jsxref("Boolean")}} y <code>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.</code></p>
+
+<p>No se puede cambiar esta propiedad directamente.</p>
+
+<h2 id="Ejemplos">Ejemplos</h2>
+
+<h3 id="Usando_ignoreCase">Usando <code>ignoreCase</code></h3>
+
+<pre class="brush: js">var regex = new RegExp('foo', 'i');
+
+console.log(regex.ignoreCase); // true
+</pre>
+
+<h2 id="Especificaciones">Especificaciones</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificación</th>
+   <th scope="col">Estatus</th>
+   <th scope="col">Comentario</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definición inicial. Implementado en JavaScript 1.2. JavaScript 1.5: <code>ignoreCase</code> es una propiedad de la instancia  {{jsxref("RegExp")}}, y no del objecto {{jsxref("RegExp")}}.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.10.7.3', 'RegExp.prototype.ignoreCase')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-get-regexp.prototype.ignorecase', 'RegExp.prototype.ignoreCase')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td><code>ignoreCase</code> es ahora una propiedad accesora del prototipo en lugar de una propiedad de dato de una instancia.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.ignorecase', 'RegExp.prototype.ignoreCase')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidad_de_navegadores">Compatibilidad de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Soporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Propiedad accesor del Prototipo</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop(38)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Soporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Propiedad accesor del Prototipo</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile(38)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_también">Ver también</h2>
+
+<ul>
+ <li>{{jsxref("RegExp.lastIndex")}}</li>
+ <li>{{jsxref("RegExp.prototype.global")}}</li>
+ <li>{{jsxref("RegExp.prototype.multiline")}}</li>
+ <li>{{jsxref("RegExp.prototype.source")}}</li>
+ <li>{{jsxref("RegExp.prototype.sticky")}}</li>
+</ul>
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..8439c565a9
--- /dev/null
+++ b/files/es/web/javascript/reference/global_objects/regexp/index.html
@@ -0,0 +1,265 @@
+---
+title: RegExp
+slug: Web/JavaScript/Reference/Global_Objects/RegExp
+tags:
+  - Clase
+  - Expresiones Regulares
+  - JavaScript
+  - Referencia
+  - RegExp
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp
+original_slug: Web/JavaScript/Referencia/Objetos_globales/RegExp
+---
+<div>{{JSRef}}</div>
+
+<p>El objeto <strong><code>RegExp</code></strong> se utiliza para hacer coincidir texto con un patrón.</p>
+
+<p>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")}}.</p>
+
+<h2 id="Descripción">Descripción</h2>
+
+<h3 id="Notación_literal_y_constructor">Notación literal y constructor</h3>
+
+<p>Hay dos formas de crear un objeto <code>RegExp</code>: una <em>notación literal</em> y un <em>constructor</em>.</p>
+
+<ul>
+ <li>Los parámetros de <strong>la notación literal</strong> se encierran entre barras y no utilizan comillas.</li>
+ <li>Los parámetros de <strong>la función constructora</strong> no se encierran entre barras, pero utilizan comillas.</li>
+</ul>
+
+<p>Las siguientes tres expresiones crean el mismo objeto de expresión regular:</p>
+
+<pre class="brush: js notranslate">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)
+</pre>
+
+<p>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.</p>
+
+<p>El constructor del objeto de expresión regular, por ejemplo, <code>new RegExp('ab+c')</code>, 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.</p>
+
+<h3 id="Banderas_en_el_constructor">Banderas en el constructor</h3>
+
+<p>A partir de ECMAScript 6, <code>new RegExp(/ab+c/, 'i')</code> ya no arroja un {{JSxRef("TypeError")}} (<code>"no puedes proporcionar banderas cuando construyes una expresión regular a partir de otra"</code>) cuando el primer argumento es una <code>RegExp</code> y el segundo argumento <code><var>flags</var></code> está presente. En su lugar, se crea una nueva <code>RegExp</code> a partir de los argumentos.</p>
+
+<p>Cuando se utiliza la función constructora, las reglas de escape de cadenas normales (antes de los caracteres especiales con <code>\</code> cuando se incluyen en una cadena) son necesarias.</p>
+
+<p>Por ejemplo, los siguientes son equivalentes:</p>
+
+<pre class="brush: js notranslate">let er = /\w+/
+let er = new RegExp('\\w+')
+</pre>
+
+<h3 id="Propiedades_de_expresiones_regulares_similares_a_Perl">Propiedades de expresiones regulares similares a Perl</h3>
+
+<p>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")}}</p>
+
+<h2 id="Constructor">Constructor</h2>
+
+<dl>
+ <dt>{{JSxRef("Objetos_globales/RegExp/RegExp", "RegExp()")}}</dt>
+ <dd>Crea un nuevo objeto <code>RegExp</code>.</dd>
+</dl>
+
+<h2 id="Propiedades_estáticas">Propiedades estáticas</h2>
+
+<dl>
+ <dt>{{JSxRef("RegExp.@@species", "get RegExp[@@species]")}}</dt>
+ <dd>La función constructora utilizada para crear objetos derivados.</dd>
+ <dt>{{JSxRef("RegExp.lastIndex")}}</dt>
+ <dd>El índice en el que comenzará la siguiente búsqueda.</dd>
+</dl>
+
+<h2 id="Propiedades_de_la_instancia">Propiedades de la instancia</h2>
+
+<dl>
+ <dt>{{JSxRef("RegExp.prototype.flags")}}</dt>
+ <dd>Una cadena que contiene las banderas del objeto <code>RegExp</code>.</dd>
+ <dt>{{JSxRef("RegExp.prototype.dotAll")}}</dt>
+ <dd>Si el "<code>.</code>" coincide con nuevas líneas o no.</dd>
+ <dt>{{JSxRef("RegExp.prototype.global")}}</dt>
+ <dd>Si se debe probar o no la expresión regular con todas las posibles ocurrencias en una cadena, o solo con la primera.</dd>
+ <dt>{{JSxRef("RegExp.prototype.ignoreCase")}}</dt>
+ <dd>Si se deben o no ignorar las mayúsculas/minúsculas al buscar en una cadena.</dd>
+ <dt>{{JSxRef("RegExp.prototype.multiline")}}</dt>
+ <dd>Si buscar o no en cadenas multilínea.</dd>
+ <dt>{{JSxRef("RegExp.prototype.source")}}</dt>
+ <dd>El texto del patrón.</dd>
+ <dt>{{JSxRef("RegExp.prototype.sticky")}}</dt>
+ <dd>Si la búsqueda es pegajosa o no.</dd>
+ <dt>{{JSxRef("RegExp.prototype.unicode")}}</dt>
+ <dd>Si las funciones Unicode están habilitadas o no.</dd>
+</dl>
+
+<h2 id="Métodos_de_instancia">Métodos de instancia</h2>
+
+<dl>
+ <dt>{{JSxRef("RegExp.prototype.compile()")}}</dt>
+ <dd>(Re)compila una expresión regular durante la ejecución de un script.</dd>
+ <dt>{{JSxRef("RegExp.prototype.exec()")}}</dt>
+ <dd>Ejecuta una búsqueda de una coincidencia en su parámetro de cadena.</dd>
+ <dt>{{JSxRef("RegExp.prototype.test()")}}</dt>
+ <dd>Prueba una coincidencia en su parámetro de cadena.</dd>
+ <dt>{{JSxRef("RegExp.prototype.toString()")}}</dt>
+ <dd>Devuelve una cadena que representa el objeto especificado. Redefine el método {{JSxRef("Object.prototype.toString()")}}.</dd>
+ <dt>{{JSxRef("RegExp.prototype.@@match()", "RegExp.prototype[@@match]()")}}</dt>
+ <dd>Realiza la coincidencia con la cadena dada y devuelve el resultado de la coincidencia.</dd>
+ <dt>{{JSxRef("RegExp.prototype.@@matchAll()", "RegExp.prototype[@@matchAll]()")}}</dt>
+ <dd>Devuelve todas las coincidencias de la expresión regular con una cadena.</dd>
+ <dt>{{JSxRef("RegExp.prototype.@@replace()", "RegExp.prototype[@@replace]()")}}</dt>
+ <dd>Reemplaza las coincidencias en una cadena dada con una nueva subcadena.</dd>
+ <dt>{{JSxRef("RegExp.prototype.@@search()", "RegExp.prototype[@@search]()")}}</dt>
+ <dd>Busca la coincidencia en la cadena dada y devuelve el índice del patrón encontrado en la cadena.</dd>
+ <dt>{{JSxRef("RegExp.prototype.@@split()", "RegExp.prototype[@@split]()")}}</dt>
+ <dd>Divide la cadena dada en un arreglo separando la cadena en subcadenas.</dd>
+</dl>
+
+<h2 id="Ejemplos">Ejemplos</h2>
+
+<h3 id="Usar_una_expresión_regular_para_cambiar_el_formato_de_los_datos">Usar una expresión regular para cambiar el formato de los datos</h3>
+
+<p>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 <em>primero último</em> y enviarlo en el formato <em>último, primero</em>.</p>
+
+<p>En el texto de reemplazo, el script usa <code>$1</code> y <code>$2</code> para indicar los resultados de los correspondientes paréntesis coincidentes en el patrón de expresión regular.</p>
+
+<pre class="brush: js notranslate">let er = /(\w+)\s(\w+)/
+let str = 'John Smith'
+let newstr = str.replace(er, '$2, $1')
+console.log(newstr)
+</pre>
+
+<p>Esto muestra <code>"Smith, John"</code>.</p>
+
+<h3 id="Uso_de_expresiones_regulares_para_dividir_líneas_con_diferentes_finales_de_líneasaltos_de_línea">Uso de expresiones regulares para dividir líneas con diferentes finales de línea/saltos de línea</h3>
+
+<p>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.</p>
+
+<pre class="brush: js notranslate">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' ]
+</pre>
+
+<p>Ten en cuenta que el orden de los patrones en la expresión regular es importante.</p>
+
+<h3 id="Usar_expresiones_regulares_en_varias_líneas">Usar expresiones regulares en varias líneas</h3>
+
+<pre class="brush: js notranslate">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"]
+</pre>
+
+<h3 id="Usar_una_expresión_regular_con_la_bandera_pegajosa">Usar una expresión regular con la bandera pegajosa</h3>
+
+<p>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")}}.</p>
+
+<pre class="brush: js notranslate">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)</pre>
+
+<h3 id="La_diferencia_entre_la_bandera_pegajosa_y_la_bandera_global">La diferencia entre la bandera pegajosa y la bandera global</h3>
+
+<p>Con la bandera pegajosa <code>y</code>, la siguiente coincidencia tiene que ocurrir en la posición <code>lastIndex</code>, mientras que con la bandera global <code>g</code>, la coincidencia puede ocurrir en la posición <code>lastIndex</code> o posterior:</p>
+
+<pre class="brush: js notranslate">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.</pre>
+
+<p>Con la bandera global <code>g</code>, coincidirían los 6 dígitos, no solo 3.</p>
+
+<h3 id="Expresión_regular_y_caracteres_Unicode">Expresión regular y caracteres Unicode</h3>
+
+<p><code>\w</code> y <code>\W</code> solo coincide con caracteres basados en ASCII; por ejemplo, <code>a</code> a <code>z</code>, <code>A</code> a <code>Z</code>, <code>0</code> a <code>9</code> y <code>_</code>.</p>
+
+<p>Para hacer coincidir caracteres de otros idiomas como Cirílico o Hebreo, usa <code>\u<var>hhhh</var></code>, donde <code><var>hhhh</var></code> es el Valor Unicode en hexadecimal.</p>
+
+<p>Este ejemplo demuestra cómo se pueden separar los caracteres Unicode de una palabra.</p>
+
+<pre class="brush: js notranslate">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
+</pre>
+
+<p>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 <code>\p{scx=Cyrl}</code>.</p>
+
+<h3 id="Extraer_el_nombre_de_subdominio_de_la_URL">Extraer el nombre de subdominio de la URL</h3>
+
+<pre class="brush: js notranslate">let url = 'http://xxx.dominio.com'
+console.log(/[^.]+/.exec(url)[0].substr(7)) // registra 'xxx'
+</pre>
+
+<div class="blockIndicator note">
+<p>En lugar de utilizar expresiones regulares para analizar las URL, normalmente es mejor utilizar el analizador de URL integrado en los navegadores mediante la <a href="/es/docs/Web/API/URL_API">API URL</a>.</p>
+</div>
+
+<h2 id="Especificaciones">Especificaciones</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificación</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-regexp-regular-expression-objects', 'RegExp')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidad_del_navegador">Compatibilidad del navegador</h2>
+
+<div>
+<div class="hidden">La tabla de compatibilidad de esta página se genera a partir de datos estructurados. Si deseas contribuir con los datos, consulta <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> y envíanos una solicitud de extracción.</div>
+
+<p>{{Compat("javascript.builtins.RegExp")}}</p>
+</div>
+
+<h3 id="Notas_específicas_de_Firefox">Notas específicas de Firefox</h3>
+
+<p>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 <code>undefined</code> en lugar de una cadena vacía:</p>
+
+<pre class="brush: js notranslate">// 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'
+</pre>
+
+<p>Ten en cuenta que, debido a la compatibilidad web, <code>RegExp.<var>$N</var></code> seguirá devolviendo una cadena vacía en lugar de <code>undefined</code> ({{bug(1053944)}}).</p>
+
+<h2 id="Ve_también">Ve también</h2>
+
+<ul>
+ <li>El capítulo de {{JSxRef("../Guide/Regular_Expressions", "Expresiones regulares")}} en la {{JSxRef("../Guide", "Guía de JavaScript")}}</li>
+ <li>{{JSxRef("String.prototype.match()")}}</li>
+ <li>{{JSxRef("String.prototype.replace()")}}</li>
+ <li>{{JSxRef("String.prototype.split()")}}</li>
+</ul>
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..f4d4cfb535
--- /dev/null
+++ b/files/es/web/javascript/reference/global_objects/regexp/regexp/index.html
@@ -0,0 +1,115 @@
+---
+title: Constructor RegExp()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/RegExp
+tags:
+  - Constructor
+  - JavaScript
+  - Referencia
+  - RegExp
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/RegExp
+original_slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/RegExp
+---
+<div>{{JSRef}}</div>
+
+<p>El constructor <strong><code>RegExp</code></strong> crea un objeto de expresión regular para hacer coincidir el texto con un patrón.</p>
+
+<p>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")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/regexp-constructor.html")}}</div>
+
+<p class="hidden">La fuente de este ejemplo interactivo se almacena en un repositorio de GitHub. Si deseas contribuir al proyecto de ejemplos interactivos, clona <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> y envíanos una solicitud de extracción.</p>
+
+<h2 id="Sintaxis">Sintaxis</h2>
+
+<p>Son posibles las notaciones literal, constructor y de fábrica:</p>
+
+<pre class="syntaxbox notranslate">/<var>patrón</var>/<var>banderas</var>
+new RegExp(<var>patrón</var>[, <var>banderas</var>])
+RegExp(<var>patrón</var>[, <var>banderas</var>])
+</pre>
+
+<h3 id="Parámetros">Parámetros</h3>
+
+<dl>
+ <dt><code><var>patrón</var></code></dt>
+ <dd>El texto de la expresión regular.</dd>
+ <dd>A partir de ES5, también puede ser otro objeto o <code>RegExp</code> 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.</dd>
+ <dt><code><var>banderas</var></code></dt>
+ <dd>
+ <p>Si se especifica, <code><var>banderas</var></code> es una cadena que contiene las banderas para agregar.</p>
+
+ <p>Alternativamente, si se proporciona un objeto para el patrón, la cadena <code><var>banderas</var></code> reemplazará cualquiera de las banderas de ese objeto (y <code>lastIndex</code> se restablecerá a <code>0</code>) (a partir de ES2015).</p>
+
+ <p>Si no se especifica <code><var>banderas</var></code> y se proporciona un objeto de expresiones regulares, las banderas de ese objeto (y el valor de <code>lastIndex</code>) se copiarán.</p>
+
+ <p><code>banderas</code> puede contener cualquier combinación de los siguientes caracteres:</p>
+
+ <dl>
+  <dt><code>g</code> (coincidencia global)</dt>
+  <dd>Encuentra todas las coincidencias en lugar de detenerse después de la primera.</dd>
+  <dt><code>i</code> (ignorar mayúsculas y minúsculas)</dt>
+  <dd>Si el indicador <code>u</code> también está habilitado, utiliza el plegado de mayúsculas y minúsculas Unicode.</dd>
+  <dt><code>m</code> (multilínea)</dt>
+  <dd>Trata los caracteres iniciales y finales (<code>^</code> y <code>$</code>) como si estuvieran trabajando en varias líneas. En otras palabras, hace coincidir el principio o el final de <em>cada</em> línea (delimitada por <code>\n</code> o <code>\r</code>), no solo al principio o final de toda la cadena de entrada.</dd>
+  <dt><code>s</code> («<em>dotAll</em>» o punto para todo)</dt>
+  <dd>Permite que el punto (<code>.</code> coincida con nuevas líneas o no.</dd>
+  <dt><code>u</code> (unicode)</dt>
+  <dd>Trata el <code><var>patrón</var></code> como una secuencia de puntos de código Unicode. (Consulta también <a href="/es/docs/Web/API/DOMString/Binary">Cadenas binarias</a>).</dd>
+  <dt><code>y</code> (sticky)</dt>
+  <dd>Coincide solo con el índice indicado por la propiedad <code>lastIndex</code> de esta expresión regular en la cadena destino. No intenta coincidir con índices posteriores.</dd>
+ </dl>
+ </dd>
+</dl>
+
+<h2 id="Ejemplos">Ejemplos</h2>
+
+<h3 id="Notación_literal_y_constructor">Notación literal y constructor</h3>
+
+<p>Hay dos formas de crear un objeto <code>RegExp</code>: una <em>notación literal</em> y un <em>constructor</em>.</p>
+
+<ul>
+ <li>Los parámetros de <strong>la notación literal</strong> se encierran entre barras y no utilizan comillas.</li>
+ <li>Los parámetros de <strong>la función constructora</strong> no se encierran entre barras, pero utilizan comillas.</li>
+</ul>
+
+<p>Las siguientes tres expresiones crean la misma expresión regular:</p>
+
+<pre class="brush: js notranslate">/ab+c/i
+new RegExp(/ab+c/, 'i') // notación literal
+new RegExp('ab+c', 'i') // constructor
+</pre>
+
+<p>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.</p>
+
+<p>El constructor del objeto de expresión regular, por ejemplo, <code>new RegExp('ab+c')</code>, 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.</p>
+
+<h2 id="Especificaciones">Especificaciones</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificación</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-regexp-constructor', 'RegExp constructor')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidad_del_navegador">Compatibilidad del navegador</h2>
+
+<div>
+<div class="hidden">La tabla de compatibilidad de esta página se genera a partir de datos estructurados. Si deseas contribuir con los datos, consulta <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> y envíanos una solicitud de extracción.</div>
+
+<p>{{Compat("javascript.builtins.RegExp.RegExp")}}</p>
+</div>
+
+<h2 id="Ve_también">Ve también</h2>
+
+<ul>
+ <li>El capítulo de {{JSxRef("../Guide/Regular_Expressions", "Expresiones regulares")}} en la {{JSxRef("../Guide", "Guía de JavaScript")}}</li>
+ <li>{{JSxRef("String.prototype.match()")}}</li>
+ <li>{{JSxRef("String.prototype.replace()")}}</li>
+</ul>
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..ad127b9f08
--- /dev/null
+++ b/files/es/web/javascript/reference/global_objects/regexp/rightcontext/index.html
@@ -0,0 +1,55 @@
+---
+title: RegExp.rightContext ($')
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/rightContext
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/rightContext
+original_slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/rightContext
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>La propiedad <strong>rightContext <em>(No es estándar)</em></strong> 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 <code>RegExp.$'</code>.</p>
+
+<h2 id="Sintaxis">Sintaxis</h2>
+
+<pre class="syntaxbox"><code><var>RegExp</var>.rightContext
+RegExp["$'"]</code>
+</pre>
+
+<h2 id="Descripción">Descripción</h2>
+
+<p>La propiedad <code>rightContext</code> es estática, no es una propiedad de un objeto de expresión regular individual. Debe usarse como <code>RegExp.rightContext</code> o <code>RegExp["$'"].</code></p>
+
+<p>El valor de la propiedad <code>rightContext</code> es de solo lectura y se modifica cada que hay una coincidencia exitosa.</p>
+
+<p>Tenga presente que no puede usar la abreviatura (<code>RegExp.$'</code>), 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 <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors">notación de paréntesis para acceso a la propiedad</a>.</p>
+
+<h2 id="Ejemplos">Ejemplos</h2>
+
+<h3 id="Usando_rightContext_y_'">Usando <code>rightContext</code> y <code>$'</code></h3>
+
+<pre class="brush: js">var re = /hola/g;
+re.test('hola mundo!');
+RegExp.rightContext; // " mundo!"
+RegExp["$'"];       // " mundo!"
+</pre>
+
+<h2 id="Especificaciones">Especificaciones</h2>
+
+<p>No estándar. No forma parte de ninguna especificación actual.</p>
+
+<h2 id="Navegadores_compactibles">Navegadores compactibles</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.RegExp.rightContext")}}</p>
+</div>
+
+<h2 id="Ver_también">Ver también</h2>
+
+<ul>
+ <li>{{non-standard_inline}} {{jsxref("RegExp.input", "RegExp.input ($_)")}}</li>
+ <li>{{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&amp;)")}}</li>
+ <li>{{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}</li>
+ <li>{{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}</li>
+ <li>{{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}</li>
+</ul>
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..712b914236
--- /dev/null
+++ b/files/es/web/javascript/reference/global_objects/regexp/test/index.html
@@ -0,0 +1,153 @@
+---
+title: RegExp.prototype.test()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/test
+tags:
+  - Expresion Regular
+  - Prototipo
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test
+original_slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/test
+---
+<div>{{JSRef}}</div>
+
+<p>El método <code><strong>test()</strong></code> ejecuta la búsqueda de una ocurrencia entre una expresión regular y una cadena especificada. Devuelve <code>true</code> o <code>false</code>.</p>
+
+<h2 id="Sintaxis">Sintaxis</h2>
+
+<pre class="syntaxbox"><code><var>regexObj</var>.test(<var>cadena</var>)</code></pre>
+
+<h3 id="Parámetros">Parámetros</h3>
+
+<dl>
+ <dt><code>cadena</code></dt>
+ <dd>La cadena a comparar contra la expresión regular.</dd>
+</dl>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>Retorna <code>true</code> si existe una coincidencia entre la expresión regular y la cadena especificada; de lo contrario retorna <code>false</code>.</p>
+
+<h2 id="Descripción">Descripción</h2>
+
+<p>Use <code>test()</code> 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 <code>test()</code> devuelve un booleano, mientras que <code>search()</code> devuelve el índice de la coincidencia (si la encuentra) o -1 si no la encuentra).</p>
+
+<p>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 <code>test()</code> sobre la misma instancia global de una expresión regular avanzará desde de la ocurrencia anterior.</p>
+
+<h2 id="Ejemplos">Ejemplos</h2>
+
+<h3 id="Usando_test()">Usando <code>test()</code></h3>
+
+<p>Ejemplo simple que prueba si "hello" está contenido al principio de una cadena y devuelve un valor booleano.</p>
+
+<pre class="brush: js">var cadena = "hello world!";
+var result = /^hello/.test(cadena);
+console.log(result); // true
+</pre>
+
+<p dir="ltr" id="tw-target-text">El siguiente ejemplo registra un mensaje que depende del éxito de la prueba:</p>
+
+<pre class="brush: js">function probarEntrada(regexp, cadena){
+  var subcadena;
+  if (regexp.test(cadena)) {
+    subcadena = ' contiene ';
+  } else {
+    subcadena = ' no contiene ';
+  }
+  console.log(cadena + subcadena + regexp.source);
+}
+</pre>
+
+<h2 id="Especificaciones">Especificaciones</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificación</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentario</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definition inicial. Implementado en JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.10.6.3', 'RegExp.test')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-regexp.prototype.test', 'RegExp.test')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-regexp.prototype.test', 'RegExp.test')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidad_en_Navegadores">Compatibilidad en Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h3 id="Notas_específicas_para_Gecko">Notas específicas para Gecko</h3>
+
+<p>Antes de Gecko 8.0 {{geckoRelease("8.0")}}, <code>test()</code> estaba incorrectamente implementado; cuando era llamado sin parámetros, buscaba emparejar contra el valor de la entrada anterior (la propiedad <code>RegExp.input</code>) en lugar de hacerlo contra la cadena <code>"undefined"</code>. Esto ha sido corregido; ahora <code>/undefined/.test()</code> resulta correctamente en <code>true</code>, en lugar de un error.</p>
+
+<h2 id="Vea_también">Vea también</h2>
+
+<ul>
+ <li>El capítulo <a href="/es/docs/Web/JavaScript/Guide/Regular_Expressions">Expresiones Regulares</a> de la <a href="https://developer.mozilla.org/es/docs/Web/JavaScript/Guide">Guía JavaScript</a></li>
+ <li>{{jsxref("RegExp")}}</li>
+</ul>
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..724de783f7
--- /dev/null
+++ b/files/es/web/javascript/reference/global_objects/regexp/tostring/index.html
@@ -0,0 +1,172 @@
+---
+title: RegExp.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/toString
+tags:
+  - Expresion Regular
+  - Prototipo
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/toString
+original_slug: Web/JavaScript/Referencia/Objetos_globales/RegExp/toString
+---
+<div>{{JSRef}}</div>
+
+<p>El método <strong><code>toString()</code></strong> devuelve una cadena que representa el patrón de la expresión regular.</p>
+
+<h2 id="Sintaxis">Sintaxis</h2>
+
+<pre class="syntaxbox"><code><var>regexObj</var>.toString();</code></pre>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>Una cadena que representa el objeto dado.</p>
+
+<h2 id="Descripción">Descripción</h2>
+
+<p>El objeto {{jsxref("RegExp")}} reemplaza el método <code>toString()</code> del objeto {{jsxref("Object")}}; no hereda de {{jsxref("Object.prototype.toString()")}}. Para objetos {{jsxref("RegExp")}}, el método <code>toString()</code> retorna una cadena que representa el patrón de la expresión regular.</p>
+
+<h2 id="Ejemplos">Ejemplos</h2>
+
+<h3 id="Usando_toString()">Usando <code>toString()</code></h3>
+
+<p dir="ltr" id="tw-target-text">El siguiente ejemplo muestra la cadena de representación de un objeto {{jsxref("RegExp")}}:</p>
+
+<pre class="brush: js">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'
+</pre>
+
+<h3 id="Expresiones_regulares_vacías_y_escapado">Expresiones regulares vacías y escapado</h3>
+
+<p>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:</p>
+
+<pre class="brush: js">new RegExp().toString(); // "/(?:)/"
+
+new RegExp('\n').toString() === "/\n/";  // true, antes de ES5
+new RegExp('\n').toString() === "/\\n/"; // true, desde ES5
+</pre>
+
+<h2 id="Especificaciones">Especificaciones</h2>
+
+<table class="standard-table" style="color: #3b3c40; font-size: 14px; font-weight: normal;">
+ <tbody>
+  <tr>
+   <th scope="col">Especificación</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentario</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definición inicial. Implementado en JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.2', 'RegExp.prototype.toString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Agregado de la definición para escapado de caracteres especiales y "(?:)" para expresiones regulares vacías.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-regexp.prototype.tostring', 'RegExp.prototype.toString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-regexp.prototype.tostring', 'RegExp.prototype.toString')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidad_en_Navegadores">Compatibilidad en Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Escaping</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop(38)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Generic function</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop(39)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Escaping</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile(38)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Generic function</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile(39)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Vea_también">Vea también</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>