Как разбить массив на подмассивы js

Курсы javascript

Очень жаль , что мы друг друга не понимаем , или не хотим понять . Попробую обьяснить еще раз помогите составить цикл.
Имеется исходный массив и то что я должен получить. Только без дополнительных функций по разбиеню массивов.

29.01.2022, 16:31
Интересующийся
Регистрация: 28.01.2022
Сообщений: 16
очень жаль , что мы не понимаем друг друга.
29.01.2022, 16:35
Интересующийся
Регистрация: 28.01.2022
Сообщений: 16

Попробую обьяснить еще раз , Вы можете помогти ставить цикл , без Вашей первой функции permute() . она мне не нужна , да и работает с ошибкой ругается на строку.

for (let i = 0; i < l; ++i)

Uncaught SyntaxError: Unexpected token ';'

29.01.2022, 17:00
Регистрация: 27.05.2010
Сообщений: 33,031
29.01.2022, 17:17
Интересующийся
Регистрация: 28.01.2022
Сообщений: 16
. Эти ссылки имеют какое нибудь отношение к моему вопросу? Или это так , лишь бы отмазаться ?
29.01.2022, 17:45
Регистрация: 27.05.2010
Сообщений: 33,031
видимо я точно не телепат, что вам нужно мне неизвестно)))
29.01.2022, 17:54
Интересующийся
Регистрация: 28.01.2022
Сообщений: 16

Видимо Вы просто не желаете помочь . В самом первом Вашем ответе была доля истины . Но там была ссылка с ответом на другой вопрос, в котором была ненужная мне функция. Я попросил упростить , Вы начали кидаться ссылками . Если нет желания , могли бы просто послать меня и все.
Ну да ладно , помогать , или нет , это Ваше личное желание , и я не могу на это повлиять.
Все равно спасибо Вам , что откликнулись . Хорошего дня.

29.01.2022, 17:59
Регистрация: 27.05.2010
Сообщений: 33,031
DzonyB,
ты бы для начала толком объяснил что тебе надо, а не в . лез.
29.01.2022, 18:22
Интересующийся
Регистрация: 28.01.2022
Сообщений: 16
Да я никуда и не лезу . ОК! Попытаюсь обьяснить сначала.

Дано arr= [1,2,4,7,1,6,2,8] Нужно получить arr_new=[[8,2],[6,4],[1,2,7,1]]

Т.е -«Разделите элементы массива на группы, сумма каждой из которых максимально равна друг другу.»
Вариантов решения здесь несколько , можно разбить

1. array1=>[ [8][6,2][7,1][1,2,4] ]=> 8 - 4группы 2. array2=>[[8,2][7,2,1][6,4,1]]=>10/11 - 3 группы 3. array3=>[[1,2,4,7,1][6,2,8]]=>15/16 -2 группы

Я выбрал среднюю группу , чтобы упростить задачу . Т.е создать функцию в которую передается 2 аргумента , массив и кол. групп . И на выходе получаем один из трех массивов в зависимости от количества групп .
В первом Вашем ответе была ссылка , в принципе по той ссылке function permutDevide(arr) делает то , что нужно , но в ней вызывается функция function permute(arr) . А вот с ней и проблема код не работает , выдает ошибки , я писал . А Вы мне начинаете давать другие ссылки. Если честно , я уже запутался, мозг кипит.
Надеюсь я понятно изложил.

Как разбить массив на несколько массивов js

Можно использовать метод reduce() для разделения исходного массива на несколько массивов, основываясь на некотором условии.

Пример. Разделим массив чисел на два массива — один сочетает в себе все четные числа, а другой — все нечетные числа.

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]; const [evenNumbers, oddNumbers] = numbers.reduce( (acc, val) =>  acc[val % 2].push(val); return acc; >, [[], []] ); console.log(evenNumbers); // [2, 4, 6, 8] console.log(oddNumbers); // [1, 3, 5, 7, 9] 

Здесь мы использовали reduce() , чтобы создать два массива внутри массива acc , один для четных чисел и другой для нечетных. Затем мы проходим по каждому числу в исходном массиве и добавляем его в соответствующий массив внутри acc на основе остатка от деления на 2.

Затем мы деструктурируем результат reduce() в две переменные evenNumbers и oddNumbers , чтобы получить два отдельных массива, содержащих только четные и нечетные числа соответственно.

26 сентября 2022

Для того что бы получить «срез» массива, можно воспользоваться встроенным методом slice

const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; console.log(nums.slice(3)); // Вывод: [ 4, 5, 6, 7, 8, 9, 10 ] console.log(nums.slice(2, 6)); // Вывод: [ 3, 4, 5, 6 ] console.log(nums.slice(-2)); // Вывод: [ 9, 10 ] console.log(nums.slice()); // Вывод: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 

Для того чтобы «нарезать» массив на одинаковые части, можно воспользоваться методом chunk из библиотеки lodash:

_.chunk(['a', 'b', 'c', 'd'], 2); // Вывод: [['a', 'b'], ['c', 'd']] _.chunk(['a', 'b', 'c', 'd'], 3); // Вывод: [['a', 'b', 'c'], ['d']] 

Как разбить массив на подмассивы?

Допустим, есть массив из 233 элементов: [<>,<>,<>. <>] ; Как разбить такой массив на подмассивы, чтобы в каждом подмассиве было не более 100 элементов? (число элементов может меняться) Например так: [ [0-99], [100-199], [200-232] ] ;

