Function.prototype.apply() - JavaScript

Function.prototype.apply()
==========================

O método **`apply()`** chama uma função com um dado valor `this` e `arguments` providos como uma array (ou um objeto parecido com um array).

**Nota:** A sintaxe desta função é quase idêntica a essa da `call()`, a diferença é que `call()` aceita uma **lista de** **argumentos**, enquanto `apply()` aceita um **array de argumentos**.

Sintaxe
-------
```

fun.apply(thisArg, [argsArray])
```

### Parâmetros

`thisArg`

O valor de `this` é fornecido para a chamada de *fun.* Note que isso talvez não seja o valor real visto pelo método: se um método é uma função em código non-strict mode , `null` e `undefined` serão substituidos com o objeto global, e os valores primitivos serão embalados.

`argsArray`

Um objeto parecido com um array (array-like), especificando os argumentos com os quais *fun* deve ser chamado, ou `null` ou `undefined` se não houverem argumentos que possam ser passados para a função. Começando com ECMAScript5 esses argumentos podem ser um objeto genérico array-like ao invés de um array. Veja abaixo a informação de compatibilidade de browsers.

Descrição
---------

Você pode atribuir um objeto *`this`* diferente quando chamar uma função existente. *`this`* refere-se ao objeto atual, o objeto da chamada. Com *`apply`*, você pode escrever um método apenas uma vez e então herdá-lo em outro objeto, sem ter que reescrever o método para o novo objeto.

`apply` é muito parecido com `call()`, exceto pelo tipo de argumentos que ele suporta. Você pode usar um array de argumentos em vez de conjunto de parâmetros nomeados. Com `apply`, você pode usar um array literal, por exemplo, `fun.apply(this, ['comer', 'bananas'])`, ou um objeto `Array`, por exemplo `fun.apply(this, new Array('comer', 'bananas')).`

Você pode também usar `arguments` para o parâmetro `argsArray`. `arguments`é uma variável local de uma função. Ele pode ser utilizado para todos os argumentos não especificados do objeto chamado. Assim, você não tem que saber os argumentos do objeto chamado quando você usa o método `apply`. Você pode usar `arguments` para passar todos os argumentos para o objeto da chamada. O objeto chamado fica então responsável por manipular os argumentos.

Desde a 5a versão do ECMAScript você pode utilizar qualquer tipo de objeto que é parecido com um array (array-like), então na prática isso significa que ele vai ter uma propriedade `length` e propriedades inteiras no intervalor (`0... length`). Como um exemplo, você pode agora usar um `NodeList` ou um objeto personalizado como `{ 'length': 2, '0': 'comer', '1': 'bananas' }`.

**Nota:** Muitos navegadores, incluindo o Chrome 14 e o Internet Explorer 9, ainda não aceitam objetos parecidos com array e irão lançar uma exceção.

Exemplos
--------

### Usando `apply` para cadeia de construtores

Você pode usar `apply` para encadear construtores em um objeto, similar ao Java. No exemplo seguinte nós iremos criar um método de `Função` global chamado `construct`, que fará você capaz de usar um objeto parecido com um array com um construtor ao invés de uma lista de argumentos

```js
Function.prototype.construct = function (aArgs) {
  var oNew = Object.create(this.prototype);
  this.apply(oNew, aArgs);
  return oNew;
};
```

**Nota:** O método `Object.create()` usado acima é relativamente novo. Para um método alternativo utilizando closures, por favor considere a seguinte alternativa.

```js
Function.prototype.construct = function (aArgs) {
  var fConstructor = this,
    fNewConstr = function () {
      fConstructor.apply(this, aArgs);
    };
  fNewConstr.prototype = fConstructor.prototype;
  return new fNewConstr();
};
```

Exemplo de uso:

```js
function MyConstructor() {
  for (var nProp = 0; nProp < arguments.length; nProp++) {
    this["property" + nProp] = arguments[nProp];
  }
}

var myArray = [4, "Hello world!", false];
var myInstance = MyConstructor.construct(myArray);

console.log(myInstance.property1); // logs 'Hello world!'
console.log(myInstance instanceof MyConstructor); // logs 'true'
console.log(myInstance.constructor); // logs 'MyConstructor'
```

**Nota:** Este método não nativo `Function.construct` não irá funcionar com alguns construtores nativos (como `Date`, por exemplo). Nestes casos você tem que usar o método `Function.prototype.bind` (por exemplo, imagine ter um array como o seguinte, para ser usado com o construtor `Date`: `[2012, 11, 4]`; Neste caso você tem que escrever algom como: `new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))()` - de qualquer maneira essa não é a melhor forma de fazer as coisas e provavelmente não deve ser utilizado em qualquer ambiente de produção.

### Usando `apply` e funções embutidas

A forma inteligente com que `apply` é utilizado permite à você usar funções nativas que de outra forma provavelmente teriam que ser escritas iterando sobre um array de valores. Aqui, como exemplo, iremos utilizar `Math.max`/`Math.min` para achar o valor máximo/mínimo value em um array.

```js
/\* número min/max em um array \*/
var numbers = [5, 6, 2, 3, 7];

/\* utilizando Math.min/Math.max apply \*/
var max = Math.max.apply(
  null,
  numbers,
); /\* Isso está prestes a ser igual a Math.max(numbers[0], ...)
 ou Math.max(5, 6, ...) \*/
var min = Math.min.apply(null, numbers);

/\* vs. algoritmo simples baseado em loop \*/
(max = -Infinity), (min = +Infinity);

for (var i = 0; i < numbers.length; i++) {
  if (numbers[i] > max) {
    max = numbers[i];
  }
  if (numbers[i] < min) {
    min = numbers[i];
  }
}
```

Mas tome cuidado: ao utilizar o `apply` desta forma, você corre o risco de exceder o limite de argumentos do JavaScript. As consequências de fazer applying em uma função com muitos argumentos (pense em algo como dezenas de centenas de argumentos) varia de acordo com os engines (JavaScriptCore tem um limite de argumentos de 65536 hard-coded), visto que o limite (na verdade, até mesmo a natureza de qualquer comportamento de um stack excessivamente grande) não é especificado. Algumas engines irão jogar uma excessão. De uma forma mais incisiva, outras engines irão limitar de forma arbitrária o número de argumentos que poderção ser aplicados à função. (Para ilustrar esse último caso: se uma engine dessas tem um limite de quatro argumentos [obviamente, os limites atuais são significativamente maiores], isso seria como se os argumentos `5, 6, 2, 3` do exemplo anterior fossem passados ao `apply`, ao invés do array completo.) Se o valor do seu array puder crescer à casa das dezenas de centenas, use uma estratégia híbrida: aplique suas funções em cada bloco de array por vez:

```js
function minOfArray(arr) {
  var min = Infinity;
  var QUANTUM = 32768;

  for (var i = 0, len = arr.length; i < len; i += QUANTUM) {
    var submin = Math.min.apply(null, arr.slice(i, Math.min(i + QUANTUM, len)));
    min = Math.min(submin, min);
  }

  return min;
}

var min = minOfArray([5, 6, 2, 3, 7]);
```

### Usando apply em "monkey-patching"

Apply pode ser a melhor forma de monkey-patch uma função nativa do Firefox, ou de bibliotecas em JS. Dada uma função `someobject.foo`, você poderá modificar a função de uma maneira hackeresca, como por exemplo:

```js
var originalfoo = someobject.foo;
someobject.foo = function () {
  // Faça coisas antes de chamar a função
  console.log(arguments);
  // Chama a função como se ela estivesse sido chamada normalmente:
  originalfoo.apply(this, arguments);
  // Rode as coisas que vem depois, aqui.
};
```

Esse método é especialmente útil quando você quer fazer debug de eventos, ou interagir com algo que não tem nenhuma API como os diversos eventos `.on([event]...` events, por exemplo aqueles utilizáveis no Devtools Inspector).

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-function.prototype.apply |

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* Objeto `arguments`
* `Function.prototype.bind()`
* `Function.prototype.call()`
* Funções e escopo de funções


Function.length - JavaScript

Function.length
===============

A propriedade **`length`** especifica o número de argumentos esperados pela função.

| Property attributes of `Function.length` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | yes |

Descrição
---------

`length é uma propriedade de um objeto função`, e indica quantos argumentos a função espera, i.e. o número de parametros formais. Este número não incluí o rest parameter (en-US). Por contraste, `arguments.length` (en-US) é local para a função e fornece o número de argumentos que foram realmente passados.

### Propriedade de Dados do construtor `Function`

O construtor `Function` é propriamente um objeto `Function`. A proproedade de dados do seu `length` tem o valor de 1. Os atributos da propriedade são: Escrita: `false`, Enumerável: `false`, Configurável: `true`.

### Propriedades do objeto prototype de `Function`

A propriedade length do objeto prototype `Function` tem o valor de 0.

Exemplos
--------

```js
console.log(Function.length); /\* 1 \*/

console.log(function () {}.length); /\* 0 \*/
console.log(function (a) {}.length); /\* 1 \*/
console.log(function (a, b) {}.length); /\* 2 etc. \*/
console.log(
  function (...args) {}.length,
); /\* 0, rest parameter is not counted \*/
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-instances-length |

Compatibilidade com navegadores
-------------------------------

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

Veja tambem
-----------

* `Function`


Function.caller - JavaScript

Function.caller
===============

**Non-standard:** This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

A propriedade **`function.caller`** retorna a função que invocou a função especificada.

Descrição
---------

Se a função `f` foi invocada pelo codigo mais alto nível, o valor de `f.caller` é `null`, caso contrario, o valor será a função a qual invocou `f`.

Esta propriedade substitui a propriedade obsoleta `arguments.caller` do objeto `arguments`.

A propriedade especial `__caller__`, a qual retornou o objeto de ativação do chamador, permitindo assin reconstruir o stack, foi removido por motivo de segurança.

### Notas

Note que no caso de recurção, você não pode reconstruir o stack de chamadas usando esta propriedade. Considere:

```js
function f(n) {
  g(n - 1);
}
function g(n) {
  if (n > 0) {
    f(n);
  } else {
    stop();
  }
}
f(2);
```

No momento em que `stop()` é chamado o stack será:

```js
f(2) -> g(1) -> f(1) -> g(0) -> stop()
```

O seguinte é true:

```js
stop.caller === g && f.caller === g && g.caller === f;
```

então se você tentou recuperar o stack trace na função `stop()` assim:

```js
var f = stop;
var stack = "Stack trace:";
while (f) {
  stack += "\n" + f.name;
  f = f.caller;
}
```

o loop nunca irá parar.

Exemplos
--------

### Verificando o valor da propriedade `caller` de uma função

O código a seguir verifica o valor da propriedade `caller` de uma função.

```js
function myFunc() {
  if (myFunc.caller == null) {
    return "The function was called from the top!";
  } else {
    return "This function's caller was " + myFunc.caller;
  }
}
```

Especificações
--------------

Não faz parte de nenhuma especificação. Implementado no JavaScript 1.5.

Compatibilidade com navegadores
-------------------------------

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

Ver também
----------

* Implementation bug for SpiderMonkey Erro do Firefox 65683


Function.prototype.bind() - JavaScript

Function.prototype.bind()
=========================

O método **`bind()`** cria uma nova função que, quando chamada, tem sua palavra-chave `this` definida com o valor fornecido, com uma sequência determinada de argumentos precedendo quaisquer outros que sejam fornecidos quando a nova função é chamada.

Experimente
-----------

Sintaxe
-------
```

