다음과 같은 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]]], 그리고 null 구분자로하기로 결정했습니다).
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/
어떻게 하시겠습니까? 감사!
답변
슬라이스를 “균형”(서버 레이의 길이가 가능한 한 작게 다름) 또는 “균등”(모든 서브 어레이지만 마지막은 동일한 길이)으로 만들 수 있습니다.
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>답변
스플 라이스를 사용하는 것이 가장 깨끗하다고 생각합니다.
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 = 31/3, 나머지 부분의 1/2, 나머지 배열을 차례로 사용합니다. Math.ceil요소 수가 고르지 않은 경우 가장 빠른 청크로 이동합니다.
(참고 : 이것은 초기 어레이를 파괴합니다.)
답변
function split(array, n) {
let [...arr] = array;
var res = [];
while (arr.length) {
res.push(arr.splice(0, n));
}
return res;
}답변
알고리즘을 반복적으로 구현했습니다 : 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;
}
답변
그것을 행렬로 줄일 수 있습니다. 아래의 예는 배열 ( arr)을 두 위치 배열의 행렬로 분할합니다 . 다른 크기를 원하면 두 번째 줄의 2 값을 변경하십시오.
target.reduce((memo, value, index) => {
if (index % 2 === 0 && index !== 0) memo.push([])
memo[memo.length - 1].push(value)
return memo
}, [[]])
도움이 되었기를 바랍니다.
편집 : 일부 사람들은 여전히 내가 원하는 청크 수 대신 각 청크 의 크기를 수정했기 때문에 질문에 대답하지 않습니다 . 주석 섹션에서 설명하려는 내용을 설명하는 코드가 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>') }답변
업데이트 : 2020 년 7 월 21 일
내가 몇 년 전에 준 대답은 originalArray.length<= 인 경우에만 작동합니다 numCols. 아래의이 기능과 같은 것을 대신 사용할 수 있지만, 당면한 질문과 완전히 일치하지 않는 레이아웃이 생성됩니다 (수직 정렬이 아닌 수평 정렬). AKA : [1,2,3,4]-> [[1,4],[2],[3]]. 나는 이것이 여전히 가치를 제공 할 수 있음을 이해하므로 여기에 남겨 둘 것이지만 Senthe의 대답을 권장 합니다.
function splitArray(flatArray, numCols){
const newArray = []
for (let c = 0; c < numCols; c++) {
newArray.push([])
}
for (let i = 0; i < flatArray.length; i++) {
const mod = i % numCols
newArray[mod].push(flatArray[i])
}
return newArray
}
2017 년의 원래 답변 :
오래된 질문이지만 vanillaJS는 요구 사항이 아니기 때문에 많은 사람들이 lodash / chunk로이 문제를 해결하려고 노력하고 있으며 _.chunk실제로 수행 하는 작업을 착각하지 않고 lodash다음 을 사용하는 간결하고 정확한 솔루션이 있습니다 .
(허용되는 답변과 달리 originalArray.length< 하더라도 n 열을 보장합니다. 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끝에 있는 루프는 원하는 “열”수를 보장합니다.
답변
재귀 적 접근 방식, 테스트되지 않았습니다.
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);
}
}
