recursal/MDN huggingface dataset:
Date.prototype.getTime()
========================

Resumen
-------

El método **`getTime()`** devuelve el valor numérico correspondiente a la hora para la fecha especificada según la hora universal.

Puede utilizar este método para ayudar a asignar una fecha y hora a otro objeto `Date`. Este método es funcionalmente equivalente al metodo `valueOf()` (en-US).

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

dateObj.getTime()
```

### Valor devuelto

El valor devuelto por el método `getTime()` es un número de milisegundos desde el 1 de enero de 1970 00:00:00 UTC.

Ejemplos
--------

### Ejemplo: Uso de `getTime()` para copiar fechas

Construir un objeto de fecha con el mismo valor de tiempo.


```js
var birthday = new Date(1994, 12, 10);
var copy = new Date();
copy.setTime(birthday.getTime());
```

### Ejemplo: Medir el tiempo de ejecución

Restando dos llamadas `getTime()` subsiguientes en objetos `Date` recién generados, dé el intervalo de tiempo entre estas dos llamadas. Esto se puede utilizar para calcular el tiempo de ejecución de algunas operaciones.


```js
var end, start;

start = new Date();
for (var i = 0; i < 1000; i++) {
  Math.sqrt(i);
}
end = new Date();

console.log("Operation took " + (end.getTime() - start.getTime()) + " msec");
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.gettime |

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

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

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

* `Date.prototype.setTime()` (en-US)
* `Date.prototype.valueOf()` (en-US)
Date.now()
==========

Resumen
-------

Devuelve el número de milisegundos transcurridos desde las 00:00:00 UTC del 1 de enero de 1970.

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

var fechaEnMiliseg = Date.now();
```

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

El método `now` devuelve los milisegundos transcurridos desde las 00:00:00 UTC del 1 de enero de 1970 justo hasta ahora como un `Number`.

Cuando se usa `now` para crear registros temporales or identificadores únicos, tenga en cuenta que la precisión de Windows puede ser de 15 milisegundos (vea Error 363258 en Firefox), lo que puede provocar valores iguales si `now` se llama múltiples veces en un breve intervalo de tiempo.

Ejemplos
--------

### Ejemplo: Usando `now`

El siguiente ejemplo usa `now` para crear un registro temporal.


```js
var registro = Date.now();
```

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

* `window.performance.now`
* `console.time` / `console.timeEnd`
Date.prototype.getHours()
=========================

El método **`getHours()`** retorna la hora de la fecha especificada, de acuerdo a la hora local.

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

dateObj.getHours()
```

### Valor de retorno

Un número entero, entre 0 y 23, representando la hora de la fecha dada de acuerdo a la hora local.

Ejemplos
--------

### Usando `getHours()`

La segunda sentencia abajo asigna el valor 23 a la variable hours, basado en el valor del objeto `Date` `Xmas95`.


```js
var Xmas95 = new Date("December 25, 1995 23:15:30");
var hours = Xmas95.getHours();

console.log(hours); // 23
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.gethours |

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

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

Ver tambien
-----------

* `Date.prototype.getUTCHours()` (en-US)
* `Date.prototype.setHours()` (en-US)
Date.prototype.setFullYear()
============================

El método **`setFullYear()`** fija el año completo para una fecha específica de acuerdo a la zona horaria local. Devuelve un nuevo valor de tipo timestamp.

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

dateObj.setFullYear(valorAño[, valorMes[, valorDia]])
```

### Parámetros

`valorAño`

Valor de tipo entero que contiene el valor numérico del año, por ejemplo, 1995.

`valorMes`

Opcional. Valor entero entre 0 y 11 que representa el mes de Enero a Diciembre.

`valorDia`

Opcional. Valor entero entre 1 y 31 que representa el día del mes. Si se especifica este parámetro debe incluirse también el parámetro `valorMes`.

### Valor devuelto

El número de milisegundos entre 1 Enero 1970 00:00:00 UTC y a la fecha actualizada con el valor del año.

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

Si en la invocación al método no se especifican los parámetros `valorMes` y `valorDia`, se emplean en su lugar los valores devueltos por `getMonth()` y `getDate()`.

