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

Resumen
-------

Causa que una cadena se muestre como subíndice, como si estuviese dentro de una etiqueta `<sub>`.

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

cadena.sub()
```

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

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

Ejemplos
--------

### Ejemplo: Usando los métodos `sub` y `sup` para formatear una cadena

El siguiente ejemplo usa los métodos `sub` y `sup` para formatear una cadena:


```js
var superText = "superscript";
var subText = "subscript";

console.log("Esto es lo que un " + superText.sup() + " parece.");
console.log("Esto es lo que un " + subText.sub() + " parece.");
```


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


```html
Esto es lo que <sup>superscript</sup> parece.
Esto es lo que <sub>subscript</sub> parece.
```

### Vea También

* `String.prototype.sup()`
String.prototype.padStart()
===========================

**Experimental:** **Esta es una tecnología experimental**  
Comprueba la Tabla de compabilidad de navegadores cuidadosamente antes de usarla en producción.

El método **`padStart()`** rellena la cadena actual con una cadena dada (repetida eventualmente) de modo que la cadena resultante alcance una longitud dada. El relleno es aplicado desde el inicio (izquierda) de la cadena actual.

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

str.padStart(targetLength [, padString])
```

### Parámetros

`targetLength`

La longitud de la cadena resultante una vez la cadena actual haya sido rellenada. Si este parámetro es más pequeño que la longitud de la cadena actual, la cadena actual será devuelta sin modificar.

`padString` Opcional

La cadena para rellenar la cadena actual. Si esta cadena es muy larga, será recortada y la parte más a la izquierda será aplicada. El valor por defecto para este parámetro es " " (U+0020).

### Valor devuelto

Un `String` de la longitud específicada con la cadena de relleno aplicada desde el inicio.

Ejemplos
--------


```js
"abc".padStart(10); // " abc"
"abc".padStart(10, "foo"); // "foofoofabc"
"abc".padStart(6, "123465"); // "123abc"
```

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

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

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

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

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

* `String.padEnd()` (en-US)
String.prototype.substring()
============================

Resumen
-------

El **`substring()`** método devuelve un subconjunto de un objeto `String`.

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

