recursal/MDN huggingface dataset:
Document.images
===============

Summary
-------

`document.images` retorna uma coleção de imagens (en-US) do documento HTML.

Sintaxe
-------
```

var htmlCollection = document.images;
```

Exemplo
-------


```js
var ilist = document.images;

for (var i = 0; i < ilist.length; i++) {
  if (ilist[i].src == "banner.gif") {
    // found the banner
  }
}
```

Notas
-----

`document.images.length` – propriedade, retorna o número de imagens na página.

`document.images` é parte do DOM HTML, e só trabalho com documentos HTML.

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

| Specification |
| --- |
| HTML Standard # dom-document-images-dev |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Document.querySelector()
========================

Sumário
-------

Retorna o primeiro elemento dentro do documento (usando ordenação em profundidade, pré-ordenada e transversal dos nós do documento) que corresponde ao grupo especificado de seletores.

Sintaxe
-------
```

element = document.querySelector(selectors);
```


Onde:

* `element` é um objeto `Element`.
* `selectors` é uma string que contém um ou mais seletores CSS separados por vírgulas.
Exemplo
-------

Neste exemplo, o primeiro elemento no documento com a classe "`myclass`" é retornado:


```js
var el = document.querySelector(".myclass");
```

Notas
-----

Retorna `null` se nenhum resultado for encontrado; caso contrário, retorna o primeiro elemento correspondente.

Se o seletor utilizado for um `ID` e este `ID` foi erroneamente utilizado várias vezes no documento, ele retorna somente o primeiro elemento correspondente.

Gera uma exceção `SYNTAX_ERR` se o grupo de seletores utilizado for inválido.

`querySelector()` foi introduzido com a API de seletores.

Compatibilidade dos navegadores
-------------------------------

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

Especificação
-------------

* Selectors API
Veja também
-----------

* `document.querySelectorAll()`
* `element.querySelector()`
* `element.querySelectorAll()`
* Code snippets for querySelector
Document.body
=============

Retorna o elemento `<body>` ou o `<frameset>` (en-US) do documento atual, ou `null` se nenhum destes elementos existir.

Sintaxe
-------
```

var objRef = document.body;
document.body = objRef;
```

Exemplo
-------


```js
// No HTML: <body id="oldBodyElement"></body>
alert(document.body.id); // "oldBodyElement"

var aNewBodyElement = document.createElement("body");

aNewBodyElement.id = "newBodyElement";
document.body = aNewBodyElement;
alert(document.body.id); // "newBodyElement"
```

Notas
-----

`document.body` é o elemento que envolve o conteúdo do documento. Em documentos com conteúdo no `<body>`, retorna o elemento `<body>`, e em documentos que usam frameset, retorna o elemento `<frameset>` mais periférico.

Apesar do `body` ser configurável, definir um novo `body` em um documento irá remover todos os elementos contidos no elemento `<body>` existente.

Especificação
-------------

* DOM Level 2 HTML: HTMLDocument.body
* HTML5: DOM Tree Accessors
Veja Também
-----------

* `document.head`
Document.write()
================

O método **`Document.write()`** grava uma sequência de caracteres em um documento aberto por `document.open()` (en-US).

**Nota:** à medida que `document.write` grava no **fluxo** de documentos, chamando `document.write` em um documento fechado (carregado) invoca automaticamente `document.open`, que limpará o documento (en-US).

Sintaxe
-------


```js
document.write(markup);
```

### Parametros

*markup*

Uma string contendo o texto a ser gravado no documento.

### Exemplo


```html
<html>
  <head>
    <title>Escreva exemplo</title>

    <script>
 function newContent() {
 document.open();
 document.write("<h1>Sair com o velho - entrar com o novo!</h1>");
 document.close();
 }
 </script>
  </head>

  <body onload="newContent();">
    <p>Algum conteúdo do documento original.</p>
  </body>
</html>
```

Notas
-----

Escrevendo em um documento que já foi carregado sem chamar `document.open()` (en-US) automaticamente vai chamar `document.open`. Ao términno da escrita, é recomendável chamar `document.close()` para dizer ao navegador para encerrar o carregamento da página. O texto que você escreve é analisado no modelo de estrutura do documento. No exemplo acima, o elemento `h1` se torna um nó (node) no documento.