function.bind(thisArg[, arg1[, arg2[, ...]]])
```

### Parâmetros

`thisArg`

O valor a ser passado como parâmetro `this` para a função de destino quando a função vinculada é chamada. O valor é ignorado se a função ligada é construída usando o operador `new`.

`arg1, arg2, ...`

Argumentos que precedem outros argumentos fornecidos para a função vinculada ao invocar a função de destino.

### Valor de retorno

Uma cópia da função fornecida com o valor `this` especificado e argumentos iniciais.

Descrição
---------

A função `bind()` cria uma nova **função vinculada** (*bound function*). Uma função vinculada é um **objeto de função exótico** (termo da **ECMAScript 2015**) que encapsula o objeto de função original. Chamar uma função vinculada geralmente resulta na execução de sua **função encapsulada**.

Uma função vinculada tem as seguintes propriedades internas:

* **[[BoundTargetFunction]]** - o objeto de função encapsulado;
* **[[BoundThis]]** - o valor que sempre é passado como `this` quando se chama a função encapsulada;
* **[[BoundArguments]]** - uma lista de valores cujos elementos são usados como os primeiros argumentos para qualquer chamada da função encapsulada;
* **[[Call]]** - executa código associado com este objeto. Invocado através de uma expressão de chamada de função. Os argumentos para o método interno são um valor `this` e uma lista contendo os argumentos passados para a função por uma expressão de chamada.

Quando a função vinculada é chamada, ela chama seu método interno **[[Call]]** na **[[BoundTargetFunction]],** na forma `Call(boundThis, args)`, onde `boundThis` é **[[BoundThis]]** e `args` é **[[BoundArguments]]** seguido pelos argumentos passados pela chamada de função.

Uma função vinculada também pode ser construída usando-se o operador `new`; ao fazê-lo, o resultado é o mesmo que seria se a função alvo tivesse sido construída. O valor de `this` fornecido é ignorado, porém os argumentos precedentes são fornecidos à função emulada.

Exemplos
--------

### Criando uma função vinculada

O uso mais simples de `bind()` é fazer com que uma função que, independentemente da chamada, é chamada com um determinado valor `this`. Um erro comum para programadores JavaScript novatos é extrair um método de um objeto e, em seguida, chamar essa função e esperar que ele use o objeto original como o seu `this` (por exemplo, usando esse método num código baseado em *callback*). Sem a devida atenção, no entanto, o objeto original é normalmente perdido. Criar uma função vinculada a partir da função, usando o objeto original, resolve perfeitamente esse problema:

```js
this.x = 9; //this aqui se refere ao objeto global "window" do navegador
var module = {
  x: 81,
  getX: function () {
    return this.x;
  },
};

module.getX(); // 81

var retrieveX = module.getX;
retrieveX();
// retorna 9 - a função foi invocada no escopo global

// Criando uma nova função com 'this' vinculada ao módulo
// Programadores novatos podem confundir a variável x
// global com a propriedade x do módulo
var boundGetX = retrieveX.bind(module);
boundGetX(); // 81
```

### Funções parcialmente aplicadas

O próximo uso mais simples de `bind()` é criar uma função com argumentos iniciais pré-especificados. Esses argumentos (caso existam) acompanham o valor `this` fornecido e então são inseridos no início dos argumentos passados para a função alvo, seguidos pelos argumentos passados para a função vinculada, sempre que a função vinculada é chamada.

```js
function list() {
  return Array.prototype.slice.call(arguments);
}

var list1 = list(1, 2, 3); // [1, 2, 3]

// Cria uma função com um argumento principal predefinido
var leadingThirtysevenList = list.bind(null, 37);

var list2 = leadingThirtysevenList();
// [37]

var list3 = leadingThirtysevenList(1, 2, 3);
// [37, 1, 2, 3]
```

### Com `setTimeout`

Por padrão, dentro de `window.setTimeout()` (en-US) a palavra-chave `this` vai ser definida com o objeto `window` (ou com o objeto `global`). Ao trabalhar com métodos de classes que requerem que `this` se refira à instâncias de classes, você pode vincular `this` explicitamente à função de *callback*, de modo a manter a instância.

```js
function LateBloomer() {
  this.petalCount = Math.ceil(Math.random() \* 12) + 1;
}

// Declarar bloom depois de um intervalo de 1 segundo
LateBloomer.prototype.bloom = function () {
  window.setTimeout(this.declare.bind(this), 1000);
};

LateBloomer.prototype.declare = function () {
  console.log("I am a beautiful flower with " + this.petalCount + " petals!");
};

var flower = new LateBloomer();
flower.bloom();
// depois de 1 segundo, ativa o método 'declare'
```

### Funções vinculadas usadas como construtores

**Aviso:** Esta seção demonstra capacidades do JavaScript e documenta alguns casos de borda do método `bind()`. Os métodos mostrados abaixo não são os melhores jeitos de se fazer as coisas e provavelmente não deveriam ser usados em nenhum ambiente produtivo.

Funções vinculadas são automaticamente adequadas para uso com o operador `new` para construir novas instâncias criadas pela função alvo. Quando uma função vinculada é usada para construir um valor, o `this` fornecido é ignorado. Porém, argumentos fornecidos ainda são prefixados à chamada do construtor:

```js
function Point(x, y) {
  this.x = x;
  this.y = y;
}

Point.prototype.toString = function () {
  return this.x + "," + this.y;
};

var p = new Point(1, 2);
p.toString(); // '1,2'

// não suportado no polyfill abaixo,
// funciona bem com o bind nativo:

var YAxisPoint = Point.bind(null, 0 /\*x\*/);

var emptyObj = {};
var YAxisPoint = Point.bind(emptyObj, 0 /\*x\*/);

var axisPoint = new YAxisPoint(5);
axisPoint.toString(); // '0,5'

axisPoint instanceof Point; // true
axisPoint instanceof YAxisPoint; // true
new Point(17, 42) instanceof YAxisPoint; // true
```

Note que você não precisa fazer nada de especial para criar uma função vinculada para usar com `new`. O corolário é que você não precisa fazer nada de especial para criar uma função vinculada que será chamada de forma clara, mesmo que você preferisse que a função vinculada fosse somente chamada usando-se `new`.

```js
// Exemplo pode ser executado diretamente no seu console JavaScript
// ...continuando o exemplo acima

// Ainda pode ser chamada como uma função normal
// (apesar de que isso geralmente não é desejado)
YAxisPoint(13);

emptyObj.x + "," + emptyObj.y;
// > '0,13'
```

Se você quer suportar o uso de uma função vinculada somente através de `new`, ou somente a chamando, a função alvo deve impor essa restrição.

### Criando atalhos

`bind()` itambém é útil em casos onde você quer criar um atalho para uma função que requer um valor específico de `this`.

Tome por exemplo `Array.prototype.slice`, que você quer usar para converter um objeto *array-like* em um vetor verdadeiro. Você poderia criar um atalho assim:

```js
var slice = Array.prototype.slice;

// ...

slice.apply(arguments);
```

Com `bind()`, isso pode ser simplificado. No seguinte trecho de código, `slice` é uma função vinculada à função `apply()` de `Function.prototype` (en-US), com o valor `this` definido com a função `slice()` de `Array.prototype`. Isso significa que chamadas adicionais de `apply()` podem ser eliminadas:

```js
// mesmo que "slice" no exemplo anterior
var unboundSlice = Array.prototype.slice;
var slice = Function.prototype.apply.bind(unboundSlice);

// ...

slice(arguments);
```

Polyfill
--------

A função `bind` é uma adição à ECMA-262, 5ª. edição; como tal, pode não estar presente em todos os navegadores. Você pode contornar isso parcialmente inserindo o seguinte código no começo de seus *scripts*, permitindo o uso de muita parte da funcionalidade de `bind()` em implementações que não a suportam nativamente.

```js
if (!Function.prototype.bind) {
  Function.prototype.bind = function (oThis) {
    if (typeof this !== "function") {
      // mais próximo possível da função interna
      // IsCallable da ECMAScript 5
      throw new TypeError(
        "Function.prototype.bind - what is trying to be bound is not callable",
      );
    }

    var aArgs = Array.prototype.slice.call(arguments, 1),
      fToBind = this,
      fNOP = function () {},
      fBound = function () {
        return fToBind.apply(
          this instanceof fNOP ? this : oThis,
          aArgs.concat(Array.prototype.slice.call(arguments)),
        );
      };

    fNOP.prototype = this.prototype;
    fBound.prototype = new fNOP();

    return fBound;
  };
}
```

Algumas das muitas diferenças (é bem possível que haja outras, já que esta lista não pretende seriamente ser completa) entre este algoritmo e o algoritmo especificado são:

* Esta implementação parcial depende dos métodos internos `Array.prototype.slice()`, `Array.prototype.concat()`, `Function.prototype.call()` e `Function.prototype.apply()` possuírem seus valores originais.
* Esta implementação parcial cria funções que não tem um `caller` imutável como "mecanismo de defesa" e propriedades `arguments` que lançam um `TypeError` ao usar *get*, *set*, ou ao deletar. (Isto pode ser adicionado se a implementação suporta `Object.defineProperty`, ou parcialmente implementado sem um comportamento *throw-on-delete* se a implementação suporta as extensões `Object.prototype.__defineGetter__()` e `Object.prototype.__defineSetter__()`)
* Esta implementação parcial cria funções que tem uma propriedade `prototype`. (Funções vinculadas apropriadas não a tem.)
* Esta implementação parcial cria funções vinculadas cuja propriedade `length` não cumpre com a regra da ECMA-262: cria funções com comprimento zero, quando uma implementação completa, dependendo do comprimento da função alvo e do número de argumentos pre-especificados, pode retornar um comprimento não-nulo.

Se você escolher utilizar esta implementação parcial, **você não deve confiar em casos onde o comportamento é diferente da ECMA-262, 5ª. edição!** Porém, com algum cuidado (e talvez com modificação adicional para atender necessidades específicas), esta implementação parcial pode ser uma ponte razoável para quando `bind()` for amplamente implementada de acordo com a especificação.

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-function.prototype.bind |

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Function.prototype.apply()`
* `Function.prototype.call()`
* Functions


