recursal/MDN huggingface dataset:
String.raw()
============

El método estatico **`String.raw()`** es una función de plantilla de literales (en-US), similar al prefijo `r` en Python o al prefijo `@` en C# para strings literales (con ciertas diferencias: ver la explicación en este problema). Se utiliza para obtener un *string* crudo a partir de plantillas de *string* (es decir, el original, texto no interpretado).

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

String.raw(callSite, ...substitutions)

String.raw`templateString`
```

### Parametros

`callSite`

Plantilla bien estructurada, similar a `{ raw: ['foo', 'bar', 'baz'] }`.

`...substitutions`

Contiene valores de sustitución.

`templateString`

[opcional] Una plantilla *string* (en-US), con sustituciones (`${...}`).

### Valor de regreso

La forma cruda del *string* de una plantilla *string* proporcionada.

### Excepciones

`TypeError`

Un `TypeError` es arrojado si el primer argumento no es un objeto bien estructurado.

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

En la mayoría de los casos, `String.raw()` es usado con plantillas *string*. La primera sintaxis mencionada arriba es raramente usada, porque el motor de JavaScript hará la llamada por ti con los argumentos apropiados, al igual que otras funciones de etiqueta (en-US).

`String.raw()` es la unica función de etiqueta incorporada en las plantillas *string*; trabaja igual que la función de la plantilla por defecto y ejecuta la concatenación. Incluso puedes reimplementarlo con código normal de JavaScript.

Ejemplos
--------

### Usando `String.raw()`


```js
String.raw`Hi\n${2 + 3}!`;
// 'Hi\n5!', the character after 'Hi'
// is not a newline character,
// '\' and 'n' are two characters.

String.raw`Hi\u000A!`;
// 'Hi\u000A!', same here, this time we will get the
// \, u, 0, 0, 0, A, 6 characters.
// All kinds of escape characters will be ineffective
// and backslashes will be present in the output string.
// You can confirm this by checking the .length property
// of the string.

let name = "Bob";
String.raw`Hi\n${name}!`;
// 'Hi\nBob!', substitutions are processed.

// Normally you would not call String.raw() as a function,
// but to simulate `t${0}e${1}s${2}t` you can do:
String.raw({ raw: "test" }, 0, 1, 2); // 't0e1s2t'
// Note that 'test', a string, is an array-like object
// The following is equivalent to
// `foo${2 + 3}bar${'Java' + 'Script'}baz`
String.raw(
  {
    raw: ["foo", "bar", "baz"],
  },
  2 + 3,
  "Java" + "Script",
); // 'foo5barJavaScriptbaz'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.raw |

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

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

Tambien ver
-----------

* Template strings (en-US)
* `String`
* Lexical grammar
String.fromCharCode()
=====================

Resumen
-------

El **`String.fromCharCode()`** método estático que devuelve una cadena creada mediante el uso de una secuencia de valores Unicode especificada.

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

String.fromCharCode(num1, ..., numN)
```

### Parámetros

`num1, ..., numN`

Secuencia de números con los valores Unicode.

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

Este método devuelve una cadena y no un objeto `String`.

Debido a que `fromCharCode` es un método estático de `String`, usted siempre lo usará como `String.fromCharCode()`, en vez de un método de un objeto `String` creado por usted.

Ejemplos
--------

### Ejemplo: Usando `fromCharCode`

El siguiene ejemplo devuelve la cadena "ABC".


```js
String.fromCharCode(65, 66, 67);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.fromcharcode |

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

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

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

* `String.prototype.charCodeAt()`
* `String.prototype.charAt()`
* `String.fromCodePoint()`
* `String.prototype.codePointAt()`
String.prototype.link()
=======================

Resumen
-------

Crea un enlace de hipertexto HTML, `<a>`, que solicita otra URL.

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