Si se especifica un parámetro con un valor fuera del rango esperado, `setFullYear()` intenta actualizar el resto de parámetros y la informacion de fecha en el objeto `Date` de manera consistente. Por ejemplo, si se especifica el valor 15 para el parametro `valorMes`, el parámetro año se incrementa en 1 (`valorAño+ 1`), y se emplea 3 como valor para el parámetro mes.

Ejemplos
--------

### Uso de `setFullYear()`


```js
var theBigDay = new Date();
theBigDay.setFullYear(1997);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.setfullyear |

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

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

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

* `Date.prototype.getUTCFullYear()`
* `Date.prototype.setUTCFullYear()` (en-US)
* `Date.prototype.setYear()` (en-US)
Date.UTC()
==========

Resumen
-------

Accepts the same parameters as the longest form of the constructor, and returns the number of milliseconds in a `Date` object since January 1, 1970, 00:00:00, universal time.

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

Date.UTC(año,mes[, dia[, hora[, minutos[, segundos, milisegundos]]]])
```

### Parámetros

`año`

Un año mayor de 1900.

`mes`

Un entero entre 0 y 11 que representa al mes.

`dia`

Un entero entre 1 y 31 que representa al día del mes.

`hora`

Un entero entre 0 y 23 que representa la hora.

`minutos`

Un entero entre 0 y 59 que representa los minutos.

`segundos`

Un entero entre 0 y 59 que representa los segundos.

`milisegundos`

Un entero entre 0 y 999 que representa los milisegundos.

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

`UTC` toma los parámetros de la fecha delimitados por punto y comay devuelve el número de milisegundos entre las 00:00:00 del 1 de enero de 1970 (hora universal) y la hora que especifique.

Debería especificar los dígitos del año completo; por ejemplo, 1998. Si se especifica un año entre 0 y 99, el método convierte dicho año en uno del siglo XX (1900 + año); por ejemplo, si especifica 95, se usará el año 1995.

El método `UTC` difiere del constructor de `Date` de dos modos.

* `Date.UTC` utiliza la fecha y hora universal en vez de la local.
* `Date.UTC` devuelve la fecha y hora como un número en vez de crear un objeto `Date`.

Si especifica un parámetro fuera del rango esperado, el método `UTC` modifica los otros parámetros para tener en cuenta su número. Por ejemplo, si usa 15 para el mes, el año será incrementado en 1 (año + 1), y 3 se usará para el mes.

Debido a que `UTC` es un método estático de `Date`, utilícelo siempre como `Date.UTC()`, en vez de como un método del objeto `Date` que usted cree.

Ejemplos
--------

### Ejemplo: Usando `Date.UTC`

La sentencia siguiente crea un objeto `Date` usando GMT en vez de la hora local:


```js
fechaGmt = new Date(Date.UTC(96, 11, 1, 0, 0, 0));
```

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

* `Date.parse()`
Date.prototype.getMonth()
=========================

Resumen
-------

El método getMonth() devuelve el mes del objeto Date según la hora local, donde el número cero indica el primer mes del año.

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

dateObj.getMonth()
```

### Parámetros

Ninguno.

### Resultado

El valor devuelto por getMonth() es un entero entre 0 y 11, donde 0 corresponde a Enero, 1 a Febrero y así sucesivamente.

Ejemplos
--------

### Usando `getMonth()`

En el siguiente ejemplo, la segunda línea asigna el valor 11 a la variable mes, basado en el valor del objeto `Date` `Navidad`.


```js
var Navidad = new Date("December 25, 2014 23:15:30");
var mes = Navidad.getMonth();

console.log(mes); // 11
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getmonth |

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

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

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

* `Date.prototype.getUTCMonth()` (en-US)
* `Date.prototype.setMonth()`
Date.prototype.getDate()
========================

El método **`getDate()`** devuelve el día del mes para la fecha especificada de acuerdo con la hora local.

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

