Come dividere l'elenco ImmutableJS in più elenchi

Question

C'è un modo per separare un elenco ImmutableJS in un elenco di più elenchi? Praticamente cerco qualcosa come lodash's chunk ma per gli elenchi ImmutableJS.

Potrei trasformare la mia lista in una matrice prima di passarla a chunk e riconvertire la risposta in una lista ImmutableJS, ma mi è stato detto che le trasformazioni poco profonde non sono efficienti e le mie liste sono piuttosto grandi.

Grazie, G.

Answer 1

Immutable.js non prevede che a destra, fuori dalla scatola.

Ecco la funzione che divide l'elenco in blocchi di dimensioni uguali. L'ultimo blocco potrebbe essere più piccolo se l'elenco non può essere suddiviso equamente.

function splitIntoChunks(list, chunkSize = 1) { 
    return Immutable.Range(0, list.count(), chunkSize) 
    .map(chunkStart => list.slice(chunkStart, chunkStart + chunkSize)); 
} 

enumera prima gli indici in cui ogni pezzo dovrebbe iniziare e poi trasforma l'elenco degli indici in una lista di fette che vanno dalla ogni indice l'indice più chunk dimensioni.

Mi sembra semplice ed efficiente.

Answer 2

Questa funzione chunk da questa discussione sembra funzionare bene con i miei dati immutabili, fuori dalla scatola.

function chunk(chunkSize, array) { 
    return array.reduce(function(previous, current) { 
     var chunk; 
     if (previous.length === 0 || 
      previous[previous.length -1].length === chunkSize) { 
      chunk = []; // 1 
      previous.push(chunk); // 2 
     } 
     else { 
      chunk = previous[previous.length -1]; // 3 
     } 
     chunk.push(current); // 4 
     return previous; // 5 
    }, []); // 6 
} 

var list = Immutable.fromJS(['something','nothing','anything','hello']) 

console.log(chunk(3,list)) 

Esempio: https://jsfiddle.net/lau_chung/c67g7469/2/

Answer 3

Ho appena incontrato questo problema troppo e ho risolto con la scrittura di questa funzione:

const getListAsChunks = (list, chunkSize) => { 
    const iterations = Math.ceil(list.count()/chunkSize); 

    return range(0, iterations).reduce((all, item, i) => { 
     const start = i * chunkSize; 
     const end = (i + 1) * chunkSize; 
     return all.push(list.slice(start, end)); 
    }, List()); 
}; 

Quindi chiamare in questo modo:

const myChunkedList = getListAsChunks(myImmutableList, 5); 

ho importato range da lodash/range e List da immutable Spero che questo aiuti.

Answer 4

mudash (un wraash di lodash che fornisce supporto js immutabile) fornisce un chunk method. Dovrebbe darti quello che ti serve. Nessuna trasformazione eseguita, quindi le prestazioni rimangono elevate.

import _ from 'mudash' 
import Immutable from 'immutable' 

const list = Immutable.List([1, 2, 3, 4]) 
_.chunk(list, 2) // List [ List [ 1, 2 ], List [ 3, 4 ] ] 

divulgazione completa, io sono l'autore del modulo mudash.