Function.displayName - JavaScript

Function.displayName
====================

**Non-standard:** This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

A propriedade **`function.displayName`** retorna o nome de exibição da função.

Descrição
---------

Quando definida, a propriedade `displayName` retorna o nome de exibição da função.

```js
function doSomething() {}

console.log(doSomething.displayName); // "undefined"

var popup = function (content) {
  console.log(content);
};

popup.displayName = "Show Popup";

console.log(popup.displayName); // "Show Popup"
```

Você pode definir uma função com uma nome de exibição em um function expression:

```js
var object = {
  someMethod: function () {},
};

object.someMethod.displayName = "someMethod";

console.log(object.someMethod.displayName); // logs "someMethod"

try {
  someMethod;
} catch (e) {
  console.log(e);
}
// ReferenceError: someMethod is not defined
```

Você pode mudar dinamicamente o`displayName` de uma função:

```js
var object = {
  // anonymous
  someMethod: function (value) {
    arguments.callee.displayName = "someMethod (" + value + ")";
  },
};

console.log(object.someMethod.displayName); // "undefined"

object.someMethod("123");
console.log(object.someMethod.displayName); // "someMethod (123)"
```

Exemplos
--------

Geralmente, é preferida por consoles e perfis em vez de `func.name` mostrar o nome de uma função.

Entrando com o seguinte em um console, isso deverá mostrar algo como "`function My Function()`":

```js
var a = function () {};
a.displayName = "My Function";

a; // "function My Function()"
```

Especificações
--------------

Não faz parte de denhuma especificação.

Compatibilidade com navegadores
-------------------------------

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


Date.prototype.getUTCDay() - JavaScript

Date.prototype.getUTCDay()
==========================

O método **`getUTCDay()`** retorna o dia da semana na data especificada de acordo com o horário universal, onde 0 representa domingo.

Sintaxe
-------
```

dateObj.getUTCDay()
```

### Parâmetros

Nenhum.

### Valor retornado

O valor retornado por `getUTCDay()` é um inteiro correspondente ao dia da semana: 0 para domingo, 1 para segunda-feira, 2 para terça-feira e assim por diante.

Exemplos
--------

### Usando `getUTCDay()`

O exemplo a seguir atribui a parte do dia da semana da data atual à variável `diaDaSemana`.

```js
var hoje = new Date();
var diaDaSemana = hoje.getUTCDay();
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCDate()`
* `Date.prototype.getDay()`
* `Date.prototype.setUTCDate()`


Date.prototype.setUTCHours() - JavaScript

Date.prototype.setUTCHours()
============================

O método **`setUTCHours()`** atribui a hora para a data especificada de acordo com o horário universal, e retorna o número de milissegundos desde 1 de Janeiro de 1970 00:00:00 UTC até o horário representado pela instância `Date` atualizada.

Experimente
-----------

Sintaxe
-------
```

dateObj.setUTCHours(hoursValue[, minutesValue[, secondsValue[, msValue]]])
```

### Parâmetros

`hoursValue`

Um inteiro entre 0 e 23, representando a hora.

`minutesValue`

Opcional. Um inteiro entre 0 e 59, representando os minutos.

`secondsValue`

Opcional. Um inteiro entre 0 e 59, representando os segundos. Se você especificar o parâmetro `secondsValue`, você também deve especificar `minutesValue`.

`msValue`

Opcional. Um número entre 0 e 999, representando os milissegundos. Se você especificar o parâmetro `msValue`, você também deve especificar `minutesValue` e `secondsValue`.

### Valor de retorno

O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se você não especificar os parâmetros `minutesValue`, `secondsValue`, e `msValue`, os valores retornados dos métodos `getUTCMinutes()`, `getUTCSeconds()`, e `getUTCMilliseconds()` serão utilizados.

Se o parâmetro que você especificou estiver fora do alcance esperado, `setUTCHours()` tentará atualizar a informação da data no objeto `Date`. Por exemplo, se você usa 100 para `secondsValue`, os minutos serão incrementados em 1 (`minutesValue + 1`), e 40 será usado para os segundos.

Exemplos
--------

### Usando `setUTCHours()`

```js
var theBigDay = new Date();
theBigDay.setUTCHours(8);
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCHours()`
* `Date.prototype.setHours()`


Date.prototype.getTimezoneOffset() - JavaScript

Date.prototype.getTimezoneOffset()
==================================

O método **`getTimezoneOffset()`** retorna a diferença, em minutos, do deslocamento de fuso horário entre o UTC (Tempo Universal Coordenado) e a localidade atual.

Sintaxe
-------
```

dateObj.getTimezoneOffset()
```

### Parâmetros

Nenhum

### Valor de retorno

O deslocamento de fuso horário é a diferença, em minutos, entre o UTC (Tempo Universal Coordenado) e o horário local. Perceba que isto significa que o deslocamento será negativo se o fuso horário local está à direita do UTC e positivo se está a esquerda. Por exemplo, se seu fuso horário é UTC+10(Padrão da Austrália Oriental), -600 será retornado. O Horário de verão evita que este valor seja sempre o mesmo para uma determinada localidade.

Exemplo

### Utilizando `getTimezoneOffset()`

```js
var x = new Date();
var currentTimeZoneOffsetInHours = x.getTimezoneOffset() / 60;
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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


Date.prototype.getUTCFullYear() - JavaScript

Date.prototype.getUTCFullYear()
===============================

O método **`getUTCFullYear()`** retorna o ano na data indicada de acordo com o horário universal.

Experimente
-----------

Sintaxe
-------
```

dateObj.getUTCFullYear()
```

### Retorna

Um número que representa o ano na data indicada de acordo com o horário universal.

Descrição
---------

O valor retornado por `getUTCFullYear()` é um número absoluto compatível com ano 2000, por exemplo, 1995.

Exemplos
--------

### Usando `getUTCFullYear()`

O exemplo a seguir atribui o valor de 4 dígitos do ano atual à variável `year.`

```js
var today = new Date();
var year = today.getUTCFullYear();
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getFullYear()`
* `Date.prototype.setFullYear()`


Date.prototype.setUTCDate() - JavaScript

Date.prototype.setUTCDate()
===========================

O método **`setUTCDate()`** atribui o dia do mês para uma data especifica de acordo com o horário universal.

Experimente
-----------

Sintaxe
-------
```

dateObj.setUTCDate(dayValue)
```

### Parâmetros

`dayValue`

Um inteiro entre 1 e 31, representando o dia do mês.

### Valor de retorno

O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se um parâmetro que você especificou está fora do alcance esperado, `setUTCDate()` tentará atualizar a informação da data no objeto `Date`. Por exemplo, se você usar 40 para `dayValue`, e o mês guardado no objeto `Date` é Junho, o dia será trocado para 10 e o mês será incrementado para Julho.

Exemplos
--------

### Usando `setUTCDate()`

```js
var theBigDay = new Date();
theBigDay.setUTCDate(20);
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCDate()`
* `Date.prototype.setDate()`


Date.prototype.toLocaleDateString() - JavaScript

Date.prototype.toLocaleDateString()
===================================

O método **`toLocaleDateString()`** retorna uma string com a representação de parte da data baseando-se no idioma. Os novos argumentos `locales` e `options` deixam as aplicações especificarem o idioma cujas convenções de formatação devem ser usadas e permitem customizar o comportamento da função. Em implementações antigas, nas quais ignoram os argumentos `locales` e `options`, o locale usado e a forma da string retornada são inteiramente dependente da implementação nativa.

Sintáxe
-------
```

dateObj.toLocaleDateString([locales [, options]])
```

### Parametros

Verifique a seção Compatibilidade entre navegadores para ver quais navegadores dão suporte aos argumentos `locales` e `options`, e o Example: Verificação para suporte dos argumentos `locales` e `options` para detectar a funcionalidade.

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/DateTimeFormat', 'Parameters')}}O valor padrão para cada propriedade do componente date-time é `undefined`, mas se as propriedades `weekday`, `year`, `month`, `day` são todas `undefined`, então `year`, `month` and `day` são assumidos como "`numeric`".

### Return value

Uma representação em string de parte da data dada a instância `Date` de acordo com as convenções específicas do idioma.

Exemplos
--------

### Usando `toLocaleDateString()`

Em uso básico sem especificação de locale, uma string formatada no padrão do locale e com as opções padrões é retornada.

```js
var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));

// toLocaleDateString() sem argumentos depende da implementação,
// o locale padrão, e o time zone padrão
console.log(date.toLocaleDateString());
// → "12/11/2012" se rondando em locale en-US com time zone de America/Los\_Angeles
```

### Checagem para o suporte dos argumentos `locales` e `options`

Os argumentos `locales` e `options` não são suportados em todos os browser ainda. Para verificar se uma uma implementação já suporta eles, você pode usar o requisito de que tags de idioma ilegal são rejeitadas com uma exceção `RangeError` (en-US):

```js
function toLocaleDateStringSupportsLocales() {
  try {
    new Date().toLocaleDateString("i");
  } catch (e) {
    return e.name === "RangeError";
  }
  return false;
}
```

### Usando `locales`

Esse exemplo mostra algumas das variações em formatos de data localizados. A fim de obter oformato do idioma usado na interface de usuário da usa aplicação, certifique-se de especificar esse idioma (e possivelmente algumas outros idiomas de reserva) usando o argumento `locales`:

```js
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));

// os formatos abaixo assumem o time zone local do locale;
// America/Los\_Angeles for the US

// Inglês americano usa a ordem mês-dia-ano
console.log(date.toLocaleDateString("en-US"));
// → "12/19/2012"

// Inglês Britânico usa a ordem dia-mês-ano
console.log(date.toLocaleDateString("en-GB"));
// → "20/12/2012"

// Coreano usa a ordem ano-mês-dia
console.log(date.toLocaleDateString("ko-KR"));
// → "2012. 12. 20."

