Tipos De Array En JavaScript

En el mundo de la programación, existe una gran variedad de conceptos que pueden resultar confusos para quienes apenas se inician en este mundo. Uno de ellos es el array, una estructura de datos que resulta fundamental en muchos lenguajes, incluyendo JavaScript. En este artículo, exploraremos los distintos tipos de array que podemos encontrar en JavaScript y cuándo es conveniente utilizarlos.

Antes de profundizar en los distintos tipos de array, conviene que hagamos una breve introducción a lo que es esta estructura de datos. En términos muy generales, un array es un conjunto de elementos que guardan una cierta relación entre sí en una misma variable. Esto significa que los elementos son accesibles a través de un único nombre, lo que hace que los arrays sean muy útiles para almacenar grandes cantidades de datos de manera organizada.

JavaScript cuenta con varios tipos de arrays, cada uno de los cuales presenta ventajas y desventajas en función del uso que quieras darle. Los repasamos a continuación.

¿De que hablaremos?

Tipos de Array en JavaScript
Preguntas Frecuentes

Array Estándar

Este es el array más básico de JavaScript. Se trata de un array unidimensional que se inicializa con corchetes [].
Array Multidimensional

Este tipo de array se compone de dos o más arrays que se encuentran anidados. Se pueden definir de varias formas, por ejemplo:
Tipos de arreglos en Java
```
let arrayMultidimensional = [[1,2], [3,4], [5,6]];
let otraForma = new Array(new Array(1,2), new Array(3,4), new Array(5,6));
```
Array de Objetos

Este tipo de array se compone de objetos en lugar de valores primitivos. Cada objeto tiene una serie de propiedades y valores asociados.
Array Typed

Este tipo de array es una mejora del array estándar que introduce dos grandes cambios: en primer lugar, se especifica el tipo de dato que contendrá el array al crearlo; en segundo lugar, se almacena el array en una memoria contigua, lo que mejora su eficiencia. Existen distintos tipos de arrays Typed, que se definen a través de la clase ArrayBuffer. Algunos de ellos son:
- Int8Array: Cada elemento del array contiene un número entero de 8 bits con signo.
- Uint8Array: Cada elemento del array contiene un número entero de 8 bits sin signo.
- Uint8ClampedArray: Cada elemento del array contiene un número entero de 8 bits sin signo, pero los valores se recortan a un rango de 0 a 255.
- Int16Array: Cada elemento del array contiene un número entero de 16 bits con signo.
- Uint16Array: Cada elemento del array contiene un número entero de 16 bits sin signo.
- Int32Array: Cada elemento del array contiene un número entero de 32 bits con signo.
- Uint32Array: Cada elemento del array contiene un número entero de 32 bits sin signo.
- Float32Array: Cada elemento del array contiene un número en coma flotante de 32 bits.
- Float64Array: Cada elemento del array contiene un número en coma flotante de 64 bits.
Array de Strings

Este tipo de array simplemente almacena cadenas de texto en lugar de valores numéricos u objetos.
Array Spread

Este tipo de array permite combinar varios arrays en uno solo mediante el uso de spread operator (...) en lugar de métodos como push o concat. Su sintaxis es muy sencilla:
```
let array1 = [1, 2, 3];
let array2 = [4, 5, 6];
let arrayFinal = [...array1, ...array2];
```
Array.from()

Este tipo de array se utiliza para convertir arrays-like objects (objetos que no son arrays pero que se parecen a ellos) en arrays. Su sintaxis es la siguiente:
Tipos de arreglos en programación
```
let arrayLikeObject = {0: "hola", 1: "mundo", length: 2};
let arrayFinal = Array.from(arrayLikeObject);
```
Array.at()

