Console API - APIs da Web

Console API
===========

O Console API traz funcionalidades que permitem desenvolvedores realizar tarefas de debug, como registrar mensagens or os valores das variáveis em sertoes pontos do código, or cronometrar quanto tempo uma operação leva para concluir.

Conceitos e uso
---------------

O Console API começou como uma API proprietária, com diferentes navegadores a implementando. A especificação do Console API foi criado para definir um comportamento consistente, e todos o navegadores atuais ventualmente foram implementando a funconalidade — Apsar de algumas implementações ainda terem funções adicionais proprietárias. Veja mais sobre isso em:

* Google Chrome DevTools implementação
* Safari DevTools implementação

Uso é bastante simples — o objeto `console` — disponível via `window.console` (en-US), ou `WorkerGlobalScope.console` (en-US) em workers; acessível apenas usando `console` — contém vários métodos que você pode chamar para executar tarefas de depuração, geralmente focado no registro de vários valores no navegador Web Console.

De longe o método mais comum usado é o `console.log`, que é usado para mostrar o valor atual contido em uma variável específica.

Interfaces
----------

`console`

Provides rudimentary debugging functionality, including logging, stack traces, timers, and counters.

Examples
--------

```js
let myString = "Hello world";

// Output "Hello world" to the console
console.log(myString);
```

See the Console reference page for more examples.

Specifications
--------------

| Specification |
| --- |
| Console Standard # console-namespace |

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

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

See also
--------

* Tools
* Web Console — how the Web Console in Firefox handles console API calls
* Remote debugging — how to see console output when the debugging target is a mobile device


Notificações - APIs da Web

Notificações
============

**Note:** This feature is available in Web Workers

**Secure context:** This feature is available only in secure contexts (en-US) (HTTPS), in some or all supporting browsers.

A interface da API de Notificações (en-US) é usada para configurar e exibir notificações na área de trabalho do usuário. A aparência e algumas funcionalidades específicas das notificações variam entre as plataformas mas geralmente eles fornecem uma forma assíncrona de prover informações para o usuário.

Construtor
----------

`Notification()` (en-US)

Cria uma nova instancia do objeto `Notification`.

Propriedades
------------

### Propriedades estáticas

Estas propriedades estão disponíveis apenas no próprio objeto `Notification`.

`Notification.permission` (en-US) Somente leitura

Uma sequência de caracteres que representa a permissão atual para exibir notificações. Valor possíveis são: "denied" (o usuário se recusa a ter notificações exibidas), "granted" (o usuário aceita ter notificações exibidas) ou "default" (a escolha do usuário é desconhecido e, portanto, o navegador irá agir como se o valor foram negados).

### Propriedades da instância

Estas propriedades estão disponíveis apenas em instâncias do objeto `Notification`.

`Notification.title` (en-US) Somente leitura

Retorna o título da notificação conforme foi definido no parâmetro opções do construtor.

`Notification.dir` (en-US) Somente leitura

A direção do texto da notificação, conforme especificado no parâmetro opções do construtor.

`Notification.lang` (en-US) Somente leitura

O código de idioma da notificação, conforme especificado no parâmetro opções do construtor.

`Notification.body` (en-US) Somente leitura

O corpo(mensagem) da notificação, conforme especificado no parâmetro opções do construtor.

`Notification.tag` (en-US) Somente leitura

O ID da notificação (se houver), conforme especificado no parâmetro opções do construtor.

`Notification.icon` (en-US) Somente leitura

A URL da imagem usada como um ícone da notificação, conforme especificado no parâmetro opções do construtor.

`Notification.data` (en-US) Somente leitura

Retorna um clone estruturado de dados da notificação.

`Notification.silent` (en-US) Somente leitura

Especifica se a notificação deve ser silenciosa, ou seja, sons ou vibrações não devem ser emitidos, independentemente das configurações do dispositivo.

#### Propriedades não suportadas

As propriedades a seguir estão listados na especificação mais up-to-date, mas não são suportadas em quaisquer navegadores ainda. É aconselhável manter a verificação de volta regularmente para ver se o status destes actualiza, e deixe-nos saber se você encontrar qualquer informações desatualizadas.

`Notification.noscreen` Somente leitura

Especifica se o disparo notificação deve permitir que a tela do dispositivo ou não.

`Notification.renotify` (en-US) Somente leitura

Especifica se o usuário deve ser notificado após uma nova notificação substitui um antigo.

`Notification.sound` Somente leitura

Especifica um recurso de som para reproduzir durante o disparo da notificação, em vez do som de notificação do sistema padrão.

`Notification.sticky` Somente leitura

Especifica se a notificação deve ser "fixa", ou seja, não facilmente eliminável pelo usuário.

`Notification.vibrate` (en-US) Somente leitura

Especifica um padrão de vibração para dispositivos com hardware de vibração.

#### Manipuladores de Eventos

`Notification.onclick` (en-US)

O manipulador para o evento `click (en-US)` é acionado cada vez que o usuário clica sobre a notificação.

`Notification.onerror` (en-US)

O manipulador para o evento `error (en-US)` é acionado quando a notificação encontra um erro.

#### Manipuladores Obsoletos

Os seguintes manipuladores de eventos ainda são suportados, conforme listado na seção browser compatibility. Estes serão listados abaixo, mas não são listados na especificação atual. Saiba que eles são obsoletos, e pode parar de funcionar em versões futuras do navegador.

`Notification.onclose` (en-US)

Manipulador do evento `close` é acionado quando a notificação é fechada.

`Notification.onshow` (en-US)

Manipulador do evento `show`. é acionado quando a notificação é exibida.

Métodos
-------

### Métodos Estáticos

Estes métodos estão disponíveis apenas no próprio objeto `Notification`.

`Notification.requestPermission()` (en-US)

Solicita a permissão do usuário para exibir notificações.

### Métodos de instância

Estas propriedades estão disponíveis apenas no objeto Notification ou através do seu `prototype`. O objeto de notificação também herda a interface `EventTarget`.

`Notification.close()` (en-US)

Programaticamente fecha uma notificação.

Exemplos
--------

Leve em conta este HTML básico:

```html
<button onclick="notifyMe()">Notifique me!</button>
```

É possível enviar uma notificação da seguinte forma - aqui nós apresentamos um conjunto bastante detalhado e completo de código que você pode usar se você quiser verificar primeiro se as notificações são suportados, em seguida, verifique se a permissão foi concedida para a origem atual para enviar notificações, em seguida, solicitar permissão, se necessário, antes, em seguida, enviar uma notificação.

```js
function notifyMe() {
  // Verifica se o browser suporta notificações
  if (!("Notification" in window)) {
    alert("Este browser não suporta notificações de Desktop");
  }

  // Let's check whether notification permissions have already been granted
  else if (Notification.permission === "granted") {
    // If it's okay let's create a notification
    var notification = new Notification("Hi there!");
  }

  // Otherwise, we need to ask the user for permission
  else if (Notification.permission !== "denied") {
    Notification.requestPermission(function (permission) {
      // If the user accepts, let's create a notification
      if (permission === "granted") {
        var notification = new Notification("Hi there!");
      }
    });
  }

  // At last, if the user has denied notifications, and you
  // want to be respectful there is no need to bother them any more.
}
```

Em muitos casos, você não precisa estar presente detalhado. Por exemplo, na nosso Emogotchi demo (veja o código fonte), basta simlesmente executar `Notification.requestPermission` (en-US) independentemente de se certificar de que pode obter permissão para enviar notificações:

```js
Notification.requestPermission();
```

Em seguida executar um simples `spawnNotification()` quando queremos disparar uma notificação — este é passado argumentos para especificar o, ícone corpo e título que queremos, então ele cria as opções necessárias objeto e dispara a notificação usando o construtor `Notification()` (en-US).

```js
function spawnNotification(corpo, icone, titulo) {
  var opcoes = {
    body: corpo,
    icon: icone,
  };
  var n = new Notification(titulo, opcoes);
}
```

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

| Specification |
| --- |
| Notifications API Standard # api |

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

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

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

* Usando a API de Notificações (en-US)


WindowBase64.atob() - APIs da Web

WindowBase64.atob()
===================

A função **`WindowBase64.atob()`** decodifica uma string de dados que foi codificada através da codificação base-64. Você pode usar o método `window.btoa()` (en-US) para codificar e transmitir dados que, se não codificados, podem causar problemas de comunicação. Após transmití-los pode-se usar o método `window.atob()` para decodificar os dados novamente. Por exemplo, você pode codificar, transmitir, e decodificar caracteres de controle como valores ASCII de 0 a 31.

Para utilizar com strings Unicode ou UTF-8, veja esta nota em *Base64 encoding and decoding* (en-US) e essa nota em `window.btoa()` (en-US).

Sintaxe
-------
```

var dadoDecodificado = window.atob(dadoCodificado);
```

Exemplo
-------

```js
var dadoCodificado = window.btoa("Olá, mundo"); // codifica a string
var dadoDecodificado = window.atob(dadoCodificado); // decodifica a string
```

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

| Specification |
| --- |
| HTML Standard # dom-atob-dev |

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

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

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

* Base64 encoding and decoding (en-US)
* `data` URIs (en-US)
* `window.btoa()` (en-US)
* Components.utils.importGlobalProperties


Encoding API - APIs da Web

Encoding API
============

**Experimental:** **Esta é uma tecnologia experimental (en-US)**
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

O **Encoding API** providência uma mecânismo para tratar textos em vários tipos de encode de caracteres, incluindo encodes legados non-UTF-8

A API provém de quatro interfaces: `TextDecoder` (en-US), `TextEncoder` (en-US), `TextDecoderStream` (en-US) e `TextEncoderStream` (en-US).

Interfaces
----------

* `TextDecoder` (en-US)
* `TextEncoder` (en-US)
* `TextDecoderStream` (en-US)
* `TextEncoderStream` (en-US)
Tutoriais & ferramentas
-----------------------

* O shim permite usar essa interface em navegadores que não a suportam.
* `StringView` – Um C-like reperesentação de strings baseados em arrays tipados
Especificações
--------------

| Specification |
| --- |
| Encoding Standard # interface-textdecoder |
| Encoding Standard # interface-textencoder |
| Encoding Standard # interface-textencoderstream |
| Encoding Standard # interface-textdecoderstream |

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

### api.TextDecoder

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

### api.TextEncoder

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

### api.TextEncoderStream

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

### api.TextDecoderStream

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


DocumentoXML - APIs da Web

DocumentoXML
============

**Experimental:** **Esta é uma tecnologia experimental (en-US)**
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

A interface **XMLDocument** representa um document XML. Ele herda de `Document` e não adiciona nenhum método específico ou propriedades para este: no entanto, alguns algoritmos tem comportamento diferente com os dois tipos de documentos.

Propridades
-----------

*Esta interface não tem e nem herda nenhuma propriedade específica.*

Metodos
-------

*Esta interface não adiciona nenhum método novo.*

`XMLDocument.load()` (en-US)
Non-standard

Deprecated

Carrega um documento XML

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

| Specification |
| --- |
| DOM Standard # xmldocument |

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

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

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

* Indice de interfaces DOM (en-US)


Response - APIs da Web

Response
========

A interface **`Response`** da Fetch API representa a resposta para uma requisição.