dateObj.getDate()
```

### Parámetros

Ninguno.

### Valor de retorno

El valor devuelto por `getDate()` es un número entero, entre 1 y 31, que representa el día del mes para la fecha dada según la hora local.

Ejemplos
--------

### Uso de `getDate()`

La segunda instrucción asigna el valor 25 a la variable `day`, en función del valor del objeto `Date` `Xmas95`.


```js
var Xmas95 = new Date("December 25, 1995 23:15:30");
var day = Xmas95.getDate();

console.log(day); // 25
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getdate |

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

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

Véase también
-------------

* `Date.prototype.getUTCDate()` (en-US)
* `Date.prototype.getUTCDay()` (en-US)
* `Date.prototype.setDate()` (en-US)
Date.prototype.getMinutes()
===========================

El método **`getMinutes()`** devuelve los minutos de la fecha especificada en función de la hora local.

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

dateObj.getMinutes()
```

### Parámetros

Ninguno.

### Devuelve

El valor devuelto por `getMinutes()` es un número entero entre 0 y 59.

Ejemplos
--------

### `Uso de getMinutes()`

La segunda declaración del código mostrado a continuación le asigna el valor 15 a la variable `minutos`, basado en el valor del `Date` `objeto Xmas95`.


```js
var Xmas95 = new Date("December 25, 1995 23:15:30");
var minutos = Xmas95.getMinutes();

console.log(minutos); // 15
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getminutes |

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

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

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

* `Date.prototype.getUTCMinutes()` (en-US)
* `Date.prototype.setMinutes()` (en-US)
Generator.prototype.return()
============================

El método **`return()`** regresa el valor dado y finaliza al generador.

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

gen.return(valor)
```

### Parámetros

`valor`

El valor a regresar.

### Valor de retorno

El valor dado como argumento.

Ejemplos
--------

### Utilizando `return()`

El siguiente ejemplo muestra un generador simple y su método `return`.


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}

var g = gen();

g.next(); // { value: 1, done: false }
g.return("foo"); // { value: "foo", done: true }
g.next(); // { value: undefined, done: true }
```


Si `return(valor)` es invocado en un generador que ya está en su estado "completado", el generador permanecerá en estado "completado". Si no se da ningún argumento, el objeto regresado es el mismo a que si se invocara `.next()`. Si se da un argumento, éste se asignará como valor en la propiedad `value` del objeto regresado.


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}

var g = gen();
g.next(); // { value: 1, done: false }
g.next(); // { value: 2, done: false }
g.next(); // { value: 3, done: false }
g.next(); // { value: undefined, done: true }
g.return(); // { value: undefined, done: true }
g.return(1); // { value: 1, done: true }
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.return |

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

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

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

* `function*`
Generator.prototype.throw()
===========================

El método **`throw()`** reanuda la ejecución de un generador al lanzar un error en éste y regresar un objeto con las dos propiedades `done` y `value`.

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

gen.throw(excepción)
```

### Parámetros

`excepción`

La excepción a lanzar. Al hacer depuración, es útil que la excepción cumpla con `instanceof` `Error`.

### Valor de retorno

Un `Object` con dos propiedades:

* `done` (booleano)
    + Es `verdadero` si el iterador ya llegó al final de la secuencia. En este caso `valor` define opcionalmente el *valor de retorno* del iterador.
    + Es `falso` si el iterador puede dar un siguiente valor en la secuencia. Es equivalente a no definir la propiedad `done`.
* `value` - cualquier valor Javascript regresado por el iterador. Éste puede ser omitido si `done` is `verdadero`.
Examples
--------

### Using `throw()`

The following example shows a simple generator and an error that is thrown using the `throw` method. An error can be caught by a `try...catch` block as usual.


```js
function\* gen() {
  while (true) {
    try {
      yield 42;
    } catch (e) {
      console.log("Error caught!");
    }
  }
}

var g = gen();
g.next();
// { value: 42, done: false }
g.throw(new Error("Something went wrong"));
// "Error caught!"
// { value: 42, done: false }
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.throw |

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

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

See also
--------

* `function*`
Generator.prototype.next()
==========================

El método **`next()`** regresa un objeto con las propiedades `done` y `value`. También puedes pasar un parámetro al método `next` para enviar un valor al generador.

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