Se chamar `document.write()` incorporada em uma tag HTML `<script>` embutida, então `document.open()` não será chamada. Por exemplo:


```html
<script>
 document.write("<h1>Título principal</h1>");
</script>
```


**Nota:** `document.write` e `document.writeln` não funcionam em documentos XHTML (você receberá o erro "Operation is not supported" [`NS_ERROR_DOM_NOT_SUPPORTED_ERR`] no console de erros). Isso acontece ao abrir um arquivo local com a extensão .xhtml ou em qualquer documento exibido com um MIME type `application/xhtml+xml` MIME type (en-US). Mais informações disponíveis em W3C XHTML FAQ.

**Nota:** `document.write` em deferred ou asynchronous scripts será ignorado, e você receberá uma mensagem como "A call to `document.write()` from an asynchronously-loaded external script was ignored" no console de erros.

**Nota:** Somente no Edge, chamando `document.write` mais de uma vez em `<iframe>` causa o erro "SCRIPT70: Permission denied".

**Nota:** A partir de 55, Chrome não executará elementos `<script>` injetados via `document.write()` caso haja falta de cache HTTP para usuários em uma conexão 2G. Há uma lista de condições que precisam ser atendidas para que isso seja verdade.

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

| Specification |
| --- |
| HTML Standard # dom-document-write-dev |

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

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

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

* `element.innerHTML`
* `document.createElement()`
Document.importNode()
=====================

Cria uma cópia de um nó a partir de um documento externo para ser inserido no document atual.

Sintaxe
-------
```

var node = document.importNode(externalNode, deep);
```


`node`

`O novo nó que será importado no documento. A propriedade parentNode do novo nó é null, desde que ele não foi inserido na árvores do documento.`

`externalNode`

`O nó de outro documento para ser importado.`

`deep`

`Um boolean, indicando se os nós filhos, do nó a ser importado, devem ser importados também.`


**Nota:** In the DOM4 specification (as implemented in Gecko 13.0), `deep` is an optional argument. If omitted, the method acts as if the value of `deep` was **`true`**, defaulting to using deep cloning as the default behavior. To create a shallow clone, `deep` must be set to `false`.

This behavior has been changed in the latest spec, and if omitted, the method will act as if the value of `deep` was **`false`**. Though It's still optional, you should always provide the `deep` argument both for backward and forward compatibility. With Gecko 28.0, the console warned developers not to omit the argument. Starting with Gecko 29.0), a shallow clone is defaulted instead of a deep clone.

Exemplo
-------


```js
var iframe = document.getElementsByTagName("iframe")[0];
var oldNode = iframe.contentWindow.document.getElementById("myNode");
var newNode = document.importNode(oldNode, true);
document.getElementById("container").appendChild(newNode);
```

Notas
-----

O nó original não é removido do documento de origem. O nó importado é um clone do original.

Nodes from external documents should be cloned using `document.importNode()` (or adopted using `document.adoptNode()` (en-US)) before they can be inserted into the current document. For more on the `Node.ownerDocument` (en-US) issues, see the W3C DOM FAQ.

Firefox doesn't currently enforce this rule (it did for a while during the development of Firefox 3, but too many sites break when this rule is enforced). We encourage Web developers to fix their code to follow this rule for improved future compatibility.

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-document-importnode① |

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

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

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

* `document.adoptNode()` (en-US)
Document.doctype
================

Retorna a declaração do tipo de documento(Document Type Declaration (DTD)) associado ao documento atual. O objeto retornado implementa a interface `DocumentType` (en-US). Use `DOMImplementation.createDocumentType()` (en-US) para criar um `DocumentType`.

Sintaxe
-------
```

doctype = document.doctype;
```


* `doctype` é uma proriedade somente de leitura.
Exemplo
-------


```js
var doctypeObj = document.doctype;

console.log(
  "doctypeObj.name: " +
    doctypeObj.name +
    "\n" +
    "doctypeObj.internalSubset: " +
    doctypeObj.internalSubset +
    "\n" +
    "doctypeObj.publicId: " +
    doctypeObj.publicId +
    "\n" +
    "doctypeObj.systemId: " +
    doctypeObj.systemId,
);
```

