recursal/MDN huggingface dataset:
String.prototype.substr()
=========================

**Advertencia:** Advertencia: Aunque `String.prototype.substr(…)` no está estrictamente obsoleto (como en "eliminado de los estándares web"), se define en el anexo B de la norma ECMA-262, cuya introducción establece:

> 
> ... Todas las características y comportamientos del lenguaje especificados en este anexo tienen una o más características indeseables y, en ausencia de uso heredado, se eliminarían de esta especificación. ... ... Los programadores no deben usar ni asumir la existencia de estas características y comportamientos al escribir un nuevo código ECMAScript.
> 
> 
> 

Resumen
-------

El método **`substr()`** devuelve los caracteres de una cadena que comienzan en una localización especificada y de acuerdo al número de caracteres que se especifiquen.

Sintaxis
--------
```

cadena.substr(inicio[, longitud])
```

### Parámetros

`inicio`

Localización en la cual se empiezan a extraer caracteres. Si se da un número negativo, se trata como `longCad + inicio` donde `longCad` es la longitud de la cadena (por ejemplo, si `inicio` es -3 se trata como `longCad - 3`).

`longitud`

Opcional. El número de caracteres a extraer. Si este argumento es `undefined`, todos los caracteres desde `inicio` hasta el final de la cadena serán extraidos.

### Valor retornado

Una nueva cadena que contiende la sección extraída de la cadena dada. Sí la longitud es 0 o un número negativo, retorna la cadena vacía.

Descripción
-----------

`inicio` es el índice de un carácter. El índice del primer carácter es 0, y el índice del último carácter es la longitud de la cadena menos 1. `substr` comienza extrayendo caracteres a partir de `inicio` y recolecta `longitud` caracteres (a menos que se alcance primero el final de la cadena, en cuyo caso devuelve menos).

Si `inicio` es positivo y es mayor o igual que la longitud de la cadena, `substr()` devuelve una cadena vacía.

Si `inicio` es negativo, `substr()` lo usa como un índice de carácter desde el final de la cadena. Si `inicio` es negativo y `abs(inicio)` es mayor que la longitud de la cadena, `substr` usa 0 como índice inical. Nota: el uso descrito de valores negativos del argumento `inicio` no es soportado por Microsoft JScript.

Si `longitud` es 0 o negativa, `substr` devuelve una cadena vacía. Si se omite `longitud`, `inicio` extrae caracteres hasta el final de la cadena.

Ejemplos
--------

### Ejemplo: Uso de `substr()`


```js
var cadena = "abcdefghij";

console.log("(1,2): " + cadena.substr(1, 2)); // '(1, 2): bc'
console.log("(-3,2): " + cadena.substr(-3, 2)); // '(-3, 2): hi'
console.log("(-3): " + cadena.substr(-3)); // '(-3): hij'
console.log("(1): " + cadena.substr(1)); // '(1): bcdefghij'
console.log("(-20, 2): " + cadena.substr(-20, 2)); // '(-20, 2): ab'
console.log("(20, 2): " + cadena.substr(20, 2)); // '(20, 2): '
```


Este script muestra:
```

(1,2): bc
(-3,2): hi
(-3): hij
(1): bcdefghij
(-20, 2): ab
(20, 2):
```

Vea También
-----------

* `String.prototype.slice()`
* `String.prototype.substring()`
String.prototype.concat()
=========================

El método **`concat()`** combina dos o más cadenas de texto y devuelve una cadena de texto nueva.

Pruébalo
--------

Sintaxis
--------
```

str.concat(str2 [, ...strN])
```

### Parámetros

`str2 [, ...strN]`

Cadenas que se concatenarán con `str`.

### Valor devuelto

Una nueva cadena que contiene el texto combinado de las cadenas proporcionadas.

Descripción
-----------

La función `concat()` concatena los argumentos de tipo texto con la cadena de sobre la que se llama a la función y devuelve una nueva cadena de texto. Los cambios en la cadena original o la cadena devuelta no afectan al otro.