Você pode criar um novo objeto `Response` usando o construtor `Response.Response()` (en-US), porém é mais provável você encontrar um objeto Response sendo retornado como o resultado de uma outra operação da API, por exemplo um service worker `Fetchevent.respondWith` (en-US), ou um simples `GlobalFetch.fetch()` (en-US).

Construtor
----------

`Response()` (en-US)

Cria um novo objeto `Response`.

Propriedades
------------

`Response.headers` (en-US) Somente leitura

Contém o objeto `Headers` (en-US) associado à resposta.

`Response.ok` (en-US) Somente leitura

Contém um valor booleano indicando se a resposta foi bem sucedida ("status" no intervalo 200-299) ou não.

`Response.redirected` (en-US) Somente leitura

Indica se a resposta é ou não o resultado de um redirecionamento; isto é, sua lista de URL tem mais de uma entrada.

`Response.status` (en-US) Somente leitura

Contém o código de "status" da resposta (ex., `200` para um sucesso).

`Response.statusText` (en-US) Somente leitura

Contém a mensagem de "status" correspondente ao código de "status" (ex., `OK` para `200`).

`Response.type` (en-US) Somente leitura

Contém o tipo da resposta (ex., `basic`, `cors`).

`Response.url` (en-US) Somente leitura

Contém a URL de resposta.

`Response.useFinalURL`

Contém um valor boleano indicando se essa é a URL final da resposta.

`Response` implementa `Body`, por isso também tem as seguintes propriedades disponíveis:

`Body.body` (en-US) Somente leitura

Um simples "getter" para ler do conteúdo do corpo através da interface `ReadableStream` (en-US).

`Body.bodyUsed` (en-US) Somente leitura

Armazena um `Boolean` (en-US) que indica se o corpo já foi utilizado em uma resposta.

Métodos
-------

`Response.clone()` (en-US)

Cria uma cópia do objeto `Response`.

`Response.error()` (en-US)

Retorna um novo objeto `Response` associado a um erro de rede.

`Response.redirect()` (en-US)

Cria uma nova resposta com uma URL diferente.

`Response` implementa `Body`, por isso também tem as seguintes propriedades disponíveis:

`Body.arrayBuffer()` (en-US)

Recebe um "stream" `Response` e lê até a conclusão. Retorna uma "promise" que resolve com um `ArrayBuffer`.

`Body.blob()` (en-US)

Recebe um "stream" `Response` e lê até a conclusão. Retorna uma "promise" que resolve com um `Blob`.

`Body.formData()` (en-US)

Recebe um "stream" `Response` e lê até a conclusão. Retorna uma "promise" que resolve com um objeto `FormData`.

`Body.json()` (en-US)

Recebe um "stream" `Response` e lê até a conclusão. Retorna uma "promise" que resolve com o resultado do parseamento do texto do corpo como `JSON`.

`Body.text()` (en-US)

Recebe um "stream" `Response` e lê até a conclusão. Retorna uma "promise" que resolve com um `USVString` (en-US) (texto).

Exemplos
--------

Em nosso exemplo básico fetch (executar exemplo live) nós usamos uma simples chamada `fetch()` para pegar uma imagem e exibi-la em uma tag `<img>`. A chamada `fetch()` retorna uma "promise", que resolve com o objeto `Response` associado com o recurso da operação "fetch". Você irá notar que como estamos solicitando uma imagem, nós precisamos executar `Body.blob` (en-US) (`Response` implementa o "body") para dar à resposta seu tipo MIME correto.

```js
var myImage = document.querySelector(".my-image");
fetch("flowers.jpg")
  .then(function (response) {
    return response.blob();
  })
  .then(function (blob) {
    var objectURL = URL.createObjectURL(blob);
    myImage.src = objectURL;
  });
```

Você também pode usar o construtor `Response.Response()` (en-US) para criar seu objeto `Response` personalizado:

```js
var myResponse = new Response();
```

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

| Specification |
| --- |
| Fetch Standard # response-class |

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

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

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

* ServiceWorker API (en-US)
* HTTP access control (CORS) (en-US)
* HTTP


Attr - APIs da Web

