Javascript 将对象数组反规范化为非规范化数组

我正试图找到一种方法，在JavaScript中对对象数组进行非规范化，以获得一组数组。我需要一个表的结构（非规范化的数据集）

因此，考虑到输入：

var data = [
    { v1: 1, v2: [ { a: 1 }, { a: 2 } ] },
    { v1: 2, v2: [ { a: 3 }, { a: 4 } ], v3: 5 },
];

我需要一个像这样的结构

var data2 = [
    { v1: 1, v2_a: 1 },
    { v1: 1, v2_a: 2 },
    { v1: 2, v2_a: 3, v3: 5 },
    { v1: 2, v2_a: 4, v3: 5 }
];

递归方式

我的第一次尝试是在一个时态变量中添加属性，进行深度的全扫描搜索：

var result = [];
function aArray(data) {
    for(var i = 0; i < data.length; i++){
        var temp = {};
        for(var prop in data[i]){
            var val = data[i][prop];
            if( Object.prototype.toString.call( val ) === '[object Array]' ) {
                aArray(val);
            }else{
                temp[prop] = val;
            }
        }
        result.push(temp);
    }
}

var结果=[]；
函数（数据）{
对于（变量i=0；i

---

但是有些东西没有按预期工作

您可以尝试此解决方案

var data = [
    { v1: 1, v2: [ { a: 1 }, { a: 2 } ] },
    { v1: 2, v2: [ { a: 3 }, { a: 4 } ], v3: 5 },
];

function is_a(a){
  return (typeof a == "object") && (a instanceof Array);
}
function extend(a, b){
  for(var i in b){
    a[i] = b[i];
  }
  return a;
}

现在这里的主要逻辑是：

var p = data.map(function(item){

  var output = {};
  var list   = [];

  for(var i in item){
    if(is_a(item[i])){
      for(var j = 0; j < item[i].length; j++){
        for(var z in item[i][j]){
          var k = {}; k[i + "_" + z] = item[i][j][z];
          list.push(k);
        }
      }
    }
    else{
      output[i] = item[i];
    }
  }    

  for(var i = 0; i < list.length; i++){
    list[i] = extend(list[i], output);
  }

  console.log(list);

});

var p=data.map（函数（项）{
var输出={}；
var列表=[]；
用于（项目中的变量i）{
如果（是_a（项目[i]））{
对于（var j=0；j

输出： 首先

0:对象 v1:1 v2_a:1

1：对象 v1:1 v2_a:2

第二

0:对象 v1:2 v2_a:3 v3:5

1：对象 v1:2 v2_a:4 v3:5

---

请尝试

是否要对包含数组的任何属性进行常规扩展，以及是否需要对嵌套在数组中的数组进行扩展？或者只是顶层的

v2

属性？它是否需要对嵌套在对象内部的对象起作用，以便子对象也在它们自己的世界中展开？不起作用的是，在所需的输出数组中有4个对象，而从输入数组中只创建了2个。Dude。我一直在努力，但是我没有更多的时间来完成它。。你可以试着完成你自己。退房对不起=/很抱歉通用方式。不匹配属性和深度级别，必须以递归方式工作。递归方式。根据你的评论：但仍然不起作用。。。