Разделение массива JS на N массивов
Представьте, что у меня есть массив JS следующим образом:
var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
Я хочу разбить этот массив на N меньших массивов. Например:
split_list_in_n(a, 2)
[[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11]]
For N = 3:
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11]]
For N = 4:
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]]
For N = 5:
[[1, 2, 3], [4, 5], [6, 7], [8, 9], [10, 11]]
Для Python у меня есть это:
def split_list_in_n(l, cols):
""" Split up a list in n lists evenly size chuncks """
start = 0
for i in xrange(cols):
stop = start + len(l[i::cols])
yield l[start:stop]
start = stop
Для JS наилучшим правильным решением, которое я мог бы придумать, является рекурсивная функция, но мне она не нравится, потому что она сложна и уродлива. Эта внутренняя функция возвращает массив, подобный этому [1, 2, 3, null, 4, 5, 6, null, 7, 8], а затем мне нужно его снова закольтать и разбить вручную. (Моя первая попытка возвращала это: [1, 2, 3, [4, 5, 6, [7, 8, 9]]], и я решил сделать это с нулевым разделителем).
function split(array, cols) {
if (cols==1) return array;
var size = Math.ceil(array.length / cols);
return array.slice(0, size).concat([null]).concat(split(array.slice(size), cols-1));
}
Здесь jsfiddle: http://jsfiddle.net/uduhH/
Как вы это сделаете? Спасибо!
Ответы
Ответ 1
Вы можете сделать срезы "сбалансированными" (длины субарирей отличаются как можно меньше) или "ровный" (все подмассивы, но последние имеют одинаковую длину):
function chunkify(a, n, balanced) {
if (n < 2)
return [a];
var len = a.length,
out = [],
i = 0,
size;
if (len % n === 0) {
size = Math.floor(len / n);
while (i < len) {
out.push(a.slice(i, i += size));
}
}
else if (balanced) {
while (i < len) {
size = Math.ceil((len - i) / n--);
out.push(a.slice(i, i += size));
}
}
else {
n--;
size = Math.floor(len / n);
if (len % size === 0)
size--;
while (i < size * n) {
out.push(a.slice(i, i += size));
}
out.push(a.slice(size * n));
}
return out;
}
///////////////////////
onload = function () {
function $(x) {
return document.getElementById(x);
}
function calc() {
var s = +$('s').value, a = [];
while (s--)
a.unshift(s);
var n = +$('n').value;
$('b').textContent = JSON.stringify(chunkify(a, n, true))
$('e').textContent = JSON.stringify(chunkify(a, n, false))
}
$('s').addEventListener('input', calc);
$('n').addEventListener('input', calc);
calc();
}
<p>slice <input type="number" value="20" id="s"> items into
<input type="number" value="6" id="n"> chunks:</p>
<pre id="b"></pre>
<pre id="e"></pre>
Ответ 2
Я просто сделал итеративную реализацию алгоритма: http://jsfiddle.net/ht22q/. Он передает ваши тестовые примеры.
function splitUp(arr, n) {
var rest = arr.length % n, // how much to divide
restUsed = rest, // to keep track of the division over the elements
partLength = Math.floor(arr.length / n),
result = [];
for(var i = 0; i < arr.length; i += partLength) {
var end = partLength + i,
add = false;
if(rest !== 0 && restUsed) { // should add one element for the division
end++;
restUsed--; // we've used one division element now
add = true;
}
result.push(arr.slice(i, end)); // part of the array
if(add) {
i++; // also increment i in the case we added an extra element for division
}
}
return result;
}
Ответ 3
function split(arr, n) {
var res = [];
while (arr.length) {
res.push(arr.splice(0, n));
}
return res;
}
Ответ 4
Я думаю, что этот способ с использованием сплайсинга является самым чистым:
splitToChunks(array, parts) {
let result = [];
for (let i = parts; i > 0; i--) {
result.push(array.splice(0, Math.ceil(array.length / i)));
}
return result;
}
Например, для parts = 3 вы должны взять 1/3, затем 1/2 оставшейся части, а затем оставшуюся часть массива. Math.ceil гарантирует, что в случае Math.ceil количества элементов они попадут в самые ранние фрагменты.
(Примечание: это уничтожает исходный массив.)
Ответ 5
Вы можете свести его к матрице. Приведенный ниже пример разбивает массив (arr) на матрицу двухпозиционных массивов. Если вы хотите, чтобы другие размеры просто меняли значение 2 во второй строке:
target.reduce((memo, value, index) => {
if (index % 2 == 0 && index !== 0) memo.push([])
memo[memo.length - 1].push(value)
return memo
}, [[]])
Надеюсь, что это поможет!
EDIT: поскольку некоторые люди все еще комментируют это, это не отвечает на вопрос, так как я исправлял размер каждого фрагмента, а не количество блоков. Здесь приведен код, объясняющий, что я пытаюсь объяснить в разделе комментариев: Использование target.length.
// Chunk function
const chunk = (target, size) => {
return target.reduce((memo, value, index) => {
// Here it comes the only difference
if (index % (target.length / size) == 0 && index !== 0) memo.push([])
memo[memo.length - 1].push(value)
return memo
}, [[]])
}
// Usage
write(chunk([1, 2, 3, 4], 2))
write(chunk([1, 2, 3, 4], 4))
// For rendering pruposes. Ignore
function write (content) { document.write(JSON.stringify(content), '</br>') }
Ответ 6
Старый вопрос, но поскольку vanillaJS не является требованием, и многие пытаются решить это с помощью lodash/chunk и не ошибаясь, что на самом деле делает _.chunk, здесь краткое + точное решение с использованием lodash:
(В отличие от принятого ответа, это также гарантирует n столбцов, даже если originalArray.length < numCols)
import _chunk from 'lodash/chunk'
/**
* Split an array into n subarrays (or columns)
* @param {Array} flatArray Doesn't necessarily have to be flat, but this func only works 1 level deep
* @param {Number} numCols The desired number of columns
* @return {Array}
*/
export function splitArray(flatArray, numCols){
const maxColLength = Math.ceil(flatArray.length/numCols)
const nestedArray = _chunk(flatArray, maxColLength)
let newArray = []
for (var i = 0; i < numCols; i++) {
newArray[i] = nestedArray[i] || []
}
return newArray
}
Цикл for в конце - это то, что гарантирует желаемое количество "столбцов".
Ответ 7
Рекурсивный подход, не проверенный.
function splitArray(array, parts, out) {
var
len = array.length
, partLen
if (parts < len) {
partLen = Math.ceil(len / parts);
out.push(array.slice(0, partLen));
if (parts > 1) {
splitArray(array.slice(partLen), parts - 1, out);
}
} else {
out.push(array);
}
}
Ответ 8
Другой рекурсивный работает довольно хорошо, он менее уродлив
function nSmaller(num, arr, sliced) {
var mySliced = sliced || [];
if(num === 0) {
return sliced;
}
var len = arr.length,
point = Math.ceil(len/num),
nextArr = arr.slice(point);
mySliced.push(arr.slice(0, point));
nSmaller(num-1, nextArr, mySliced);
return(mySliced);
}
Ответ 9
Вероятно, более чистый подход был бы следующим (без использования какой-либо другой библиотеки):
var myArray = [];
for(var i=0; i<100; i++){
myArray.push(i+1);
}
console.log(myArray);
function chunk(arr, size){
var chunkedArr = [];
var noOfChunks = Math.ceil(arr.length/size);
console.log(noOfChunks);
for(var i=0; i<noOfChunks; i++){
chunkedArr.push(arr.slice(i*size, (i+1)*size));
}
return chunkedArr;
}
var chunkedArr = chunk(myArray, 3);
console.log(chunkedArr);
Я создал свой собственный массив, который должен быть помечен. Вы можете найти код здесь
Также у нас есть метод "chunk" в библиотеке lodash, который очень полезен. Надеюсь, что поможет
Ответ 10
function splitArray(arr, numOfParts = 10){
const splitedArray = []
for (let i = 0; i < numOfParts;i++) {
const numOfItemsToSplice = arr.length / 10;
splitedArray.push(arr.splice(0, numOfItemsToSplice))
}
return splitedArray;
}
Ответ 11
function parseToPages(elements, pageSize = 8) {
var result = [];
while (elements.length) {
result.push(elements.splice(0, pageSize));
}
return result;
}
Ответ 12
Если вы заранее знаете размер нужных кусков, есть довольно элегантный способ сделать это в ES6:
const groupsOfFour = ([a,b,c,d, ...etc]) =>
etc.length? [[a,b,c,d], groupsOfFour(etc)] : [[a,b,c,d]];
console.log(groupsOfFour([1,2,3,4,1,2,3,4,1,2,3,4]));
Ответ 13
Вы можете использовать простую рекурсивную функцию
const chunkify = (limit, completeArray, finalArray = [])=>{
if(!completeArray.length) return finalArray
const a = completeArray.splice(0,limit);
return chunkify(limit, completeArray, [...finalArray,a])
}
Ответ 14
Я сделал это так, это работает...
function splitArray(array, parts) {
if (parts< array.length && array.length > 1 && array != null) {
var newArray = [];
var counter1 = 0;
var counter2 = 0;
while (counter1 < parts) {
newArray.push([]);
counter1 += 1;
}
for (var i = 0; i < array.length; i++) {
newArray[counter2++].push(array[i]);
if (counter2 > parts - 1)
counter2 = 0;
}
return newArray;
} else
return array;
}
Ответ 15
проверить мою версию этого массива split
// divide array
Array.prototype.divideIt = function(d){
if(this.length <= d) return this;
var arr = this,
hold = [],
ref = -1;
for(var i = 0; i < arr.length; i++){
if(i % d === 0){
ref++;
}
if(typeof hold[ref] === 'undefined'){
hold[ref] = [];
}
hold[ref].push(arr[i]);
}
return hold;
};
Ответ 16
если вы знаете, хотите установить child_arrays.length, я думаю, что это решение лучше всего:
function sp(size, arr){ //size - child_array.length
var out = [],i = 0, n= Math.ceil((arr.length)/size);
while(i < n) { out.push(arr.splice(0, (i==n-1) && size < arr.length ? arr.length: size)); i++;}
return out;
}
вызов fn: sp (2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])//2 - child_arrat.length
Ответ: [1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11]
Ответ 17
Просто используйте функцию блока lodash для разбиения массива на меньшие массивы https://lodash.com/docs#chunk Вам больше не нужно играть с петлями!
Ответ 18
Если вы можете использовать lodash и хотите использовать функциональный подход к программированию, вот что я lodash:
const _ = require('lodash')
function splitArray(array, numChunks) {
return _.reduce(_.range(numChunks), ({array, result, numChunks}, chunkIndex) => {
const numItems = Math.ceil(array.length / numChunks)
const items = _.take(array, numItems)
result.push(items)
return {
array: _.drop(array, numItems),
result,
numChunks: numChunks - 1
}
}, {
array,
result: [],
numChunks
}).result
}
Ответ 19
все вышеперечисленное может работать нормально, но что если у вас есть associative массив со строками в качестве ключей?
objectKeys = Object.keys;
arraySplit(arr, n) {
let counter = 0;
for (const a of this.objectKeys(arr)) {
this.arr[(counter%n)][a] = arr[a];
counter++;
}
}
Ответ 20
У меня есть тот, который не меняет исходный массив
function splitArray(array = [], nPieces = 1){
const splitArray = [];
let atArrPos = 0;
for(let i = 0; i < nPieces; i++){
const splitArrayLength = Math.ceil((array.length - atArrPos)/ (nPieces - i));
splitArray.push([]);
splitArray[i] = array.slice(atArrPos, splitArrayLength + atArrPos);
atArrPos += splitArrayLength;
}
return splitArray
}
Ответ 21
Лодаш chunk(array, Math.round(array.length / n))
Ответ 22
Если вы используете lodash, вы можете достичь его довольно легко, как показано ниже:
import {chunk} from 'lodash';
// divides the array into 2 sections
chunk([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 2); // => [[1,2,3,4,5,6], [7,8,9,10,11]]
