DataView
========

O **`DataView`** provê uma interface de baixo nível para leitura e escrita de múltiplos tipos de número em um `ArrayBuffer`, independentemente da extremidade (*endianness*) da plataforma.

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

Sintaxe
-------
```

new DataView(buffer [, byteOffset [, byteLength]])
```

### Parâmetros

`buffer`

`ArrayBuffer` ou `SharedArrayBuffer` (en-US) 
Experimental
 existente para usar como armazenamento de um novo objeto `DataView`.

`byteOffset` Optional

A mudança, em bytes, do primeiro byte determinado em um buffer, que será referenciado pela nova view. Se não for especificado, a view do buffer começará no primeiro byte.

`byteLength` Optional

O número de elementos no array de bytes. Se não especificado, o tamanho da view será do mesmo tamanho do buffer.

### Retorno

Um novo objeto `DataView` que representa o buffer de dados especificado. (Provavelmente não foi uma descrição muito útil.)

Você pode pensar nesse objeto retornado como um "intérprete" de um array buffer de bytes - ele sabe como converter números para inserir em um buffer corretamente, tanto ao ler quanto ao gravar. Isso significa lidar com conversões *integer,* *float,* *endianness* e outros detalhes da representação de números em formato binário.

### Exceções

``RangeError` (en-US)`

Lançado se o `byteOffset` ou `byteLength` especificados ultrapassarem o final do buffer.

Por exemplo, se o buffer tem 16 bytes de comprimento, o `byteOffset` é 8 e o `byteLength` é 10, esse erro será lançado porque a view resultante tenta estender 2 bytes acima do comprimento total do buffer.

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

### *Endianness*

Formatos de números *Multi-byte* são representados de maneira diferente na memória, dependendo da arquitetura da máquina, veja Endianness para mais informações. Assessores de `DataView` fornecem controle explícito de como o dado será acessado, independente do *endianness* da arquitetura em execução.


```js
var littleEndian = (function () {
  var buffer = new ArrayBuffer(2);
  new DataView(buffer).setInt16(0, 256, true /\* littleEndian \*/);
  // Int16Array uses the platform's endianness.
  return new Int16Array(buffer)[0] === 256;
})();
console.log(littleEndian); // true or false
```

### Valores inteiros de 64 bits

Como JavaScript atualmente não inclui suporte padrão para valores inteiros de 64 bits, `DataView` não oferece operações nativas de 64 bits. Como solução alternativa, você poderia implementar sua própria função getUint64() para obter um valor com a precisão de `Number.MAX_SAFE_INTEGER`, o que pode ser bom para determinados casos.


```js
function getUint64(dataview, byteOffset, littleEndian) {
  // split 64-bit number into two 32-bit (4-byte) parts
  const left = dataview.getUint32(byteOffset, littleEndian);
  const right = dataview.getUint32(byteOffset + 4, littleEndian);

  // combine the two 32-bit values
  const combined = littleEndian
    ? left + 2 \*\* 32 \* right
    : 2 \*\* 32 \* left + right;

  if (!Number.isSafeInteger(combined))
    console.warn(combined, "exceeds MAX\_SAFE\_INTEGER. Precision may be lost");

  return combined;
}
```


Como alternativa, se você precisar de um intervalo completo de 64 bits, poderá criar um `BigInt`.


```js
function getUint64BigInt(dataview, byteOffset, littleEndian) {
  // split 64-bit number into two 32-bit (4-byte) parts
  const left = dataview.getUint32(byteOffset, littleEndian);
  const right = dataview.getUint32(byteOffset + 4, littleEndian);

  // combine the two 32-bit values as their hex string representations
  const combined = littleEndian
    ? right.toString(16) + left.toString(16).padStart(8, "0")
    : left.toString(16) + right.toString(16).padStart(8, "0");

  return BigInt(`0x${combined}`);
}
```

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

Todas as instâncias de `DataView` herdam `DataView.prototype` (en-US) e permitem a adição de propriedades a todos os objetos DataView.

{{page('en-US/Web/JavaScript/Reference/Global\_Objects/DataView/prototype','Properties')}}Métodos
-------

{{page('en-US/Web/JavaScript/Reference/Global\_Objects/DataView/prototype','Methods')}}Exemplo
-------


```js
var buffer = new ArrayBuffer(16);
var dv = new DataView(buffer, 0);

dv.setInt16(1, 42);
dv.getInt16(1); //42
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview-objects |

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

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

Notas de compatibilidade
------------------------

Começando com o Firefox 40, `DataView` deve ser construído com o operador `new` . Chamando `DataView()` como uma função sem o `new`, irá lançar um `TypeError` de agora em diante.


```js
var dv = DataView(buffer, 0);
// TypeError: calling a builtin DataView constructor without new is forbidden
```



```js
var dv = new DataView(buffer, 0);
```

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

* jDataView: Biblioteca javascript que faz o polyfill e extende a API do `DataView` para todos os browsers e para o Node.js.
* `ArrayBuffer`
* `SharedArrayBuffer` (en-US)