gen.next(valor)
```

### Parámetros

`valor`

El valor a enviar al generador.

### Valor de retorno

Un `Object` con dos propiedades:

* `done` (booleano)
    + Es `verdadero` si el iterador ya llegó al final de la secuencia. En este caso `valor` define opcionalmente el *valor de retorno* del iterador.
    + Es `falso` si el iterador puede dar un siguiente valor en la secuencia. Es equivalente a no definir la propiedad `done`.
* `value` - cualquier valor Javascript regresado por el iterador. Éste puede ser omitido si `done` is `verdadero`.
Examples
--------

### Using `next()`

The following example shows a simple generator and the object that the `next` method returns:


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}

var g = gen(); // "Generator { }"
g.next(); // "Object { value: 1, done: false }"
g.next(); // "Object { value: 2, done: false }"
g.next(); // "Object { value: 3, done: false }"
g.next(); // "Object { value: undefined, done: true }"
```

### Sending values to the generator

In this example, `next` is called with a value. Note that the first call did not log anything, because the generator was not yielding anything initially.


```js
function\* gen() {
  while (true) {
    var value = yield null;
    console.log(value);
  }
}

var g = gen();
g.next(1);
// "{ value: null, done: false }"
g.next(2);
// 2
// "{ value: null, done: false }"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.next |

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

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

See also
--------

* `function*`
* Iterators and generators
Intl.RelativeTimeFormat
=======================

El objeto **`Intl.RelativeTimeFormat`** te proporciona una manera de formatear tiempos relativos con traducciones.

Pruébalo
--------

El código de este ejemplo interactivo está disponible en un repositorio GitHub. Si quieres contribuir a los ejemplos interactivos del proyecto, por favor, clona https://github.com/mdn/interactive-examples y manda una Pull Request.

Constructor
-----------

`Intl.RelativeTimeFormat.RelativeTimeFormat()` (en-US)

Crea una nueva instancia de `Intl.RelativeTimeFormat`.

Métodos estáticos
-----------------

`Intl.RelativeTimeFormat.supportedLocalesOf()` (en-US)

Devuelve un `Array` con todos los idiomas disponibles sin necesidad de usar el que hay por defecto.

Métodos de instancia
--------------------

`Intl.RelativeTimeFormat.prototype.format()` (en-US)

Formatea `value` y `unit` conforme al idioma y las opciones de formateo al crear la instancia con `Intl.RelativeTimeFormat` (en-US).

`Intl.RelativeTimeFormat.prototype.formatToParts()` (en-US)

Devuelve un `Array` de objetos representando el tiempo relativo en partes que pueden ser usadas en traducciones.

`Intl.RelativeTimeFormat.prototype.resolvedOptions()` (en-US)

Devuelve un nuevo objeto con las propiedades que reflejan las opciones de localización y formato usadas durante la inicialización del objeto.

Ejemplos
--------

### Ejemplo básico

El siguiente ejemplo muestra cómo conseguir el tiempo relativo para el mejor idioma según el usuario.


```js
// Crea un formateador de tiempo relativo en tu lenguaje
// con los valores por defectos pasados expresamente.
const rtf = new Intl.RelativeTimeFormat("en", {
  localeMatcher: "best fit", // otros valores: "lookup"
  numeric: "always", // otros valores: "auto"
  style: "long", // otros valores: "short" or "narrow"
});

// Formatea el tiempo relativo con valores negativos (-1).
rtf.format(-1, "day");
// > "Hace 1 día"

// Formatea el tiempo relativo con valores positivos (1).
rtf.format(1, "day");
// > "Dentro de 1 día"
```

### Usando `formatToParts`

El siguiente ejemplo muestra cómo crear un formateador de tiempo relativo que devuelve las partes separadas:


```js
const rtf = new Intl.RelativeTimeFormat("es", { numeric: "auto" });

// Formatea el tiempo relativo usando día como unidad.
rtf.formatToParts(-1, "day");
// > [{ type: "literal", value: "ayer"}]

