TypedArray
==========

Un objeto ***TypedArray*** describe una vista similar a un arreglo de un búfer de datos binarios subyacente. No existe una propiedad global denominada `TypedArray`, ni existe un constructor `TypedArray` directamente visible. En cambio, hay una serie de diferentes propiedades globales, cuyos valores son constructores de arreglos tipados para tipos de elementos específicos, que se enumeran a continuación. En las siguientes páginas, encontrarás propiedades y métodos comunes que se pueden utilizar con cualquier arreglo tipado que contenga elementos de cualquier tipo.

Pruébalo
--------

La fuente de este ejemplo interactivo se almacena en un repositorio de GitHub. Si deseas contribuir al proyecto de ejemplos interactivos, clona https://github.com/mdn/interactive-examples y envíanos una solicitud de extracción.

Descripción
-----------

ECMAScript 2015 define un constructor `TypedArray` que sirve como `[[Prototype]]` de todos los constructores `TypedArray`. Este constructor no está expuesto directamente: no existe una propiedad global `%TypedArray%` o `TypedArray`. Solo es accesible directamente a través de `Object.getPrototypeOf(Int8Array)` y similares. Todos los constructores de `TypedArray` heredan propiedades comunes de la función constructora `%TypedArray%`. Además, todos los prototipos de arreglos con tipo (`TypedArray.prototype`) tienen `%TypedArray%.prototype` como su `[[Prototype]]`.

El constructor `%TypedArray%` por sí solo no es particularmente útil. Llamarlo o usarlo en una expresión `new` arrojará un `TypeError`, excepto cuando se usa durante la creación de objetos en motores JS que admiten subclases. Actualmente no existen tales motores, por lo que `%TypedArray%` solo es útil para rellenar funciones o propiedades en todos los constructores `TypedArray`.

Al crear una instancia de `TypedArray` (p. ej., `Int8Array`), se crea un arreglo de búfer internamente en la memoria o, si se proporciona un objeto `ArrayBuffer` como argumento del constructor, entonces se usa en su lugar. La dirección del búfer se guarda como una propiedad interna de la instancia y todos los métodos de `%TypedArray%.prototype`, es decir, establecer el valor y obtener valor, etc.., operan en esa dirección del arreglo de búfer.

### Objetos TypedArray

| Tipo | Intervalo de valores | Tamaño en bytes | Descripción | Tipo de IDL web | Tipo C equivalente |
| --- | --- | --- | --- | --- | --- |
| `Int8Array` (en-US) | `-128` a `127` | 1 | Dos enteros complementarios de 8 bits con signo | `byte` | `int8_t` |
| `Uint8Array` | `0` a `255` | 1 | Entero de 8-bit sin signo | `octet` | `uint8_t` |
| `Uint8ClampedArray` (en-US) | `0` a `255` | 1 | Entero de 8 bits sin signo (sujeto) | `octet` | `uint8_t` |
| `Int16Array` (en-US) | `-32768` a `32767` | 2 | Dos enteros complementarios de 16 bits con signo | `short` | `int16_t` |
| `Uint16Array` (en-US) | `0` a `65535` | 2 | Entero de 16 bits sin signo | `Short sin signo` | `uint16_t` |
| `Int32Array` (en-US) | `-2147483648` a `2147483647` | 4 | dos enteros complementarios de 32 bits con signo | `long` | `int32_t` |
| `Uint32Array` (en-US) | `0` a `4294967295` | 4 | Enteros de 32 bits sin signo | `long sin signo` | `uint32_t` |
| `Float32Array` (en-US) | `1.2`×`10^-38` a `3.4`×`10^38` | 4 | Número de coma flotante IEEE de 32 bits (7 dígitos significativos, p. ej., `1.1234567`) | `float sin restricciones` | `float` |
| `Float64Array` (en-US) | `5.0`×`10^-324` a `1.8`×`10^308` | 8 | Número de coma flotante IEEE de 64 bits (16 dígitos significativos, p. Ej., `1.123...15`) | `doble sin restricciones` | `double` |
| `BigInt64Array` (en-US) | `-2^63` a `2^63-1` | 8 | Dos enteros complementarios de 64 bits con signo | `bigint` | `int64_t (long long con signo)` |
| `BigUint64Array` (en-US) | `0` a `2^64-1` | 8 | Entero de 64 bits sin signo | `bigint` | `uint64_t (long long sin signo)` |

Constructor
-----------

No se puede crear una instancia de este objeto directamente. En su lugar, crea una instancia de un arreglo de un tipo particular, tal como `Int8Array` (en-US) o `BigInt64Array` (en-US). Todos estos objetos tienen una sintaxis común para sus constructores:
```

new TypedArray();
new TypedArray(length);
new TypedArray(typedArray);
new TypedArray(object);
new TypedArray(buffer [, byteOffset [, length]]);
```


Donde *TypedArray* es un constructor para uno de los tipos concretos.

### Parámetros

`length`