Notas
-----

A propriedade retornará `null` se não houvernehum DTD associado ao documento atual.

O nível 2 do DOM não suporta a edição da declaração do tipo de documento.

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-document-doctype① |

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

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

Sumário
-------

Em navegadores, retorna o objeto window (en-US) associado ao documento ou `null` se não houver.

Sintaxe
-------
```

var win = document.defaultView;
```


Esta propriedade é de somente-leitura.

Notas
-----

De acordo com o quirksmode, `defaultView` não é suportado no IE até o IE 9.

Especificação
-------------

* HTML5: defaultView
* DOM Level 2 Views: defaultView
* DOM Level 3 Views (Apenas desenvolvido para o Working Group Note e não implementado)
Document.fullscreen
===================

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

A propriedade de somente leitura da interface **`fullscreen`** retorna se o documento correspondente está mostrando conteúdo em modo de tela cheia (full-screen).

Apesar dessa propriedade ser de somente leitura, ela não será executa se for modificada (mesmo em modo estrito); o setter não é um operador e não será modificado.

**Nota:** Desde que esta propriedade foi descontinuada, você pode determinar se o modo full-screen está ativo no documento checando se `Document.fullscreenElement` (en-US) não é `null`.

Síntaxe
-------
```

var isFullScreen = document.fullscreen;
```

### Valor

Um valor booleano é `true` se o documento está mostrando um elemento no modo full-screen; se não, o valor é `false`.

Exemplo
-------

Esta simples função retorna se o modo full-sreen está ativo, usando a obsoleta propriedade **`fullscreen`**.


```js
function isDocumentInFullScreenMode() {
  return document.fullscreen;
}
```


Neste próximo exemplo, de outra maneira, usa a propriedade atual `fullscreenElement` para determinar a mesma coisa:


```js
function isDocumentInFullScreenMode() {
  return document.fullscreenElement !== null;
}
```


Se `fullscreenElement` não é `null`, retorna `true`, indicando se modo full-screen está sendo usado.

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

| Specification |
| --- |
| Fullscreen API Standard # dom-document-fullscreen |

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

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

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

* Fullscreen API (en-US)
* Guide to the Fullscreen API (en-US)
* `Document.fullscreenEnabled` (en-US)
Document()
==========

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

O construtor **`Document`** cria um novo objeto `Document`, o qual trata de uma página carregada no navegador servindo como porta de entrada para o conteúdo da página.

Sintaxe
-------
```

var document = new Document()
```

### Parâmetros

Nenhum.

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-document-document① |

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

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

Sumário
-------

Retorna "*loading*" enquanto `document` está carregando, "*interactive*" quando foi carregado porém seus sub-recursos (como imagens, por exemplo) ainda não, e "*complete*" quando foi totalmente carregado.

O evento `readystatechange` é acionado no objeto `document` quando esse valor é alterado.

Sintaxe
-------
```

var string = document.readyState;
```

### Valores

O `readyState` de um documento pode ser um dos seguintes:

`loading`

O `document` ainda está carregando.

`interactive`

O documento terminou de ser carregado e o documento foi analisado, mas sub-recursos, como imagens, folhas de estilo e quadros, ainda estão sendo carregados.

`complete`

O documento e todos os sub-recursos terminaram de carregar. O estado indica que o `load (en-US)` evento está prestes a disparar.

Exemplos
--------

### Diferentes estados de readyState
```

switch (document.readyState) {
  case "loading":
    // O documento esta carregando
    break;
  case "interactive":
    // O documento acabou de carregar. Nós podemos acessar os elementos do DOM.
    // mas sub-recursos, como imagens, folhas de estilo e quadros, ainda estão sendo carregados.
    var span = document.createElement("span");
    span.textContent = "A <span> element.";
    document.body.appendChild(span);
    break;
  case "complete":
    // A pagina carregou por completo.
    console.log("The first CSS rule is: " + document.styleSheets[0].cssRules[0].cssText);
    break;
}
```

### readystatechange como uma alternativa para DOMContentLoaded evento
```

// alternativa para DOMContentLoaded evento
document.onreadystatechange = function () {
  if (document.readyState === 'interactive') {
    initApplication();
  }
}
```