cadena.link(atributoHref)
```

### Parámetros

`atributoHref`

Cualquier cadena que especifique el atributo `href` de la etiqueta `<a>`; debería ser una URL válida (relativa o absoluta).

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

Usa el método `link` para crear un atajo HTML para un enlace de hipertexto. La cadena devuelta puede ser añadida al documento vía `element.innerHTML`.

Los enlaces creados con el método `link` serán elementos del array `links` del objeto `document`. Vea `document.links` (en-US).

Ejemplos
--------

### Ejemplo: Usando `link`

El siguiente ejemplo muestra la palabra "Netscape" como un enlace de hipertexto que devuelve al usuario a la página inicial de Netscape:


```js
var textoActivo = "MDN";
var URL = "https://developer.mozilla.org/";

console.log("Haga click para volver a " + textoActivo.link(URL));
```


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


```html
Haga click para volver a <a href="http://developer.mozilla.org/">MDN</a>
```

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

* `String.prototype.anchor()`
String.prototype.endsWith()
===========================

El método **`endsWith()`** determina si una cadena de texto termina con los caracteres de una cadena indicada, devolviendo `true` o `false` según corresponda.

Pruébalo
--------

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

str.endsWith(searchString[, position])
```

### Parámetros

`searchString`

Los caracteres a buscar hasta el final de la cadena *`str`*.

`length` Opcional

Si se indica, se utiliza como el tamaño de *`str`*. Por defecto se usa `str.length`.

### Valor devuelto

**`true`** si los caracteres proporcionados se encuentran al final de la cadena de texto; en caso contrario, **`false`**.

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

Este método determina si una cadena de texto termina en otra cadena o no. Este método distingue entre mayúsculas y minúsculas.

Polyfill
--------

Este método ha sido añadido a la especificación ECMAScript 6 y puede no estar disponible en todas las implementaciones de JavaScript. Sin embargo, puedes implementar el polyfill `String.prototype.endsWith()` con el siguiente fragmento de código:


```js
if (!String.prototype.endsWith) {
  String.prototype.endsWith = function (search, this\_len) {
    if (this_len === undefined || this_len > this.length) {
      this_len = this.length;
    }
    return this.substring(this_len - search.length, this_len) === search;
  };
}
```

Ejemplos
--------

### Usando `endsWith()`


```js
let str = "To be, or not to be, that is the question.";

console.log(str.endsWith("question.")); // true
console.log(str.endsWith("to be")); // false
console.log(str.endsWith("to be", 19)); // true
```

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

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

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

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

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

* `String.prototype.startsWith()`
* `String.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
String.prototype.strike()
=========================

**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 muestre como texto tachado, como si estuviese dentro de una etiqueta `<strike>`.

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

cadena.strike()
```

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

Usa el método `strike` 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 los 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!</i>
<strike>¡Hola mundo!</strike>
```

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

* `String.prototype.blink()`
* `String.prototype.bold()`
* `String.prototype.italics()`
String.prototype.charAt()
=========================

Resumen
-------

El método **`charAt()`** de `String` devuelve en un nuevo String el carácter UTF-16 de una cadena.

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

str.charAt(indice)
```

### Parámetros

`indice`

Un entero entre 0 y 1 menos que la longitud de la cadena. Si no se proporciona ningún indice charAt() utilizará 0.

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

Los caracteres de una cadena se indexan de izquierda a derecha. El índice del primer caracter es 0, y el índice del último caracter en una cadena llamada `nombreCadena` es `nombreCadena.length - 1`. Si el `indice` que usted proporciona está fuera del rango, JavaScript devuelve una cadena vacía.

Ejemplos
--------

### Ejemplo: Mostrando caracteres de diferentes localizaciones en una cadena

El siguiente ejemplo muestra caracteres de diferentes localizaciones en la cadena "`Brave new world`":


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

