1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
---
title: DataView
slug: Web/JavaScript/Reference/Global_Objects/DataView
tags:
- Constructor
- DataView
- JavaScript
- TypedArrays
translation_of: Web/JavaScript/Reference/Global_Objects/DataView
---
<div>{{JSRef}}</div>
<p>O <strong><code>DataView</code></strong> provê uma interface de baixo nível para leitura e escrita de múltiplos tipos de número em um {{jsxref("ArrayBuffer")}}, independentemente da <a href="/pt-BR/docs/Glossario/Endianness">extremidade (<em>endianness</em>) da plataforma</a>.</p>
<p>{{EmbedInteractiveExample("pages/js/dataview-constructor.html")}}</p>
<div class="hidden">
<p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
</div>
<h2 id="Sintaxe">Sintaxe</h2>
<pre class="syntaxbox">new DataView(buffer [, byteOffset [, byteLength]])</pre>
<h3 id="Parâmetros">Parâmetros</h3>
<dl>
<dt><code>buffer</code></dt>
<dd>{{jsxref("ArrayBuffer")}} ou {{jsxref("SharedArrayBuffer")}} {{experimental_inline}} existente para usar como armazenamento de um novo objeto <code>DataView</code>.</dd>
<dt><code>byteOffset</code> {{optional_inline}}</dt>
<dd>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.</dd>
<dt><code>byteLength</code> {{optional_inline}}</dt>
<dd>O número de elementos no array de bytes. Se não especificado, o tamanho da view será do mesmo tamanho do buffer.</dd>
</dl>
<h3 id="Retorno">Retorno</h3>
<p>Um novo objeto <code>DataView</code> que representa o buffer de dados especificado. (Provavelmente não foi uma descrição muito útil.)</p>
<p><font>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. </font><font>Isso significa lidar com conversões <em>integer,</em> <em>float,</em> <em>endianness</em> e outros detalhes da representação de números em formato binário.</font></p>
<h3 id="Exceções">Exceções</h3>
<dl>
<dt><code>{{jsxref("RangeError")}}</code></dt>
<dd>Lançado se o <code>byteOffset</code> ou <code>byteLength</code> especificados ultrapassarem o final do buffer.</dd>
<dd><font><font>Por exemplo, se o buffer tem 16 bytes de comprimento, o </font></font><code>byteOffset</code> <font><font>é 8 e o </font></font><code>byteLength</code> <font><font>é 10, esse erro será lançado porque a view resultante tenta estender 2 bytes acima do comprimento total do buffer.</font></font></dd>
</dl>
<h2 id="Descrição">Descrição</h2>
<h3 id="Endianness"><em>Endianness</em></h3>
<p>Formatos de números <em>Multi-byte</em> são representados de maneira diferente na memória, dependendo da arquitetura da máquina, veja {{Glossary("Endianness")}} para mais informações. Assessores de <code>DataView</code> fornecem controle explícito de como o dado será acessado, independente do <em>endianness </em>da arquitetura em execução. </p>
<pre class="brush: 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
</pre>
<h3 id="Valores_inteiros_de_64_bits"><font><font>Valores inteiros de 64 bits</font></font></h3>
<p>Como JavaScript atualmente não inclui suporte padrão para valores inteiros de 64 bits, <code>DataView</code> 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 {{jsxref("Number.MAX_SAFE_INTEGER")}}, o que pode ser bom para determinados casos.</p>
<pre class="brush: 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;
}</pre>
<p>Como alternativa, se você precisar de um intervalo completo de 64 bits, poderá criar um {{jsxref("BigInt")}}.</p>
<pre class="brush: 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}`);
}
</pre>
<h2 id="Propriedades">Propriedades</h2>
<p>Todas as instâncias de <code>DataView</code> herdam {{jsxref("DataView.prototype")}} e permitem a adição de propriedades a todos os objetos DataView.</p>
<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Properties')}}</p>
<h2 id="Métodos">Métodos</h2>
<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Methods')}}</p>
<h2 id="Exemplo">Exemplo</h2>
<pre class="brush: js">var buffer = new ArrayBuffer(16);
var dv = new DataView(buffer, 0);
dv.setInt16(1, 42);
dv.getInt16(1); //42
</pre>
<h2 id="Especificações">Especificações</h2>
<table class="standard-table">
<tbody>
<tr>
<th scope="col">Especificação</th>
<th scope="col">Status</th>
<th scope="col">Comentário</th>
</tr>
<tr>
<td>{{SpecName('Typed Array')}}</td>
<td>{{Spec2('Typed Array')}}</td>
<td>Substituído pelo ECMAScript 6</td>
</tr>
<tr>
<td>{{SpecName('ES6', '#sec-dataview-constructor', 'DataView')}}</td>
<td>{{Spec2('ES6')}}</td>
<td>Definição inicial no ECMA standard</td>
</tr>
<tr>
<td>{{SpecName('ESDraft', '#sec-dataview-constructor', 'DataView')}}</td>
<td>{{Spec2('ESDraft')}}</td>
<td> </td>
</tr>
</tbody>
</table>
<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
<div class="hidden">
<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>and send us a pull request.</p>
</div>
<p>{{Compat("javascript.builtins.DataView")}}</p>
<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2>
<p>Começando com o Firefox 40, <code>DataView</code> deve ser construído com o operador {{jsxref("Operators/new", "new")}} . Chamando <code>DataView()</code> como uma função sem o <code>new</code>, irá lançar um {{jsxref("TypeError")}} de agora em diante.</p>
<pre class="brush: js example-bad">var dv = DataView(buffer, 0);
// TypeError: calling a builtin DataView constructor without new is forbidden</pre>
<pre class="brush: js example-good">var dv = new DataView(buffer, 0);</pre>
<h2 id="Veja_também">Veja também</h2>
<ul>
<li><a class="link-https" href="https://github.com/jDataView/jDataView">jDataView</a>: Biblioteca javascript que faz o polyfill e extende a API do <code>DataView</code> para todos os browsers e para o Node.js.</li>
<li>{{jsxref("ArrayBuffer")}}</li>
<li>{{jsxref("SharedArrayBuffer")}}</li>
</ul>
|