### readystatechange como uma alternativa para load evento
```

// ternativa para load evento
document.onreadystatechange = function () {
  if (document.readyState === 'complete') {
    initApplication();
  }
}
```

### readystatechange como ouvinte de evento para inserir ou modificar o DOM antes de DOMContentLoaded
```

document.addEventListener('readystatechange', event => {
  if (event.target.readyState === 'interactive') {
    initLoader();
  }
  else if (event.target.readyState === 'complete') {
    initApp();
  }
});
```

Especificação
-------------

* http://www.whatwg.org/specs/web-apps/current-work/multipage/dom.html#current-document-readiness
Veja também
-----------

* document.onreadystatechange
Document.anchors
================

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

`anchors` retorna uma lista de todas as âncoras no documento.

Sintaxe
-------
```

nodeList = document.anchors;
```

Exemplo
-------


```js
if (document.anchors.length >= 5) {
  dump("dump found too many anchors");
  window.location = "http://www.google.com";
}
```


O código a seguir é um exemplo que popula automaticamente um índice de conteúdo com cada âncora encontrada na página:


```html
<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Test</title>
    <script>
 function init() {
 var toc = document.getElementById("toc");
 var i, li, newAnchor;
 for (i = 0; i < document.anchors.length; i++) {
 li = document.createElement("li");
 newAnchor = document.createElement("a");
 newAnchor.href = "#" + document.anchors[i].name;
 newAnchor.innerHTML = document.anchors[i].text;
 li.appendChild(newAnchor);
 toc.appendChild(li);
 }
 }
 </script>
  </head>
  <body onload="init()">
    <h1>Title</h1>
    <h2><a name="contents">Contents</a></h2>
    <ul id="toc"></ul>

    <h2><a name="plants">Plants</a></h2>
    <ol>
      <li>Apples</li>
      <li>Oranges</li>
      <li>Pears</li>
    </ol>

    <h2><a name="veggies">Veggies</a></h2>
    <ol>
      <li>Carrots</li>
      <li>Celery</li>
      <li>Beats</li>
    </ol>
  </body>
</html>
```


View on JSFiddle

Notas
-----

Por motivos de compatibilidade, o conjunto de âncoras retornadas por `anchors` contém apenas as âncoras criadas com o atributo `name`, não incluindo as âncoras criadas com o atributo `id`.

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

| Specification |
| --- |
| HTML Standard # dom-document-anchors |
Document.querySelectorAll()
===========================

Introdução
----------

Retorna uma lista de elementos presentes no documento (usando ordenação em profundidade, pré-ordenada e transversal dos nós do documento) que coincidam com o grupo de seletores especificado. O objeto retornado é uma `NodeList`.

Sintaxe
-------
```

elementList = document.querySelectorAll(selectors);
```


onde

* `elementList` é uma `NodeList` não-viva (alterações no DOM não refletem na lista) de objetos `Element`.
* `selectors` é uma *string* contendo um ou mais seletores CSS separados por vírgulas.

A NodeList retornada irá conter todos os elementos do documento que coincidam com os seletores especificados. Se a string `selectors` conter um CSS `PseudoElements`, o retorno será uma NodeList vazia.

Exemplo
-------

Esse exemplo retorna uma lista de todos os elementos `div` presentes no `document` que contenham as classes "`note`" ou "`alert`":


```js
var matches = document.querySelectorAll("div.note, div.alert");
```

Notas
-----

Retorna uma `NodeList` não-viva (alterações no DOM não refletem na lista) de todos os elementos que coincidam com os seletores informados.

Lança uma exceção `SYNTAX_ERR` se o grupo especificado de seletores for inválido.

`querySelectorAll()` foi introduzida na WebApps API.

Navegadores baseados em *WebKit* têm um *bug*: quando a string `seletores` contém um pseudo-elemento CSS (en-US), a `NodeList` retornada não esta vazia, neste caso ela contém o elemento `<html>`.

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

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

Especificação
-------------

* API Selectors
Veja também
-----------

* `Element.querySelectorAll`
* `Document.querySelector`
* `Element.querySelector`
* `Exemplos de código com querySelector`
Document.getSelection()
=======================

