Creación de arrays

Array.of()

Forma un array con todos los valores de los parámetros como elementos.

console.log(Array.of(1, 2, 3, 4)); // [1, 2, 3, 4] //Los valores de los parámetros pueden ser de diferentes tipos. console.log(Array.of(1, '2', true)); // [1, '2', true] //Devuelve un array vacío cuando no hay parámetros. console.log(Array.of()); // []

Array.from()

Convierte objetos array-like u objetos iterables en arrays.

//Si el parámetro es un array, devuelve un array idéntico al array original. console.log(Array.from([1, 2])); // [1, 2] //El parámetro contiene huecos. console.log(Array.from([1, , 3])); // [1, undefined, 3]

Parámetros

Array.from(arrayLike[, mapFn[, thisArg]])

El valor de retorno es el array convertido.

arrayLike

El objeto array-like u objeto iterable que se desea convertir.

console.log(Array.from([1, 2, 3])); // [1, 2, 3]

mapFn

Opcional, función map, utilizada para procesar cada elemento; los elementos procesados se colocan en el array.

console.log(Array.from([1, 2, 3], (n) => n * 2)); // [2, 4, 6]

thisArg

Opcional, utilizado para especificar el objeto this al ejecutar la función map.

let map = { do: function(n) { return n * 2; } } let arrayLike = [1, 2, 3]; console.log(Array.from(arrayLike, function (n){ return this.do(n); }, map)); // [2, 4, 6]

Objetos array-like

Un objeto array-like debe contener una propiedad length, y los nombres de las propiedades de los elementos deben ser numéricos o caracteres que puedan convertirse a valores numéricos.

let arr = Array.from({ 0: '1', 1: '2', 2: 3, length: 3 }); console.log(arr); // ['1', '2', 3] //Sin la propiedad length, devuelve un array vacío. let array = Array.from({ 0: '1', 1: '2', 2: 3, }); console.log(array); // [] //Si los nombres de las propiedades de los elementos no son numéricos y no pueden convertirse a valores numéricos, devuelve un array de longitud length con valores de elementos undefined. let array1 = Array.from({ a: 1, b: 2, length: 2 }); console.log(array1); // [undefined, undefined]

Conversión de objetos iterables

Conversión de Map

let map = new Map(); map.set('key0', 'value0'); map.set('key1', 'value1'); console.log(Array.from(map)); // [['key0', 'value0'],['key1', // 'value1']]

Conversión de Set

let arr = [1, 2, 3]; let set = new Set(arr); console.log(Array.from(set)); // [1, 2, 3]

Conversión de cadenas

let str = 'abc'; console.log(Array.from(str)); // ["a", "b", "c"]

Métodos extendidos

Búsqueda

find()

Busca elementos en el array que cumplan la condición; si hay varios elementos que la cumplen, devuelve el primer elemento.

let arr = Array.of(1, 2, 3, 4); console.log(arr.find(item => item > 2)); // 3 //Los huecos en el array se tratan como undefined. console.log([, 1].find(n => true)); // undefined

findIndex()

Busca el índice del elemento en el array que cumpla la condición; si hay varios elementos que la cumplen, devuelve el índice del primer elemento.

let arr = Array.of(1, 2, 1, 3); //Parámetro 1: función callback //Parámetro 2 (opcional): especifica el valor de this en la función callback console.log(arr.findIndex(item => item == 2)); // 1 //Los huecos en el array se tratan como undefined. console.log([, 1].findIndex(n => true)); //0

Relleno

fill()

Rellena el contenido de los elementos del array dentro de un cierto rango de índices con un único valor especificado.

let arr = Array.of(1, 2, 3, 4); //Parámetro 1: el valor utilizado para rellenar //Parámetro 2: el índice inicial a rellenar //Parámetro 3 (opcional): el índice final a rellenar, por defecto el final del array console.log(arr.fill(0,1,2)); // [1, 0, 3, 4]

copyWithin()

Modifica los elementos del array dentro de un cierto rango de índices con los elementos de otro rango de índices especificado de este array.

