3
votes

morceau de lodash de la fin du tableau

J'ai un tableau

const myArray = [1, 2, 2, 2, 3, 3, 3, 4, 4, 4];

qui Je veux me diviser en plus petits tableaux. J'utilise un morceau de lodash pour le faire.

_.chain(myArray).reverse().chunk(3).reverse().value()

cela retournera

[1], [2, 2, 2], [3, 3, 3], [4, 4, 4]

mais je voudrais qu'il retourne

[1, 2, 2], [2, 3, 3], [3, 4, 4], [4]

ma solution était la suivante

_.chunk(myArray, 3);

il inverse le tableau, le divise puis l'inverse à nouveau. Mais y a-t-il une meilleure façon de faire cela? Le bloc commence donc par la fin et non par le début.

javascript lodash

3 commentaires

Votre revers inversera probablement également l'ordre des éléments dans chaque sous-tableau. Vous ne le voyez peut-être pas car ils ont tous la même valeur, mais vous devriez probablement vérifier avec des données plus diverses

La solution doit-elle utiliser Lodash ou vanilla JS est-il également approprié?

@Phil Hey. Vous avez raison. Maintenant, quand je l'ai testé avec des données plus diverses, il inverse les sous-tableaux. La solution doit utiliser lodash mais vanilla js convient tant que ce n'est pas trop de code.

3 Réponses :

1
votes

Il n'y a pas d'option d'argument intégrée pour cela (ou une méthode distincte comme chunkEnd ), mais il est trivial d'écrire quelque chose vous-même qui réalise la même chose sans reverse array:

const chunkFromEnd = (arr, size) => {
  const firstSize = arr.length % size;
  const result = [arr.slice(0, firstSize)];
  
  for (let i = firstSize; i < arr.length; i += size) {
    result.push(arr.slice(i, i + size));
  }
  return result;
};
console.log(chunkFromEnd([1, 2, 2, 2, 3, 3, 3, 4, 4, 4], 3));
console.log(chunkFromEnd([1, 2, 2, 2, 3, 3, 3, 4, 9, 4, 4, 6, 2, 1], 3));

0 commentaires

4
votes

Recherchez le reste a>, et s'il y a du reste, coupez-le du côté gauche et combinez-le avec les morceaux du reste du tableau. S'il n'y a pas de reste, segmentez normalement:

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>

const myArray = [1, 21, 22, 23, 31, 32, 33, 41, 42, 43];

const chunkRight = (arr, size) => {
  const rm = arr.length % size;
  
  return rm ?
    [arr.slice(0, rm), ..._.chunk(arr.slice(rm), size)]
    :
    _.chunk(arr, size);
};

const result = chunkRight(myArray, 3);

console.log(result);

0 commentaires

1
votes

Une alternative pourrait être d'utiliser la fonction reduceRight.

.as-console-wrapper { max-height: 100% !important; top: 0; }

const myArray = [1, 2, 2, 2, 3, 3, 3, 4, 4, 4];
const chunks = myArray.reduceRight((a, n, i, arr) => {
  if (((arr.length - 1) - i) % a.chunk === 0) {
    a.current = [];
    a.chunks.unshift(a.current);
  }
  
  a.current.push(n);  
  return a;
}, {
  /*This is the size per chunk*/chunk: 3, 
  /*The array with the chunks*/ chunks: [], 
  /*The current array which is being filled*/ current: []}).chunks;

console.log(chunks);

0 commentaires