// Árabe na maioria dos países de língua árabe usa dígitos árabes reais
console.log(date.toLocaleDateString("ar-EG"));
// → "٢٠/١٢/٢٠١٢"

// para Japonês, aplicações podem querer usar o calendário japonês,
// onde 2012 foi o ano 24 da era Heisei
console.log(date.toLocaleDateString("ja-JP-u-ca-japanese"));
// → "24/12/20"

// quando um idioma que pode não ser suportado é requerido, tal como
// Balinês, inclua um idioma de reserva, nesse caso Indonésio
console.log(date.toLocaleDateString(["ban", "id"]));
// → "20/12/2012"
```

### Usando `options`

O resultados gerados por `toLocaleDateString()` podem ser customizado usando o argumento `options`:

```js
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));

// requer um dia da semana jutamente com uma data longa
var options = {
  weekday: "long",
  year: "numeric",
  month: "long",
  day: "numeric",
};
console.log(date.toLocaleDateString("de-DE", options));
// → "Donnerstag, 20. Dezember 2012"

// uma aplicação pode querer usar UTC e fazê-lo visível
options.timeZone = "UTC";
options.timeZoneName = "short";
console.log(date.toLocaleDateString("en-US", options));
// → "Thursday, December 20, 2012, GMT"
```

Performance
-----------

Ao formatar um grande número de datas, é melhor criar um objeto `Intl.DateTimeFormat` (en-US) e usar a função fornecido porsua propriedade `format` (en-US).

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.tolocaledatestring |
| ECMAScript Internationalization API Specification # sup-date.prototype.tolocaledatestring |

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Intl.DateTimeFormat` (en-US)
* `Date.prototype.toLocaleString()` (en-US)
* `Date.prototype.toLocaleTimeString()`
* `Date.prototype.toString()`


Date.prototype.getHours() - JavaScript

Date.prototype.getHours()
=========================

Resumo
------

O método **`getHours()`** retorna a hora para a data especificada, de acordo com a hora local.

Sintaxe
-------
```

dateObj.getHours()
```

### Parâmetros

Nenhum.

### Retorna

O valor retornado por `getHours()` é um inteiro entre 0 e 23.

Exemplos
--------

### Exemplo: Usando `getHours()`

O segundo statement abaixo atribui o valor 23 à variável `hours`, baseado no valor do objeto `Date` `Xmas95`.

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

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

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCHours()`
* `Date.prototype.setHours()`


Date.prototype.setDate() - JavaScript

Date.prototype.setDate()
========================

O método **`setDate()`** configura o dia do objeto `Date` relativamente ao início do mês configurado previamente.

Experimente
-----------

Sintaxe
-------
```

dateObj.setDate(dayValue)
```

### Parâmetros

`dayValue`

Um número inteiro que representa o dia do mês.

### Valor de retorno

O número de milisegundos entre 1o de janeiro de 1970 00:00:00 UTC e a data indicada (o objeto `Date` é mudado no lugar).

Descrição
---------

Se o `dayValue` estiver fora da extensão de valores de data para o mês, `setDate()` vai atualizar o objeto `Date` consequentemente.

Por exemplo, se 0 for fornecido para `dayValue`, a data será configurada para o último dia do mês anterior.

Se um número negativo for fornecido para `dayValue`, a data será configurada contando-se regressivamente desde o último dia do mês anterior. -1 resultará na data sendo configurada para um dia antes do último dia o mês anterior.

Exemplos
--------

### Usando `setDate()`

```js
var theBigDay = new Date(1962, 6, 7); // 1962-07-07 (7th of July 1962)
theBigDay.setDate(24); // 1962-07-24 (24th of July 1962)
theBigDay.setDate(32); // 1962-08-01 (1st of August 1962)
theBigDay.setDate(22); // 1962-08-22 (22th of August 1962)
theBigDay.setDate(0); // 1962-07-31 (31th of July 1962)
theBigDay.setDate(98); // 1962-10-06 (6th of October 1962)
theBigDay.setDate(-50); // 1962-08-11 (11th of August 1962)
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getDate()`
* `Date.prototype.setUTCDate()`


Date.prototype.getMinutes() - JavaScript

Date.prototype.getMinutes()
===========================

O método **`getMinutes()`** retorna os minutos em uma data específica de acordo com o horário local.

Sintaxe
-------
```

dateObj.getMinutes()
```

### Retorna

Um número inteiro, entre 0 e 59, representando os minutos em uma data de acordo com o horário local.

Exemplos
--------

### Usando o `getMinutes()`

The second statement below assigns the value 15 to the variable `minutes`, based on the value of the `Date` object `Xmas95`.

No exemplo abaixo, a segunda linha atribui o valor 15 à variável `minutes`, baseado no valor de objeto `Global_Objects/Date` `Xmas95`.

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

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

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCMinutes()`
* `Date.prototype.setMinutes()`


Date.prototype.toDateString() - JavaScript

Date.prototype.toDateString()
=============================

O método **`toDateString()`** retorna a porção da data de um objeto `Date` em um formato legível para humanos em inglês dos Estados Unidos.

Sintaxe
-------
```

objetoDate.toDateString()
```

Descrição
---------

Exemplares de `Date` referem-se a um ponto específico no tempo. Chamar `toString()` retorna a data num formato legível para humanos em inglês dos Estados Unidos. No SpiderMonkey, isso consiste na porção da data (dia, mês e ano) seguida pela porção da hora (horas, minutos, segundos e fuso horário). Ás vezes, deseja-se obter uma string apenas da porção da data; Isso pode ser conseguido com o método `toDateString()`.

`O método toDateString()` é especialmente útil porque motores que implementam o padrão ECMA-262 (en-US) podem divergir na string retornada pelo `toString()` de objetos `Date` , pois o formato é dependente da implentação e abordagens simples que repartem a string podem não produzir resultados consistentes nos vários motores.

Exemplos
--------

### Um uso básico de `toDateString()`

```js
var d = new Date(1993, 6, 28, 14, 39, 7);

console.log(d.toString()); // exibe Wed Jul 28 1993 14:39:07 GMT-0600 (PDT) no log
console.log(d.toDateString()); // exibe Wed Jul 28 1993 no log
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Ver também
----------

* `Date.prototype.toLocaleDateString()`
* `Date.prototype.toTimeString()`
* `Date.prototype.toString()`


Date.prototype.toUTCString() - JavaScript

Date.prototype.toUTCString()
============================

O método **`toUTCString()`** converte uma data para uma cadeia de caracteres (*string*), usando o fuso horário UTC.

Baseado na RFC7231 e modificado de acordo com a ECMA-262 toUTCString, ele pode ter valores negativos na versão de 2021.

Experimente
-----------

Sintaxe
-------
```

dateObj.toUTCString()
```

### Valor de retorno

Uma *string* representando a data usando o fuso horário UTC.

Descrição
---------

O valor retornado por `toUTCString()` é uma *string* no formato `Www, dd Mmm yyyy hh:mm:ss GMT`, onde:

| Formato da String | Descrição |
| --- | --- |
| `Www` | Dia da semana, em três letras (e.g. Sun, Mon, ...) |
| `dd` | Dia do mês, como dois dígitos com zero à esquerda se requisitado |
| `Mmm` | Mês, em três letras (e.g. Jan, Feb, ...) |
| `yyyy` | Ano, como 4 ou mais dígitos com zeros à esquerda se requisitado |
| `hh` | Hora, como dois dígitos com zero à esquerda se requisitado |
| `mm` | Minutos, como dois dígitos com zero à esquerda se requisitado |
| `ss` | Segundos, como dois dígitos com zero à esquerda se requisitado |

Antes do ECMAScript 2018, o formato do valor de retorno variava de acordo com a plataforma. O valor de retorno mais comum era um carimbo de data formatada na RFC-1123, que é uma versão relativamente atualizada dos carimbos de data da RFC-822.

Exemplos
--------

### Usando `toUTCString()`

```js
let today = new Date("Wed, 14 Jun 2017 00:00:00 PDT");
let UTCstring = today.toUTCString(); // Wed, 14 Jun 2017 07:00:00 GMT
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.toLocaleString()` (en-US)
* `Date.prototype.toDateString()`
* `Date.prototype.toISOString()`


Date.prototype.setUTCMilliseconds() - JavaScript

Date.prototype.setUTCMilliseconds()
===================================

O método **`setUTCMilliseconds()`** atribui os milissegundos para a data especificada de acordo com o horário universal.

Experimente
-----------

Sintaxe
-------
```

dateObj.setUTCMilliseconds(millisecondsValue)
```

### Parâmetros

`millisecondsValue`

Um número entre 0 e 999, representando os milissegundos.

### Valor de retorno

O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se o parâmetro que você especificou estiver fora do alcance esperado, `setUTCMilliseconds()` tentará atualizar a informação da data no objeto `Date`. Por exemplo, se você usar 1100 para `millisecondsValue`, os segundos guardados no objeto `Date` serão incrementados em 1, e 100 serão usados para os milissegundos.

Exemplos
--------

### Usando `setUTCMilliseconds()`

```js
var theBigDay = new Date();
theBigDay.setUTCMilliseconds(500);
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCMilliseconds()`
* `Date.prototype.setMilliseconds()`


Date.prototype.getDate() - JavaScript

Date.prototype.getDate()
========================

Resumo
------

O método **`getDate()`** retorna o dia do mês da data especificada de acordo com a hora local.

Sintaxe
-------
```

dateObj.getDate()
```

### Parâmetros

Nenhum.

### Retorna

O valor retornado por `getDate()` é um inteiro entre 1 e 31.

Exemplos
--------

### Exemplo: Usando `getDate()`

O segundo statement abaixo atribui o valor 25 à variável day, baseado no valor do objeto `Date` `Xmas95`.

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

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

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCDate()`
* `Date.prototype.getUTCDay()`
* `Date.prototype.setDate()`


Date.prototype.toTimeString() - JavaScript

Date.prototype.toTimeString()
=============================

O método **`toTimeString()`** retorna uma porção de tempo de um objeto `Date` de forma legível para um ser humano em Inglês Americano.

Experimente
-----------

Sintaxe
-------
```

dateObj.toTimeString()
```

### Valor de retorno

Uma *string* representando a porção de tempo da data de forma legível para um ser humano em Inglês Americano.

Descrição
---------

Instâncias de `Date` referem-se a um ponto específico no tempo. Chamando `toString()` irá retornar uma data formatada de forma legível para um ser humano em Inglês Americano. No SpiderMonkey, isso consiste na porção da data (dia, mês e ano) seguido pela porção de tempo (horas, minutos, segundos e fuso horário). Algumas vezes é desejável obter a *string* da porção do tempo; tal coisa pode ser atingida utilizando o método `toTimeString()`.

