Question

我有以下结构：

const array = [
  [
    [
      [
        [
          {
            'name':'John'
          }
        ],
        {
          'name':'Mary'
        }
      ],
      {
        'name':'Cris'
      }
    ],
    {
      'name':'Deen'
    }
  ],
  {
    'name':'Bob'
  }
]

我希望得到以下结构：

const expect = [
  {
    'name':'John'
  },
  {
    'name':'Mary'
  },
  {
    'name':'Cris'
  },
  {
    'name':'Deen'
  },
  {
    'name':'Bob'
  },
]

如何使用lodash或其他图书馆进行此类转换？

Answer 1

您可以使用lodash中的_.flattenDeep：

递归展平数组。

const array = [[[[[{ name: 'John' }], { name: 'Mary' }], { name: 'Cris' }], { name: 'Deen' }], { name: 'Bob' }];
    
console.log(_.flattenDeep(array));

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

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.15.0/lodash.min.js"></script>

Answer 2

您可以使用2Pi创建递归函数以返回所需的结果。

reduce()

Answer 3

您可以使用此npm包npm underscore，这是一个简单的示例： var _ = require('underscore-node'); var extractedArray = _.flatten(deepArray)

Answer 4

function flattenArray(array, result) {
    result = result || [];
    for (var i = 0; i < array.length; i++) {
        if (Array.isArray(array[i])) {
            flattenArray(array[i], result);
        } else {
            result.push(array[i]);
        }
    }

    return result;
}

我写了一段时间回来。遵循递归方法，也非常快。

JSPerf：https://jsperf.com/flatten-array-r1

Answer 5

通过纯ES6和通过解构实现的Haskellesque模式匹配，您可以简单地执行以下操作;

function flat([a,...b]){
  return (Array.isArray(a) ? flat(a) : [a]).concat(b.length ? flat(b) : []);
}

var arr = [[[[[{"name":"John"}],{"name":"Mary"}],{"name":"Cris"}],{"name":"Deen"}],{"name":"Bob"}],
    res = flat(arr);
console.log(res);

Answer 6

您可以使用闭包和ES6的单行代码来完成。图书馆，如果没有必要，是一种负担。尽可能避免使用它们。

const flatten = arr => arr.reduce((r, e) => (r = r.concat(Array.isArray(e) ? flatten(e) : e), r), []);

const array = [
  [
    [
      [
        [{
          'name': 'John'
        }],
        {
          'name': 'Mary'
        }
      ],
      {
        'name': 'Cris'
      }
    ],
    {
      'name': 'Deen'
    }
  ],
  {
    'name': 'Bob'
  }
];
console.log(flatten(array))

Answer 7

没有任何库并使用古老的JS逻辑的最佳方式：

＆＃13;

var arr = [
  [
    [
      [
        [
          {
            'name':'John'
          }
        ],
        {
          'name':'Mary'
        }
      ],
      {
        'name':'Cris'
      }
    ],
    {
      'name':'Deen'
    }
  ],
  {
    'name':'Bob'
  }
];

// convert to string and remove all Array "[" and "]" symbols
var str = JSON.stringify(arr).replace(/\[|]/g,'');
// convert the String back to an Object (Array)
var flatArr = JSON.parse("[" + str + "]");

console.log(flatArr)

＆＃13;

Answer 8

考虑学习object-scan。一旦把头缠起来，在内存数据结构处理中就非常强大。

这是解决示例的方法

const objectScan = require('object-scan');

const find = (input) => objectScan(['**'], {
  rtn: 'value',
  filterFn: ({ value }) => typeof value.name === 'string'
})(input).reverse();

const array = [[[[[{ name: 'John' }], { name: 'Mary' }], { name: 'Cris' }], { name: 'Deen' }], { name: 'Bob' }];

console.log(JSON.stringify(find(array)));
// => [{"name":"John"},{"name":"Mary"},{"name":"Cris"},{"name":"Deen"},{"name":"Bob"}]

在深度数组nodejs中合并数组

8 个答案:

没有任何库并使用古老的JS逻辑的最佳方式：