//Parámetro 1: el índice inicial a modificar //Parámetro 2: el índice inicial de los datos utilizados para sobrescribir //Parámetro 3 (opcional): el índice final de los datos utilizados para sobrescribir, por defecto el final del array console.log([1, 2, 3, 4].copyWithin(0,2,4)); // [3, 4, 3, 4] //Un parámetro 1 negativo indica contar desde el final console.log([1, 2, 3, 4].copyWithin(-2, 0)); // [1, 2, 1, 2] console.log([1, 2, ,4].copyWithin(0, 2, 4)); // [, 4, , 4]

Iteración

entries()

Itera sobre los pares clave-valor.

for(let [key, value] of ['a', 'b'].entries()){ console.log(key, value); } // 0 "a" // 1 "b" //No utiliza el bucle for...of let entries = ['a', 'b'].entries(); console.log(entries.next().value); // [0, "a"] console.log(entries.next().value); // [1, "b"] //El array contiene huecos console.log([...[,'a'].entries()]); // [[0, undefined], [1, "a"]]

keys()

Itera sobre las claves.

for(let key of ['a', 'b'].keys()){ console.log(key); } // 0 // 1 //El array contiene huecos console.log([...[,'a'].keys()]); // [0, 1]

values()

Itera sobre los valores.

for(let value of ['a', 'b'].values()){ console.log(value); } // "a" // "b" //El array contiene huecos console.log([...[,'a'].values()]); // [undefined, "a"]

Incluye

includes()

Comprueba si el array incluye el valor especificado.

Nota: distinguirlo del método has de Set y Map; el método has de Set se utiliza para buscar valores; el método has de Map se utiliza para buscar claves.

//Parámetro 1: el valor especificado a incluir [1, 2, 3].includes(1); // true //Parámetro 2: opcional, el índice inicial de búsqueda, por defecto 0 [1, 2, 3].includes(1, 2); // false //Comprobación de inclusión de NaN [1, NaN, 3].includes(NaN); // true

Conversión de arrays anidados a arrays unidimensionales

flat()

console.log([1 ,[2, 3]].flat()); // [1, 2, 3] //Especifica el número de niveles de anidamiento a convertir console.log([1, [2, [3, [4, 5]]]].flat(2)); // [1, 2, 3, [4, 5]] //Sin importar cuántos niveles esté anidado console.log([1, [2, [3, [4, 5]]]].flat(Infinity)); // [1, 2, 3, 4, 5] //Omite automáticamente los huecos console.log([1, [2, , 3]].flat());<p> // [1, 2, 3]
flatMap()

Primero procesa cada elemento del array y luego ejecuta el método flat() sobre el array.

//Parámetro 1: una función de iteración, que puede aceptar 3 parámetros: el elemento actual, el índice del elemento actual y el array original //Parámetro 2: especifica el this dentro de la función de iteración console.log([1, 2, 3].flatMap(n => [n * 2])); // [2, 4, 6]

ArrayBuffer

Un ArrayBuffer es un segmento de direcciones en la memoria.

La base de los arrays tipados.

El número real de bytes se determina en el momento de la creación; después, solo se pueden modificar los datos dentro de él, no su tamaño.

Creación de ArrayBuffer

Creación mediante el constructor:

let buffer = new ArrayBuffer(10); console.log(buffer.byteLength); // 10División de un ArrayBuffer existentelet buffer = new ArrayBuffer(10); let buffer1 = buffer.slice(1, 3); console.log(buffer1.byteLength); // 2

Vistas

Una vista es una interfaz para operar sobre la memoria.

Una vista puede operar sobre un ArrayBuffer o un subconjunto de los bytes del búfer, y lee y escribe datos según uno de los tipos de datos numéricos.

El tipo DataView es una vista genérica de ArrayBuffer que admite los 8 tipos de datos numéricos.

Creación:

//Por defecto, DataView puede operar sobre todo el contenido del ArrayBuffer let buffer = new ArrayBuffer(10); dataView = new DataView(buffer); dataView.setInt8(0,1); console.log(dataView.getInt8(0)); // 1 //Especifica el rango de bytes sobre el que DataView puede operar estableciendo el desplazamiento (parámetro 2) y la longitud (parámetro 3) let buffer1 = new ArrayBuffer(10); dataView1 = new DataView(buffer1, 0, 3); dataView1.setInt8(5,1); // RangeError

Arrays tipados

Un tipo específico de vista del ArrayBuffer.