console.log(
  "El carácter en el índice 0 es '" + cualquierCadena.charAt(0) + "'",
);
console.log(
  "El carácter en el índice 1 es '" + cualquierCadena.charAt(1) + "'",
);
console.log(
  "El carácter en el índice 2 es '" + cualquierCadena.charAt(2) + "'",
);
console.log(
  "El carácter en el índice 3 es '" + cualquierCadena.charAt(3) + "'",
);
console.log(
  "El carácter en el índice 4 es '" + cualquierCadena.charAt(4) + "'",
);
console.log(
  "El carácter en el índice 999 es '" + cualquierCadena.charAt(999) + "'",
);
```


Estas líneas muestran lo siguiente:
```

El carácter en el índice 0 es 'B'
El carácter en el índice 1 es 'r'
El carácter en el índice 2 es 'a'
El carácter en el índice 3 es 'v'
El carácter en el índice 4 es 'e'
El carácter en el índice 999 es ''
```

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

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

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

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

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

* `String.prototype.indexOf()`, `String.prototype.lastIndexOf()`
* `String.prototype.split()`
* `String.prototype.charCodeAt()`
* `String.fromCodePoint()`
* `String.prototype.codePointAt()`
String.prototype.fontsize()
===========================

**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 **`fontsize()`** crea `<font>` elemento HTML que muestra una cadena con el tamaño especificado.

**Nota:** El elemento <font> ha sido eliminado HTML5 (en-US) y no se debe usar. Los desarrolladores web deben usar propiedades CSS.

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

str.fontsize(size)
```

### Parámetros

`size`

Un entero entre 1 y 7.

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

Cuando especificas el tamaño como entero, estableces el tamaño de la fuente. Cuando especificas el tamaño como cadena tal como "-2", se ajusta el tamaño de la fuente al de la etiqueta `<basefont>`.

When you specify size as an integer, you set the font size of `str` to one of the 7 defined sizes. When you specify `size` as a string such as "-2", you adjust the font size of `str` relative to the size set in the `<basefont>` tag.

Ejemlpos
--------

### `Usos fontsize()`

The following example uses string methods to change the size of a string:


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

console.log(worldString.small()); // <small>Hello, world</small>
console.log(worldString.big()); // <big>Hello, world</big>
console.log(worldString.fontsize(7)); // <font size="7">Hello, world</fontsize>
```


With the `element.style` (en-US) object you can get the element's `style` attribute and manipulate it more generically, for example:


```js
document.getElementById("yourElemId").style.fontSize = "0.7em";
```

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

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

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

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

See also
--------

* `String.prototype.big()`
* `String.prototype.small()`
String.prototype.big()
======================

**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 sea mostrada con un tamaño de fuente grade, como si estuviese en una etiqueta `<big>`.

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

cadena.big()
```

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

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

Ejemplos
--------

### Ejemplo: Usando `big`

El siguiente ejemplo usa los métodos de `string` para cambiar el tamañó de una cadena:


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

console.log(cadenaMundo.small());
console.log("<P>" + cadenaMundo.big());
console.log("<P>" + cadenaMundo.fontsize(7));
```


Este ejemplo produce el mismo resultado que el siguiente HTML:


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

### Vea También

* `String.prototype.fontsize()`
* `String.prototype.small()`
String.prototype.bold()
=======================

**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 se muestre en negrita como si estuviera en una etiqueta `<b>`.

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

cadena.bold()
```

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

Usa el método `bold` 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!</i>
<strike>¡Hola mundo!</strike>
```

### Vea También

* `String.prototype.blink()`
* `String.prototype.italics()`
* `String.prototype.strike()`
String.prototype.toString()
===========================

Resumen
-------

El **`toString()`** método devuelve una cadena que representa al objeto especificado.

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

cadena.toString()
```

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

El objeto `String` sobreescribe el método `toString` del objeto `Object` object; no hereda `Object.toString()`. Para objetos `String`, el método `toString` devuelve una cadena que representa al objeto.

Ejemplos
--------

### Ejemplo: Usando `toString`

El siguiente ejemplo muestra el valor cadena de un objeto String:


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

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

* `Object.prototype.toSource()`
* `String.prototype.valueOf()`
String.prototype.sup()
======================

