Aserciones
==========

Las aserciones incluyen límites, que indican el comienzo y el final de líneas y palabras, y otros patrones que indican de alguna manera que el reconocimiento es posible (incluidas las expresiones anticipadas, condicionales e inversas).

Pruébalo
--------

Tipos
-----

La siguiente sección también está duplicada en `esta hoja de trucos`. No olvides editarla también, ¡gracias!

### Aserciones de tipo límite

| Caracteres | Significado |
| --- | --- |
| `^` | Coincide con el comienzo de la entrada. Si el indicador multilínea se establece en `true`, también busca inmediatamente después de un caracter de salto de línea. Por ejemplo, `/^A/` no coincide con la "A" en "alias A", pero coincide con la primera "A" en "Alias A".

Este caracter tiene un significado diferente cuando aparece al comienzo de un `grupo`.
 |
| `$` | Coincide con el final de la entrada. Si el indicador multilínea se establece en `true`, también busca hasta inmediatamente antes de un caracter de salto de línea. Por ejemplo, `/r$/` no coincide con la "r" en "espera", pero sí en "esperar". |
| `\b` | Marca el límite de una palabra. Esta es la posición en la que un caracter de palabra no va seguido o precedido por otro caracter de palabra, por ejemplo, entre una letra y un espacio. Ten en cuenta que el límite de una palabra encontrada no se incluye en el resultado. En otras palabras, la longitud de un límite de palabra encontrada es cero.
Ejemplos:* `/\bl/` encuentra la "l" en "luna".
* `/un\b/` no concuerda con "un" en "luna", porque "un" va seguido de "a", que es un carácter de palabra.
* `/una\b/` coincide con "una" en "luna", porque "una" es el final de la cadena, por lo tanto no va seguido de un carácter de palabra.
* `/\w\b\w/` nunca encontrará con nada, porque un caracter de palabra nunca puede ir seguido de un caracter que no sea de palabra y otro de palabra.

Para hacer coincidir un carácter de retroceso (`[\b]`), consulta `Clases de caracteres`. |
| `\B` | Coincide con un límite sin palabra. Esta es una posición en la que el caracter anterior y siguiente son del mismo tipo: ambos deben ser palabras o ambos deben ser no palabras, por ejemplo, entre dos letras o entre dos espacios. El principio y el final de una cadena se consideran no palabras. Igual que el límite de palabras encontradas, el límite sin palabras reconocidas tampoco se incluye en el resultado. Por ejemplo, `/\Bme/` coincide con "me" en "al mediodía", y `/ay\B/` coincide con "ay" en "posiblemente ayer". |

### Otras aserciones

**Nota:** El caracter `?` también se puede utilizar como cuantificador.


| Caracteres | Significado |
| --- | --- |
| `x(?=y)` | **Aserción anticipada**: Coincide con "x" solo si "x" va seguida de "y". Por ejemplo, `/Jack(?=Sprat)/` coincide con "Jack" solo si va seguido de "Sprat". `/Jack(?=Sprat|Frost)/` coincide con "Jack" solo si va seguido de "Sprat" o "Frost". Sin embargo, ni "Sprat" ni "Frost" forman parte del resultado. |
| `x(?!y)` | **Aserción anticipada negativa**: Coincide con "x" solo si "x" no está seguida de "y". Por ejemplo, `/\d+(?!\.)/` coincide con un número solo si no va seguido de un punto decimal. `/\d+(?!\.)/.exec('3.141')` coincide con "141" pero no con "3." |
| `(?<=y)x` | **Aserción de búsqueda inversa**: coincide con "x" solo si "x" está precedida por "y". Por ejemplo, `/(?<=Jack)Sprat/` coincide con "Sprat" sólo si va precedida de "Jack". `/(?<=Jack|Tom)Sprat/` coincide con "Sprat" solo si va precedido de "Jack" o "Tom". Sin embargo, ni "Jack" ni "Tom" forman parte del resultado. |
| `(?<!y)x` | **Aserción de búsqueda inversa negativa**: coincide con "x" solo si "x" *no* está precedida por "y". Por ejemplo, `/(?<!-)\d+/` coincide con un número solo si no está precedido por un signo de menos. `/(? coincide con "3". /(?<!-)\d+/.exec('-3') no se encuentra la coincidencia porque el número está precedido por el signo menos.` |

Ejemplos
--------

### Ejemplo de descripción de tipo límite


```js
// Usa límites Regex para arreglar cadenas con errores.
let multilineaIncorrecta = `tey, la brillante manzena vered
toy cuelga en una rama del arbol vered`;

// 1) Usa ^ para corregir la coincidencia al principio de la cadena y justo después de la nueva línea.
multilineaIncorrecta = multilineaIncorrecta.replace(/^t/gim, "h");
console.log(1, multilineaIncorrecta); // corrige 'tey', 'toy' => 'hey', 'hoy'.

// 2) Usa $ para arreglar el reconocimiento al final del texto.
multilineaIncorrecta = multilineaIncorrecta.replace(/ed$/gim, "de");
console.log(2, multilineaIncorrecta); // corrige 'vered' => 'verde'.

// 3) Usa \b para encontrar los caracteres justo en el borde entre una palabra y un espacio.
multilineaIncorrecta = multilineaIncorrecta.replace(/\ba/gim, "á");
console.log(3, multilineaIncorrecta); // corrige 'arbol' sin tocar nada más.

// 4) Usa \B para encontrar los caracteres dentro de los bordes de una entidad.
multilineaCorrecta = multilineaIncorrecta.replace(/\Ben/gim, "an");
console.log(4, multilineaCorrecta); // corrige 'manzena' pero no toca 'en'.
```