rtf.formatToParts(100, "day");
// > [{ type: "literal", value: "Dentro de " },
// > { type: "integer", value: "100", unit: "day" },
// > { type: "literal", value: " días" }]
```

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # relativetimeformat-objects |

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

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

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

* The Intl.RelativeTimeFormat API
Intl.NumberFormat.prototype.format()
====================================

El método **`Intl.NumberFormat.prototype.format()`** formatea un número de acuerdo con la configuración regional y las opciones de formato de este objeto `NumberFormat` (en-US).

Pruébalo
--------

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

numberFormat.format(number)
```

### Parametros

`number`

A `Number` or `BigInt` (en-US) to format.

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

The `format` getter function formats a number into a string according to the locale and formatting options of this `NumberFormat` (en-US) object.

Ejemplos
--------

### Usando `format`

Use the `format` getter function for formatting a single currency value, here for Russia:


```js
var options = { style: "currency", currency: "RUB" };
var numberFormat = new Intl.NumberFormat("ru-RU", options);
console.log(numberFormat.format(654321.987));
// → "654 321,99 руб."
```

### Usando `format` con `map`

Use the `format` getter function for formatting all numbers in an array. Note that the function is bound to the `NumberFormat` (en-US) from which it was obtained, so it can be passed directly to `Array.prototype.map`.


```js
var a = [123456.789, 987654.321, 456789.123];
var numberFormat = new Intl.NumberFormat("es-ES");
var formatted = a.map(numberFormat.format);
console.log(formatted.join("; "));
// → "123.456,789; 987.654,321; 456.789,123"
```

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.numberformat.prototype.format |

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

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

See also
--------

* `Intl.NumberFormat` (en-US)
* `Number.prototype.toLocaleString()`
String.prototype.includes()
===========================

El método **`includes()`** determina si una cadena de texto puede ser encontrada dentro de otra cadena de texto, devolviendo **`true`** o **`false`** según corresponda.

Pruébalo
--------

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

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

### Parametros

`searchString`

Una cadena a buscar en el texto *`str`*.

`position` Opcional

La posición dentro de la cadena en la cual empieza la búsqueda de `searchString` (Por defecto este valor es 0).

### Valor devuelto

**`true`** si la cadena de texto contiene la cadena buscada; en caso contrario, **`false`**.

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

Este método permite determinar si una cadena de texto se encuentra incluida dentro de la otra.

### Sensibilidad a Mayúsculas/Minúsculas

El método `includes()` es "case sensitive" (tiene en cuenta mayúsculas y minúsculas). Por ejemplo, la siguiente expresión devolverá `false`:


```js
"Ballena azul".includes("ballena"); // devuelve false
```

Polyfill
--------

Este método ha sido agregado a la especificación ECMAScript 2015 y puede no estar disponible en toda las implementaciones de JavaScript.

Sin embargo, puedes usar este método como polyfill:


```js
if (!String.prototype.includes) {
  String.prototype.includes = function (search, start) {
    "use strict";

    if (search instanceof RegExp) {
      throw TypeError("first argument must not be a RegExp");
    }
    if (start === undefined) {
      start = 0;
    }
    return this.indexOf(search, start) !== -1;
  };
}
```

Ejemplos
--------

### Usando `includes()`


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

console.log(str.includes("To be")); // true
console.log(str.includes("question")); // true
console.log(str.includes("nonexistent")); // false
console.log(str.includes("To be", 1)); // false
console.log(str.includes("TO BE")); // false
console.log(str.includes("")); // true
```

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

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

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

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

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

* `Array.prototype.includes()`
* `TypedArray.prototype.includes()` (en-US)
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.startsWith()`
* `String.prototype.endsWith()`
String.prototype.fixed()
========================

**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 con una fuente de ancho fijo, como si estuviesde dentro de una etiqueta `<tt>`.

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

cadena.fixed()
```

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

Usa el método `fixed` para formatear y mostrar unacadena en un documento.

Ejemplos
--------

### Ejemplo: Usando `fixed` para cambiar el formateado de una cadena

El siguiente ejemplo usa el método `fixed` para cambiar el formateado de una cadena:


```js
var cadenaMundo = "¡Hola Mundo!";
console.log(cadenaMundo.fixed());
```


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


```html
<tt>¡Hola Mundo!</tt>
```

### Vea También

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