Si los argumentos no son de tipo texto, son convertidos a texto antes de concatenarlos

Rendimiento
-----------

Es altamente recomendado que se utilicen operadores de asignación (en-US) (`+`, `+=`) en lugar del método `concat()`.

Ejemplos
--------

### Usando concat()

El siguiente ejemplo combina cadenas de texto en una nueva.


```js
let hello = "Hello, ";
console.log(hello.concat("Kevin", ". Have a nice day."));
// Hello, Kevin. Have a nice day.

let greetList = ["Hello", " ", "Venkat", "!"];
"".concat(...greetList); // "Hello Venkat!"

"".concat({}); // [object Object]
"".concat([]); // ""
"".concat(null); // "null"
"".concat(true); // "true"
"".concat(4, 5); // "45"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.concat |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Array.prototype.concat()`
* Operadores de asignación (en-US)
String.length
=============

La propiedad **`length`** de un objeto `String` representa la longitud de una cadena, en unidades de código UTF-16.

Sintaxis
--------
```

str.length
```

Descripción
-----------

Esta propiedad devuelve el número de caracteres de una cadena. UTF-16, el formato usado por JavaScript, usa 16-bit para representar los caracteres más comunes, pero necesita usar dos caracteres para otros menos usados, así que es posible que el valor devuelto por `length` no corresponda al número de caracteres de la cadena.

ECMASCript 2016 (ed. 7) estableció una longitud máxima de `2^53 - 1` elementos. Anteriormente, ninguna longitud máxima era especificada.

Para una cadena vacía, `length` es 0.

La propiedad static `String.length` devuelve 1.

Ejemplos
--------

### Uso Básico


```js
var x = "Mozilla";
var empty = "";

console.log("Mozilla is " + x.length + " code units long");
/\* "Mozilla is 7 code units long" \*/

console.log("The empty string has a length of " + empty.length);
/\* "The empty string has a length of 0" \*/
```

### Asignando a length


```js
var myString = "bluebells";

// Attempting to assign a value to a string's .length property has no observable effect.
myString.length = 4;
console.log(myString);
/\* "bluebells" \*/
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-string-instances-length |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* JavaScript String.length and Internationalizing Web Applications
String.prototype.search()
=========================

Resumen
-------

El método **`search()`** ejecuta una búsqueda que encaje entre una expresión regular y el objeto `String` desde el que se llama.

Sintaxis
--------
```