Resumen
-------

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

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

cadena.sup()
```

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

Usa el método `sup` 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 textoSuper = "superscript";
var textoSub = "subscript";

console.log("Esto es lo que un " + textoSuper.sup() + " parece.");
console.log("Esto es lo que un " + textoSub.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.sub()`
String.prototype.trimEnd()
==========================

El método **`trimEnd()`** elimina los espacios en blanco al final de una cadena de carácteres. `trimRight()` es el alias de este método.

Pruébalo
--------

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

str.trimEnd();
str.trimRight();
```

### Valor de retorno

Una nueva cadena de texto que representa la cadena de texto llamada sin espacios en blanco de su extremo (derecho).

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

`trimEnd()` / `trimRight()` Los metodos devuelven una cadena de texto sin espacios en blanco desde su extremo derecho. `trimEnd()` ó `trimRight()` no afectan el valor de la cadena de texto en sí.

### Superposición

Por coherencia de funciones como `String.prototype.padEnd` (en-US) el nombre del método estandar es `trimEnd`. Sin embargo por compatibilidad web, `trimRight` permanece como un alias para `trimEnd`. En algunos motores esto significa:


```js
String.prototype.trimRight.name === "trimEnd";
```

Ejemplo
-------

### Usando `trimEnd()`

El siguiente ejemplo muestra la cadena de texto en minusculas `' foo'`:


```js
var str = " foo ";

console.log(str.length); // 8

str = str.trimEnd();
console.log(str.length); // 6
console.log(str); // ' foo'
```

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

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

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

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

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

* `String.prototype.trim()`
* `String.prototype.trimStart()` (en-US)
String.prototype.slice()
========================

Resumen
-------

El método **`slice()`** extrae una sección de una cadena y devuelve una cadena nueva.

Sintaxis
--------


```html
cadena.slice(inicioTrozo[, finTrozo])
```

### Parameters

`inicioTrozo`

El índice basado en cero en el cual empieza la extracción. Si es negativo, se trata como `longCadena + inicioTrozo` donde `longCadena` es la longitud de la cadena (por ejemplo, si `inicioTrozo` es `-3` se trata como `longCadena - 3`)

`finTrozo`

Opcional. El índice basado en cero en el que termina la extracción. Si se omite, `slice` extrae hasta el final de la cadena. Si es negativo, se trata como `longCadena + finTrozo` donde `longCadena` es la longitud de la cadena (por ejemplo, si `finTrozo` es `-3` se trata como `longCadena - 3`).

### Valor retornado

Una nueva cadena que contiene la sección de la cadena.

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

`slice` extrae el texto de una cadena y devuelve una nueva cadena. Los cambios en el texto de una cadena no afectan a la otra cadena.

`slice` extrae hasta, pero sin incluir `finalTrozo`. `string.slice(1,4)` extrae del segundo carácter hasta el cuarto carácter (caracteres con índice 1, 2 y 3).

Si se usa un índice negativo, finalTrozo indica el punto desde el final de la cadena.string.slice(2, -1) extrae desde tercer carácter hasta el último carácter de la cadena.

Ejemplos
--------

### Ejemplo: Uso de `slice()` para crear una nueva cadena

El siguiente ejemplo usa `slice()` para crear una nueva cadena.


```js
var cadena1 = "La mañana se nos echa encima.";
var cadena2 = cadena1.slice(3, -2);
console.log(cadena2);
```


Esto escribe:
```

mañana se nos echa encim
```

### Uso de `slice()` con índices negativos

El siguiente ejemplo usa `slice()` con índices negativos.


```js
var cad = "La mañana se nos echa encima.";
cad.slice(-3); // retorna 'ma.'
cad.slice(-3, -1); // retorna 'ma'
cad.slice(0, -1); // retorna 'La mañana se nos echa encima'
```

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

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

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

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

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

* `String.prototype.substr()`
* `String.prototype.substring()`
* `Array.prototype.slice()`