Справка по алгоритму разбиения на части JS

Question

Работа над несколькими алгоритмами для начинающих c упражнений в JS. Я не понимаю, как работает «разбиение на части», когда доходит до оператора «если».

Основная путаница у меня возникает после итерации до второго значения; потому что в первом прогоне он соответствует критериям неопределенности последнего; поэтому "1" вставляется в переменную с фрагментами. Итак, как только появится вторая переменная, 2, поскольку последняя теперь определена и длина Last не равна аргументу "len", она будет go в части else. 2 будет помещено в "последний" и сформируется last = "[1], 2"?

Затем, когда начинает поступать третье значение (3), я еще больше запутываюсь. Каким образом оператор if chunked.pu sh ([number]) знает, что именно pu sh [1], 2 в chunked, если число в этой точке также равно 3? Это пропуск 3 ?. Я знаю, что длина last в этой точке соответствует len, но как она формулируется от [1], 2 до фрагмента [1,2]?

Я предполагал, что 3 также будет помещено в «последний».

Прошу прощения, если это тоже сбивает с толку! Я просмотрел множество руководств по решению этой же проблемы в Интернете, но нигде не объясняет это подробно.

function chunkedArr(arr, len){
    const chunked = [];

    for (let number of arr){
        const last = chunked[chunked.length-1] 

        console.log(last)

        if(!last || last.length === len){
            chunked.push( [number]);
        } else {
            last.push(number)
        }
    }

    return chunked;

}

console.log(chunkedArr([1,2,3,4,5,6],2))

Answer 1

Одним из ключевых выводов может быть то, что chunked представляет собой массив массивов.

В этом примере на второй итерации chunked будет не [1], а [[1]]. Обратите внимание, что это массив массива. Таким образом, last получает назначенный единственный подмассив внутри chunked, т.е. [1], а в блоке else значение 2 добавляется к этому подмассиву, поэтому оно становится [1, 2]. Поскольку last на самом деле - это , подмассив, который находится внутри chunked, chunked, теперь выглядит следующим образом: [[1, 2]].

В следующей итерации значение равно 3 , и условие if истинно, потому что теперь last равно [1, 2] и, таким образом, имеет требуемую длину 2. На этом этапе значение last остается нетронутым. Этот подмассив теперь "заполнен". Подмассив новый добавляется к chunked, так что он выглядит как [[1, 2], [3]]

На следующей итерации значение равно 4, и теперь last будет присвоено более новое подмассив, т.е. [3]. И так продолжается ...

Answer 2

Давайте пройдемся по вашему алгоритму. Разделенный массив вызывается с двумя аргументами: [1,2,3,4,5,6], а len - 2, что является желаемым размером фрагментов. Внутри вашей функции определен пустой массив chunked. Теперь функция перебирает массив arr.

1. Первая итерация; last не определено, поскольку chunked пуст. Условие !last истинно и, следовательно, [1] помещается внутрь фрагмента. Теперь chunked имеет следующую форму: [ [1] ].
2. Теперь последний - это массив длиной 1 со следующей формой: [1]. !last ложно, и last.length === len также ложно, так как len равно 2. Итак, 2 помещается в последнее. Форма последнего - [1, 2], а форма фрагментов - [ [1, 2] ].
3. Last теперь является массивом размера 2 и формы [1, 2,]. Условие в if оценивается как истинное, поскольку last.length === len. Итак, массив с текущим значением 3 помещается в фрагменты. Размер фрагмента теперь равен 2, а форма - [ [1, 2], [3] ].
4. Last определяется и представляет собой массив размером 1 и формой [3]. Если оценивается как false и 4 помещается в последнее. Последний теперь имеет размер 2 и форму [3, 4]. Массив с фрагментами имеет размер 2 и форму [ [1, 2], [3, 4] ].
5. Теперь текущее значение 5, а последний - массив размера 2. Если условие истинно и есть, массив со значением 5 помещается в фрагменты. Chunked имеет размер 3 и форму [ [1, 2], [3, 4], [5] ].
6. Last - массив размером 1 и имеет в нем значение 6. Если ложно, и поэтому 6 помещается в последнюю очередь. Последний имеет размер 2 и форму [5, 6], а разделенный на части имеет форму [ [1, 2], [3,4], [5,6] ]

На этом этапе итерация по массиву завершается, так как записей больше нет, и функция возвращает фрагменты, которые при печати имеют та же форма, что и в шаге 6. Функция просто проходит по входному массиву и копирует его в новый массив с условием, что новый массив имеет записи, которые представляют собой массив размером len со значениями из arr. последовательно.