O `toTimeString()` método é especialmente útil por que motores parecidos que implementam a ECMA-262 (en-US) podem ter *strings* diferentes obtidas de `toString()` para objetos `Date`, como o formato é dependente de implementação; abordagens de corte simples de *strings* pode não produzir resultados consistentes entre múltiplos motores.

Exemplos
--------

### Uso básico de `toTimeString()`

```js
var d = new Date(1993, 6, 28, 14, 39, 7);

console.log(d.toString()); // Wed Jul 28 1993 14:39:07 GMT-0600 (PDT)
console.log(d.toTimeString()); // 14:39:07 GMT-0600 (PDT)
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.toLocaleTimeString()`
* `Date.prototype.toDateString()`
* `Date.prototype.toString()`


Date.prototype.getUTCDate() - JavaScript

Date.prototype.getUTCDate()
===========================

O método **`getUTCDate()`** retorna o dia (data) do mês na data especificada de acordo com o horário universal.

Sintaxe
-------
```

dateObj.getUTCDate()
```

### Retorna

Um número inteiro, entre 1 e 31, representando o dia do mês na data especificada de acordo com o horário universal.

Exemplos
--------

### Usando `getUTCDate()`

O exemplo a seguir atribui o dia da data atual à variável `day`:

```js
var today = new Date();
var day = today.getUTCDate();
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getDate()`
* `Date.prototype.getUTCDay()`
* `Date.prototype.setUTCDate()`


Date.prototype.toISOString() - JavaScript

Date.prototype.toISOString()
============================

O método **`toISOString()`** retorna uma cadeia de caracteres (*string*) simplificada no formato ISO extendido (ISO 8601), que é sempre 24 ou 27 caracteres de tamanho (`YYYY-MM-DDTHH:mm:ss.sssZ` ou `±YYYYYY-MM-DDTHH:mm:ss.sssZ`, respectivamente). O fuso horário é sempre o deslocamento zero UTC, como denotado pelo sufixo "`Z`".

Experimente
-----------

Sintaxe
-------
```

dateObj.toISOString()
```

### Valor de retorno

Uma *string* representando a data no formato ISO 8601 de acordo com o horário universal.

Polyfill
--------

Este método foi padronizado na quinta edição da ECMA-262. Motores que não foram atualizados para suportar este método podem funcionar com uma gambiarra na ausência deste método da seguinte forma:

```js
if (!Date.prototype.toISOString) {
  (function () {
    function pad(number) {
      if (number < 10) {
        return "0" + number;
      }
      return number;
    }

    Date.prototype.toISOString = function () {
      return (
        this.getUTCFullYear() +
        "-" +
        pad(this.getUTCMonth() + 1) +
        "-" +
        pad(this.getUTCDate()) +
        "T" +
        pad(this.getUTCHours()) +
        ":" +
        pad(this.getUTCMinutes()) +
        ":" +
        pad(this.getUTCSeconds()) +
        "." +
        (this.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) +
        "Z"
      );
    };
  })();
}
```

Exemplos
--------

### Usando `toISOString()`

```js
let today = new Date("05 October 2011 14:48 UTC");

console.log(today.toISOString()); // Retorna 2011-10-05T14:48:00.000Z
```

O exemplo acima usa uma conversão de uma *string* não-padrão que pode não ser convertida corretamente em navegadores que não sejam da Mozilla..

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.toLocaleDateString()`
* `Date.prototype.toTimeString()`
* `Date.prototype.toUTCString()`


Date.prototype.valueOf() - JavaScript

Date.prototype.valueOf()
========================

O método **`valueOf()`** retorna o valor primitivo do objeto `Date`.

Experimente
-----------

Sintaxe
-------
```

dateObj.valueOf()
```

### Valor de retorno

O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data.

Descrição
---------

O método `valueOf()` retorna o valor primitivo do objeto `Date` como um tipo de dado numérico, o número de milissegundos desde a meia noite do dia 1 de Janeiro de 1970 UTC.

Este método é funcionalmente equivalente ao método `Date.prototype.getTime()`.

Este método é geralmente chamado internamente pelo JavaScript e não explícito em código.

Exemplos
--------

### Usando `valueOf()`

```js
var x = new Date(56, 6, 17);
var myVar = x.valueOf(); // atribui -424713600000 to myVar
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Object.prototype.valueOf()`
* `Date.prototype.getTime()`


Date.prototype.setMilliseconds() - JavaScript

Date.prototype.setMilliseconds()
================================

O método **`setMilliseconds()`** atribui os milissegundos para a data específica de acordo com a hora local.

Experimente
-----------

Sintaxe
-------
```

dateObj.setMilliseconds(millisecondsValue)
```

### Parâmetros

`millisecondsValue`

Um número entre 0 e 999, representando os milissegundos.

### Valor de retorno

O número de milissegundos entre dia 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se você especifica um número fora do alcance esperado, a informação de data no objeto `Date` é atualizado de acordo. Por exemplo, se você especifica 1005, o número de segundos é incrementado em 1, e 5 é utilizado para os milissegundos.

Exemplos
--------

### Usando `setMilliseconds()`

```js
var theBigDay = new Date();
theBigDay.setMilliseconds(100);
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getMilliseconds()`
* `Date.prototype.setUTCMilliseconds()`


Date.prototype.setUTCMonth() - JavaScript

Date.prototype.setUTCMonth()
============================

O método **`setUTCMonth()`** atribui o mês para a data especificada de acordo com o horário universal.

Experimente
-----------

Sintaxe
-------
```

dateObj.setUTCMonth(monthValue[, dayValue])
```

### Parâmetros

`monthValue`

Um inteiro entre 0 e 11, representando os meses de Janeiro até Dezembro.

`dayValue`

Opcional. Um inteiro de 1 a 31, representando o dia do mês.

### Valor de retorno

O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se você não especificar o parâmetro `dayValue`, o valor retornado do método `getUTCDate()` é utilizado.

Se um parâmetro que você especificou está fora do alcance especificado, `setUTCMonth()` tentará atualizar a informação da data no objeto `Date`. Por exemplo, se você usar 15 para `monthValue`, o ano irá incrementar em 1, e 3 será usado para o mês.

Exemplos
--------

### Usando `setUTCMonth()`

```js
var theBigDay = new Date();
theBigDay.setUTCMonth(11);
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCMonth()`
* `Date.prototype.setMonth()`


Date.prototype.getUTCMinutes() - JavaScript

Date.prototype.getUTCMinutes()
==============================

O método **`getUTCMinutes()`** retorna os minutos na data especificada de acordo com o tempo universal.

Experimente
-----------

Sintaxe
-------
```

dateObj.getUTCMinutes()
```

### Valor retornado

Um número inteiro, entre 0 e 59, representando os minutos na data especificada de acordo com o horário universal (UTC).

Exemplos
--------

### Usando `getUTCMinutes()`

O seguinte exemplo atribui a parte dos minutos do tempo atual para a variável `minutes`.

```js
var today = new Date();
var minutes = today.getUTCMinutes();
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getMinutes()`
* `Date.prototype.setUTCMinutes()`


Date.prototype.getFullYear() - JavaScript

Date.prototype.getFullYear()
============================

Resumo
------

O método **`getFullYear()`** retorna o ano da data especificada de acordo com a hora local.

Use este método ao invés do `getYear()`.

Sintaxe
-------
```

dateObj.getFullYear()
```

### Parâmetros

Nenhum.

### Retorna

O valor retornado por `getFullYear()` é um número absoluto. Para datas entre os anos 1000 e 9999, `getFullYear()` retorna um número de quatro dígitos, por exemplo, 1995. Use esta função para ter certeza de que o ano é compatível com os anos depois de 2000.

Exemplos
--------

### Exemplo: Usando `getFullYear()`

O exemplo seguinte atribui o valor de quatro dígitos do ano corrente à variável year.

```js
var today = new Date();
var year = today.getFullYear();
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCFullYear()`
* `Date.prototype.setFullYear()`
* `Date.prototype.getYear()`


Date.prototype.toLocaleTimeString() - JavaScript

Date.prototype.toLocaleTimeString()
===================================

O método **`toLocaleTimeString()`** retorna uma string com uma representação sensível ao idioma de uma porção de tempo desta data. Os novos argumentos `locales` e `options` possibilitam aplicações especificarem que formato de linguagem deve ser usado, podendo customizar o comportamento da função. Em implementações antigas, que ignoram os argumentos `locales` e `options`, o local utilizado e o formato retornado da string são implementações completamente dependentes.Experimente
-----------

Sintaxe
-------
```

dateObj.toLocaleTimeString([locales[, options]])
```

### Parâmetros

Confira a seção Browser compatibility para ver o suporte em browsers dos argumentos `locales` e `options`, e Checking for support for `locales` and `options` arguments para ver suas features.

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/DateTimeFormat', 'Parameters')}}
O valor default para cada propriedade do componente date-time é `undefined`, mas se as propriedades `hour`, `minute`, `second` são todas `undefined`, então `hour`, `minute`, e `second` espera-se que seja `"numeric"`.

### Valor retornado

Uma string representando uma porção de tempo de uma instância `Date`, fornecida de acordo com as convenções específicas do idioma.

Exemplos
--------

### Usando `toLocaleTimeString()`

Em um uso simples, sem especificar uma localidade, é retornado uma string formatada de uma localidade default e com opções default.

```js
var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));

// toLocaleTimeString() sem argumentos, depende da implementação,
// da localidade padrão, e do fuso horário padrão
console.log(date.toLocaleTimeString());
// → "7:00:00 PM" se rodar em en-US com o fuso horário de America/Los\_Angeles
```

### Verificando o suporte para os argumentos `locales` e `options`

Os argumentos `locales` e `options` não são suportados em todos os browsers ainda. Para conferir se uma implementação já os suporta, você pode usar a exigência que tags ilegais de liguagem são rejeitadas com uma exceção `RangeError` (en-US):

```js
function toLocaleTimeStringSupportsLocales() {
  try {
    new Date().toLocaleTimeString("i");
  } catch (e) {
    return e.name === "RangeError";
  }
  return false;
}
```

### Usando `locales`

Este exemplo mostra algumas das variações em um formato de tempo localizado. Para obter o formato do idioma usado na interface do usuário da sua aplicação, tenha certeza de especificar esse idioma (e possivelmente alguns idiomas de retorno) usando o argumento `locales`:

```js
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));