### Busca al comienzo de la entrada usando un caracter de control `^`

Usa `^` para hacer coincidir al comienzo de la entrada. En este ejemplo, podemos obtener las frutas que comienzan con 'A' con una expresión regular `/^A/`. Para seleccionar las frutas adecuadas, podemos utilizar el método `filter` con un `función flecha`.


```js
let frutas = ["Manzana", "Sandía", "Naranja", "Aguacate", "Fresa", "Melón"];

// Selecciona frutas que comiencen con 'M' por la Regex /^M/.
// Aquí se usa el símbolo de control '^' solo en un rol: Reconocer desde el inicio una entrada.

let frutasEmpiezanConM = frutas.filter((fruta) => /^M/.test(fruta));
console.log(frutasEmpiezanConM); // [ 'Manzana', 'Melón' ]
```


En el segundo ejemplo, `^` se usa tanto para hacer coincidir al comienzo de la entrada como para crear conjuntos de caracteres negados o complementados cuando se usa dentro de `grupos`.


```js
let frutas = ["Manzana", "Sandía", "Naranja", "Aguacate", "Fresa", "Melón"];

// Seleccionar frutas que no comiencen por 'M' con la regexp /^[^M]/.
// En este ejemplo, se representan dos significados del símbolo de control '^':
// 1) Inicio coincidente de la entrada
// 2) Un conjunto de caracteres negado o complementado: [^M]
// Es decir, coincide con cualquier cosa que no esté encerrado entre los corchetes.

let frutasNoEmpiezanConM = frutas.filter((fruta) => /^[^M]/.test(fruta));

console.log(frutasNoEmpiezanConM); // [ "Sandía", "Naranja", "Aguacate", "Fresa" ]
```

### Reconoce el límite de palabra


```js
let frutasConDescripcion = ["Manzana roja", "Piña amarilla", "Aguacate verde"];

// Selecciona descripciones que contengan terminaciones de palabras 'ja' o 'de':
let deJaSeleccion = frutasConDescripcion.filter((descr) =>
  /(de|ja)\b/.test(descr),
);

console.log(deJaSeleccion); // ["Manzana roja", "Aguacate verde"]
```

### Aserción anticipada


```js
// JS aserción anticipada x(?=Y)

let regex = /Primer(?= prueba)/g;

console.log("Primer prueba".match(regex)); // [ 'Primer' ]
console.log("Primer melocotón".match(regex)); // null
console.log("Esta es mi Primer prueba en un año.".match(regex)); // [ 'Primer' ]
console.log("Este es mi Primer melocotón en un mes.".match(regex)); // null
```

### Aserción anticipada negativa básica

Por ejemplo, `/\d+(?!\.)/` coincide con un número solo si no va seguido de un punto decimal. `/\d+(?!\.)/.exec('3.141')` coincide con "141" pero no con "3."


```js
console.log(/\d+(?!\.)/g.exec("3.141")); // [ '141', index: 2, input: '3.141' ]
```

### Diferente significado del uso de la combinación '?!' en aserciones y rangos

Diferente significado del uso de la combinación `?!` en `Aserciones` `/x(?!y)/` y de `[^?!]` en `Rangos`.


```js
let naranjaNoLimon =
  "¿Quieres beber jugo de naranja? ¡Sí, no quiero tomar jugo de limón!";

// Diferente significado del uso de la combinación '?!' en Aserciones /x(?!y)/ y [^?!] en Rangos.
let regexNoSeleccionaLimon = /[^?!]+beber(?! de limón)[^?!]+[?!]/gi;
console.log(naranjaNoLimon.match(regexNoSeleccionaLimon)); // [ '¿Quieres beber jugo de naranja?' ]

let regexNoSeleccionaNaranja = /[^?!]+tomar(?! de naranja)[^?!]+[?!]/gi;
console.log(naranjaNoLimon.match(regexNoSeleccionaNaranja)); // [ ' ¡Sí, no quiero tomar jugo de limón!' ]
```

### Aserción inversa


```js
let naranjas = ["naranja madura A", "naranja verde B", "naranja madura C"];

let naranjas_maduras = naranjas.filter((fruta) =>
  fruta.match(/(?<=naranja) madura/),
);
console.log(naranjas_maduras); // [ 'naranja madura A ', 'naranja madura C' ]
```

Especificaciones
----------------

{{Specifications}}Compatibilidad del navegador
----------------------------

Para obtener información sobre la compatibilidad del navegador, consulta la `tabla principal de compatibilidad de expresiones regulares`.

Ve también
----------

* `Guía de expresiones regulares`
    + `Clases de caracteres`
    + `Cuantificadores`
    + `Escapes de propiedades Unicode`
    + `Grupos y rangos`
* `El constructor RegExp()`