str.search(expresionregular)
```

### Parámetros

regexp

Un objeto expresión regular. Si se pasa un objeto `obj` que no sea una expresión regular, se convierte implicitamente en una expresión regualar usando `new RegExp(obj)`.

### Valor devuelto

El índice de la primera coincidencia entre la expresión regular y la cadena de texto proporcionada, si no se encuentra devuelve **-1**.

Descripción
-----------

Cuando se desee saber en qué casos un patrón se encuentra en una cadena de texto utiliza `search()` (si sólo deseas saber si existe, utiliza el método `test()` del prototipo de `RegExp`); para más información (pero de ejecución más lenta) utiliza `match()` (similar al método `exec()` de las expresiones regulares).

Ejemplos
--------

### Utilizando `search()`

El siguiente ejemplo imprime un mensaje dependiendo de cuál sea el resultado de la evaluación.


```js
function testinput(re, str) {
  var midstring;
  if (str.search(re) != -1) {
    midstring = " contains ";
  } else {
    midstring = " does not contain ";
  }
  console.log(str + midstring + re);
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.search |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Vea también
-----------

* `String.prototype.match()`
* `RegExp.prototype.exec()`
String.prototype.lastIndexOf()
==============================

Resumen
-------

El método **`lastIndexOf()`** `devuelve` la posicion (indice) en la que se encuentra el **valorBusqueda**, dentro del objeto `String` que realiza la llamada, de la última ocurrencia del valor especificado; o -1 si no se halla. La búsqueda se realiza empezando por el final de la cadena que realiza la llamada, empezando en **`indiceDesde`**.

Sintaxis
--------
```

cadena.lastIndexOf(valorBusqueda[, indiceDesde])
```

### Parámetros

`valorBusqueda`

Una cadena que representa el valor que se desea buscar.

`indiceDesde`

La localización dentro de la cadena que realiza la llamada desde donde comenzará la búsqueda. Puede ser cualquier entero entre 0 y la longitud de la cadena. El valor predeterminado es la longitud de la cadena.

Descripción
-----------

Los caracteres de una cadena se indexan de izquierda a derecha. El índice del primer carácter es 0, y el índice del último carácter es `nombreCadena.length - 1`.


```js
"canal".lastIndexOf("a"); // returns 3
"canal".lastIndexOf("a", 2); // returns 1
"canal".lastIndexOf("a", 0); // returns -1
"canal".lastIndexOf("x"); // returns -1
```


El método `lastIndexOf` es sensible a mayúsculas. Por ejemplo, la siguiente expresión devuelve -1:


```js
"Ballena Azul, Ballena Asesina".lastIndexOf("azul");
```

Ejemplos
--------

### Ejemplo: Usando `indexOf` y `lastIndexOf`

El siguiente ejemplo utiliza `indexOf` y `lastIndexOf` para localizar valores en la cadena "`Brave new world`".


```js
var anyString = "Brave new world";

// Displays 8
document.write(
  "<P>The index of the first w from the beginning is " + anyString.indexOf("w"),
);
// Displays 10
document.write(
  "<P>The index of the first w from the end is " + anyString.lastIndexOf("w"),
);
// Displays 6
document.write(
  "<P>The index of 'new' from the beginning is " + anyString.indexOf("new"),
);
// Displays 6
document.write(
  "<P>The index of 'new' from the end is " + anyString.lastIndexOf("new"),
);
```

Vea También
-----------

* `String.prototype.charAt()`
* `String.prototype.indexOf()`
* `String.prototype.split()`
* `Array.prototype.indexOf()`
* `Array.prototype.lastIndexOf()`
String.prototype.anchor()
=========================

Resumen
-------

El método **`anchor()`** crea un ancla HTML, `<a>`, que se usa como un enlace a hipertexto.

Sintaxis
--------
```

cadena.anchor(nombreAtributo)
```

### Parámetros

`nombreAtributo`

Una cadena.

Descripción
-----------

Usa el método `anchor` con los métodos `document.write` o `document.writeln` para crear y mostrar programando un ancla en un documento. Crea el ancla con el método `anchor`, y entonces llama a `write` o `writeln` para mostrar el ancla en el documento. En JavaScript en el lado Servidor, usa la función `write` para mostrar el ancla.

En la sintaxis, la cadena de texto representa el texto literal que usted quiere que el usuario vea. La cadena `nombreAtributo` representa el atributo `NAME` de la etiqueta A.

Los anclas creados con el método `anchor` serán elementos del arreglo `document.anchors`

Ejemplos
--------

### Ejemplo: Usando `anchor`

El siguiente código de ejemplo dentro de un elemento HTML `script`:


```js
var miCadena = "Tabla de Contenidos";
document.body.innerHTML = miCadena.anchor("ancla\_contenidos");
```


obtendrá el siguiente HTML:


```html
<a name="ancla\_contenidos">Tabla de Contenidos</a>
```

### Vea También

* `String.prototype.link()`
String.prototype.toLowerCase()
==============================

Resumen
-------

El método **`toLowerCase()`** devuelve el valor **en minúsculas** de la cadena que realiza la llamada.

Sintaxis
--------
```

cadena.toLowerCase()
```

Descripción
-----------

El método `toLowerCase` devuelve el valor de la cadena convertida a minúsculas. `toLowerCase` no afecta al valor de la cadena en sí misma.

Ejemplos
--------

### Ejemplo: Usando `toLowerCase`

El siguiente ejemplo muestra la cadena "alfabeto" en minúsculas:


```js
var textoMayusculas = "ALFABETO";
document.write(textoMayusculas.toLowerCase());
```

Vea También
-----------

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toUpperCase()`
String.prototype.valueOf()
==========================

Resumen
-------

The **`valueOf()`** método devuelve el valor primitivo de un objeto String.

Sintaxis
--------
```

caneda.valueOf()
```

Descripción
-----------

El método `valueOf` de `String` devuelve el valor primitivo de un objeto String como un tipo de dato cadena. Este valor es equivalente a String.toString.

Normalmente este método es llamado internamente por JavaScript y no en el código.

Ejemplos
--------

### Ejemplo: Usando `valueOf`


```js
cadena = new String("Hello world");
alert(cadena.valueOf()); // Displays "Hello world"
```

Vea También
-----------

* `String.prototype.toString()`
* `Object.prototype.valueOf()`
String.prototype.small()
========================

**Obsoleto:** Esta característica ya no se recomienda. Aunque es posible que algunos navegadores aún lo admitan, probablemente ya se ha eliminado de los estándares web relevantes, está en proceso de eliminación o solo se conserva por motivos de compatibilidad. Evite usarlo y actualice el código existente si es posible; consulte la tabla de compatibilidad en la parte inferior de esta página para orientar su decisión. Tenga en cuenta que esta característica puede dejar de funcionar en cualquier momento.

Resumen
-------

Causa que una cadena se muestra con una fuente pequeña, como si estuviese dentro de una etiqueta `<small>`.

Sintaxis
--------
```

cadena.small()
```

Descripción
-----------

Usa el método `small` para formatear y mostrar una cadena en un documento.

Ejemplos
--------

### Ejemplo: Usando métodos de `string` para cambiar el tamaño de una cadena


```js
var cadenaMundo = "¡Hola mundo!";

console.log(cadenaMundo.small());
console.log(cadenaMundo.big());
console.log(cadenaMundo.fontsize(7));
```


Este ejemplo produce el mismo resultado que el siguiente código HTML:


```html
<small>¡Hola mundo!</small>
<big>¡Hola mundo!</big>
<font size="7">¡Hola mundo!</font>
```

### Vea También

* `String.prototype.fontsize()`
* `String.prototype.big()`
String.prototype.toLocaleLowerCase()
====================================

El método **`toLocaleLowerCase()`** retorna la cadena de texto desde la que se llama convertida en minúsculas, de acuerdo con cualquier localización específica de correspondencia de mayúsculas y minúsculas.Pruébalo
--------

Los fuentes para este ejemplo interactivo están almacenados en un repositorio GitHub. Si quieres contribuir en el proyecto de ejemplos interactivos, por favor clona `https://github.com/mdn/interactive-examples` y envíanos un pull request.

Sintaxis
--------
```

str.toLocaleLowerCase()
str.toLocaleLowerCase(locale)
str.toLocaleLowerCase([locale, locale, ...])
```

### Parámetros

`locale` Opcional

El parámetro `locale` indica la localización que se utilizará para convertir a minúsculas de acuerdo con culalquier correspondencia de mayúsculas y minúsculas. Si se proporcionan múltiples locales en un `Array`, se utiliza el mejor local disponible. La localización por defecto es la localización actual configurada en el *host*.

### Valor retornado

Una nueva cadena que representa la cadena desde la que se llama convertida a minúsculas, de acuerdo con cualquier localización específica de correspondencia de mayúsculas y minúsculas.

### Excepciones

* Una excepción de tipo `RangeError` ("invalid language tag: xx\_yy") se lanzará si el argumento `locale` no es una etiqueta válida de lenguaje.
* Una excepción de tipo `TypeError` ("invalid element in locales argument") se lanzará si un elemento del arreglo no es del tipo cadena.
Descripción
-----------

El método `toLocaleLowerCase()` retorna la cadena de texto desde la que se llama convertida en minúsculas, de acuerdo con cualquier localización específica de correspondencia de mayúsculas y minúsculas. `toLocaleLowerCase()` no afecta el valor de la cadena desde la que se llama. En la mayoría de los casos, producirá el mismo resultado que `toLowerCase()`, pero para algunos locales, como el turco, cuyas correspondencias de mayúsculas y minúsculas no siguen las correpsondencias por defecto de Unicode, podría producir de un resultado diferente.

Ejemplos
--------

### Utilizando `toLocaleLowerCase()`


```js
"ALPHABET".toLocaleLowerCase(); // 'alphabet'

"\u0130".toLocaleLowerCase("tr") === "i"; // true
"\u0130".toLocaleLowerCase("en-US") === "i"; // false

let locales = ["tr", "TR", "tr-TR", "tr-u-co-search", "tr-x-turkish"];
"\u0130".toLocaleLowerCase(locales) === "i"; // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolocalelowercase |
| ECMAScript Internationalization API Specification # sup-string.prototype.tolocalelowercase |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Vea también
-----------

* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toLowerCase()`
* `String.prototype.toUpperCase()`
String.prototype.blink()
========================

**Obsoleto:** Esta característica ya no se recomienda. Aunque es posible que algunos navegadores aún lo admitan, probablemente ya se ha eliminado de los estándares web relevantes, está en proceso de eliminación o solo se conserva por motivos de compatibilidad. Evite usarlo y actualice el código existente si es posible; consulte la tabla de compatibilidad en la parte inferior de esta página para orientar su decisión. Tenga en cuenta que esta característica puede dejar de funcionar en cualquier momento.

Resumen
-------

Causa que una cadena parpadee como si estuviese en una etiqueta `<blink>`.

Sintaxis
--------
```

cadena.blink()
```

Descripción
-----------

Usa el método `blink` para formatear y mostrar una cadena en un documento.

Ejemplos
--------

### Ejemplo: Usando métodos de `string` para cambiar el formateado de una cadena

El siguiente ejemplo usa métodos de `string` para cambiar el formateado de una cadena:


```js
var cadenaMundo = "¡Hola mundo!";

console.log(cadenaMundo.blink());
console.log(cadenaMundo.bold());
console.log(cadenaMundo.italics());
console.log(cadenaMundo.strike());
```


Este ejemplo produce el mismo resultado que el siguiente código HTML:


```html
<blink>¡Hola mundo!</blink>
<b>¡Hola mundo!</b>
<i>¡Hola mundo!</b>
<strike>¡Hola mundo!</strike>
```

Vea también
-----------

* `String.prototype.bold()`
* `String.prototype.italics()`
* `String.prototype.strike()`
String.prototype.normalize()
============================

El método **`normalize()`** retorna la Forma de Normalización Unicode de la cadena dada (si el valor no es una cadena, primero será convertido a ese tipo).

Sintaxis
--------
```

str.normalize([form])
```

### Parámetros

`form`

Uno de`"NFC"`, `"NFD"`, `"NFKC"`, o `"NFKD"`, especificando la Forma de Normalización Unicode. Si es omitida o `undefined`, se utiliza `"NFC"`.

* `NFC` — Forma de Normalización de Composición Canónica.
* `NFD` — Forma de Normalización de Descomposición Canónica.
* `NFKC` — Forma de Normalización de Composición de Compatibilidad.
* `NFKD` — Forma de Normalización de Descomposición de Compatibilidad.

### Valor de retorno

Una cadena que contiene la Forma de Normalización Unicode de la cadena dada.

### Errores lanzados

`RangeError`

Un error `RangeError` es lanzado si `form` no es uno de los valores especificados arriba.

Descripción
-----------

El método `normalize()` retorna la Forma de Normalización Unicode de una cadena. No afecta el valor de la cadena en sí misma.

Ejemplos
--------

### Uso de `normalize()`


```js
// Cadena inicial

// U+1E9B: LETRA S LATINA MINÚSCULA CON PUNTO ARRIBA
// U+0323: COMBINACIÓN CON PUNTO ABAJO
var str = "\u1E9B\u0323";

// Forma compuesta canónicamente (NFC)

// U+1E9B: LETRA S LATINA MINÚSCULA CON PUNTO ARRIBA
// U+0323: COMBINACIÓN CON PUNTO ABAJO
str.normalize("NFC"); // '\u1E9B\u0323'
str.normalize(); // lo mismo que arriba

// Forma canónicamente descompuesta (NFD)

// U+017F: LETRA S LATINA MINÚSCULA
// U+0323: COMBINACIÓN CON PUNTO ABAJO
// U+0307: COMBINACIÓN CON PUNTO ARRIBA
str.normalize("NFD"); // '\u017F\u0323\u0307'

// Compuesta con compatibilidad (NFKC)

// U+1E69: LETRA S LATINA MINÚSCULA CON PUNTO ARRIBA Y ABAJO
str.normalize("NFKC"); // '\u1E69'

// Descompuesta con compatibilidad (NFKD)

// U+0073: LETRA S LATINA MINÚSCULA
// U+0323: COMBINACIÓN CON PUNTO ABAJO
// U+0307: COMBINACIÓN CON PUNTO ARRIBA
str.normalize("NFKD"); // '\u0073\u0323\u0307'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.normalize |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Vea también
-----------

* Anexo del Estándar Unicode #15, Formas de Normalización Unicode
* Equivalencia Unicode
String.prototype.repeat()
=========================

El método **`repeat()`** construye y devuelve una nueva cadena que contiene el número especificado de copias de la cadena en la cual fue llamada, concatenados.

Sintáxis
--------


```js
str.repeat(count);
```

### Parámetros

`count`

Un entero entre 0 y +∞: [0, +∞), indicando el número de veces a repetir la cadena en la nueva cadenada creada que será devuelta.

### Valor devuelto

Un nuevo string que contiene el número especificado de copias del string original.

### Excepciones

* `RangeError` (en-US): El número de repeticiones no debe ser negativo.
* `RangeError` (en-US): El número de repeticiones debe ser menor que infinito y no desbordar el tamaño máximo para un string.
Ejemplos
--------


```js
"abc".repeat(-1); // RangeError
"abc".repeat(0); // ''
"abc".repeat(1); // 'abc'
"abc".repeat(2); // 'abcabc'
"abc".repeat(3.5); // 'abcabcabc' (count will be converted to integer)
"abc".repeat(1 / 0); // RangeError

({ toString: () => "abc", repeat: String.prototype.repeat }).repeat(2);
// 'abcabc' (repeat() is a generic method)
```

Polyfill
--------

Este método ha sido añadido a la especificación ECMAScript 6 y tal vez aún no se encuentre disponible en todas las implementaciones de JavaScript. Sin embargo, usted puede establecer `String.prototype.repeat()` con el siguiente fragmento de código:


```js
if (!String.prototype.repeat) {
  String.prototype.repeat = function (count) {
    "use strict";
    if (this == null) {
      throw new TypeError("can't convert " + this + " to object");
    }
    var str = "" + this;
    count = +count;
    if (count != count) {
      count = 0;
    }
    if (count < 0) {
      throw new RangeError("repeat count must be non-negative");
    }
    if (count == Infinity) {
      throw new RangeError("repeat count must be less than infinity");
    }
    count = Math.floor(count);
    if (str.length == 0 || count == 0) {
      return "";
    }
    // Ensuring count is a 31-bit integer allows us to heavily optimize the
    // main part. But anyway, most current (August 2014) browsers can't handle
    // strings 1 << 28 chars or longer, so:
    if (str.length \* count >= 1 << 28) {
      throw new RangeError(
        "repeat count must not overflow maximum string size",
      );
    }
    var rpt = "";
    for (;;) {
      if ((count & 1) == 1) {
        rpt += str;
      }
      count >>>= 1;
      if (count == 0) {
        break;
      }
      str += str;
    }
    return rpt;
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.repeat |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.