Сглаживание вложенного массива в JavaScript

У меня есть ужасно выглядящий массив, который выглядит так:

EDIT:

array = [
    {
        Letters: [{ Letter: 'A' }, { Letter: 'B' }, { Letter: 'C' }],
        Numbers: [{ Number: '1' }, { Number: '2' }, { Number: '3' }]
    },
    null,
    {
        Letters: [{ Letter: 'D' }, { Letter: 'E' }, { Letter: 'F' }, { Letter: 'G' }, { Letter: 'H' }],
        Numbers: [{ Number: '4' }, { Number: '5' }, { Number: '6' }, { Number: '7' }]
    }
];

И хотите, чтобы массив выглядел так:

flattenedArray = [a,b,c,1,2,3,d,e,f,g,h,4,5,6,7]

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

Я попытался использовать:

var flattenedArray = [].concat.apply([], array);

Но он просто представляет массив в том же формате, в котором он был введен.

Мне было интересно, есть ли у кого-нибудь совет?

EDIT: Я пробовал реализовать предложенные предложения - большое вам спасибо за вашу помощь. Кажется, что это проблема с форматом списка - к сожалению, с помощью хром-консоли, которая находится в формате "дерева", я не вижу прямой структуры вывода массива.

Спасибо вам за вашу помощь! EDIT 2: см. Выше для фактического массива, спасибо за то, что вы показали мне, как это увидеть!

Ответы

Ответ 1

Изменить новый запрос вложенных массивов/объектов и сгладить, вы можете использовать комбинированный подход с тестированием для типа элемента.

var array = [{ Letters: [{ Letter: 'A' }, { Letter: 'B' }, { Letter: 'C' }], Numbers: [{ Number: '1' }, { Number: '2' }, { Number: '3' }] }, null, { Letters: [{ Letter: 'D' }, { Letter: 'E' }, { Letter: 'F' }, { Letter: 'G' }, { Letter: 'H' }], Numbers: [{ Number: '4' }, { Number: '5' }, { Number: '6' }, { Number: '7' }] }],
    result = array.reduce(function iter(r, a) {
        if (a === null) {
            return r;
        }
        if (Array.isArray(a)) {
            return a.reduce(iter, r);
        }
        if (typeof a === 'object') {
            return Object.keys(a).map(k => a[k]).reduce(iter, r);
        }
        return r.concat(a);
    }, []);

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Ответ 2

Если у вас lodash, вы можете использовать:

_.flattenDeep(array)

Вы также можете проверить их исходный код для получения информации о том, как реализовать себя, если хотите.

Ответ 3

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

var array = [[['a','b','c'],[1,2,3]],[],[['d','e','f','g','h'],[4,5,6,7]]]
function flat(data) {
  var r = []
  data.forEach(e => Array.isArray(e) ? r = r.concat(flat(e)) : r.push(e));
  return r;
}

console.log(flat(array))

Ответ 4

Вы можете попробовать flatten в Ramda.

  R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);
    //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

Ответ 5

Хорошо использовать рекурсивную функцию для таких случаев:

arr = [[['a','b','c'],[1,2,3]],[],[['d','e','f','g','h'],[4,5,6,7]]];

function flatten(arr) {
    var result = [];
    for (var i = 0, len = arr.length; i < len; i++) {
       result = result.concat(Array.isArray(arr[i])? flatten(arr[i]) : [arr[i]]);
    }
    return result;
}
console.log(flatten(arr));

Ответ 6

Формат вашего массива неверен, вам не хватает commas(,). Это правильный массив.

var array = [[['a','b','c'],[1,2,3]],[],[['d','e','f','g','h'],[4,5,6,7]]];

var array = [[['a','b','c'],[1,2,3]],[],[['d','e','f','g','h'],[4,5,6,7]]];
var result = flatten(array);
    
function flatten(array) {
    var flat = [];
    if(array !== undefined){
    var flat = [];
    for (var i = 0; i < arguments.length; i++) {
          if (arguments[i] instanceof Array) {
            flat = flat.concat(flatten.apply(null, arguments[i]));
          } else {
            flat.push(arguments[i]);
          }
        }
      }
    return flat;
}

console.log(result);

Ответ 7

function steamrollArray(arr) {
  var tmp = [];
  arr.forEach(function(val){
    if(Array.isArray(val))
      tmp = tmp.concat(steamrollArray(val));
    else
      tmp.push(val);
  });

  console.log(tmp);
  return tmp;
}

steamrollArray([1, [2], [3, [[4]]]]);

Ответ 8

Никто не думал о сращивании на месте?

function flatten(array){
    for (var i = 0; i < array.length; i++) {
        if(array[i] instanceof Array){
            array.splice.apply(array,[i,1].concat(array[i]));
            i--;
        }
    };
    return array;
}

Одна итерация, без рекурсии.