// Os formatos abaixo assumem o fuso horário local da região;
// America/Los\_Angeles for the US

// US English usa o formato 12 horas com AM/PM
console.log(date.toLocaleTimeString("en-US"));
// → "7:00:00 PM"

// British English usa o formato 24 horas sem AM/PM
console.log(date.toLocaleTimeString("en-GB"));
// → "03:00:00"

// Korean usa o formato 12 horas com AM/PM
console.log(date.toLocaleTimeString("ko-KR"));
// → "오후 12:00:00"

// Arabic na maiorias dos países que falam árabe usa-se os dígitos arábicos reais
console.log(date.toLocaleTimeString("ar-EG"));
// → "٧:٠٠:٠٠ م"

// quando solicitar um idioma que talvez não seja suportado, como o
// Balinese, inclua um idioma de fallback, nesse caso Indonesian
console.log(date.toLocaleTimeString(["ban", "id"]));
// → "11.00.00"
```

### Usando `options`

Os resultados fornecidos por `toLocaleTimeString()` podem ser customizados usando o argumento `options`:

```js
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));

// uma aplicação pode querer usar UTC e tornar isso visível
var options = { timeZone: "UTC", timeZoneName: "short" };
console.log(date.toLocaleTimeString("en-US", options));
// → "3:00:00 AM GMT"

// ás vezes, até em US precise usar o formato 24 horas
console.log(date.toLocaleTimeString("en-US", { hour12: false }));
// → "19:00:00"
```

Performance
-----------

Quando se formata um grande número de datas, é aconselhável criar um objeto `Intl.DateTimeFormat` (en-US) e usar a função fornecida pela propriedade dele: `format` (en-US).

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.tolocaletimestring |
| ECMAScript Internationalization API Specification # sup-date.prototype.tolocaletimestring |

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Intl.DateTimeFormat` (en-US)
* `Date.prototype.toLocaleDateString()`
* `Date.prototype.toLocaleString()` (en-US)
* `Date.prototype.toTimeString()`
* `Date.prototype.toString()`


Date.prototype.setMinutes() - JavaScript

Date.prototype.setMinutes()
===========================

O método **`setMinutes()`** atribui os minutos para uma data específica de acordo com o horário local.

Experimente
-----------

Sintaxe
-------
```

dateObj.setMinutes(minutesValue[, secondsValue[, msValue]])
```

### Versões anteriores ao JavaScript 1.3
```

dateObj.setMinutes(minutesValue)
```

### Parâmetros

`minutesValue`

Um inteiro entre 0 e 59, representando os mintuos.

`secondsValue`

Opcional. Um inteiro entre 0 e 59, representando os segundos. Se você especificar o parâmetro `secondsValue`, você também deve especificar `minutesValue`.

`msValue`

Opcional. Um número entre 0 e 999, representando os milissegundos. Se você especificar o parâmetro `msValue`, você deve também especificar `minutesValue` e `secondsValue`.

### Valor de retorno

O número de milissegundos entre dia 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se você não especifica os parâmetros `secondsValue` e `msValue`, os valores retornados dos métodos `getSeconds()` e `getMilliseconds()` são usados.

Se um parâmetro que você especificou estiver fora do alcance esperado, `setMinutes()` tentará atualizar a informação da data no objeto `Date`. Por exemplo, se você usa 100 para `secondsValue`, os minutos serão incrementados em 1 (`minutesValue + 1`), e 40 serão usados para segundos.

Exemplos
--------

### Usando `setMinutes()`

```js
var theBigDay = new Date();
theBigDay.setMinutes(45);
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getMinutes()`
* `Date.prototype.setUTCMinutes()`


Date.prototype.getUTCMilliseconds() - JavaScript

Date.prototype.getUTCMilliseconds()
===================================

o método **`getUTCMilliseconds()`** retorna os milisegundos na data especificada, de acordo com o horário universal (UTC).

Sintaxe
-------
```

dateObj.getUTCMilliseconds()
```

### Valor de retorno

Um número inteiro, entre 0 e 999, representando os milisegundos na data especificada de acordo com o horário universal (UTC).

Exemplos
--------

### Usando `getUTCMilliseconds()`

O exemplo a seguir associa a parte dos milissegundos do tempo atual à variável `milissegundos`.

```js
var hoje = new Date();
var milissegundos = today.getUTCMilliseconds();
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getMilliseconds()`
* `Date.prototype.setUTCMilliseconds()`


Date.prototype.getMilliseconds() - JavaScript

Date.prototype.getMilliseconds()
================================

O método **`getMilliseconds()`** retorna os milissegundos em uma data específica de acordo com o horário local.

Sintaxe
-------
```

dateObj.getMilliseconds()
```

### Retorna

Um número, entre 0 e 999, representando os milissegundos de uma data de acordo com o horário local.

Exemplos
--------

### Usando o `getMilliseconds()`

O exemplo a seguir atribui a porção de milissegundos do horário atual à variável `milliseconds`:

```js
var today = new Date();
var milliseconds = today.getMilliseconds();
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCMilliseconds()`
* `Date.prototype.setMilliseconds()`


Date.prototype[@@toPrimitive] - JavaScript

Date.prototype[@@toPrimitive]
=============================

O método **`[@@toPrimitive]()`** converte o objeto `Date` para um valor primitivo.

Sintaxe
-------
```

Date()[Symbol.toPrimitive](hint);
```

### Valor de retorno

O valor primitivo do objeto `Date`. Dependendo do argumento, o método pode retornar uma cadeia de caracteres (*string*) ou um número.

Descrição
---------

O método `[@@toPrimitive]()` do objeto `Date` retorna um valor primitivo, que pode ser tanto um tipo numérico quanto uma string.

Se `hint` é `"string"` ou `"default"`, `[@@toPrimitive]()` tenta chamar o método `toString`. Se a propriedade `toString` não existe, ele tenta chamar o método `valueOf` e se o `valueOf` não existir, `[@@toPrimitive]()` joga um `TypeError`.

Se `hint` é `"number"`, `[@@toPrimitive]()` tenta primeiro chamar `valueOf`, e se ele falha, chama `toString`.

O JavaScript chama o método `[@@toPrimitive]()` para converter um objeto para um valor primitivo. Você raramente precisa invocar o método `[@@toPrimitive]()` em si; JavaScript automaticamente o invoca quando encontra um objeto onde um valor primitivo é esperado.

Exemplos
--------

### Retornando primitivos de data

```js
const testDate = new Date(1590757517834);
// "Date Fri May 29 2020 14:05:17 GMT+0100 (British Summer Time)"

testDate[Symbol.toPrimitive]("string");
// Returns "Date Fri May 29 2020 14:05:17 GMT+0100 (British Summer Time)"

testDate[Symbol.toPrimitive]("number");
// Returns "1590757517834"

testDate[Symbol.toPrimitive]("default");
// Returns "Date Fri May 29 2020 14:05:17 GMT+0100 (British Summer Time)"
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype-@@toprimitive |

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Symbol.toPrimitive`


Date.prototype.getMonth() - JavaScript

Date.prototype.getMonth()
=========================

O método **`getMonth()`** retorna o mês na data especificada de acordo com o horário local, como um valor zero-based (onde o zero indica o primeiro mês do ano).

Sintaxe
-------
```

dateObj.getMonth()
```

### Parâmetros

Nenhum.

### Retorno

O valor retornado pelo método `getMonth()` é um inteiro entre 0 e 11. 0 corresponde a Janeiro, 1 a Fevereiro, e assim sucessivamente.

Exemplos
--------

### Usando o `getMonth()`

A segunda declaração abaixo atribui o valor 11 à variavel `month`, baseado no valor do objeto `Date` `Xmas95`.

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

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

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCMonth()`
* `Date.prototype.setMonth()`


Date.prototype.setUTCSeconds() - JavaScript

Date.prototype.setUTCSeconds()
==============================

O método **`setUTCSeconds()`** atribui os segundos para a data especificada de acordo com o horário universal.

Experimente
-----------

Sintaxe
-------
```

dateObj.setUTCSeconds(secondsValue[, msValue])
```

### Parâmetros

`secondsValue`

Um inteiro entre 0 e 59, representando os segundos.

`msValue`

Opcional. Um número entre 0 e 999, representando os milissegundos.

### Valor de retorno

O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se você não especifica o parâmetro `msValue`, o valor retornado pelo método `getUTCMilliseconds()` é utilizado.

Se o parâmetro que você especificou está fora do alcance esperado, `setUTCSeconds()` tentará atualizar a informação da data no objeto `Date`. Por exemplo, se você usar 100 para `secondsValue`, os minutos guardados no objeto `Date` irá ser incrementado em 1, e 40 será usado para os segundos.

Exemplos
--------

### Usando `setUTCSeconds()`

```js
var theBigDay = new Date();
theBigDay.setUTCSeconds(20);
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCSeconds()`
* `Date.prototype.setSeconds()`


Date.prototype.getUTCHours() - JavaScript

Date.prototype.getUTCHours()
============================

O método **`getUTCHours()`** retorna o número de horas na data especificada de acordo com o horário universal (UTC).Experimente
-----------

Sintaxe
-------
```

dateObj.getUTCHours()
```

### Valor retornado

Um número inteiro, entre 0 e 23, representando as horas em uma data de acordo com o horário universal (UTC).

Exemplos
--------

### Usando `getUTCHours()`

O exemplo a seguir atribui a porção de horas do horário corrente à variável `hours`.

```js
var today = new Date();
var hours = today.getUTCHours();
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getHours()`
* `Date.prototype.setUTCHours()`


Date.prototype.getSeconds() - JavaScript

Date.prototype.getSeconds()
===========================

O método **`getSeconds()`** retorna os segundos de uma data específica de acordo com o horário local.

Sintaxe
-------
```

dateObj.getSeconds()
```

### Retorna

Um número inteiro, entre 0 e 59, representando os segundos de uma data específica de acordo com o horário local.

Exemples
--------

### Usando o `getSeconds()`

The second statement below assigns the value 30 to the variable `seconds`, based on the value of the `Date` object `Xmas95`.

No exemplo a seguir, a segunda linha atribui o valor 30 à variável `seconds`, baseado no valor do objeto `Date` `Xmas95`.

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

console.log(seconds); // 30
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCSeconds()`
* `Date.prototype.setSeconds()`


Date.prototype.toJSON() - JavaScript

Date.prototype.toJSON()
=======================

O método **`toJSON()`** retorna uma representação representation do objeto `Date` como string.

Experimente
-----------

