Dividir una matriz en fragmentos en JavaScript Implica dividir la matriz en matrices más pequeñas de un tamaño específico. Este proceso es útil para administrar grandes conjuntos de datos de manera más eficiente o para procesar datos en porciones más pequeñas y manejables dentro de la aplicación.

Métodos para dividir la matriz en trozos:

Tabla de contenidos

• Usando el método de segmento de JavaScript ()
• Usando el método de empalme() de JavaScript
• Usando el método Lodash _.chunk()
• Usar un bucle para dividir la matriz
• Usando Array.reduce():
• Usando Array.from() y Array.splice()

Usando el método de segmento de JavaScript ()

El método de corte () devuelve una nueva matriz que contiene los elementos seleccionados. Este método selecciona los elementos a partir del argumento inicial dado y termina en, pero excluyendo el argumento final dado.

Sintaxis:

array.slice(start, end);>

Ejemplo: Este ejemplo utiliza el rebanada() Método para dividir la matriz en partes de la matriz. Este método se puede utilizar repetidamente para dividir una matriz de cualquier tamaño.

// Size of chunk let chunk = 4; // Input array let arr = [1, 2, 3, 4, 5, 6, 7, 8]; // Spiltted arrays let arr1 = arr.slice(0, chunk); let arr2 = arr.slice(chunk, chunk + arr.length); // Display Output console.log('Array1: ' + arr1 + '
Array2: ' + arr2);>

Array1: 1,2,3,4 Array2: 5,6,7,8>

Usando el método de empalme() de JavaScript

método de empalme () agrega/elimina elementos a/de una matriz y devuelve la lista de elementos eliminados.

Sintaxis:

array.splice(index, number, item1, ....., itemN);>

Ejemplo: Este ejemplo utiliza el empalme() Método para dividir la matriz en partes de la matriz. Este método elimina los elementos de la matriz original. Este método se puede utilizar repetidamente para dividir una matriz de cualquier tamaño.

conversión de int a cadena

// Size of aaray chunks let chunk = 2; // Input array let arr = [1, 2, 3, 4, 5, 6, 7, 8]; // Splitted arrays let arr1 = arr.splice(0, chunk); let arr2 = arr.splice(0, chunk); let arr3 = arr.splice(0, chunk); let arr4 = arr.splice(0, chunk); // Display output console.log('Array1: ' + arr1); console.log('Array2: ' + arr2); console.log('Array3: ' + arr3); console.log('Array4: ' + arr4);>

Array1: 1,2 Array2: 3,4 Array3: 5,6 Array4: 7,8>

Usando Método Lodash _.chunk()

En este enfoque, estamos utilizando Método Lodash _.chunk() que devuelve la matriz dada en fragmentos de acuerdo con el valor dado.

Ejemplo: En este ejemplo, estamos rompiendo la matriz pasando el tamaño '3' al método _.chunk(). El tamaño del fragmento se puede variar y se puede utilizar una matriz de diferentes tipos de datos con la función de fragmento.

// Requiring the lodash module // in the script let _ = require('lodash'); let arr = [1, 2, 3, 4, 5, 6,  'a', 'b', 'c', 'd']; console.log('Before: ', arr) // Making chunks of size 3 console.log('After: ', _.chunk(arr, 3))>

Producción:

Before: [  1, 2, 3, 4, 5,  6, 'a', 'b', 'c', 'd' ] After: [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 'a', 'b', 'c' ], [ 'd' ] ]>

Usar un bucle para dividir la matriz

En este enfoque, iteramos sobre la matriz original y la dividimos en fragmentos del tamaño deseado, empujando cada fragmento a una nueva matriz.

Ejemplo:

function chunkArray(array, chunkSize) {  const chunks = [];  for (let i = 0; i < array.length; i += chunkSize) {  chunks.push(array.slice(i, i + chunkSize));  }  return chunks; } const arr = [1, 2, 3, 4, 5, 6, 7, 8]; const chunkedArray = chunkArray(arr, 4); console.log(chunkedArray);>

[ [ 1, 2, 3, 4 ], [ 5, 6, 7, 8 ] ]>

Usando Array.reduce()

Usando matriz.reducir() , divide una matriz en fragmentos de un tamaño específico. La función de reducción acumula fragmentos según el tamaño del fragmento, empujando porciones cortadas de la matriz a la matriz de fragmentos y devuelve la matriz de fragmentos resultante.

Ejemplo: En este ejemplo, dividimos una matriz en fragmentos de un tamaño específico utilizando el método de reducción. Itera a través de la matriz, empujando submatrices del tamaño de fragmento definido en una matriz resultante.

// Size of chunk let chunk = 4; // Input array let arr = [1, 2, 3, 4, 5, 6, 7, 8]; // Split array into chunks using reduce method let splittedArrays = arr.reduce((result, item, index) =>{ if (índice % fragmento === 0) { resultado.push(arr.slice(índice, índice + fragmento));  } devolver resultado; }, []); // Mostrar salida splittedArrays.forEach((subArray, index) => { console.log(`Array${index + 1}: ${subArray}`); });>

Array1: 1,2,3,4 Array2: 5,6,7,8>

Usando Array.from() y Array.splice()

Este método implica crear una nueva matriz a partir de la matriz original usando Array.from() y luego eliminar elementos repetidamente usando splice() para formar fragmentos.

Ejemplo: En este ejemplo, la función chunkArray divide una matriz en fragmentos de un tamaño específico. Crea una copia de la matriz original y extrae iterativamente partes según el tamaño del fragmento hasta que la matriz está vacía.

function chunkArray(array, chunkSize) {  const chunks = [];  const copyArray = Array.from(array); // Create a copy of the original array  while (copyArray.length>0) { trozos.push(copyArray.splice(0, tamaño de trozos));  } devolver fragmentos; } // Ejemplo de uso: const arr = [1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd']; Tamaño del fragmento constante = 3; trozos constantes = trozoArray(arr, tamaño de trozo); console.log(fragmentos);>

[ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 'a', 'b', 'c' ], [ 'd' ] ]>