Se puede forzar el uso de un tipo de datos específico en lugar de utilizar el objeto genérico DataView para operar sobre el ArrayBuffer.

Creación

Generado a partir de un ArrayBuffer

let buffer = new ArrayBuffer(10), view = new Int8Array(buffer); console.log(view.byteLength); // 10

Mediante el constructor

let view = new Int32Array(10); console.log(view.byteLength); // 40 console.log(view.length); // 10 //Si no se pasa ningún parámetro, la longitud por defecto es 0 //En este caso, no se asigna espacio para el ArrayBuffer, y el array tipado creado no se puede utilizar para almacenar datos let view1 = new Int32Array(); console.log(view1.byteLength); // 0 console.log(view1.length); // 0 //Los parámetros aceptables incluyen arrays tipados, objetos iterables, arrays y objetos array-like let arr = Array.from({ 0: '1', 1: '2', 2: 3, length: 3 }); let view2 = new Int16Array([1, 2]), view3 = new Int32Array(view2), view4 = new Int16Array(new Set([1, 2, 3])), view5 = new Int16Array([1, 2, 3]), view6 = new Int16Array(arr); console.log(view2 .buffer === view3.buffer); // false console.log(view4.byteLength); // 6 console.log(view5.byteLength); // 6 console.log(view6.byteLength); // 6

Puntos importantes

La propiedad length no es modificable; si se intenta modificar este valor, la operación se ignora silenciosamente en modo no estricto, y se lanza un error en modo estricto.

let view = new Int16Array([1, 2]); view.length = 3; console.log(view.length); // 2

Los arrays tipados se pueden iterar con entries(), keys() y values().

let view = new Int16Array([1, 2]); for(let [k, v] of view.entries()){ console.log(k, v); } // 0 1 // 1 2

Métodos como find() también se pueden utilizar en arrays tipados, pero los métodos de los arrays tipados verifican adicionalmente si el tipo numérico es seguro, y también confirman mediante Symbol.species que el valor de retorno del método es un array tipado y no un array normal. El método concat() no se puede utilizar en arrays tipados porque el resultado de combinar dos arrays tipados es incierto; además, dado que el tamaño de los arrays tipados no se puede modificar, los métodos que pueden cambiar el tamaño de un array, como splice(), no son aplicables a los arrays tipados.

let view = new Int16Array([1, 2]); view.find((n) > 1); // 2

Todos los arrays tipados contienen los métodos estáticos of() y from(), cuyo comportamiento es similar al de los métodos Array.of() y Array.from() respectivamente; la diferencia es que los métodos de los arrays tipados devuelven arrays tipados, mientras que los métodos de los arrays normales devuelven arrays normales.

let view = Int16Array.of(1, 2); console.log(view instanceof Int16Array); // true

Los arrays tipados no son arrays normales y no heredan de Array.

let view = new Int16Array([1, 2]); console.log(Array.isArray(view)); // false

Los arrays tipados añaden los métodos set() y subarray(). El método set() se utiliza para copiar otros arrays en un array tipado existente, y subarray() se utiliza para extraer una parte de un array tipado existente y formar un nuevo array tipado.

//Método set //Parámetro 1: un array tipado o un array normal //Parámetro 2: opcional, el desplazamiento, la posición donde comienza la inserción de datos, por defecto 0 let view= new Int16Array(4); view.set([1, 2]); view.set([3, 4], 2); console.log(view); // [1, 2, 3, 4] //Método subarray //Parámetro 1: opcional, posición inicial //Parámetro 2: opcional, posición final (la posición final no se incluye) let view= new Int16Array([1, 2, 3, 4]), subview1 = view.subarray(), subview2 = view.subarray(1), subview3 = view.subarray(1, 3); console.log(subview1); // [1, 2, 3, 4] console.log(subview2); // [2, 3, 4] console.log(subview3); // [2, 3]

Operador de propagación

Copia de arrays

let arr = [1, 2], arr1 = [...arr]; console.log(arr1); // [1, 2] //El array contiene huecos let arr2 = [1, , 3], arr3 = [...arr2]; console.log(arr3); [1, undefined, 3]

Combinación de arrays

console.log([...[1, 2],...[3, 4]]); // [1, 2, 3, 4]