Este tipo de array se utiliza para acceder a un elemento de un array en una posición concreta. Es una mejora sobre el método tradicional array[index], ya que permite acceder a elementos en posiciones negativas y devuelve undefined en lugar de un error en caso de que la posición no exista. Su sintaxis es:
```
let miArray = ["hola", "que", "tal"];
console.log(miArray.at(0)); // "hola"
console.log(miArray.at(-1)); // "tal"
console.log(miArray.at(5)); // undefined
```
Array.filter()

Este tipo de array se utiliza para filtrar los elementos de un array que cumplan una cierta condición. Devuelve un nuevo array con los elementos que la cumplen. Su sintaxis es:
```
let miArray = [1, 2, 3, 4, 5];
let arrayFiltrado = miArray.filter(function(elemento) {
  return elemento > 2;
});
console.log(arrayFiltrado); // [3, 4, 5]
```

Array.reduce()

Este tipo de array se utiliza para reducir un array a un único valor aplicando una función a cada uno de sus elementos. Su sintaxis es:

let miArray = [1, 2, 3, 4, 5];
let suma = miArray.reduce(function(valorAnterior, valorActual) {
  return valorAnterior + valorActual;
});
console.log(suma); // 15

Array.every()

Este tipo de array se utiliza para comprobar que todos los elementos de un array cumplan una cierta condición. Devuelve true si es así, y false en caso contrario. Su sintaxis es:
```
let miArray = [1, 2, 3, 4, 5];
let resultado = miArray.every(function(elemento) {
  return elemento 
```
Array.some()

Este tipo de array se utiliza para comprobar que al menos uno de los elementos de un array cumpla una cierta condición. Devuelve true si es así, y false en caso contrario. Su sintaxis es similar a la del método every:
Tipos de bloque
```
let miArray = [1, 2, 3, 4, 5];
let resultado = miArray.some(function(elemento) {
  return elemento > 3;
});
console.log(resultado); // true
```
Array.find()

Este tipo de array se utiliza para encontrar el primer elemento de un array que cumpla una cierta condición. Devuelve dicho elemento, o undefined si no lo encuentra. Su sintaxis es la siguiente:
```
let miArray = [1, 2, 3, 4, 5];
let elemento = miArray.find(function(elemento) {
  return elemento > 2;
});
console.log(elemento); // 3
```
Array.findIndex()

Este tipo de array se utiliza para encontrar el índice del primer elemento de un array que cumpla una cierta condición. Devuelve dicho índice, o -1 si no lo encuentra. Su sintaxis es igual que la del método find:
```
let miArray = [1, 2, 3, 4, 5];
let indice = miArray.findIndex(function(elemento) {
  return elemento > 3;
});
console.log(indice); // 3
```
Array.includes()

Este tipo de array se utiliza para comprobar si un array contiene un cierto elemento. Devuelve true si es así, y false en caso contrario. Su sintaxis es muy sencilla:
```
let miArray = [1, 2, 3, 4, 5];
let resultado = miArray.includes(3);
console.log(resultado); // true
```

Preguntas Frecuentes

¿Es posible hacer un array de arrays en JavaScript?

Sí, se llama array multidimensional y se compone de dos o más arrays anidados.
¿Qué ventaja tiene un array Typed frente a un array estándar?

El array Typed se define con un tipo de dato concreto, lo que mejora su eficiencia al trabajar con grandes cantidades de datos. Además, su almacenamiento en una memoria contigua también contribuye a su mayor eficiencia.
Tipos de borde CSS
¿Cómo se pueden combinar varios arrays en uno solo en JavaScript?

A través del array Spread, que utiliza el operador ... seguido de los arrays a combinar.
¿Qué métodos se pueden utilizar en JavaScript para procesar un array?

Existen numerosos métodos disponibles en JavaScript para procesar un array, algunos de los cuales hemos visto en este artículo, como filter, reduce, every, some, find

4.4/5 - (2319 votos)

Si quieres conocer otros artículos parecidos a Tipos de Array en JavaScript puedes visitar la categoría Programación.

Conoce mas Tipos

Tipos de Array en JavaScript