Sintaxe
-------
```

dateObj.toJSON()
```

### Retorno

Uma representação da data como string.

Descrição
---------

Instâncias de `Date` referem-se a um específico ponto no tempo. Invocar `toJSON()` retorna uma string (usando `toISOString()`) representando o valor do objeto `Date`. Por padrão este método é destinado a serializar objetos `Date` em serializações JSON.

Exemplos
--------

### Usando `toJSON()`

```js
var jsonDate = new Date().toJSON();
var backToDate = new Date(jsonDate);

console.log(jsonDate); //2015-10-26T07:46:36.611Z
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.toLocaleDateString()`
* `Date.prototype.toTimeString()`
* `Date.prototype.toUTCString()`


Date.prototype.setUTCFullYear() - JavaScript

Date.prototype.setUTCFullYear()
===============================

O método **`setUTCFullYear()`** atribui o ano completo na data especificada de acordo com o horário universal.

Experimente
-----------

Sintaxe
-------
```

dateObj.setUTCFullYear(yearValue[, monthValue[, dayValue]])
```

### Parâmetros

`yearValue`

Um inteiro especificando o valor numérico do ano, por exemplo, 1995.

`monthValue`

Opcional. Um inteiro entre 0 e 11 representando os meses Janeiro até Dezembro.

`dayValue`

Opcional. Um inteiro entre 1 e 31 representando o dia do mês. Se você especificar o parâmetro `dayValue`, vocẽ deve especificar `monthValue` também.

### Valor de retorno

O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se você não especificar os parâmetros `monthValue` e `dayValue`, os valores retornados dos métodos `getUTCMonth()` e `getUTCDate()` serão utilizados.

Se um parâmetro que você especificou está fora do alcance esperado, `setUTCFullYear()` tentará atualizar os outros parâmetros e a informação da data no objeto `Date`. Por exemplo, se você especificar 15 para o `monthValue`, o ano será incrementado em 1 (`yearValue + 1`), e 3 será usado para o mês.

Exemplos
--------

### Usando `setUTCFullYear()`

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

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCFullYear()`
* `Date.prototype.setFullYear()`


Date.prototype.setTime() - JavaScript

Date.prototype.setTime()
========================

O método **`setTime()`** atribui ao objecto `Date` a hora representada pelo número de milisegundos desde 1 de janeiro de 1970 as 00:00:00 UTC.Experimente
-----------

Sintáxe
-------
```

dateObj.setTime(timeValue)
```

### Parâmetros

`timeValue`

Um inteiro representando o número de milisegundos desde 1 de janeiro 1970, 00:00:00 UTC.

### Valor retornado

O número de milisegundos entre 1 de janeiro de 1970 00:00:00 UTC e a data atualizada (efetivamente, o valor do argumento).

Descrição
---------

Use o método `setTime()` para ajudar a atribuir data e hora para outro objeto `Date`.

Exemplos
--------

### Usando `setTime()`

```js
var theBigDay = new Date("July 1, 1999");
var sameAsBigDay = new Date();
sameAsBigDay.setTime(theBigDay.getTime());
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getTime()`
* `Date.prototype.setUTCHours()`


Date.prototype.toString() - JavaScript

Date.prototype.toString()
=========================

O método **`toString()`** retorna uma cadeia de caracteres (*string*) representando o objeto `Date` especificado.

Experimente
-----------

Sintaxe
-------
```

dateObj.toString()
```

### Valor de retorno

Uma *string* representando a data.

Descrição
---------

Instâncias de `Date` herdam o método `toString()` de `Date.prototype` (en-US), não `Object.prototype` (en-US). `Date.prototype.toString()` retorna uma *string* com a representação de Date no formato especificado na ECMA-262 que pode ser resumida como:

* Dia da semana: 3 letras do nome do dia da semana em Inglês, e.g. "Sat"
* espaço
* Nome do mês: 3 letras do nome do mês em Inglês, e.g. "Sep"
* espaço
* Dia: Dia do mês em 2 dígitos, e.g. "01"
* espaço
* Ano: Ano no formato de 4 dígitos, e.g. "2018"
* espaço
* Hora: Hora do dia em 2 dígitos, e.g. "14"
* dois-pontos
* Minuto: Minutos da hora em 2 dígitos, e.g. "53"
* dois-pontos
* Segundos: Segundos do minuto em 2 dígitos, e.g. "26"
* espaço
* A *string* "GMT"
* Sinal do deslocamento do fuso horário, pode ser:
    + "+" para deslocamentos positivos (0 ou maior)
    + "-" para deslocamentos negativos (menores que 0)
* Dois dígitos da hora do deslocamento, e.g. "14"
* Dois dígitos dos minutos do deslocamento, e.g. "00"
* Opcionalmente, um nome de fuso horário consistindo de:
    + espaço
    + parênteses esquerdo, i.e. "("
    + Uma representação de *string* dependente da implementação do fuso horário, que pode ser uma abreviação ou o nome completo (não há um padrão para nomes ou abreviação de fusos horários), e.g. "Line Islands Time" ou "LINT"
    + parênteses direito, i.e. ")"

E.g. "Sat Sep 01 2018 14:53:26 GMT+1400 (LINT)"

Até o ECMAScript 2018 (edição 9), o formato da *string* retornada pelo `Date.prototype.toString` era dependente da implementação. Portanto, não se deve confiar que ela está no formato especificado.

O método `toString()` é automaticamente chamado quando a data deve ser representada como texto, e.g. `console.log(new Date())`, ou quando a data é utilizada em uma concatenação de *string*, como `var today = 'Today is ' + new Date()`.

`toString()` é um método genérico, ele não requer que seu `this` seja uma instância de `Date`. Entretanto, ele deve ter uma propriedade interna `[[TimeValue]]` que não pode ser construída usando JavaScript nativo, então ela é efetivamente limitada a ser usada com instâncias `Date`. Se chamado em uma instância que não seja Date, um `TypeError` é jogado.

Exemplos
--------

### Usando `toString()`

O exemplo asseguir atribui o valor de `toString()` de um objeto `Date` para `myVar`:

```js
var x = new Date();
var myVar = x.toString(); // atribui uma string em myVar no mesmo formato que este:
// Mon Sep 08 1998 14:36:22 GMT-0700 (PDT)
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Object.prototype.toString()`
* `Date.prototype.toDateString()`
* `Date.prototype.toLocaleString()` (en-US)
* `Date.prototype.toTimeString()`


Date.prototype.setHours() - JavaScript

Date.prototype.setHours()
=========================

O método **`setHours()`** atribui as horas para uma data especificada de acordo com a hora local e retorna o número de milissegundos desde do dia 1 de Janeiro de 1970 00:00:00 UTC até o tempo representado pela instância `Date` atualizada.

Experimente
-----------

Sintaxe
-------
```

dateObj.setHours(hoursValue[, minutesValue[, secondsValue[, msValue]]])
```

### Versões anteriores ao JavaScript 1.3
```

dateObj.setHours(hoursValue)
```

### Parâmetros

`hoursValue`

Idealmente, um número inteiro entre 0 e 23, representando a hora. Se um valor maior que 23 for fornecido, a data e hora será incrementada pelas horas extras.

`minutesValue`

Opcional. Idealmente, um número inteiro entre 0 e 59, representando os minutos. Se um valor maior que 59 for fornecido, a data e hora será incrementada em minutos extras.

`secondsValue`

Opcional. Idealmente, um número inteiro entre 0 e 59, representando os segundos. Se um valor maior que 59 for fornecido, a data e hora será incrementada em segundos extras. Se você especificar o parâmetro `secondsValue`, também deverá especificar parâmetro `minutesValue`.

`msValue`

Opcional. Idealmente, um número entre 0 e 999, representando os milissegundos. Se um valor maior que 999 for fornecido, a data e hora será incrementada em milissegundos extras. Se você especificar o parâmetro `msValue`, você também deve especificar `minutesValue` e `secondsValue`.

### Valor de retorno

O número de milissegundos entre dia 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se você não especifica os parâmetros `minutesValue`, `secondsValue`, e `msValue`, os valores retornados dos métodos `getMinutes()`, `getSeconds()`, e `getMilliseconds()` são usados.

Se um parâmetro que você especificar estiver fora do intervalo esperado, `setHours()` tenta atualizar as informações de data no objeto `Date`. Por exemplo, se você usa 100 para `secondsValue`, os minutos serão incrementados em 1 (`minutesValue + 1`), e 40 serão usados para os segundos.

Exemplos
--------

### Usando `setHours()`

```js
var theBigDay = new Date();
theBigDay.setHours(7);
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getHours()`
* `Date.prototype.setUTCHours()`


Date.prototype.getYear() - JavaScript

Date.prototype.getYear()
========================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

Resumo
------

O método **`getYear()`** retorna o ano especificado pela data de acordo com a hora local. Por conta do fato de que `getYear()` não retorna anos completos ("problema do ano 2000"), este método não é mais utilizado e foi substituido pelo método `getFullYear()`.

Sintaxe
-------
```

dateObj.getYear()
```

### Parâmetros

Nenhum.

### Retorna

O método `getYear()` retorna o ano menos 1900; então:

* Para ano maior ou igual a 2000, o valor retornado por `getYear()` é 100 ou mais. Por exemplo, se o ano for 2026, `getYear()` retorna 126.
* Para ano entre e incluindo 1900 e 1999, o valor retornado por `getYear()` é entre 0 e 99. Por exemplo, se o anor for 1976, `getYear()` retorna 76.
* Para ano menor que 1900, o valor retornado por `getYear()` é menor que 0. Por exemplo, se o ano for 1800, `getYear()` retorna -100.

Para levar em consideração anos antes e depois de 2000, você deve utilizar `getFullYear()` ao invés de `getYear()` para que o ano seja especificado por completo.

Retrocombatibilidade
--------------------

### Comportamento em JavaScript 1.2 e anteriores

O método `getYear()` retorna um ano de 2 ou 4 dígitos:

* Para anos entre e incluindo 1900 e 1999, o valor retornado por `getYear()` é o ano menos 1900. Por exemplo, se o ano é 1976, o valor retornado é 76.
* Para anos menores que 1900 ou maiores que 1999, o valor retornado por `getYear()` é um ano de 4 dígitos. Por exemplo, se o ano é 1856, o valor retornado é 1856. Se o ano é 2026, o valor retornado é 2026.
Exemplos
--------

### Exemplo: Anos entre 1900 e 1999

O segundo statement atribui o valor 95 à variável `year`.

```js
var Xmas = new Date("December 25, 1995 23:15:00");
var year = Xmas.getYear(); // returns 95
```

### Exemplo: Anos depois de 1999

O segundo statement atribui o valor 100 à variável `year`.

```js
var Xmas = new Date("December 25, 2000 23:15:00");
var year = Xmas.getYear(); // returns 100
```

### Exemplo: Anos antes de 1900

O segundo statement atribui o valor -100 à variável `year`.

```js
var Xmas = new Date("December 25, 1800 23:15:00");
var year = Xmas.getYear(); // returns -100
```

### Exemplo: Setando e recuperando um ano entre 1900 e 1999

O segundo statement atribui o valor 95 à variável `year`, representanto o ano 1995.

```js
var Xmas.setYear(95);
var year = Xmas.getYear(); // returns 95
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getFullYear()`
* `Date.prototype.getUTCFullYear()`
* `Date.prototype.setYear()`


Date.prototype.setUTCMinutes() - JavaScript

Date.prototype.setUTCMinutes()
==============================

O método **`setUTCMinutes()`** atribui os minutos para uma data específica de acordo com o horário universal.

Experimente
-----------

Sintaxe
-------
```