Cuando se llama con un argumento `length`, se crea un búfer de arreglo interno en la memoria, de tamaño `length` *multiplicado por `BYTES_PER_ELEMENT`* bytes, que contienen ceros.

`typedArray`

Cuando se llama con un argumento `typedArray`, que puede ser un objeto de cualquiera de los tipos de arreglo con tipo (como `Int32Array`), el `typedArray` se copia en un nuevo arreglo tipado. Cada valor en `typedArray` se convierte al tipo correspondiente del constructor antes de ser copiado en el nuevo arreglo. La longitud del nuevo arreglo tipado será la misma que la longitud del argumento `typedArray`.

`object`

Cuando se llama con un argumento `object`, se crea un nuevo arreglo tipado como si fuera el método `TypedArray.from()`.

`buffer`, `byteOffset`, `length`

Cuando se llama con un `buffer` y, opcionalmente, un `byteOffset` y un `length`, se crea una nueva vista del arreglo tipado que visualiza el `ArrayBuffer` especificado. Los parámetros `byteOffset` y `length` especifican el rango de memoria que será expuesto por la vista del arreglo tipado. Si se omiten ambos, se visualiza todo el `buffer`; si solo se omite `length`, se visualiza el resto de `buffer`.

Propiedades estáticas
---------------------

`TypedArray.BYTES_PER_ELEMENT` (en-US)

Devuelve un valor numérico del tamaño del elemento para los diferentes objetos `TypedArray`.

`TypedArray.name` (en-US)

Devuelve el valor de cadena del nombre del constructor (por ejemplo, `"Int8Array"`).

`get TypedArray[@@species]` (en-US)

La función constructora utilizada para crear objetos derivados.

`TypedArray.prototype` (en-US)

Prototipo para objetos `TypedArray`.

Métodos estáticos
-----------------

`TypedArray.from()` (en-US)

Crea un nuevo `TypedArray` a partir de un objeto iterable o similar a un arreglo. Consulta también `Array.from()`.

`TypedArray.of()` (en-US)

Crea un nuevo `TypedArray` con un número variable de argumentos. Consulta también `Array.of()`.

Propiedades de la instancia
---------------------------

`TypedArray.prototype.buffer`

Devuelve el `ArrayBuffer` al que hace referencia el arreglo tipado. Corregido en el momento de la construcción y, por lo tanto, de **solo lectura**.

`TypedArray.prototype.byteLength` (en-US)

Devuelve la longitud (en bytes) del arreglo tipado. Corregido en el momento de la construcción y, por lo tanto, de **solo lectura.**

`TypedArray.prototype.byteOffset` (en-US)

Devuelve el desplazamiento (en bytes) del arreglo tipado desde el inicio de su `ArrayBuffer`. Corregido en el momento de la construcción y, por lo tanto, de **solo lectura.**

`TypedArray.prototype.length` (en-US)

Devuelve el número de elementos contenidos en el arreglo tipado. Corregido en el momento de la construcción y, por lo tanto, de **solo lectura.**

Métodos de instancia
--------------------

`TypedArray.prototype.copyWithin()` (en-US)

Copia una secuencia de elementos de arreglo dentro del arreglo. Consulta también `Array.prototype.copyWithin()`.

`TypedArray.prototype.entries()` (en-US)

Devuelve un nuevo objeto `Array Iterator` que contiene los pares clave/valor para cada índice del arreglo. Consulta también `Array.prototype.entries()`.

`TypedArray.prototype.every()` (en-US)

Comprueba si todos los elementos del arreglo pasan la prueba proporcionada por una función. Consulta también `Array.prototype.every()`.

`TypedArray.prototype.fill()` (en-US)

Rellena todos los elementos de un arreglo desde un índice inicial hasta un índice final con un valor estático. Consulta también `Array.prototype.fill()`.

`TypedArray.prototype.filter()` (en-US)

Crea un nuevo arreglo con todos los elementos de este arreglo para la cual la función de filtrado proporcionada devuelve `true`. Consulta también `Array.prototype.filter()`.

`TypedArray.prototype.find()` (en-US)

Devuelve el valor encontrado en el arreglo, si un elemento del arreglo satisface la función de prueba proporcionada, o `undefined` si no se encuentra. Consulta también `Array.prototype.find()`.

`TypedArray.prototype.findIndex()` (en-US)

Devuelve el índice encontrado en el arreglo, si un elemento del arreglo satisface la función de prueba proporcionada o `-1` si no se encuentra. Consulta también `Array.prototype.findIndex()`.

`TypedArray.prototype.forEach()` (en-US)

Llama a una función para cada elemento del arreglo. Consulta también `Array.prototype.forEach()`.

`TypedArray.prototype.includes()` (en-US)

Determina si un arreglo tipado incluye un determinado elemento, devolviendo `true` o `false` según corresponda. Consulta también `Array.prototype.includes()`.

`TypedArray.prototype.indexOf()` (en-US)

Devuelve el primer (mínimo) índice de un elemento dentro del arreglo igual al valor especificado, o `-1` si no se encuentra ninguno. Consulta también `Array.prototype.indexOf()`.