Esse método funciona de forma idêntica ao método `Window.getSelection()`; Ele retorna um objeto `Selection` representando o texto atualmente selecionado no documento.
NodeFilter
==========

Uma interface **`NodeFilter`** representa um objeto usado para filtrar os nós (elementos), em uma iteração `NodeIterator` (en-US) ou `TreeWalker` (en-US). Essas interfaces não conhecem nada sobre o DOM ou sobre como percorrer ou atravessar, elementos; elas apenas sabem como avaliar se um único nó atende aos requisitos do filtro fornecido ou não.

**Nota:** O navegador não fornece nenhum objeto que implemente essa interface. É esperado que o desenvolvedor escreva tal objeto, utilizando o método `acceptNode()` conforme as suas necessidades, podendo mesclar com objetos do tipo `TreeWalker` (en-US) ou `NodeIterator` (en-US) em sua implementação..

Properties
----------

*Essa interface não implementa, nem herda, nenhuma propriedade.*

Methods
-------

*Essa interface não herda nenhum método.*

`NodeFilter.acceptNode()` (en-US)

Returns an `unsigned short` that will be used to tell if a given `Node` must be accepted or not by the `NodeIterator` (en-US) or `TreeWalker` (en-US) iteration algorithm. This method is expected to be written by the user of a `NodeFilter`. Possible return values are:

| Constant | Description |
| --- | --- |
| `FILTER_ACCEPT` | Value returned by the `NodeFilter.acceptNode()` (en-US) method when a node should be accepted. |
| `FILTER_REJECT` | Value to be returned by the `NodeFilter.acceptNode()` (en-US) method when a node should be rejected. For `TreeWalker` (en-US), child nodes are also rejected. For `NodeIterator` (en-US), this flag is synonymous with FILTER\_SKIP. |
| `FILTER_SKIP` | Value to be returned by `NodeFilter.acceptNode()` (en-US) for nodes to be skipped by the `NodeIterator` (en-US) or `TreeWalker` (en-US) object. The children of skipped nodes are still considered. This is treated as "skip this node but not its children". |

Example
-------


```js
var nodeIterator = document.createNodeIterator(
  // Node to use as root
  document.getElementById("someId"),

  // Only consider nodes that are text nodes (nodeType 3)
  NodeFilter.SHOW\_TEXT,

  // Object containing the function to use for the acceptNode method
  // of the NodeFilter
  {
    acceptNode: function (node) {
      // Logic to determine whether to accept, reject or skip node
      // In this case, only accept nodes that have content
      // other than whitespace
      if (!/^\s\*$/.test(node.data)) {
        return NodeFilter.FILTER\_ACCEPT;
      }
    },
  },
  false,
);

// Show the content of every non-empty text node that is a child of root
var node;

while ((node = nodeIterator.nextNode())) {
  alert(node.data);
}
```

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

| Specification |
| --- |
| DOM Standard # dom-document-createnodeiterator |

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

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

See also
--------

* Related interfaces: `TreeWalker` (en-US), `NodeIterator` (en-US).
Document.location
=================

A propriedade, de apenas leitura, **`Document.location`** retorna um objeto `Location`, que contém informações sobre a URL do documento e provém métodos para mudar a URL e carregar outra URL.

Embora `Document.location` seja um objeto `Location de apenas leitura`, você pode atribuir um `DOMString` para ele. Isso significa que você pode trabalhar com document.location, na maioria dos casos, como se fosse uma string: `document.location = 'http://www.example.com'` é um sinônimo de `document.location.href = 'http://www.example.com'`.

Para recuperar somente a URL como uma string, a propriedade de apenas leitura `document.URL` pode ser utilizada.

Se o documento atual não estiver no contexto de navegação, o valor retornado será `null`.

Sintaxe
-------
```

locationObj = document.location
document.location = 'http://www.mozilla.org' // Equivalente a document.location.href = 'http://www.mozilla.org'
```

Exemplo
-------


```js
dump(document.location);
// Imprime uma string como
// "http://www.example.com/juicybits.html" to the console
```

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

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

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

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

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

* O valor da interface de retorno, `Location`.
* Uma informação similar, mas anexada ao browsing context (en-US), `Window.location`.