Как работает функция lower () высшего порядка?

1

Ниже приведена функция reduce()

function reduce(array, combine, start) { 
    let current = start;
    for (let element of array) { 
        current = combine(current, element); 
    }
    return current;
}

Теперь это вопрос, который я решаю

Используйте метод уменьшения в сочетании с методом concat для "сглаживания" массива массивов в один массив, который имеет все элементы исходных массивов.

Вот решение

let arrays = [[1, 2, 3], [4,5], [6]]; 
console.log(arrays.reduce((flat,current)=> flat.concat(current), []));
// → [1, 2, 3, 4, 5, 6]

Теперь, если я попробую это

let arrays = [[1, 2, 3], [4, [79],5], [6]];
console.log(arrays.reduce((flat, current) => flat.concat(current), []));

Я получаю это

[1, 2, 3, 4, [79], 5, 6]

Это означает, что это решение может получить массив flatten только до двух вложенных массивов. Но как это работает для этих массивов = [[1, 2, 3], [4,5], [6]];

Потому что в функции reduce() я использую для (пусть элементы массива), кстати, если я использую

Он работает так

array = [1,4,6,[6,7],7,6,8,6];
for(element of array) 
   console.log(element);

// 146[6,7]7686

Он не получает значение из вложенного массива. Тогда как это делается для первого решения. Как написать решение, которое работает для любого количества вложенных массивов, я знаю, что он будет использовать рекурсию, но как?

  • 0
    Ваш вопрос не очень понятен. Вы уже правильно поняли, что этот редуктор может выравнивать массивы только на один уровень глубиной. Поэтому в первом примере нет вложенных массивов, а во втором еще есть один. Что ты не понимаешь сейчас? Попробуйте пройти функцию через строку.
  • 0
    Я хочу знать, почему эта функция может сгладить массив только до одного уровня? А как написать функцию, которая работает для любого количества вложенных массивов?
Теги:

2 ответа

2
Лучший ответ

почему эта функция может только сгладить массив до одного уровня глубиной?

let arrays = [[1, 2, 3], [4, [79],5], [6]];console.log(arrays.reduce((flat, current) => flat.concat(current), []))

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

Затем, как вы сказали, вы можете использовать рекурсию:

 function flatten(arrayToFlatten){
      return arrayToFlatten.reduce((prev, next)=>{
        if(!Array.isArray(next)){ // Base case, when you have a number
           return prev.concat(next);
        } else { // Recursive case, when you have an array
           return prev.concat(flatten(next));
        }
      }, []);
    }
Поделиться
  • 0
    @AtulMishra, если ответ вас удовлетворит, вы не могли бы отметить ответ?
2

Ты можешь сделать:

const arrays = [[1, 2, 3],[4, [79], 5],[6]];
const getFlatten = array => array.reduce((a, c) => a.concat(Array.isArray(c) ? getFlatten(c) : c), []);
const result = getFlatten(arrays);

console.log(result);
Поделиться

Ещё вопросы

Сообщество Overcoder
Наверх
Меню