Wie man die ImmutableJS-Liste in mehrere Listen zerlegt

Question

Gibt es eine Möglichkeit, eine ImmutableJS-Liste in eine Liste von mehreren Listen zu trennen? Ich suche im Grunde nach etwas wie lodash's chunk, aber für ImmutableJS Listen.

Ich könnte meine Liste in ein Array umwandeln, bevor Sie es an chunk übergeben und die Antwort auf eine ImmutableJS-Liste zurückkonvertieren, aber mir wurde gesagt, dass flache Transformationen nicht effizient sind und meine Listen ziemlich groß sind.

Danke, G.

Answer 1

Immutable.js es nicht aus der Box liefert rechts.

Hier ist die Funktion, die die Liste in gleich große Stücke teilt. Der letzte Chunk kann kleiner sein, wenn die Liste nicht gleichmäßig aufgeteilt werden kann.

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

Es zählt zuerst die Indizes wo jeder Chunk beginnen sollte und wandelt dann die Liste der Indizes in eine Liste von Scheiben aus jedem Index auf den Index und Chunkgröße überspannen.

Sieht einfach und effizient zu mir.

Answer 2

Diese chunk Funktion aus diesem Thread scheint aus der Box mit meinen unveränderlichen Daten gut zu funktionieren.

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

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

Answer 3

Ich habe gerade über dieses Problem zu kommen, und ich löste es mit dem Schreiben dieser Funktion:

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()); 
}; 

es dann rufen Sie wie folgt:

const myChunkedList = getListAsChunks(myImmutableList, 5); 

Ich importierte range von lodash/range und List aus immutable Hoffe, das hilft.

Answer 4

mudash (ein lodash Wrapper, der unveränderliche js Unterstützung bietet) bietet eine chunk method. Es sollte dir geben, was du brauchst. Keine Transformationen durchgeführt, so dass die Leistung hoch bleibt.

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

Volle Offenlegung, ich bin der Autor des Mudash-Moduls.