Diviser un tableau en morceaux en JavaScript implique de diviser le tableau en tableaux plus petits d’une taille spécifiée. Ce processus est utile pour gérer plus efficacement de grands ensembles de données ou pour traiter des données dans des parties plus petites et plus faciles à gérer au sein de l'application.

Méthodes pour diviser le tableau en morceaux :

Table des matières

• Utilisation de la méthode JavaScript slice()
• Utilisation de la méthode JavaScript splice()
• Utilisation de la méthode Lodash _.chunk()
• Utiliser une boucle pour diviser le tableau
• Utilisation de Array.reduce() :
• Utilisation de Array.from() et Array.splice()

Utilisation de la méthode JavaScript slice()

Le méthode tranche () renvoie un nouveau tableau contenant les éléments sélectionnés. Cette méthode sélectionne les éléments à partir de l'argument de début donné et se termine à, mais en excluant l'argument de fin donné.

Syntaxe:

array.slice(start, end);>

Exemple: Cet exemple utilise le tranche() méthode pour diviser le tableau en morceaux du tableau. Cette méthode peut être utilisée à plusieurs reprises pour diviser un tableau de n’importe quelle taille.

// 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>

Utilisation de la méthode JavaScript splice()

Méthode splice() ajoute/supprime des éléments dans/d'un tableau et renvoie la liste des éléments supprimés.

Syntaxe:

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

Exemple: Cet exemple utilise le épissure() méthode pour diviser le tableau en morceaux du tableau. Cette méthode supprime les éléments du tableau d'origine. Cette méthode peut être utilisée à plusieurs reprises pour diviser un tableau de n’importe quelle taille.

qu'est-ce qui rend un PC rapide

// 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>

En utilisant Méthode Lodash _.chunk()

Dans cette approche, nous utilisons Méthode Lodash _.chunk() qui renvoie le tableau donné en morceaux en fonction de la valeur donnée.

Exemple: Dans cet exemple, nous cassons le tableau en passant la taille « 3 » dans la méthode _.chunk(). La taille du morceau peut varier et un éventail de types de données différents peut être utilisé avec la fonction de morceau.

// 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))>

Sortir:

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

Utiliser une boucle pour diviser le tableau

Dans cette approche, nous parcourons le tableau d'origine et le découpons en morceaux de la taille souhaitée, en poussant chaque morceau dans un nouveau tableau.

Exemple:

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 ] ]>

Utilisation de Array.reduce()

En utilisant Tableau.réduire() , divisez un tableau en morceaux d'une taille spécifiée. La fonction de réduction accumule les morceaux en fonction de la taille de morceau, en poussant les parties découpées du tableau dans le tableau de morceaux et renvoie le tableau de morceaux résultant.

Exemple: Dans cet exemple, nous divisons un tableau en morceaux d'une taille spécifiée à l'aide de la méthode de réduction. Il parcourt le tableau, poussant les sous-tableaux de la taille de bloc définie dans un tableau résultant.

// 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 (index % chunk === 0) { result.push(arr.slice(index, index + chunk));  } renvoie le résultat ; }, []); // Afficher la sortie splittedArrays.forEach((subArray, index) => { console.log(`Array${index + 1}: ${subArray}`); });>

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

Utilisation de Array.from() et Array.splice()

Cette méthode consiste à créer un nouveau tableau à partir du tableau d'origine à l'aide de Array.from(), puis à en supprimer à plusieurs reprises des éléments à l'aide de splice() pour former des morceaux.

Exemple: Dans cet exemple, la fonction chunkArray divise un tableau en morceaux d'une taille spécifiée. Il crée une copie du tableau d'origine et extrait de manière itérative des parties en fonction de la taille du morceau jusqu'à ce que le tableau soit vide.

function chunkArray(array, chunkSize) {  const chunks = [];  const copyArray = Array.from(array); // Create a copy of the original array  while (copyArray.length>0) { chunks.push(copyArray.splice(0, chunkSize));  } renvoie des morceaux ; } // Exemple d'utilisation : const arr = [1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd']; const chunkSize = 3; const chunks = chunkArray(arr, chunkSize); console.log(morceaux);>

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