Отслеживать
123k 24 24 золотых знака 126 126 серебряных знаков 303 303 бронзовых знака
задан 18 окт 2017 в 6:56
73 1 1 золотой знак 1 1 серебряный знак 4 4 бронзовых знака

10 ответов 10

Сортировка: Сброс на вариант по умолчанию

Одно из решений, через цикл:

let array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; //массив, можно использовать массив объектов let size = 3; //размер подмассива let subarray = []; //массив в который будет выведен результат. for (let i = 0; i console.log(subarray);

Отслеживать
ответ дан 18 окт 2017 в 7:11
Sergey Glazirin Sergey Glazirin
5,628 5 5 золотых знаков 19 19 серебряных знаков 36 36 бронзовых знаков

const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; const array_size = 3; const sliced_array = []; for (let i = 0; i console.log(sliced_array); 

Отслеживать
ответ дан 21 мар 2019 в 15:04
PlayheadSTD PlayheadSTD
31 1 1 бронзовый знак

const array = [], result = [], length = 100; // Объявляем переменные for (let x = 1; x 

const s = [,,,,,]; const SIZE = 4; const res = s.reduce((p,c)=> < if(p[p.length-1].length == SIZE)< p.push([]); >p[p.length-1].push(c); return p; >, [[]]); console.log(res);

// Создаем массив из 233 элементов var array = []; for (var x = 1; x var subArray = [], subIndex = -1; for (var i = 0; i < array.length; i++) < // Каждые 200 итераций меняем ключ для добавления в подмассив if (0 === i % 200) < subIndex++; >if (subArray[subIndex] === undefined) < subArray[subIndex] = []; >subArray[subIndex].push(array[i]); > console.log(subArray);

const src = [1,2,3,4,5,6,7,8,9]; const result = []; const count = 2; for (let s = 0, e = count; s < src.length; s += count, e += count) result.push(src.slice(s, e)); console.log(result) 

function unflat(src, count) < const result = []; for (let s = 0, e = count; s < src.length; s += count, e += count) result.push(src.slice(s, e)); return result; >console.log(unflat([1,2,3,4,5,6,7,8,9,0], 3)); 

const arrayToChank = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; function chunk(arr, size) < const result = []; for (let i = 0; i < Math.ceil(arr.length/size); i++) < result.push(arr.slice((i * size), (i * size) + size)); >return result; > console.log(chunk(arrayToChank, 2));

 const arraySplitter = (arr, qtyItems) => < let countItems = 0 const lengthArr = arr.length const resultArr = [] const splitter = (arr) =>< if (countItems >= lengthArr) < return >resultArr.push(arr.slice(countItems, countItems + qtyItems)) countItems = countItems + qtyItems splitter(arr) > splitter(arr) return resultArr > 

var newArray = arr.flat(depth);

var arr1 = [1, 2, [3, 4]]; arr1.flat(); // [1, 2, 3, 4] var arr2 = [1, 2, [3, 4, [5, 6]]]; arr2.flat(); // [1, 2, 3, 4, [5, 6]] var arr3 = [1, 2, [3, 4, [5, 6]]]; arr3.flat(2); // [1, 2, 3, 4, 5, 6] var arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]]; arr4.flat(Infinity); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 

Упрощение и "дырки" в массивах

Метод flat удаляет пустые слоты из массива:

var arr4 = [1, 2, , 4, 5]; arr4.flat(); // [1, 2, 4, 5] 

Альтернативы

reduce и concat

var arr1 = [1, 2, [3, 4]]; arr1.flat(); // В одномерный массив arr1.reduce((acc, val) => acc.concat(val), []); // [1, 2, 3, 4] //или const flatSingle = (arr) => [].concat(. arr); 

// Для развёртывания многомерных массивов используем рекурсию, reduce и concat const arr = [1, 2, [3, 4, [5, 6]]]; function flatDeep(arr, d = 1)  return d > 0 ? arr.reduce( (acc, val) => acc.concat(Array.isArray(val) ? flatDeep(val, d - 1) : val), [], ) : arr.slice(); > flatDeep(arr, Infinity); // [1, 2, 3, 4, 5, 6] 

//не рекурсивное упрощение с использованием стэка var arr1 = [1, 2, 3, [1, 2, 3, 4, [2, 3, 4]]]; function flatten(input)  const stack = [. input]; const res = []; while (stack.length)  // забираем последнее значение const next = stack.pop(); if (Array.isArray(next))  // добавляем к массиву элементы не модифицируя исходное значение stack.push(. next); > else  res.push(next); > > //разворачиваем массив, чтобы восстановить порядок элементов return res.reverse(); > flatten(arr1); // [1, 2, 3, 1, 2, 3, 4, 2, 3, 4] 

//рекурсивно упрощаем массив function flatten(array)  var flattend = []; (function flat(array)  array.forEach(function (el)  if (Array.isArray(el)) flat(el); else flattend.push(el); >); >)(array); return flattend; > 

Спецификации

Совместимость с браузерами

BCD tables only load in the browser

Смотрите также

• Array.prototype.flatMap()
• Array.prototype.map()
• Array.prototype.reduce()
• Array.prototype.concat()

Found a content problem with this page?

• Edit the page on GitHub.
• Report the content issue.
• View the source on GitHub.

This page was last modified on 4 авг. 2023 г. by MDN contributors.

Your blueprint for a better internet.