`TypedArray.prototype.join()` (en-US)

Une todos los elementos de un arreglo en una cadena. Consulta también `Array.prototype.join()`.

`TypedArray.prototype.keys()` (en-US)

Devuelve un nuevo `Array Iterator` que contiene las claves para cada índice del arreglo. Consulta también `Array.prototype.keys()`.

`TypedArray.prototype.lastIndexOf()` (en-US)

Devuelve el último (mayor) índice de un elemento dentro del arreglo igual al valor especificado, o `-1` si no se encuentra ninguno. Consulta también `Array.prototype.lastIndexOf()`.

`TypedArray.prototype.map()` (en-US)

Crea un nuevo arreglo con los resultados de llamar a una función proporcionada en cada elemento de este arreglo. Consulta también `Array.prototype.map()`.

`TypedArray.prototype.reduce()` (en-US)

Aplica una función contra un acumulador y cada valor del arreglo (de izquierda a derecha) para reducirlo a un solo valor. Consulta también `Array.prototype.reduce()`.

`TypedArray.prototype.reduceRight()` (en-US)

Aplica una función contra un acumulador y cada valor del arreglo (de derecha a izquierda) para reducirlo a un solo valor. Consulta también `Array.prototype.reduceRight()`.

`TypedArray.prototype.reverse()` (en-US)

Invierte el orden de los elementos de un arreglo: el primero se convierte en el último y el último en el primero. Consulta también `Array.prototype.reverse()`.

`TypedArray.prototype.set()` (en-US)

Almacena múltiples valores en el arreglo tipado, leyendo valores de entrada de un arreglo especificado.

`TypedArray.prototype.slice()` (en-US)

Extrae una sección de un arreglo y devuelve un nuevo arreglo. Consulta también `Array.prototype.slice()`.

`TypedArray.prototype.some()` (en-US)

Devuelve `true` si al menos un elemento de este arreglo satisface la función de prueba proporcionada. Consulta también `Array.prototype.some()`.

`TypedArray.prototype.sort()` (en-US)

Ordena los elementos de un arreglo en su lugar y devuelve el arreglo. Consulta también `Array.prototype.sort()`.

`TypedArray.prototype.subarray()` (en-US)

Devuelve un nuevo `TypedArray` del índice del elemento inicial y final dado.

`TypedArray.prototype.values()` (en-US)

Devuelve un nuevo objeto `Array Iterator` que contiene los valores de cada índice del arreglo. Consulta también `Array.prototype.values()`.

`TypedArray.prototype.toLocaleString()` (en-US)

Devuelve una cadena localizada que representa el arreglo y sus elementos. Consulta también `Array.prototype.toLocaleString()`.

`TypedArray.prototype.toString()` (en-US)

Devuelve una cadena que representa el arreglo y sus elementos. Consulta también `Array.prototype.toString()`.

`TypedArray.prototype[@@iterator]()` (en-US)

Devuelve un nuevo objeto `Array Iterator` que contiene los valores de cada índice del arreglo.

Ejemplos
--------

### Se requiere `new`

A partir de ECMAScript 2015, los constructores `TypedArray` se deben construir con el operador `new`. Llamar a un constructor `TypedArray` como una función sin `new` arrojará un `TypeError`.


```js
var dv = Int8Array([1, 2, 3]);
// TypeError: llamar a un constructor Int8Array incorporado
// sin new está prohibido
```



```js
var dv = new Int8Array([1, 2, 3]);
```

### Acceso a la propiedad

Puedes hacer referencia a elementos en el arreglo utilizando la sintaxis de índice de arreglo estándar (es decir, utilizando la notación entre corchetes). Sin embargo, obtener o establecer propiedades indexadas en arreglos tipados no buscará esta propiedad en la cadena de prototipos, incluso cuando los índices estén fuera de límites. Las propiedades indexadas consultarán el `ArrayBuffer` y nunca mirarán las propiedades del objeto. Aún puedes usar propiedades con nombre, al igual que con todos los objetos.


```js
// Configuración y obtención usando la sintaxis de arreglo estándar
var int16 = new Int16Array(2);
int16[0] = 42;
[parcial]console.log(0);

// No se consultan las propiedades indexadas en los prototipos (Fx 25)
Int8Array.prototype[20] = 'foo';
(new Int8Array(32))[20]; // 0
// incluso cuando está fuera del límite
Int8Array.prototype[20] = 'foo';
(new Int8Array(8))[20]; // undefined
// o con enteros negativos
Int8Array.prototype[-1] = 'foo';
(new Int8Array(8))[-1]; // undefined

// Sin embargo, se permiten propiedades con nombre (Fx 30)
Int8Array.prototype.foo = 'bar';
(new Int8Array(32)).foo; // "bar"
```

Especificaciones
----------------

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

Compatibilidad con navegadores
------------------------------

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

Ve también
----------

* Arreglos tipados JavaScript
* `ArrayBuffer`
* `DataView` (en-US)
* TextDecoder (en-US) — Ayuda que decodifica cadenas a partir de datos numéricos