Attr
====

 Este tipo representa um atributo de elemento DOM como um objeto. Na maioria dos métodos DOM, você provavelmente irá retornar diretamente o atributo como uma string (e.g., `Element.getAttribute()`, mas certas funções (e.g., `Element.getAttributeNode()` (en-US)) ou meios de iteração retornam tipos `Attr`.

EventTarget

Node

Attr

**Aviso:** Começando no Gecko 7.0, os que serão removidos mostram mensagens de aviso no console. Você deve revisar seu código de acordo. Veja métodos e propriedades descontinuadas para uma lista completa.

Propriedades
------------

`name` (en-US) Somente leitura

O nome do Atributo.

`namespaceURI` (en-US) Somente leitura

Uma `DOMString` representando o namespace URI do atributo, ou `null` se não há namespace

`localName` Somente leitura

Uma `DOMString` representando a parte local do nome qualificado do atributo.

`prefix` (en-US) Somente leitura

Uma `DOMString` representando o prefixo do namespace do atributo ou `null` se nenhum prefixo foi especificado.

`ownerElement` (en-US) Somente leitura

O elemento que possui o atributo.

**Nota:** DOM Level 4 removeu esta propriedade. Foi suposto que como você recebe um objeto `Attr` de um `Element`, você já deve saber qual é o elemento associado.
 Como isto não é sempre verdadeiro em casos como objetos `Attr` sendo retornados pelo `Document.evaluate` (en-US), o DOM Living Standard reintroduziu a propriedade.

Gecko mostra uma mensagem de descontinuação começando no Gecko 7.0. Esta mensagem foi removida novamente no Gecko 49.0.

Propriedades e métodos descontinuados
-------------------------------------

As seguintes propriedades e métodos foram descontinuados. Quando disponíveis, são substituidas adequadamente.

`attributes`

Esta propriedade agora sempre retorna `NULL`.

`childNodes`

Esta propriedade agora sempre retorna `NULL`.

`firstChild`

Esta propriedade agora sempre retorna `NULL`.

`lastChild`

Esta propriedade agora sempre retorna `NULL`.

`nextSibling`

Esta propriedade agora sempre retorna `NULL`.

`nodeName`

Use `Attr.name` (en-US) no lugar.

`nodeType`

Esta propriedade agora sempre retorna 2 (`ATTRIBUTE_NODE`).

`nodeValue`

Use `Attr.value` (en-US) no lugar.

`ownerDocument`

Provavelmente você nunca utilizou isto, então você não se importa que isso vai desaparecer.

`ownerElement`

Desde que você obtenha o objeto `Attr` de um `Element`, você já conhece os elementos associados.

`parentNode`

Esta propriedade agora sempre retorna `NULL`.

`previousSibling`

Esta propriedade agora sempre retorna `NULL`.

`specified`

Esta propriedade agora sempre retorna `true`.

`textContent`

Use `Attr.value` (en-US) no lugar.

Os seguintes métodos foram reprovados:

`appendChild()`

Modifique o valor de `Attr.value` (en-US) no lugar.

`cloneNode()`

Provavelmente você nunca utilizou isto, então você não se importa que isso vai desaparecer.

`createAttribute()`

Use `Element.setAttribute()` no lugar.

`createAttributeNS()`

Use `Element.setAttributeNS()` no lugar.

`getAttributeNode()`

Use `Element.getAttribute()` no lugar.

`getAttributeNodeNS()`

Use `Element.getAttributeNS()` (en-US) no lugar.

`hasAttributes()`

Este método agora sempre retorna false.

`hasChildNodes()`

Este método agora sempre retorna false.

`insertBefore()`

Modifique o valor de `Attr.value` (en-US) no lugar.

`isEqualNode()`

Provavelmente você nunca utilizou isto, então você não se importa que isso vai desaparecer.

`normalize()`

Provavelmente você nunca utilizou isto, então você não se importa que isso vai desaparecer.

`removeAttributeNode()`

Use `Element.removeAttribute()` no lugar.

`removeChild()`

Modifique o valor de `Attr.value` (en-US) no lugar.

`replaceChild()`

Modifique o valor de `Attr.value` (en-US) no lugar.

`setAttributeNode()`

Use `Element.setAttribute()` no lugar.

`setAttributeNodeNS()`

Use `Element.setAttributeNS()` no lugar.

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

* Document Object Model Core level 3: Interface Attr
* Document Object Model 4: Interface Attr


CryptoKey - APIs da Web

CryptoKey
=========

A interface **`CryptoKey`** representa uma key criptografada derivada de uma key de algoritmo definido.

Um objeto **`CryptoKey`** pode ser obtido utilizando `SubtleCrypto.generateKey()`, `SubtleCrypto.deriveKey()` ou `SubtleCrypto.importKey()`

Propriedades
------------

*Esta interface não herda nehunha propriedade.*

`CryptoKey.type` (en-US)

Retorna um valor enumerado representando o tipo da key, uma key secreta (para algoritmos simétricos), uma key pública ou privada (para algoritmos assimétricos).

`CryptoKey.extractable` (en-US)

Retorna um `Boolean` indicando se a informação bruta pode ser exportada para a aplicação ou não.

`CryptoKey.algorithm` (en-US)

Retorna um objeto opaco representando uma cifra em particular que deve ser utilizada com a key.

`CryptoKey.usages` (en-US)

Retorna uma matriz de valores enumerados indicando onde a key pode ser utilizada.

Métodos
-------

*Esta interface não herda, nem implementa nenhum método.*

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

| Specification |
| --- |
| Web Cryptography API # cryptokey-interface |

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

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

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

* `Crypto` e `Crypto.subtle`.
### Dicionário

"Key" = "Chave"


SubtleCrypto - APIs da Web

SubtleCrypto
============

A interface **`SubtleCrypto`** representa um conjunto de criptografias primitivas. E está disponível via propriedades `Crypto.subtle` disponíveis em uma janela de contexto (via `Window.crypto`).

**Aviso:** Por especificação: "Desenvolvedores fazendo uso da interface SubtleCrypto devem estar cientes das preocupações associadas com o design e a implementação de vários algoritmos providos. Os algoritmos brutos são providos em ordem para permitir aos desenvolvedores uma felixibilidade máxima na implementação de uma variedade de protocolos e aplicações, cada um deve representar a composição e os parâmetros de segurança em uma maneira única que necessita do uso de algoritmos brutos."

Propriedades
------------

*Esta interface não herda e nem implementa nenhuma propriedade.*

Métodos
-------

Esta interface não herda nenhum método

`SubtleCrypto.encrypt()` (en-US)

Retorna uma `Promise` da informação criptografada correspondente com o texto, algoritmo e chave key dados como parâmetros.

`SubtleCrypto.decrypt()` (en-US)

Retorna uma `Promise` da informação correspondente ao texto encriptografado, algoritmo e key dados como parâmetros.

`SubtleCrypto.sign()` (en-US)

Retorna uma `Promise` de uma assinatura correspondente ao texto, algoritmo e key dados como parâmetros.

`SubtleCrypto.verify()` (en-US)

Retorna uma `Promise` de um valor `Boolean` indicando se a assinatura dada como parâmetro combina com o texto, algoritmo e key também dados como parâmetros.

`SubtleCrypto.digest()` (en-US)

Retorna uma `Promise` de um resumo gerado a partir do algoritmo e texto dados como parâmetros.

`SubtleCrypto.generateKey()`

Retorna uma `Promise` de uma recentemente gerada `CryptoKey`, para algoritmos simétricos, ou uma `CryptoKeyPair` (en-US), contendo duas novas keys simétricas, para algoritmos assimétricos, que combina com o algoritmo, os usos e a extrabilidade dados como parâmetros.

`SubtleCrypto.deriveKey()`

Retorna uma `Promise` de uma recentemente gerada `CryptoKey` derivada de uma master key e um algoritmo específico dados como parâmetros.

`SubtleCrypto.deriveBits()` (en-US)

Retorna uma `Promise` de um buffer recentemente gerado de bits pseudo-randômicos derivados de uma master key e um algoritmo específico dados como parâmetros.

`SubtleCrypto.importKey()`

Retorna uma `Promise` de uma `CryptoKey` correspondente ao formato, o algoritmo, a informação da key bruta, o uso e a extrabilidade dados como parâmetros.

`SubtleCrypto.exportKey()` (en-US)

Retorna uma `Promise` deu uma buffer contendo a key no formato requisitado.

`SubtleCrypto.wrapKey()` (en-US)

Retorna uma `Promise` de uma key envolvida simetricamente para uso (transferência, armazenamento) em ambientes não seguros. O buffer envolvido retornado será no formato dado nos parâmetros, e contém a key envolvida com a key envolvendo e o algoritmo dado.

`SubtleCrypto.unwrapKey()` (en-US)

Retorna uma `Promise` de uma `CryptoKey` correspondente à key envolvida dada como parâmetro.

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

| Specification |
| --- |
| Web Cryptography API # subtlecrypto-interface |

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

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

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

* `Crypto` e `Crypto.subtle`.


AnimationEvent - APIs da Web

AnimationEvent
==============

**Experimental:** **Esta é uma tecnologia experimental (en-US)**
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

A interface **`AnimationEvent`** representa eventos provendo informações relacionadas a animações.

`Event

AnimationEvent`

Propriedades
------------

*Também propriedades herdadas pelo pai ``Event``*.

``AnimationEvent.animationName` Somente leitura`

O `DOMString` contém o valor do `animation-name` (en-US) propriedade CSS associada com a transição.

``AnimationEvent.elapsedTime` Somente leitura`

`É um ponto flutuante` dado pela quantidade de tempo que a animação está rodando, em segundos, quando esse evento termina, excluindo o tempo em que animação esteve pausada. Para o evento `"animationstart"`, `elapsedTime` é `0.0` a não ser que haja um valor negativo para ``animation-delay``, nesse caso o evento terminará com `elapsedTime` contendo `(-1 * delay )`.

``AnimationEvent.pseudoElement` Somente leitura`

Um ``DOMString`` começa com `'::'`, contendo o nome do pseudo-elemento onde a animação roda. Se a animação não rodar no pseudo-elemento mas no elemento, então teremos um *string* vazio `' '`.

Constructores
-------------

``AnimationEvent()``

Cria um evento `AnimationEvent` com os dados parâmetros.

Métodos
-------

*Também herda métodos do pai ``Event``*.

``AnimationEvent.initAnimationEvent()`
Non-standard

Deprecated`

Inicializa um `AnimationEvent` criado usando diminuído `Document.createEvent("AnimationEvent")` (en-US) método.

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

| Specification |
| --- |
| CSS Animations Level 1 # interface-animationevent |

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

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

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

* Usando animações CSS


PushManager - APIs da Web

PushManager
===========

**Experimental:** **Esta é uma tecnologia experimental (en-US)**
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

A `PushManager`interface da API Push fornece uma maneira de receber notificações de servidores de terceiros, bem como solicitar URLs para notificações push.

Essa interface é acessada através da propriedade `ServiceWorkerRegistration.pushManager` (en-US).

**Nota:** : Esta interface substitui a funcionalidade anteriormente oferecida pela interface obsoleta `PushRegistrationManager`.

Propriedades
------------

`PushManager.supportedContentEncodings` (en-US)

Retorna uma série de codificações de conteúdo suportadas que podem ser usadas para criptografar a carga útil de uma mensagem push.

Métodos
-------

`PushManager.getSubscription ()`

Recupera uma assinatura de envio existente. Retorna uma `Promise` que resolve um objeto `PushSubscription` (en-US) contendo detalhes de uma assinatura existente. Se não existe uma subscrição existente, isso resolve um `null`valor.

`PushManager.permissionState ()`

Retorna uma `Promise` que resolve para o estado de permissão do atual `PushManager`, que será um dos `'granted'`, `'denied'`ou `'prompt'`.

`PushManager.subscribe ()`

Assine um serviço push. Retorna uma `Promise` que resolve um objeto `PushSubscription` (en-US) contendo detalhes de uma inscrição de envio. Uma nova assinatura de envio é criada se o trabalhador de serviço atual não tiver uma assinatura existente.

### Métodos depreciados

`PushManager.hasPermission ()`
Deprecated

Retorna uma `Promise` que resolve para o `PushPermissionStatus`do webapp requerente, que será um dos `granted`, `denied`ou `default`. Substituído por `PushManager.permissionState ()`.

`PushManager.register ()`
Deprecated

Assina uma assinatura de envio. Substituído por `PushManager.subscribe ()`.

`PushManager.registrations ()`
Deprecated

Recupera as assinaturas de envio existentes. Substituído por `PushManager.getSubscription ()`.

`PushManager.unregister ()`
Deprecated

Anula e exclui um ponto final de assinatura especificado. Na API atualizada, uma assinatura não está registrada chamando o método `PushSubscription.unsubscribe ()`.

Exemplo
-------
```

this.onpush = function(event) {
  console.log(event.data);
  // From here we can write the data to IndexedDB, send it to any open
  // windows, display a notification, etc.
}

navigator.serviceWorker.register('serviceworker.js').then(
  function(serviceWorkerRegistration) {
    serviceWorkerRegistration.pushManager.subscribe().then(
      function(pushSubscription) {
        console.log(pushSubscription.subscriptionId);
        console.log(pushSubscription.endpoint);
        // The push subscription details needed by the application
        // server are now available, and can be sent to it using,
        // for example, an XMLHttpRequest.
      }, function(error) {
        // During development it often helps to log errors to the
        // console. In a production environment it might make sense to
        // also report information about errors back to the
        // application server.
        console.log(error);
      }
    );
  });
```

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

| Specification |
| --- |
| Push API # pushmanager-interface |

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

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

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

* API de envio
* API do Worker Service


HTMLDivElement - APIs da Web

HTMLDivElement
==============

A interface `HTMLDivElement` fornece propriedades especiais ( além da interface normal `HTMLElement` (en-US) que também está a sua disposição por herança ) para manipular elementos div.

Propriedades
------------

*As propriedades são herdadas de seu pai, `HTMLElement` (en-US).*

| Nome | Tipo | Descrição |
| --- | --- | --- |
| `align` | `DOMString` | Propriedade enumerada indicando alinhamento dos conteúdos do elemento, respeitando ao contexto geral. Os valores possíveis são `"left"`, `"right"`, `"justify"`, e`"center"`. |

Métodos
-------

*Nenhum método específico; os métodos são herdados de seu pai, `HTMLElement` (en-US).*

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

| Specification |
| --- |
| HTML Standard # htmldivelement |

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

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

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

* O elemento HTML implementar essa interface: `<div>`.


HTMLCollection - APIs da Web

HTMLCollection
==============

A interface **`HTMLCollection`** representa uma coleção genérica (objeto array) de elementos (na ordem em que aparecem no documento) e oferece métodos e propriedades para selecioná-los da lista.

**Nota:** Esta interface é chamada `HTMLCollection` por razões históricas (antes do DOM4, coleções implementadas por esta interface somente podiam ter elementos HTML).

Uma coleção `HTMLCollection` de um HTML DOM está linkada com o documento; ela será automaticamente atualizada quando o documento for modificado.

Propriedades
------------

`HTMLCollection.length` (en-US) Somente leitura

Retorna o número de itens da coleção.

Métodos
-------

`HTMLCollection.item()` (en-US)

Retorna um nó especificado por `index` da lista. o primeiro index da lista é 0. Retorna `null` se `index` não existir na lista.

`HTMLCollection.namedItem()` (en-US)

Retorna o nó especificado pelo ID ou, caso não tenha ID, o item cuja propriedade `name` seja igual à pesquisa. Pesquisa por `name` só é feita em último caso, somente em HTML, e somente se os elementos referenciados suportarem o atributo `name`. Retorna `null` se nenhum nó corresponder ao nome pesquisado.

Uso no JavaScript
-----------------

`HTMLCollection` expõe seus membros diretamente como propriedades, tanto por nome quanto por índice. IDs HTML podem conter : e . como caracteres válidos, o que fará necessária a utilização de colchetes para acessar as propriedades. Atualmente HTMLCollection não reconhece IDs puramente numéricos, o que pode causar conflitos com acesso em formato array, apesar do HTML5 os permitir.

Por exemplo, assumindo que há um elemento `<form>` no documento e seu `id` é `"myForm"`:

```js
var elem1, elem2;

// document.forms é um HTMLCollection

elem1 = document.forms[0];
elem2 = document.forms.item(0);

alert(elem1 === elem2); // exibe: "true"

elem1 = document.forms.myForm;
elem2 = document.forms.namedItem("myForm");

alert(elem1 === elem2); // exibe: "true"

elem1 = document.forms["named.item.with.periods"];
```

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

Diferentes browsers se comportam de maneira diferente quando um os mais elementos são pesquisados pela string utilizada como índice (ou o argumento namedItem). Firefox 8 se comporta como especificado no DOM 2 e no DOM 4, retornando o primeiro elemento encontrado. WebKit browsers e o Internet Explorer, neste caso, retornam outro HTMLCollection e o Opera retorna um `NodeList` com todos os elementos encontrados.

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

* DOM Level 2 HTML, Section 1.4, Miscellaneous Object Definitions
* DOM4: HTMLCollection
Veja também
-----------

* `NodeList`
* `HTMLFormControlsCollection` (en-US), `HTMLOptionsCollection` (en-US)


CustomElementRegistry - APIs da Web

CustomElementRegistry
=====================

Limited availability
--------------------

This feature is not Baseline because it does not work in some of the most widely-used browsers.

* Learn more
* See full compatibility
* Report feedback
A interface **`CustomElementRegistry`** provê métodos para registro de elementos customizados e busca de elementos registrados. Para instancia-lo, use a propriedade `window.customElements` (en-US).

Métodos
-------

`CustomElementRegistry.define()`

Define um novo elemento customizado (en-US).

`CustomElementRegistry.get()`

Retorna o construtor do nome do elemento informado, ou `undefined` caso não tenha sido definido.

`CustomElementRegistry.whenDefined()`

Retorna um `promise` vazio que é resolvido quando o elemento customizado é inserido. Se o elemento já foi definido, o retorno ja é informado.

Exemplos
--------

O código a seguir foi pego do nosso word-count-web-component exemplo (veja em ação). Perceba que usamos o método `CustomElementRegistry.define()` para definir um elemento customizado.

```js
// Cria uma classe para o elemento
class WordCount extends HTMLParagraphElement {
  constructor() {
    // Sempre execute primeiro o método super
    super();

    // Conta as palavras no elemento pai
    var wcParent = this.parentNode;

    function countWords(node) {
      var text = node.innerText || node.textContent;
      return text.split(/\s+/g).length;
    }

    var count = "Words: " + countWords(wcParent);

    // Cria um shadow root
    var shadow = this.attachShadow({ mode: "open" });

    // Cria um nó de texto e adiciona o contador de palavra nele
    var text = document.createElement("span");
    text.textContent = count;

    // Acrescenta ao shadow root
    shadow.appendChild(text);

    // Atualiza o contador quando houver mudança
    setInterval(function () {
      var count = "Words: " + countWords(wcParent);
      text.textContent = count;
    }, 200);
  }
}

// Define um novo elemento
customElements.define("word-count", WordCount, { extends: "p" });
```

**Nota:** Note: The CustomElementsRegistry is available through the `Window.customElements` (en-US) property.

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

| Specification |
| --- |
| HTML Standard # custom-elements-api |

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

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


API Push - APIs da Web

API Push
========

**Experimental:** **Esta é uma tecnologia experimental (en-US)**
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

A **API Push** torna possível que aplicações web recebam mensagens enviadas a elas de um servidor, indepententemente de aplicação estar ou não em primeiro plano, ou até mesmo carregada, em um agente de usuário. Isso permite que desenvolvedores entreguem notificações e atualizações assíncronas a usuários que optarem por elas, resultando num melhor engajamento com conteúdo novo oportuno.

**Nota:** Esta documentação cobre a especificação W3C da API Push; se você procura pela documentação do sistema de notificação proprietária do mecanismo push, veja Simple Push.

Conceitos e uso de Push
-----------------------

Para uma aplicação receber mensagens push, ela precisa ter um service worker (en-US) ativo. Quando o service worker está ativo, ele pode se inscrever para utilizar notificações push `PushManager.subscribe()` (en-US).

O resultado de `PushSubscription` (en-US) inclui toda informação que a aplicação precisa para receber uma mensagem push: um endpoint e a chave encriptada necessária para o envio de dados.

O service worker será iniciado conforme o necessário para lidar com as mensagens recebidas, que são entregues ao manipulador de evento `ServiceWorkerGlobalScope.onpush` . Isto permite que a aplicação reaja a cada mensagem recebida, por exemplo para exibir a notificação ao usuário (usando `ServiceWorkerRegistration.showNotification()` (en-US).)

Cada assinatura é única para um service worker. O endpoint para a assinatura é uma capability URL única: o conhecimento do endpoint é tudo que é necessário para enviar uma mensagem para sua aplicação. A URL do endpoint precisa ser mantida em segredo, ou outras aplicações estranhas poderão enviar mensagens push para a sua aplicação.

A ativação de um service worker para entregar mensagens push pode resultar em um aumento de uso de recursos, particularmente de bateria. Diferentes navegadores tem diferentes formas para lidar com isso — atualmente não existe uma forma padrão. Firefox permite um número limitado (cota) de mensagens push para serem enviadas para uma aplicação, embora as mensagens Push que gerem notificações são isentas deste limite. O limite é atualizado a cada site visitado. Numa comparação, Chrome não aplica nenhum limite, mas requer que cada mensagem push exiba uma notificação.

**Nota:** A partir do Gecko 44, a cota permitida de mensagens push por aplicação não é incrementada quando uma nova notificação é disparada quando outra está visível, por um período de três segundos. Isso lida com casos em que várias notificações são recebidas ao mesmo tempo, mas nem todas estão visíveis.

**Nota:** Chrome atualmente requer que você crie um projeto no Google Cloud Messaging para enviar mensagens push e use um número do projeto e chave da API para o envio de notificações push. Isto também requer um *app manifest* com alguns parâmetros especiais para usar o serviço. Essa restrição deverá ser removida no futuro.

Interfaces
----------

`PushEvent` (en-US)

Representa uma ação push enviada para o global scope (en-US) de um `ServiceWorker` (en-US). Ele contém informações enviadas de uma aplicação para um `PushSubscription` (en-US).

`PushManager`

Fornece uma forma de receber notificações de servidor third-party bem como solicitar URL para notificações push. Essa interface substitui a funcionalidade oferecida que está obsoleta `PushRegistrationManager` interface.

`PushMessageData` (en-US)

Fornece acesso aos dados push enviados por um servidor, e inclui métodos para manipular os dados recebidos.

`PushSubscription` (en-US)

Fornece a URL de assinatura do endpoint e permite o cancelamento da assinatura de um serviço push.

Service worker additions
------------------------

As seguintes informações adicionais para a Service Worker API foram especificadas na Push API spec, para fornecer um ponto de entrada para usar mensagens Push, e para monitorar e responder os eventos de envio e assinatura.

`ServiceWorkerRegistration.pushManager` (en-US) Somente leitura

Retorna uma referência para a interface `PushManager` para administrar assinaturas push incluindo subscrever, obter uma assinatura ativa e acessar o status de permissão de envio. Este é o ponto de entrada para usar mensagens Push.

`ServiceWorkerGlobalScope.onpush`

Um manipulador de eventos disparado sempre que um evento `push` ocorre; isto é, sempre que uma mensagem do servidor de envio for recebida.

`ServiceWorkerGlobalScope.onpushsubscriptionchange`

Um manipulador de eventos disparado sempre que um evento `pushsubscriptionchange` ocorre; por exemplo, quando uma assinatura push está inválida, ou está prestes a ser invalidada (ex. quando um serviço push service define um tempo de expiração.)

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

| Specification |
| --- |
| Push API # pushevent-interface |
| Push API # pushmessagedata-interface |

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

### api.PushEvent

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

### api.PushMessageData

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

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

* Usando Push API (en-US)
* Push API Demo, no Github
* Push Notifications on the Open Web, Matt Gaunt
* Service Worker API


Streams API - APIs da Web

Streams API
===========

**Experimental:** **Esta é uma tecnologia experimental (en-US)**
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

A API Streams permite que o JavaScript acesse programaticamente fluxos de dados recebidos pela rede e os processe conforme desejado pelo desenvolvedor.Conceitos e Uso
---------------

O streaming envolve a divisão de um recurso que você deseja receber pela rede em pequenos blocos e, em seguida, processa esses blocos aos poucos. Isso é algo que os navegadores fazem de qualquer maneira ao receber recursos para serem exibidos em páginas da web — o buffer de vídeos e mais está gradualmente disponível para reprodução, e às vezes você verá imagens sendo exibidas gradualmente conforme mais é carregado.

Mas isto nunca esteve disponível para JavaScript antes. Anteriormente, se quiséssemos processar um recurso de algum tipo (seja ele um vídeo, ou um arquivo de texto, etc.), Teríamos que baixar o arquivo inteiro, espera até que seja desserializado em um formato adequado, então processa todo o lote após ser totalmente recebido.

Com o Streams disponível para JavaScript, tudo isso muda - agora você pode começar a processar dados brutos com JavaScript bit a bit assim que estiverem disponíveis no lado do cliente, sem a necessidade de gerar um buffer, string ou blob.

![](/pt-BR/docs/Web/API/Streams_API/concept.png)

Também há mais vantagens - você pode detectar quando os fluxos começam ou terminam, encadeia os fluxos juntos, trata os erros e cancela os fluxos quando necessário e reage à velocidade em que o fluxo está sendo lido.

O uso básico de Streams gira em torno de tornar as respostas disponíveis como streams. Por exemplo, a resposta `Body` retornada com sucesso de uma fetch request pode ser exposta como um `ReadableStream` (en-US), e você pode lê-lo usando um leitor criado com `ReadableStream.getReader()` (en-US), cancela-lo com `ReadableStream.cancel()` (en-US), etc.

Usos mais complicados envolvem a criação de seu próprio fluxo usando o contrutor `ReadableStream()` (en-US), por exemplo para processar dados dentro de um service worker.

Você também pode gravar dados em streams usando `WritableStream` (en-US).

**Nota:** Você pode encontrar muito mais detalhes sobre a teoria e prática de streams em nossos artigos — Streams API concepts, Using readable streams (en-US), e Using writable streams (en-US).

Stream interfaces
-----------------

### Readable streams

`ReadableStream` (en-US)

Represents a readable stream of data. It can be used to handle response streams of the Fetch API, or developer-defined streams (e.g. a custom `ReadableStream()` (en-US) constructor).

`ReadableStreamDefaultReader` (en-US)

Represents a default reader that can be used to read stream data supplied from a network (e.g. a fetch request).

`ReadableStreamDefaultController` (en-US)

Represents a controller allowing control of a `ReadableStream` (en-US)'s state and internal queue. Default controllers are for streams that are not byte streams.

### Writable streams

`WritableStream` (en-US)

Provides a standard abstraction for writing streaming data to a destination, known as a sink. This object comes with built-in backpressure and queuing.

`WritableStreamDefaultWriter` (en-US)

Represents a default writable stream writer that can be used to write chunks of data to a writable stream.

`WritableStreamDefaultController` (en-US)

Represents a controller allowing control of a `WritableStream` (en-US)'s state. When constructing a `WritableStream`, the underlying sink is given a corresponding `WritableStreamDefaultController` instance to manipulate.

### Related stream APIs and operations

`ByteLengthQueuingStrategy` (en-US)

Provides a built-in byte length queuing strategy that can be used when constructing streams.

`CountQueuingStrategy` (en-US)

Provides a built-in chunk counting queuing strategy that can be used when constructing streams.

### Extensions to other APIs

`Request`

When a new `Request` object is constructed, you can pass it a `ReadableStream` (en-US) in the `body` property of its `RequestInit` dictionary. This `Request` could then be passed to a `WindowOrWorkerGlobalScope.fetch()` to commence fetching the stream.

`Body`

The response `Body` returned by a successful fetch request is exposed by default as a `ReadableStream` (en-US), and can have a reader attached to it, etc.

### ByteStream-related interfaces

**Aviso:** **Important**: these are not implemented anywhere as yet, and questions have been raised as to whether the spec details are in a finished enough state for them to be implemented. This may change over time.

`ReadableStreamBYOBReader` (en-US)

Represents a BYOB ("bring your own buffer") reader that can be used to read stream data supplied by the developer (e.g. a custom `ReadableStream()` (en-US) constructor).

`ReadableByteStreamController` (en-US)

Represents a controller allowing control of a `ReadableStream` (en-US)'s state and internal queue. Byte stream controllers are for byte streams.

`ReadableStreamBYOBRequest` (en-US)

Represents a pull into request in a `ReadableByteStreamController` (en-US).

Examples
--------

We have created a directory of examples to go along with the Streams API documentation — see mdn/dom-examples/streams. The examples are as follows:

* Simple stream pump: This example shows how to consume a ReadableStream and pass its data to another.
* Grayscale a PNG: This example shows how a ReadableStream of a PNG can be turned into grayscale.
* Simple random stream: This example shows how to use a custom stream to generate random strings, enqueue them as chunks, and then read them back out again.
* Simple tee example: This example extends the Simple random stream example, showing how a stream can be teed and both resulting streams can be read independently.
* Simple writer: This example shows how to to write to a writable stream, then decode the stream and write the contents to the UI.
* Unpack chunks of a PNG: This example shows how `pipeThrough()` (en-US) can be used to transform a ReadableStream into a stream of other data types by transforming a data of a PNG file into a stream of PNG chunks.

Examples from other developers:

* Progress Indicators with Streams, Service Workers, & Fetch.
Especificações
--------------

| Specification |
| --- |
| Streams Standard # rs-class |
| Streams Standard # ws-class |

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

### api.ReadableStream

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

### api.WritableStream

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

See also
--------

* Streams API concepts
* Using readable streams (en-US)
* Using writable streams (en-US)


Node - APIs da Web

Node
====

**`Node`** é uma interface da qual diversos tipos do DOM herdam, e que permite que esses tipos sejam tratados de forma similar, por exemplo, herdando os mesmos métodos ou sendo testados da mesma forma.

Todos os tipos a seguir herdam essa interface e seus métodos e propriedades (apesar de que alguns podem devolver `null` em casos particulares em que o método ou a propriedade não são relevantes; ou lançar uma exceção quando adicionando um filho a um tipo de nó que não pode ter filhos): `Document`, `Element`, `Attr`, `CharacterData` (do qual `Text` (en-US), `Comment` (en-US), e `CDATASection` (en-US) herdam), `ProcessingInstruction`, `DocumentFragment`, `DocumentType` (en-US), `Notation`, `Entity`, `EntityReference`

EventTarget

NodePropriedades
------------

*Herda propriedades de seus pais, `EventTarget`*.[1]

`Node.baseURI` Somente leitura

Retorna uma `DOMString` representando o URL base do nó. O conceito de URL base muda de uma linguagem para outra; no HTML, ela corresponde ao protocolo, ao nome de domínio e a estrutura de diretório; tudo isso até a última `'/'`.

`Node.baseURIObject` (en-US)
Non-standard

Retorna um objeto `nsIURI`, representando o URL base do nó. *(Indisponível para conteúdo Web)*

`Node.childNodes` Somente leitura

Retorna um objeto `NodeList` "vivo" contendo todos os filhos deste nó. Dizer que um objeto `NodeList` é vivo significa que se houver alguma mudança em um dos filhos deste nó, o objeto `NodeList` é automaticamente atualizado com tais mudanças.

`Node.firstChild` Somente leitura

Retorna um `Node` representando o primeiro filho direto do nó ou `null`, caso o nó não tenha nenhum filho.

`Node.lastChild` Somente leitura

Retorna um `Node` representando o último filho direto do elemento ou `null`, caso o elemento não tenha nenhum filho.

`Node.nextSibling` Somente leitura

Retorna um `Node` representando o próximo elemento na árvore ou `null`, caso tal nó não exista.

`Node.nodeName` (en-US) Somente leitura

Retorna uma `DOMString` contendo o nome do elemento, do `Node`. A estrutura do nome irá mudar conforme o tipo do elemento. Veja as diferenças na documentação do método `Node.nodeName` (en-US).

`Node.nodePrincipal` (en-US)
Non-standard

Uma interface `nsIPrincipal` representando o nó principal.

`Node.nodeType` (en-US)Somente leitura

Retorna um `unsigned short` representando o tipo do nodo. Valores possíveis são:

| Nome | Valor |
| --- | --- |
| `ELEMENT_NODE` | 1 |
| `ATTRIBUTE_NODE` | 2 |
| `TEXT_NODE` | 3 |
| `CDATA_SECTION_NODE` | 4 |
| `ENTITY_REFERENCE_NODE` | 5 |
| `ENTITY_NODE` | 6 |
| `PROCESSING_INSTRUCTION_NODE` | 7 |
| `COMMENT_NODE` | 8 |
| `DOCUMENT_NODE` | 9 |
| `DOCUMENT_TYPE_NODE` | 10 |
| `DOCUMENT_FRAGMENT_NODE` | 11 |
| `NOTATION_NODE` | 12 |

`Node.nodeValue` (en-US)

Retorna / Define o valor do nó atual

`Node.ownerDocument` (en-US) Somente leitura

Retorna o `Document` qual esse nó pertence. Se o nó em si é um documento, retorna `null`.

`Node.parentNode` Somente leitura

Retorna um `Node` que é pai desse nó. Se não existe tal nó, como, por exemplo, se esse nó é o topo da árvore ou se ele não participa de uma árvore, essa propriedade retorna `null`.

`Node.previousSibling` Somente leitura

Retorna um `Node` representando o último nó em uma árvore ou `null` se não existe tal nodo.

`Node.textContent`

Retorna / Define o conteúdo textual de um elemento e de todos os seus descendentes.

### Propriedades descontinuadas

`Node.rootNode` (en-US) Somente leitura
Deprecated

Retorna um objeto `Node` representando o nó mais alto em uma árvore, ou o nó atual, se ele for o mais alto da árvore. Isso foi substituído por `Node.getRootNode()` (en-US).

### Propriedades obsoletas

`Node.localName` (en-US)Somente leitura

Retorna um `DOMString` representando a parte local do nome qualificado de um elemento.

**Nota:** No Firefox 3.5 e nas versões anteriores, a propriedade coloca em caixa alta o nome local de elementos HTML (mas não elementos XHTML). Em versões posteriores, isso não acontece, então a propriedade está em caixa baixa para ambos HTML e XHTML.

`Node.namespaceURI` (en-US)Somente leitura

O espaço de nomes URI desse nó, ou `null` se não estiver no espaço de nomes.

**Nota:** No Firefox 3.5 e nas versões anteriores, elementos HTML estão no espaço de nomes. Em versões posteriores, elementos HTML estão em `https://www.w3.org/1999/xhtml/`, nas árvores HTML e XML.

`Node.prefix` (en-US)Somente leitura

É um `DOMString` representando o espaço de nomes do nó, ou `null` se nenhum prefixo é especificado.

Métodos
-------

* `Node.appendChild`
* `Node.cloneNode`
* `Node.compareDocumentPosition` (en-US)
* `Node.contains`
* `Node.getFeature`
* `Node.getUserData`
* `Node.hasAttributes`
* `Node.hasChildNodes` (en-US)
* `Node.insertBefore`
* `Node.isDefaultNamespace` (en-US)
* `Node.isEqualNode` (en-US)
* `Node.isSameNode` (en-US)
Deprecated
* `Node.lookupPrefix` (en-US)
* `Node.lookupNamespaceURI` (en-US)
* `Node.normalize` (en-US)
* `Node.removeChild`
* `Node.replaceChild`
* `Node.setUserData`
Constantes
----------

Veja também `Node.nodeType` (en-US)

| Nome | Valor |
| --- | --- |
| `ELEMENT_NODE` | 1 |
| `ATTRIBUTE_NODE` | 2 |
| `TEXT_NODE` | 3 |
| `DATA_SECTION_NODE` | 4 |
| `ENTITY_REFERENCE_NODE` | 5 |
| `ENTITY_NODE` | 6 |
| `PROCESSING_INSTRUCTION_NODE` | 7 |
| `COMMENT_NODE` | 8 |
| `DOCUMENT_NODE` | 9 |
| `DOCUMENT_TYPE_NODE` | 10 |
| `DOCUMENT_FRAGMENT_NODE` | 11 |
| `NOTATION_NODE` | 12 |
| `DOCUMENT_POSITION_DISCONNECTED` | 0x01 |
| `DOCUMENT_POSITION_PRECEDING` | 0x02 |
| `DOCUMENT_POSITION_FOLLOWING` | 0x04 |
| `DOCUMENT_POSITION_CONTAINS` | 0x08 |
| `DOCUMENT_POSITION_CONTAINED_BY` | 0x10 |
| `DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC` | 0x20 |

Exemplos de código
------------------

### Recuperar todos os nós filhos

A função a seguir percorre todos os nós filhos de um nó recursivamente e executa uma função de callback em cada um deles (e no nó pai também).

```js
function DOMComb(oParent, oCallback) {
  if (oParent.hasChildNodes()) {
    for (var oNode = oParent.firstChild; oNode; oNode = oNode.nextSibling) {
      DOMComb(oNode, oCallback);
    }
  }
  oCallback.call(oParent);
}
```

#### Sintaxe
```

DOMComb(parentNode, callbackFunction);
```

#### Descrição

Percorre todos os nós filhos de `parentNode` recursivamente e o próprio `parentNode` e executa a `callbackFunction` em cada um deles como `this` (en-US).

#### Parâmetros

`parentNode`

O nó pai (`Object``do tipo Node`).

`callbackFunction`

A função de callback (`Function` (en-US)).

#### Exemplo de uso

O exemplo a seguir envia para a função `console.log` o conteúdo textual do body:

```js
function imprimeConteudo() {
  if (this.nodeValue) {
    console.log(this.nodeValue);
  }
}

onload = function () {
  DOMComb(document.body, imprimeConteudo);
};
```

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

| Specification |
| --- |
| DOM Standard # interface-node |

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

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


MediaDevices - APIs da Web

MediaDevices
============

**Experimental:** **Esta é uma tecnologia experimental (en-US)**
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

As interfaces **`MediaDevices`** proporcionam accesso aos dispositivos de entrada de midia conectados, como câmeras e microfones, bem como compartilhamento de tela. Essencialmente, isso te permite obter acesso a qualquer mídia gerada pelo hardware.

Propriedades
------------

*As mesmas propriedades de `EventTarget`.*

### Manipuladores de Evento

`MediaDevices.ondevicechange` (en-US)

O manipulador de evento para o evento `devicechange`. Esse evento é entregue ao objeto `MediaDevices` quando uma entrada de mídia ou dispositivo de saída é conectado ou removido do computador do usuário.

Métodos
-------

*Mesmos métodos de `EventTarget`.*

`EventTarget.addEventListener()`

Registra um manipulador de eventos para um tipo específico de evento.

`MediaDevices.enumerateDevices()` (en-US)

Obtém um array de informações sobre a entrada de midia e dispositivos de saída disponíveis no sistema.

`MediaDevices.getSupportedConstraints()` (en-US)

Retorna um objeto consoante com `MediaTrackSupportedConstraints` (en-US) indicando quais propriedades restritivas são suportadas na interface `MediaStreamTrack` (en-US). Veja Capacidades e restrições (en-US) para aprender mais sobre restrições e como usá-las.

`MediaDevices.getUserMedia()` (en-US)

Após a permissão do usuário (pedida através de um prompt), liga a câmera, microfone e/ou a tramissão de tela no sistema e fornece uma `MediaStream` (en-US) contendo uma faixa de vídeo e/ou áudio com a entrada.

`EventTarget.removeEventListener()`

Remove um escutador de evento.

Exemplo
-------

```js
"use strict";

// Coloca as variáveis no escopo global para torná-las disponível para o Console do navegador.
var video = document.querySelector("video");
var constraints = (window.constraints = {
  audio: false,
  video: true,
});
var errorElement = document.querySelector("#errorMsg");

navigator.mediaDevices
  .getUserMedia(constraints)
  .then(function (stream) {
    var videoTracks = stream.getVideoTracks();
    console.log("Got stream with constraints:", constraints);
    console.log("Using video device: " + videoTracks[0].label);
    stream.onremovetrack = function () {
      console.log("Stream ended");
    };
    window.stream = stream; // torna as variáveis disponíveis para o Console do navegador
    video.srcObject = stream;
  })
  .catch(function (error) {
    if (error.name === "ConstraintNotSatisfiedError") {
      errorMsg(
        "A resolução " +
          constraints.video.width.exact +
          "x" +
          constraints.video.width.exact +
          " px não é suportada pelo seu dispositivo.",
      );
    } else if (error.name === "PermissionDeniedError") {
      errorMsg(
        "As permissões para usar sua câmera e microfone não foram fornecidas. " +
          "Você precisa permitir o acesso da página aos seus dispositivos para " +
          "que a demo funcione.",
      );
    }
    errorMsg("getUserMedia error: " + error.name, error);
  });

function errorMsg(msg, error) {
  errorElement.innerHTML += "<p>" + msg + "</p>";
  if (typeof error !== "undefined") {
    console.error(error);
  }
}
```

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

| Specification |
| --- |
| Media Capture and Streams # mediadevices |

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

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

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

* Media Capture and Streams API (en-US): A API desta interface faz parte..
* WebRTC API
* `Navigator.mediaDevices` (en-US): Retorna uma referência para um objeto `MediaDevices` que pode ser usado para acessar dispositivos.
* CameraCaptureJS: Captura de vídeo e playback em HTML5 usando *MediaDevices* e a *MediaStream Recording API* (código no GitHub)
* OpenLang: Aplicação web de laboratório de linguagem de vídeo HTML5 usando *MediaDevices* e *MediaStream Recording API* para gravação de video (código no GitHub)


RTCCertificate - APIs da Web

RTCCertificate
==============

A interface da WebRTC API fornece um objeto representando um certificado que uma `RTCPeerConnection` (en-US) usa para autênticar.

Propriedades
------------

`RTCCertificate.expires` (en-US) Somente leitura

Retorna a data de expiração do certificado.

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

| Specification |
| --- |
| WebRTC: Real-Time Communication in Browsers # dom-rtccertificate |

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

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


FormData - APIs da Web

FormData
========

A interface **`FormData`** fornece uma maneira fácil de construir um conjunto de pares chave/valor representando campos de um elemento `form` e seus valores, os quais podem ser facilmente enviados utilizado o método `send()` do XMLHttpRequest. Essa interface utiliza o mesmo formato que um `form` utilizaria se o tipo de codificação estivesse configurado como "multipart/form-data".

Um objeto `FormData` pode ser usado diretamente em uma estrutura `for...of` em vez de `entries()`: `for (var p of myFormData)` é o mesmo que `for (var p of myFormData.entries())`.

**Nota:** Esse recurso está disponível em https://developer.mozilla.org/pt-BR/docs/Web/API/Web\_Workers\_API

Construtor
----------

`FormData()`

Cria um novo objeto `FormData`.

Métodos
-------

`FormData.append`

Acrescenta um novo valor em uma chave existente dentro de um objeto `FormData`, ou adiciona a chave se ela ainda não existir.

`FormData.delete`

Apaga um par chave/valor de um objeto `FormData`.

`FormData.get`

Retorna o primeiro valor associado com uma dada chave de dentro de um objeto `FormData`.

`FormData.getAll`

Retorna uma matriz de todos os valores associados a uma determinada chave de dentro de um `FormData`.

`FormData.has`

Retorna um valor boleano indicando se um objeto `FormData` contém um certo par chave/valor.

`FormData.set`

Define um novo valor para uma chave existente dentro de um objeto `FormData`, ou adiciona a chave/valor se ele ainda não existir.

**Nota:** Para ser claro, a diferença entre `FormData.set()` e `FormData.append()` é que, se a chave especificada não existir, `FormData.set()` irá substituir o valor existente por um novo, enquanto `FormData.append()` irá acrescentar um novo valor no final dos valores existentes. Veja as suas páginas dedicadas para código de exemplo.

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

| Specification |
| --- |
| XMLHttpRequest Standard # interface-formdata |

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

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

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

* `XMLHTTPRequest`
* Usando XMLHttpRequest (en-US)
* Usando objetos FormData (en-US)
* `<form>` (en-US)


EventTarget - APIs da Web

EventTarget
===========

Resumo
------

`EventTarget` é uma interface DOM implementada por objetos que podem receber eventos DOM e tem que ouvir estes.

`Element`, `document`, e `window` são os mais comuns disparadores de eventos, mas outros objetos podem disparar eventos também, por exemplo `XMLHttpRequest`, `AudioNode`, `AudioContext` e outros.

Muitos disparadores de eventos (incluindo elements, documents, e windows) também suportam definir event handlers (en-US) através `on...` propriedades e atributos.

Métodos
-------

`EventTarget.addEventListener()`

Registra um tratamento para um tipo específico de evento sobre o `EventTarget`.

`EventTarget.removeEventListener()`

Remove um *event listener* do `EventTarget`.

`EventTarget.dispatchEvent()`

Dispatch an event to this `EventTarget`.

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

| Specification |
| --- |
| DOM Standard # interface-eventtarget |

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

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

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

* Referência de eventos (en-US) - os eventos disponíveis na plataforma.
* Guia do desenvolvedor sobre Eventos
* Interface `Event`


CSS - APIs da Web

CSS
===

`A interface CSS` carrega métodos CSS-relacionados úteis. Nenhum objeto com essa interface foi implementado: Aqui só contém métodos estáticos e futuramente uma interface útil.

Propriedades
------------

*A interface CSS é a interface utilizada e nenhum objeto desse tipo pode ser criado: só métodos estáticos são definidos aqui.*

Métodos
-------

*A interface CSS é a interface utilizada e nenhum objeto desse tipo pode ser criado: só métodos estáticos são definidos aqui.*

Métodos státicos
----------------

*Nenhuma método estático herdado*.

`CSS.supports()` (en-US)

Retorna um `Boolean` (en-US) indicando se o par *property-value*, ou a condição dada do parâmetro é suportada.

`CSS.escape()` (en-US)
Experimental

Pode ser usado para escapar um string mais usado como parte de um seletor CSS.

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

| Specification |
| --- |
| CSS Object Model (CSSOM) # namespacedef-css |
| CSS Properties and Values API Level 1  |

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

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

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

* Components.utils.importGlobalProperties


Web Crypto API - APIs da Web

Web Crypto API
==============

**Experimental:** **Esta é uma tecnologia experimental (en-US)**
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

A **Web Crypto API** é uma interface que permite um script utilizar criptografias primitivas para criar sistemas usando criptografia.

Uma característica fundamental desta API é permitir a manipulação e o armazenamento de keys de criptografia privadas e secretas sem que o JavaScript tenha acesso aos bits internos das keys.

Essa interface permite que scripts acessem as seguintes primitivas:

* *digest*, a habilidade de computar um hash de um bloco arbitrário de dados com o objetivo de detectar se houve alguma mudança.
* *mac*, a habilidade de computar um código de autenticação de mensagem.
* *sign* e *verify*, a habilidade de assinar digitalmente um documento e de verificar se uma dada assinatura pertence àquele que afirma ser seu signatário.
* *encrypt* e *decrypt*, a habilidade de codificar e decodificar um documento utilizando chaves criptográficas.
* *import* e *export*, a habilidade de importar e exportar keys criptografadas.
* *key generation*, a habilidade de criar uma key ou um par de keys de criptografia segura, sem o uso de uma key base, mas utilizando a entropia do sistema local como fonte de aleatoriedade para essa geração.
* *key wrapping* e *unwrapping*, a habilidade de transmitir e receber uma key de um terceiro, codificada utilizando uma outra key, sem expor a key subjacente ao código JavaScript.
* *random*, a habilidade de gerar números pseudo-randômicos de criptografia significante.

A Web Crypto API não resolve todos os problemas de criptografia que um site Web ou aplicação pode encontrar:

* Ela não dispensa o respeito ao modelo de origem idêntica (en-US) do navegador, como em casos em que chaves são fornecidas por autoridades centrais utilizadas por diversos sítios Web.
* Ela é incapaz de interagir com hardwares dedicados, como cartões inteligentes (smartcards), tokens USB ou geradores de aleatoriedade.

**Aviso:** **Atenção!**

* O mero uso de criptografia não faz seu sistema seguro. Segurança é um **processo** que constantemente avalia os riscos em que um sistema pode incorrer dentro do seu contexto de utilização. O contexto e os riscos que podem ocorrer evoluem no tempo.
* Quando se lida com segurança, todo o **sistema** precisa ser considerado. No caso da Web Crypto API, os desenvolvedores Web não devem considerar apenas a segurança de seu código ou script, mas também a segurança da conexão que é mantida com o servidor e os dados que o servidor pode manter em texto plano (não criptografado). A segurança geral não será mais forte que a segurança de da parte mais fraca do sistema.

Interfaces
----------

Alguns navegadores implementam uma interface chamada `Crypto` sem que ela esteja bem definida ou seja substancialmente criptografado. Para evitar confusões, métodos e propriedades desta interface foram retiradas de navegadores que implementaram Web Crypto API, e todos os métodos Web Crypto API estão disponíveis em uma nova interface: `SubtleCrypto`. A propriedade `Crypto.subtle` dá acesso a um objeto que a implementa.

Casos de uso
------------

A Web Crypto API pode ser utilizada:

* Para verificar que dados não foram alterados por um terceiro. Mesmo se dados foram armazenados sem criptografia, o armazenamento de uma assinatura, gerada a partir de uma senha, permite que pessoas que conhecem a senha identificar se o conteúdo e a assinatura são genuínos.
Especificações
--------------

| Specification |
| --- |
| Web Cryptography API # crypto-interface |

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

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


WebVR API - APIs da Web

WebVR API
=========

**Experimental:** **Esta é uma tecnologia experimental (en-US)**
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

O WebVR oferece suporte para expor dispositivos de realidade virtual - por exemplo, telas montadas na cabeça, como o Oculus Rift - para aplicativos da web, permitindo que os desenvolvedores traduzam informações de posição e movimento da tela para movimento em torno de uma cena 3D. Isso tem inúmeras aplicações muito interessantes, de passeios de produtos virtuais e aplicativos de treinamento interativo para super imersivo jogos em primeira pessoa.

Conceitos e uso
---------------

![Sketch of a person in a chair with wearing goggles labelled Head mounted display (HMD) facing a monitor with a webcam labelled Position sensor ](/pt-BR/docs/Web/API/WebVR_API/hw-setup.png)

Todos os dispositivos VR ligados ao computador serão devolvidos pelo `Navigator.getVRDisplays()` (en-US) método. Que retorna uma matriz de objetos para representar os dispositivos conectados, que herdam do objeto geral `VRDevice` (en-US) Geralmente o display usado na cabeça terá dois dispositivos - o próprio display montado na cabeça, representado por `HMDVRDevice` (en-US), e uma câmera com sensor na posição que manterá o controle de sua posição de cabeça, representada por `PositionSensorVRDevice` (en-US).

O objeto `PositionSensorVRDevice` (en-US) contém o método `getState()` (en-US), que retorna um objeto `VRPositionState` (en-US) - isto representa o estado do sensor num dado carimbo de data e inclui propriedades que contêm dados úteis tais como velocidade, aceleração e orientação atuais, úteis para atualizar o processamento de uma cena em cada trama de acordo com o movimento do visor montado na cabeça VR.

O método `HMDVRDevice.getEyeParameters()` (en-US) retorna um objeto `VREyeParameters` (en-US), que pode ser usado para retornar informações do campo de exibição - quanto da cena a tela montada na cabeça pode ver.O `VREyeParameters.currentFieldOfView` (en-US) retorna um objeto `VRFieldOfView` (en-US) que contém 4 ângulos que descrevem a vista atual a partir de um ponto central. Você também pode alterar o campo de visualização usando `HMDVRDevice.setFieldOfView()` (en-US).

WebVR Interfaces
----------------

`VRDisplay` (en-US)
 Representa qualquer dispositivo VR suportado por esta API. Ele inclui informações genéricas, como IDs de dispositivo e descrições, bem como métodos para começar a apresentar uma cena VR, recuperar os parâmetros do olho e exibir capacidades e outras funcionalidades importantes.
 `VRDisplayCapabilities` (en-US)
 Descreve os recursos de um `VRDisplay` (en-US) - seus recursos podem ser usados para executar testes de capacidade do dispositivo VR, por exemplo, ele pode retornar informações de posição.
 `VRPose` (en-US)
 Representa o estado de posição em um dado carimbo de data/hora (que inclui orientação, posição, velocidade e aceleração).
 `VREyeParameters` (en-US)
 Fornece acesso a todas as informações necessárias para processar corretamente uma cena para cada olho, incluindo informações de campo de visão.
 `VRFieldOfView` (en-US)
 Representa um campo de visão definido por 4 valores de graus diferentes que descrevem a vista a partir de um ponto central.
 `VRLayer` (en-US)
 Representa uma camada a ser apresentada em `VRDisplay` (en-US).
 `VRStageParameters` (en-US)
 Representa os valores que descrevem a área de estágio para dispositivos que suportam experiências em escala de sala.

Extensões para outras interfaces
--------------------------------

`Gamepad.displayId` (en-US) Somente leitura
 Retorna o `VRDisplay.displayId` (en-US) do associado `VRDisplay` (en-US) - o VRDisplay que o gamepad está controlando a cena exibida de.
 `Navigator.activeVRDisplays` (en-US) Somente leitura
 Retorna uma matriz contendo todos os objetos `VRDisplay` (en-US) que está sendo apresentado (`VRDisplay.ispresenting` (en-US)).
 `Navigator.getVRDisplays()` (en-US)
 Retorna uma promessa que resolve uma matriz de objetos `VRDisplay` (en-US) que representa qualquer dispositivo VR disponível conectado ao computador.
 `Window.onvrdisplayconnected` (en-US)
 Representa um manipulador de eventos que será executado quando um dispositivo VR compatível tiver sido conectado ao computador (quando o evento `vrdisplayconnected` for acionado).
 `Window.onvrdisplaydisconnected` (en-US)
 Representa um manipulador de eventos que será executado quando um dispositivo VR compatível tiver sido desconectado do computador (quando o evento `vrdisplaydisconnected` for acionado).
 `Window.onvrdisplaypresentchange` (en-US)
 Representa um manipulador de eventos que será executado quando o estado de apresentação de um dispositivo VR mudar - isto é, vai de apresentar a não apresentar, ou vice-versa (quando o evento `onvrdisplaypresentchange` é acionado).

Exemplos
--------

Você pode encontrar uma série de exemplos nesses repositórios Github:

* A-Frame: Estrutura web de código aberto para a construção de experiências VR. Muitos exemplos.
* mdn/webvr-tests: Demonstrações simples construídas para ilustrar o uso de recursos básicos.
* MozVR team: Mais demonstrações, sobre WebVR e muito mais!
Especificações
--------------

#### No specification found

No specification data found for `api.Navigator.getVRDisplays`.
Check for problems with this page or contribute a missing `spec_url` to mdn/browser-compat-data. Also make sure the specification is included in w3c/browser-specs.

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

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

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

* webvr.info- Informações atualizadas sobre WebVR, configuração do navegador e comunidade.
* webvr.rocks- Informações atualizadas sobre o suporte ao navegador WebVR (incluindo compilações experimentais).
* A-Frame- A web framework para a construção de experiências VR (com HTML), a partir da equipe Mozilla VR.
* Console Game on Web- Uma coleção de demonstrações interessantes conceito de jogo, alguns dos quais incluem WebVR.
* threejs-vr-boilerplate- Um modelo de iniciador muito útil para escrever aplicações WebVR.
* Oculus Rift homepage


HTMLSpanElement - APIs da Web

HTMLSpanElement
===============

A interface **`HTMLSpanElement`** representa um elemento `<span>` e deriva de uma interface `HTMLElement` (en-US), mas sem implementar propriedades ou métodos adicionais.

Propriedades
------------

*Essa interface não possui propriedades, mas herda propriedades de: `HTMLElement` (en-US).*

Métodos
-------

*Essa interface não possui métodos, mas herda métodos de: `HTMLElement` (en-US).*

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

| Specification |
| --- |
| HTML Standard # htmlspanelement |

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

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

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

* O elemento HTML que implementa essa interface: `<span>`.


DOMStringList - APIs da Web

DOMStringList
=============

Um tipo retornado por algumas APIs, que contém uma lista de DOMString (strings).

Propriedades
------------

`DOMStringList.length` (en-US) Somente leitura

Retorna o número de itens da lista

Métodos
-------

`DOMStringList.item()` (en-US)

Retorna uma `DOMString`.

`DOMStringList.contains()` (en-US)

Retorna `Boolean` indicando se a string em questão está na lista

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

| Specification |
| --- |
| HTML Standard # the-domstringlist-interface |

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

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


HTMLInputElement - APIs da Web

HTMLInputElement
================

A interface **`HTMLInputElement`** fornece propriedades e métodos especiais para manipular as opções, layout e apresentação de elementos `<input>`.

EventTarget

Node

Element

HTMLElement

(en-US)

HTMLInputElementPropriedades da instância
-------------------------

Algumas propriedades se aplicam apenas a tipos de elemento de entrada que suportam os atributos correspondentes.

`align`
Deprecated

`string`: **Representa** o alinhamento do elemento. *Em vez disso, use CSS.*

`autocapitalize`
Experimental

`string`: **Define** o comportamento de capitalização para a entrada do usuário. Os valores válidos são `none`, `off`, `characters`, `words` ou `sentences`.

`defaultValue`

`string`: **Retorna / Define** o valor padrão como originalmente especificado no HTML que criou este objeto.

`dirName`

`string`: **Retorna / Define** a direcionalidade do elemento.

`inputmode`

Fornece uma dica aos navegadores quanto ao tipo de configuração do teclado virtual a ser usado ao editar este elemento ou seu conteúdo.

`labels` (en-US) Somente leitura

`NodeList` array: **Retorna** uma lista de elementos `<label>` que são rótulos para este elemento.

`list` Somente leitura

`HTMLElement` (en-US): **Retorna** o elemento apontado pelo atributo `list`. A propriedade pode ser `null` se nenhum elemento HTML for encontrado na mesma árvore.

`multiple` (en-US)

`boolean`: **Retorna / Define** o atributo `multiple` do elemento, indicando se mais de um valor é possível (ex. , vários arquivos).

`name`

`string`: **Retorna / Define** o atributo `name` do elemento, contendo um nome que identifica o elemento ao enviar o formulário.

`step`

`string`: **Retorna / Define** o atributo `step` do elemento, que funciona com `min` e `max` para limitar os incrementos nos quais um número ou data - valor de tempo pode ser definido. Pode ser a string `any` ou um número de ponto flutuante positivo. Se isso não for definido como `any`, o controle aceitará apenas valores em múltiplos do valor da etapa maior que o mínimo.

`type`

`string`: **Retorna / Define** o atributo `type` do elemento, indicando o tipo de controle a ser exibido. Para valores possíveis, consulte a documentação do atributo `type`.

`useMap`
Deprecated

`string`: **Representa** um mapa de imagem do lado do cliente.

`value`

`string`: **Retorna / Define** o valor atual do controle. Se o usuário inserir um valor diferente do valor esperado, isso pode retornar uma string vazia.

`valueAsDate`

`Date`: **Retorna / Define** o valor do elemento, interpretado como uma data, ou `null` se a conversão não for possível.

`valueAsNumber`

`double`: **Retorna** o valor do elemento, interpretado como um dos seguintes, em ordem: Um valor de tempo, um número ou `NaN` se a conversão for impossível

### Propriedades de instância relacionadas ao formulário pai

`form` Somente leitura

`HTMLFormElement` (en-US): **Retorna** uma referência ao elemento pai `<form>` (en-US).

`formAction`

`string`: **Retorna / Define** o atributo `formaction` do elemento, contendo a URL de um programa que processa as informações enviadas pelo elemento. Isso substitui o atributo `action` (en-US) do formulário pai.

`formEnctype`

`string`: **Retorna / Define** o atributo `formenctype` do elemento, contendo o tipo de conteúdo que é usado para enviar o formulário para o servidor. Isso substitui o atributo `enctype` (en-US) do formulário pai.

`formMethod`

`string`: **Retorna / Define** o atributo `formmethod` do elemento, contendo o método HTTP que o navegador usa para enviar a forma. Isso substitui o atributo `method` (en-US) do formulário pai.

`formNoValidate`

`boolean`: **Retorna / Define** o atributo `formnovalidate` do elemento, indicando que o formulário não deve ser validado quando ele é submetido. Isso substitui o atributo `novalidate` (en-US) do formulário pai.

`formTarget`

`string`: **Retorna / Define** o atributo `formtarget` do elemento, contendo um nome ou palavra-chave indicando onde exibir o resposta recebida após o envio do formulário. Isso substitui o atributo `target` (en-US) do formulário pai.

### Propriedades de instância que se aplicam a qualquer tipo de elemento de entrada que não esteja oculto

`autofocus`

`boolean`: **Retorna / Define** o atributo `autofocus` do elemento, que especifica que um controle de formulário deve ter foco de entrada quando a página é carregada, a menos que o usuário a substitua, por exemplo, digitando um controle diferente. Apenas um elemento de formulário em um documento pode ter o atributo `autofocus`.

`disabled` (en-US)

`boolean`: **Retorna / Define** o atributo `disabled` do elemento, indicando que o controle não está disponível para interação. Os valores de entrada não serão enviados com o formulário. Veja também `readonly`.

`required`

`boolean`: **Retorna / Define** o atributo `required` do elemento, indicando que o usuário deve preencher um valor antes de enviar um formulário.

`validationMessage` Somente leitura

`string`: **Retorna** uma mensagem localizada que descreve as restrições de validação que o controle não atende (se houver). Esta é a string vazia se o controle não for um candidato para validação de restrição (`willValidate` (en-US) é `false`), ou se satisfizer suas restrições. Este valor pode ser definido pelo método `setCustomValidity()` (en-US).

`validity` Somente leitura

`ValidityState`: **Retorna** o estado de validade atual do elemento.

`willValidate` Somente leitura

`boolean`: **Retorna** se o elemento é um candidato para validação de restrição. É `false` se alguma condição o impedir de validação de restrição, incluindo: seu `type` é um dos `hidden`, `reset` ou `button`, tem um ancestral `<datalist>` ou sua propriedade `disabled` é `true`.

### Propriedades de instância que se aplicam apenas a elementos do tipo caixa de seleção ou rádio

`checked`

`boolean`: **Retorna / Define** o estado atual do elemento.

`defaultChecked`

`boolean`: **Retorna / Define** o estado padrão de um botão de rádio ou caixa de seleção conforme originalmente especificado no HTML que criou este objeto.

`indeterminate`

`boolean`: **Retorna** se a caixa de seleção ou o botão de opção está em estado indeterminado. Para caixas de seleção, o efeito é que a aparência da caixa de seleção é obscurecida/acinzentada de alguma forma para indicar que seu estado é indeterminado (não marcado, mas não desmarcado). Não afeta o valor do atributo `checked`, e clicar na caixa de seleção definirá o valor como falso.

### Propriedades de instância que se aplicam apenas a elementos do tipo imagem

`alt`

`string`: **Retorna / Define** o atributo `alt` do elemento, contendo texto alternativo a ser usado.

`height`

`string`: **Retorna / Define** o atributo `height` do elemento, que define a altura da imagem exibida para o botão.

`src`

`string`: **Retorna / Define** o atributo `src` do elemento, que especifica um URI para a localização de uma imagem para exibir no botão gráfico de envio.

`width`

`string`: **Retorna / Define** o atributo `width` do elemento, que define a largura da imagem exibida para o botão.

### Propriedades de instância que se aplicam apenas a elementos do tipo arquivo

`accept`

`string`: **Retorna / Define** o atributo `accept` do elemento, contendo uma lista separada por vírgulas de tipos de arquivos que podem ser selecionado.

`allowdirs`
Non-standard

`boolean`: Parte da API de upload de diretório não padrão. Indica se permite ou não que diretórios e arquivos sejam selecionados na lista de arquivos. Implementado apenas no Firefox e está oculto atrás de uma preferência.

`files` (en-US)

`FileList`: **Retorna / Define** uma lista de objetos `File` representando os arquivos selecionados para upload.

`webkitdirectory` (en-US)

`boolean`: **Retorna** o atributo `webkitdirectory`. Se for verdadeiro, a interface do seletor do sistema de arquivos aceita apenas diretórios em vez de arquivos.

`webkitEntries` (en-US)

`FileSystemEntry` (en-US) array: **Descreve** os arquivos ou diretórios atualmente selecionados.

### Propriedades de instância que se aplicam apenas a elementos visíveis contendo texto ou números

`autocomplete`

`string`: **Retorna / Define** o atributo `autocomplete` do elemento, indicando se o valor do controle pode ser automaticamente preenchido pelo navegador.

`max`

`string`: **Retorna / Define** o atributo `max` do elemento, contendo o valor (numérico ou data-hora) máximo para este item, que não deve ser menor que seu valor mínimo (atributo `min`).

`maxLength`

`unsigned long`: **Retorna / Define** o atributo `maxlength` do elemento, contendo o número máximo de caracteres (em pontos de código Unicode) que o valor pode ter.

`min`

`string`: **Retorna / Define** o atributo `min` do elemento, contendo o valor (numérico ou data-hora) mínimo para este item, que não deve ser maior que seu valor máximo (atributo `max`).

`minLength`

`unsigned long`: **Retorna / Define** o atributo `minlength` do elemento, contendo o número mínimo de caracteres (em Unicode pontos de código) que o valor pode ter.

`pattern`

`string`: **Retorna / Define** o atributo `pattern` do elemento, contendo uma expressão regular em que o valor do controle é verificado contra. Use o atributo `title` para descrever o padrão para ajudar o usuário. Este atributo só se aplica quando o valor do atributo `type` é `text`, `search`, `tel`, `url` ou `e-mail`.

`placeholder`

`string`: **Retorna / Define** o atributo `placeholder` do elemento, contendo uma dica para o usuário do que pode ser inserido no controle. O texto do espaço reservado não deve conter retornos de carro ou avanços de linha. Este atributo só se aplica quando o valor do atributo `type` é `text`, `search`, `tel`, `url` ou `e-mail`.

`readOnly`

`boolean`: **Retorna / Define** o atributo `readonly` do elemento, indicando que o usuário não pode modificar o valor do controle. Isso é ignorado se o `type` for `hidden`, `range`, `color`, `checkbox`, `radio`, `file`, ou um tipo de botão.

`selectionEnd`

`unsigned long`: **Retorna / Define** o índice final do texto selecionado. Quando não há seleção, isso retorna o deslocamento do caractere imediatamente após a posição atual do cursor de entrada de texto.

`selectionStart`

`unsigned long`: **Retorna / Define** o índice inicial do texto selecionado. Quando nada é selecionado, retorna a posição do cursor de entrada de texto (caret) dentro do elemento `<input>`.

`selectionDirection`

`string`: **Retorna / Define** a direção em que a seleção ocorreu. Os valores possíveis são: `forward` (a seleção foi realizada na direção de início a fim do local atual), `backward` (a direção oposta) ou `none` (a direção é desconhecida).

`size`

`unsigned long`: **Retorna / Define** o atributo `size` do elemento, contendo o tamanho visual do controle. Este valor está em pixels, a menos que o valor de `type` seja `text` ou `password`, caso em que é um número inteiro indicando o número de caracteres. Aplica-se somente quando `type` é definido como `text`, `search`, `tel`, `url`, `email` ou `senha`.

Métodos de instância
--------------------

`blur()` (en-US)

Remove o foco do elemento de entrada; as teclas digitadas subsequentemente não irão a lugar nenhum.

`click()`

Simula um clique no elemento de entrada.

`focus()` (en-US)

Foca no elemento de entrada; os pressionamentos de tecla irão posteriormente para este elemento.

`select()`

Seleciona todo o texto no elemento de entrada e o foca para que o usuário possa substituir posteriormente todo o seu conteúdo.

`setSelectionRange()`

Seleciona um intervalo de texto no elemento de entrada (mas não o focaliza).

`setRangeText()` (en-US)

Substitui um intervalo de texto no elemento de entrada por um novo texto.

`setCustomValidity()` (en-US)

Define uma mensagem de validação personalizada para o elemento. Se esta mensagem não for a string vazia, o elemento está sofrendo de um erro de validade personalizado e não é validado.

`showPicker()` (en-US)

Mostra um seletor de navegador para data, hora, cor e arquivos.

`checkValidity()` (en-US)

Retorna um valor booleano que é `false` se o elemento for um candidato para validação de restrição e não satisfizer suas restrições. Nesse caso, ele também dispara um evento `invalid` (en-US) no elemento. Ele retorna `true` se o elemento não for um candidato para validação de restrição ou se satisfizer suas restrições.

`reportValidity()` (en-US)

Executa o método `checkValidity()` e, se retornar falso (para uma entrada inválida ou nenhum atributo de padrão fornecido), ele relata ao usuário que a entrada é inválida da mesma maneira como se você enviasse um formulário.

`stepDown()` (en-US)

Decrementa o `value` em (`step` \* n), em que n é padronizado como 1 se não for especificado. Lança uma exceção `InvalidStateError`:

* se o método não for aplicável para o valor `type` atual,
* se o elemento não tiver valor `step`,
* se o `value` não puder ser convertido em um número,
* se o valor resultante estiver acima de `max` ou abaixo de `min`.

`stepUp()` (en-US)

Incrementa o `value` em (`step` \* n), em que n é padronizado como 1 se não for especificado. Lança uma exceção `InvalidStateError`:

* se o método não for aplicável para o valor atual de `type`,
* se o elemento não tiver valor `step`,
* se o `value` não puder ser convertido em um número,
* se o valor resultante estiver acima de `max` ou abaixo de `min`.

Eventos
-------

Ouça esses eventos usando `addEventListener()` ou atribuindo um ouvinte de evento à propriedade `oneventname` desta interface:

`input`

Dispara quando o `value` de um elemento `<input>`, `<select>` ou `<textarea>` foi alterado. Observe que na verdade isso é acionado na interface `HTMLElement` (en-US) e também se aplica a elementos `contenteditable`, mas também listamos aqui porque é mais comumente usado com elementos de entrada de formulário.

`invalid` (en-US)

Disparado quando um elemento não satisfaz suas restrições durante a validação da restrição.

`search` (en-US)
Non-standard

Disparado quando uma pesquisa é iniciada em um `<input>` de `type="search"`.

`selectionchange` (en-US) evento
Experimental

Dispara quando a seleção de texto em um elemento `<input>` foi alterada.

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

| Specification |
| --- |
| HTML Standard # htmlinputelement |

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

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

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

* Elemento HTML implementando esta interface: `<input>`


EventSource - APIs da Web

EventSource
===========

A interface `EventSource` é usada para receber eventos enviados pelo servidor (server-sent events (en-US)). Ele se conecta via HTTP em um servidor e recebe eventos com o formato `text/event-stream`. A conexão permanece aberta até ser fechada chamando `EventSource.close()` (en-US).

Assim que a conexão estiver aberta, mensagens recebidas do servidor são entregues para o seu código na forma de eventos `message`.

Ao contrário dos WebSockets, server-sent events são unidirecionais; ou seja, mensagens são entregues em uma direção, do servidor para o cliente (por exemplo, um navegador web). Isso torna-os uma excelente escolha quando não há necessidade de enviar mensagens do cliente para o servidor. Por exemplo, `EventSource` é uma abordagem útil para lidar com atualizações de status de mídias sociais, feeds de notícias, or entregar dados para um mecanismo de armazenamento do lado cliente como o IndexedDB ou o web storage.

Construtor
----------

`EventSource()`

Cria um novo `EventSource` para receber enventos enviados pelo servidor de uma URL específica, opcionalmente no modo de credenciais.

Propriedades
------------

*Essa interface também herda propriedades do seu pai, `EventTarget`.*

`EventSource.readyState` (en-US) Somente leitura

Um número representando o estado da conexão. Valores possíveis são `CONNECTING` (`0`), `OPEN` (`1`), ou `CLOSED` (`2`).

`EventSource.url` (en-US) Somente leitura

Uma `DOMString` representando a URL da origem.

`EventSource.withCredentials` (en-US) Somente leitura

Um `Boolean` (en-US) indicando se a `EventSource` foi instanciada com credenciais cross-origin (CORS) definidas (`true`) ou não (`false`, o padrão).

### Eventos

`EventSource.onerror`

É um `event handler` chamado quando um erro ocorre e o evento `error (en-US)` é despachado para o objeto `EventSource`.

`EventSource.onmessage` (en-US)

É um `event handler` chamado quando um evento `message` é recebido, ou seja, quando uma mensagem está sendo recebida da origem.

`EventSource.onopen` (en-US)

É um `event handler` chamado quando um evento `open` é recebido, ou seja, logo após a abertura da conexão.

Métodos
-------

*Essa interface herda métodos de seu pai, `EventTarget`.*

`EventSource.close()` (en-US)

Fecha a conexão, se houver, e define o atributo `readyState` como `CLOSED`. Se a conexão já estiver fechada, esse método não faz nada.

Exemplos
--------

Nesse exemplo básico, um `EventSource` é criado para receber eventos do servidor; a página com o nome `"sse.php"` é responsável por gerar os eventos.

```js
var evtSource = new EventSource("sse.php");
var eventList = document.querySelector("ul");

evtSource.onmessage = function (e) {
  var newElement = document.createElement("li");

  newElement.textContent = "message: " + e.data;
  eventList.appendChild(newElement);
};
```

Cada evento recebido faz com que o handler do evento `onmessage` no objeto `EventSource` seja executado. Ele, em contrapartida, cria um novo elemento `<li>` e escreve os dados da mensagem nele, e em seguida concatena o novo elemento na lista já presente no documento.

**Nota:** Você pode encontrar um exemplo completo no GitHub — veja Simple SSE demo using PHP.

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

| Specification |
| --- |
| HTML Standard # the-eventsource-interface |

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

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

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

* Server-sent events (en-US)
* Usando server-sent events