dateObj.setUTCMinutes(minutesValue[, secondsValue[, msValue]])
```

### Parâmetros

`minutesValue`

Um inteiro entre 0 e 59, representando os minutos.

`secondsValue`

Opcional. Um inteiro entre 0 e 59, reprensentando os segundos. Se vocẽ especificar o parâmetro `secondsValue`, você também deve especificar `minutesValue`.

`msValue`

Opcional. Um número entre 0 e 999, representando os milissegundos. Se você especificar o parâmetro `msValue`, você também deve especificar `minutesValue` e `secondsValue`.

### Valor de retorno

O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se vocẽ não especificar os parâmetros `secondsValue` e `msValue`, os valores retornados dos métodos `getUTCSeconds()` e `getUTCMilliseconds()` são utilizados.

Se o parâmetro que você especificou estiver fora do alcance esperado, `setUTCMinutes()` tentará atualizar a informação da data no objeto `Date`. Por exemplo, se você usar 100 para `secondsValue`, os minutos serão incrementados em 1 (`minutesValue + 1`), e 40 será usado para os segundos.

Exemplos
--------

### Usando `setUTCMinutes()`

```js
var theBigDay = new Date();
theBigDay.setUTCMinutes(43);
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCMinutes()`
* `Date.prototype.setMinutes()`


Date.prototype.setYear() - JavaScript

Date.prototype.setYear()
========================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método **`setYear()`** atribui o ano para a data especificada de acordo com o horário local. Devido `setYear()` não colocar o anos cheios ("problema do ano 2000"), ele não é mais utilizado e foi substituído pelo método `setFullYear()`.

Sintaxe
-------
```

dateObj.setYear(yearValue)
```

### Parâmetros

`yearValue`

Um inteiro.

### Valor de retorno

O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se `yearValue` é um número entre 0 e 99 (inclusivo), então o ano para `dateObj` é atribuido para `1900 + yearValue`. Caso contrário, o ano para `dateObj` é atribuido para `yearValue`.

Exemplos
--------

### Usando `setYear()`

As duas primeiras linhas atribuem o ano para 1996. O terceiro atribui o ano para 2000.

```js
var theBigDay = new Date();

theBigDay.setYear(96);
theBigDay.setYear(1996);
theBigDay.setYear(2000);
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getFullYear()`
* `Date.prototype.getUTCFullYear()`
* `Date.prototype.setFullYear()`
* `Date.prototype.setUTCFullYear()`


Date.UTC() - JavaScript

Date.UTC()
==========

O método **`Date.UTC()`** aceita os mesmos parâmetros que o construtor mais longo de **`Date`** e retorna o total de milisegundos desde 1º de Janeiro de 1970 às 00:00:00 (horário universal). O valor retornado por **`Date.UTC()`** pode ser usado como parâmetro para criar uma instância de `Date`.

Sintaxe
-------
```

Date.UTC(ano, mês[, dia[, hora[, minuto[, segundo[, milisegundo]]]]])
```

### Parâmetros

`ano`

Um valor inteiro representando o ano, após 1970.

`mês`

Um valor inteiro que representa o mês, começando com 0 para Janeiro até 11 para Dezembro.

`dia`

Opcional. Um valor inteiro entre 1 e 31 representando o dia do mês.

`hora`

Opcional. Um valor inteiro entre 0 e 23 representando a hora do dia.

`minuto`

Opcional. Um valor entre 0 e 59 representando os minutos.

`segundo`

Opcional. Um valor entre 0 e 59 representando os segundos.

`milisegundo`

Opcional. Um valor entre 0 e 999 representando os milisegundos.

Descrição
---------

**`UTC()`** recebe argumentos de uma data separados por vírgula e retorna um número representando o total de milisegundos entre o dia 1º de Janeiro de 1970 às 00:00:00 (horário universal) e a data e hora que você especificou.

Você deve especificar o ano completo para o argumento ano. Por exemplo, 1998. Se o ano fornecido for um valor entre 0 e 99 o método irá converter este valor para o século 20 (1900 + ano); Por exemplo, se você utilizar 95, então o ano 1995 será utilizado.

O método `UTC()` se diferencia do construtor de `Date` de duas maneiras:

* `Date.UTC()` utiliza o horário universal em vez do horário local.
* `Date.UTC()` retorna um valor inteiro em vez de uma instância de `Date`.

Se você fornecer um argumento fora do intervalo esperado, o método UTC() atualiza os demais argumentos para permitir este valor. Por exemplo, se você utilizar 15 para mês, será adicionado 1 ao argumento ano (ano + 1) e será utilizado 3 para o argumento mês.

`UTC()` é um método estático, por conta disto você sempre irá chamar `Date.UTC()` em vez de chamar um método de um objeto `Date` que você tenha criado.

Exemplos
--------

### Utilizando `Date.UTC()`

A seguinte expressão cria uma instância de `Date` utilizando UTC em vez do horário local:
```

var dataUniversal = new Date(Date.UTC(96, 11, 1, 0, 0, 0));
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.utc |

Compatibilidade com navegadores
-------------------------------

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

Veja Também
-----------

* `Date.parse()`


Date.prototype.setSeconds() - JavaScript

Date.prototype.setSeconds()
===========================

O método **`setSeconds()`** atribui os segundos na data especificada de acordo com o tempo local.

Experimente
-----------

Sintaxe
-------
```

dateObj.setSeconds(secondsValue[, msValue])
```

### Versões anteriores ao JavaScript 1.3
```

dateObj.setSeconds(secondsValue)
```

### Parâmetros

`secondsValue`

Um inteiro entre 0 e 59, representando os segundos.

`msValue`

Opcional. Um número entre 0 e 999, representando os milissegundos.

### Valor de retorno

O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se você não especifica o parâmetro `msValue`, o valor retornado do método `getMilliseconds()` é utilizado.

Se um parâmetro que você especificou está fora do alcance esperado, `setSeconds()` tentará atualizar a informação da data no objeto `Date`. Por exemplo, se você usar 100 para `secondsValue`, os minutos guardados no objeto `Date` serão incrementados em 1, e 40 serão usados para os segundos.

Exemplos
--------

### Usando `setSeconds()`

```js
var theBigDay = new Date();
theBigDay.setSeconds(30);
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getSeconds()`
* `Date.prototype.setUTCSeconds()`


Date.prototype.getUTCMonth() - JavaScript

Date.prototype.getUTCMonth()
============================

A função **`getUTCMonth()`** retorna o mês da data especificada de acordo com o horário universal, como um valor iniciado em zero (aonde zero indica o primeiro mês do ano).

Sintaxe
-------
```

dateObj.getUTCMonth()
```

### Valor retornado

Um número inteiro, entre 0 e 11, correspondente ao mês da data informada de acordo com o horário universal. 0 para Janeiro, 1 para Fevereiro, 2 para Março, e assim em diante.

Exemplos
--------

### Usando `getUTCMonth()`

O exemplo a seguir atribui a parte do mês da data atual a variável `month`.

```js
var today = new Date();
var month = today.getUTCMonth();
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getMonth()`
* `Date.prototype.setUTCMonth()`


Date.prototype.setFullYear() - JavaScript

Date.prototype.setFullYear()
============================

O método **`setFullYear()`** atribui o ano completo para a data especificada de acordo com o horário universal (UTC). Retorna uma nova data e hora.

Experimente
-----------

Sintaxe
-------
```

dateObj.setFullYear(yearValue[, monthValue[, dateValue]])
```

### Parâmetros

`yearValue`

Um inteiro especificando o valor número de um ano, por exemplo, 1995.

`monthValue`

Opcional. Um inteiro entre 0 e 11 representando os meses Janeiro até Dezembro.

`dateValue`

Opcional. Um inteiro entre 1 e 31 representando o dia do mês. Se você especificar o parâmetro `dateValue`, você deve também especificar `monthValue`.

### Valor retornado

O número de milisegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.

Descrição
---------

Se você não especificar os parâmetros `monthValue` e `dateValue`, os valores retornados dos métodos `getMonth()` e `getDate()` são usados.

Se um parâmetro que você especificou está fora do alcance esperado, `setFullYear()` tenta atualizar os outros parâmetros e a informação de data no objeto `Date` adequadamente. Por exemplo, se você especificar 15 para o `monthValue`, o ano será incrementado em 1 (`yearValue + 1`), e 3 é usado para o mês.

Exemplos
--------

### Usando `setFullYear()`

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

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getUTCFullYear()`
* `Date.prototype.setUTCFullYear()`
* `Date.prototype.setYear()`


Date.prototype.getUTCSeconds() - JavaScript

Date.prototype.getUTCSeconds()
==============================

O método **`getUTCSeconds()`** retorna os segundos na data informada de acordo com a hora universal.

Experimente
-----------

Sintaxe
-------
```

dateObj.getUTCSeconds()
```

### Valor de retorno

Um número inteiro, entre 0 e 59, representando os segundos da data informada de acordo com a hora universal.

Exemplos
--------

### Usando `getUTCSeconds()`

The following example assigns the seconds portion of the current time to the variabl

O exemplo a seguir atribui a parte dos segundos da hora atual à variável `seconds`.

```js
var today = new Date();
var seconds = today.getUTCSeconds();
```

Especificações
--------------

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

Compatibilidade com navegadores
-------------------------------

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

Veja também
-----------

* `Date.prototype.getSeconds()`
* `Date.prototype.setUTCSeconds()`