cadena.substring(indiceA[, indiceB'])
```

### Parámetros

`indiceA`

Un entero entre 0 y la longitud de la cadena menos 1.

`indiceB`

(opcional) Un entero entre 0 y la longitud de la cadena.

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

`substring` extrae caracteres desde `indiceA` hasta `indiceB` sin incluirlo. En particular:

* Si `indiceA` es igual a `indiceB`, `substring` devuelve una cadena vacía.
* Si se omite el `indiceB`, `substring` extrae caracteres hasta el final de la cadena.
* Si el argumento es menor que 0 o es `NaN`, se trata como si fuese 0.
* Si el argumento es mayor que `nombreCadena.length`, se trata como si fuese `nombreCadena.length`.

Si `indiceA` es mayor que `indiceB`, entonces el efecto de `substring` es como si los dos argumentos se intercambiasen; por ejemplo, `cadena.substring(1, 0) == cadena.substring(0, 1)`.

Ejemplos
--------

### Ejemplo: Usando `substring`

El siguiente ejemplo usa `substring` para mostrar caracteres de la cadena "`Mozilla`":


```js
// asume una función print ya definida
var cualquierCadena = "Mozilla";

// Muestra "Moz"
print(cualquierCadena.substring(0, 3));
print(cualquierCadena.substring(3, 0));

// Muestra "lla"
print(cualquierCadena.substring(4, 7));
print(cualquierCadena.substring(7, 4));

// Muestra "Mozill"
print(cualquierCadena.substring(0, 6));
print(cualquierCadena.substring(6, 0));

// Muestra "Mozilla"
print(cualquierCadena.substring(0, 7));
print(cualquierCadena.substring(0, 10));
```

### Ejemplo: Reemplazar una subcadena dentro de una cadena

El siguiente ejemplo reemplaza una subcadena dentro de una cadena. Reemplazará tanto caracteres individuales como subcadenas. La llamada de la función al final del ejemplo cambia la cadena "`Bravo Nuevo Mundo`" por "`Bravo Nueva Web`".


```js
function reemplazarCadena(cadenaVieja, cadenaNueva, cadenaCompleta) {
  // Reemplaza cadenaVieja por cadenaNueva en cadenaCompleta

  for (var i = 0; i < cadenaCompleta.length; i++) {
    if (cadenaCompleta.substring(i, i + cadenaVieja.length) == cadenaVieja) {
      cadenaCompleta =
        cadenaCompleta.substring(0, i) +
        cadenaNueva +
        cadenaCompleta.substring(i + cadenaVieja.length, cadenaCompleta.length);
    }
  }
  return cadenaCompleta;
}

reemplazarCadena("Mundo", "Web", "Bravo Nuevo Mundo");
```

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

* `String.prototype.substr()`
* `String.prototype.slice()`
String.prototype.trim()
=======================

Resumen
-------

El método **trim( )** elimina los espacios en blanco en ambos extremos del string. Los espacios en blanco en este contexto, son todos los caracteres sin contenido (espacio, tabulación, etc.) y todos los caracteres de nuevas lineas (LF,CR,etc.).

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

str.trim()
```


Una nueva cadena que representa la cadena de llamada sin espacios en blanco de ambos extremos.

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

El método **trim( )** devuelve la cadena de texto despojada de los espacios en blanco en ambos extremos. El método no afecta al valor de la cadena de texto.

Ejemplos
--------

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

El siguiente ejemplo muestra la cadena de texto en minúsculas 'foo':


```js
var orig = " foo ";
console.log(orig.trim()); // 'foo'

// Otro ejemplo de .trim() eliminando el espacio en blanco sólo de un lado.

var orig = "foo ";
console.log(orig.trim()); // 'foo'
```

Polyfill
--------

Ejecutar el siguiente código antes de cualquier otro código creará un trim ( ) si este no está disponible de manera nativa.


```js
if (!String.prototype.trim) {
  (function () {
    // Make sure we trim BOM and NBSP
    var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
    String.prototype.trim = function () {
      return this.replace(rtrim, "");
    };
  })();
}
```

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

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

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

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

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

* `String.prototype.trimLeft()` (en-US) 
Non-standard
* `String.prototype.trimRight()` (en-US) 
Non-standard
String.prototype.charCodeAt()
=============================

Resumen
-------

El **`charCodeAt()`** método devuelve un número indicando el valor Unicode del carácter en el índice proporcionado.

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

cadena.charCodeAt(indice);
```

### Parámetros

`indice`

Un entero entre 0 y 1 menos que la longitud de la cadena; si no se especifica, su valor predeterminado es 0.

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

El rango del código Unicode va del 0 al 1,114,1110x10FFFF. Los primeros 128 códigos de Unicode encajan directamente con los códigos de caractéres de la codificación ASCII. Para información sobre Unicode, vea la Guía de JavaScript. Observe que `charCodeAt` siempre devolverá un valor menor de 65.536.

`charCodeAt` devuelve `NaN` si el indice proporcionado no está entre 0 y 1 menos de la longitud de la cadena.

En JavaScript 1.2 el método `charCodeAt` devuelve un número indicando el valor de la hoja de códigos ISO-Latin-1 del carácter correspondiente al índice proporcionado. El rango de la hoja de códigos ISO-Latin-1 va del 0 al 255. Del 0 al 127 encajan directamente con la hoja de códigos ASCII.

Ejemplos
--------

### Ejemplo: Usando `charCodeAt`

El siguiente ejemplo devuelve 65, el valor Unicode para A.


```js
"ABC".charCodeAt(0); // returns 65
```


El siguiente ejemplo devuelve 83.


```js
"AaSdas".charCodeAt(2); // returns 83
```


teniendo en cuenta que 2 es la posicion de la letra. Si "S" fuera minuscula, el Unicode es diferente


```js
"Aasdas".charCodeAt(2); // returns 115
```

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

* `String.fromCharCode()`
* `String.prototype.charAt()`
* `String.fromCodePoint()`
* `String.prototype.codePointAt()`
String.prototype.startsWith()
=============================

El método **`startsWith()`** indica si una cadena de texto comienza con los caracteres de una cadena de texto concreta, devolviendo `true` o `false` según corresponda.

Pruébalo
--------

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

str.startsWith(stringBuscada[, posicion])
```

### Parámetros

`stringBuscada`

Los caracteres a ser buscados al inicio de la cadena de texto.

`posicion` Opcional

La posición de `str` en la cual debe comenzar la búsqueda de `stringBuscada`. El valor por defecto es `0`.

### Valor devuelto

**`true`** si los caracteres dados se encuentran al inicio de la cadena de texto; **`false`** en cualquier otro caso.

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

Este método te permite saber si una cadena de texto comienza o no con otra cadena de texto. Este método distingue entre mayúsculas y minúsculas.

Polyfill
--------

Este método se ha añadido a la especificación ECMAScript 2015 y podría no estar disponible aún en todas las implementaciones de JavaScript. Sin embargo, puedes utilizar un *polyfill* de `String.prototype.startsWith()` con el siguiente fragmento de código:


```js
if (!String.prototype.startsWith) {
  Object.defineProperty(String.prototype, "startsWith", {
    value: function (search, rawPos) {
      var pos = rawPos > 0 ? rawPos | 0 : 0;
      return this.substring(pos, pos + search.length) === search;
    },
  });
}
```


Un *polyfill* más robusto (totalmente compatible con la especificación ES2015), pero con menos rendimiento y menos compacto está disponible en GitHub, por Mathias Bynens.

Ejemplos
--------

### Usando `startsWith()`


```js
//startswith
var str = "Ser, o no ser. ¡Esa es la cuestión!";

console.log(str.startsWith("Ser")); // true
console.log(str.startsWith("no ser")); // false
console.log(str.startsWith("Esa es la", 16)); // true
```

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

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

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

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

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

* `String.prototype.endsWith()`
* `String.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
String.prototype.codePointAt()
==============================

El método **`codePointAt()`** devuelve un entero no negativo que equivale al valor Unicode code point del carácter.

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

str.codePointAt(indice)
```

### Parámetros

`indice`

Índice del carácter en la cadena del que se quiere obtener el valor del Unicode code point.

### Valor de retorno

Un número que equivale al valor code point del carácter especificado en el índice de la cadena; devuelve `undefined` si no se encuentra carácter en la posición especifica.

Description
-----------

If there is no element at the specified position, `undefined` is returned. If no UTF-16 surrogate pair begins at `pos`, the code unit at `pos` is returned.

Examples
--------

### Using `codePointAt()`


```js
"ABC".codePointAt(1); // 66
"\uD800\uDC00".codePointAt(0); // 65536

"XYZ".codePointAt(42); // undefined
```

Polyfill
--------

The following extends Strings to include the `codePointAt()` function as specified in ECMAScript 2015 for browsers not supporting it natively.


```js
/\*! http://mths.be/codepointat v0.1.0 by @mathias \*/
if (!String.prototype.codePointAt) {
  (function () {
    "use strict"; // needed to support `apply`/`call` with `undefined`/`null`
    var codePointAt = function (position) {
      if (this == null) {
        throw TypeError();
      }
      var string = String(this);
      var size = string.length;
      // `ToInteger`
      var index = position ? Number(position) : 0;
      if (index != index) {
        // better `isNaN`
        index = 0;
      }
      // Account for out-of-bounds indices:
      if (index < 0 || index >= size) {
        return undefined;
      }
      // Get the first code unit
      var first = string.charCodeAt(index);
      var second;
      if (
        // check if it’s the start of a surrogate pair
        first >= 0xd800 &&
        first <= 0xdbff && // high surrogate
        size > index + 1 // there is a next code unit
      ) {
        second = string.charCodeAt(index + 1);
        if (second >= 0xdc00 && second <= 0xdfff) {
          // low surrogate
          // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
          return (first - 0xd800) \* 0x400 + second - 0xdc00 + 0x10000;
        }
      }
      return first;
    };
    if (Object.defineProperty) {
      Object.defineProperty(String.prototype, "codePointAt", {
        value: codePointAt,
        configurable: true,
        writable: true,
      });
    } else {
      String.prototype.codePointAt = codePointAt;
    }
  })();
}
```

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

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

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

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

See also
--------

* `String.fromCodePoint()`
* `String.fromCharCode()`
* `String.prototype.charCodeAt()`
* `String.prototype.charAt()`
String.prototype.italics()
==========================

**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
-------

Provoca que una cadena ponga en cursiva, como si estuviese dentro de una etiqueta `<i>`.

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

cadena.italics()
```

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

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

Ejemplos
--------

### Ejemplo: Usando métodos de `italics()`

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());
```

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

* `String.prototype.blink()`
* `String.prototype.bold()`
* `String.prototype.strike()`
String.prototype.toLocaleUpperCase()
====================================

El método **`toLocaleUpperCase()`** devuelve el valor de la cadena que lo llama convertido en mayúsculas, de acuerdo con las asignaciones de casos específicos de la configuración regional.

Syntaxis
--------
```

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

### Parámetros

`locale` Opcional

El parámetro `locale` indica la configuración regional que se va a utilizar para convertir en mayúsculas según las asignaciones de casos específicos de la configuración regional. Si se proporcionan varios locales en un `Array`, se utiliza la mejor configuración regional disponible. La configuración regional predeterminada es la configuración regional actual del entorno de host.

### Valor de retorno

Una nueva cadena que representa la cadena de llamada convertida en mayúsculas, de acuerdo con cualquier asignación de mayúsculas de idioma específico.

### Exceciones

* Un `RangeError` ("invalid language tag: xx\_yy") se arroja si un argumento de configuración regional no es una etiqueta de idioma válida.
* Un `TypeError` ("invalid element in locales argument") se lanzará si un elemento de matriz no es de tipo cadena.
Descripción
-----------

El método `toLocaleUpperCase()` devuelve el valor de la cadena convertida en mayúsculas según las asignaciones de casos específicos de la configuración regional. `toLocaleUpperCase()` no afecta al valor de la cadena en sí. En la mayoría de los casos, esto producirá el mismo resultado que `toUpperCase()`, pero para algunas localidades, como turco, cuyas asignaciones de mayúsculas y minúsculas no siguen la mayúsculas y minúsculas en Unicode, puede haber un resultado diferente.

Ejemplos
--------

### Usando `toLocaleUpperCase()`


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

"i\u0307".toLocaleUpperCase("lt-LT"); // 'I'

let locales = ["lt", "LT", "lt-LT", "lt-u-co-phonebk", "lt-x-lietuva"];
"i\u0307".toLocaleUpperCase(locales); // 'I'
```

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

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

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

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

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

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLowerCase()`
* `String.prototype.toUpperCase()`
String.prototype.fontcolor()
============================

**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.

El método **`fontcolor()`** crea `<font>` elemento HTML que cambia el color de la cadena.

**Nota:** La etiqueta <font> fue eliminada en HTML5 (en-US) y no debe ser usada. En lugar de es, es necesario aplicar propiedades CSS.

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

str.fontcolor(color)
```

### Parametros

`color`

A string expressing the color as a hexadecimal RGB triplet or as a string literal. String literals for color names are listed in the CSS color reference.

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

Si expresas el color como hexadecimal, usa el formato rrggbb. Por ejemplo, el color hexadecimal para salmón es R=FA, G=80, B=72, así que el valor será `"FA8072"`.

Ejemplos
--------

### `Usos fontcolor()`

Los siguientes ejemplos usan el método `fontcolor()` para cambiar el color de una cadena.


```js
var worldString = "Hello, world";

console.log(worldString.fontcolor("red") + " en rojo");
// '<font color="red">Hello, world</font> en rojo'

console.log(worldString.fontcolor("FF00") + " es rojo en hexadecimal");
// '<font color="FF00">Hello, world</font> es rojo en hexadecimal'
```


Con el objeto `element.style` (en-US) obtienes el atributo `style` y manipularlo:


```js
document.getElementById("yourElemId").style.color = "red";
```

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

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

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

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

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

* `String.prototype.fontsize()`
String.prototype.toUpperCase()
==============================

Resumen
-------

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

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

cadena.toUpperCase()
```

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

El método `toUpperCase` devuelve el valor de la cadena convertida a mayúsculas. `toUpperCase` no afecta al valor de la cadena en sí mismo.

Ejemplos
--------

### Ejemplo: Usando `toUpperCase`

El siguiente ejemplo muestra la cadena "`ALPHABET`":


```js
console.log("alphabet".toUpperCase()); // "ALPHABET"
```

### Vea También

* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toLowerCase()`
RegExp.prototype.test()
=======================

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 `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 `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.


```js
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:


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

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.test |

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

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

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

* El capítulo Expresiones Regulares de la Guía JavaScript
* `RegExp`
RegExp.prototype.compile()
==========================

**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.

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.


```js
var regexObj = new RegExp("foo", "gi");
regexObj.compile("new foo", "g");
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.compile |

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

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

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

* `RegExp`