Question

我正在使用Nodejs。我需要在关系数据库中存储JavaScript对象。 JavaScript对象中的每个键代表DB中的列名。我有以下内容：

var data = {
  "aa": "99",
  "bb": ["11","22"],
  "cc": ["44","55","66"]
}

我想将此对象转换为数组，如下所示：

  data =  [
    {
    "aa": "99",
    "bb": "11",
    "cc": "44"
    },
    {
    "aa": "99",
    "bb": "11",
    "cc": "55"
    },
    {
    "aa": "99",
    "bb": "11",
    "cc": "66"
    },
    {
    "aa": "99",
    "bb": "22",
    "cc": "44"
    },
    {
    "aa": "99",
    "bb": "22",
    "cc": "55"
    },
    {
    "aa": "99",
    "bb": "22",
    "cc": "66"
    }
    ]

有没有办法做到这一点？我想使用递归我们可以做到。但是在谷歌找不到任何参考。

Answer 1

您可以使用组合算法的迭代和递归方法。

这个解决方案基本上遍历给定的数据（一个数组由对象组成），并在数组内部迭代遍历项目。在这种情况下，您有一个包含三个数组的数组。

[
    ["99"],
    ["11","22"],
    ["44","55","66"]
]

它从第一个数组开始并迭代。这里只有一个项目和iteraton的回调检查零件长度，如果它等于给定的数组长度，则可以找到al item。这是退出迭代adn以将收集的部分推送到结果数组的结果。（这些项目将转换为reduce回调中的对象。）

如果零件数组没有所需的长度，请继续执行外部数组的下一项。

基本上迭代和重复工作如下

part       0      1      2   action
       ------  -----  -----  ---------------
          99                 go to next level
          99     11          go to next level
          99     11     44   push to result, end level 2
          99     11     55   push to result, end level 2
          99     11     66   push to result, end level 2
          99     11          end level 1
          99     22          go to next level
          99     22     44   push to result, end level 2
          99     22     55   push to result, end level 2
          99     22     66   push to result, end level 2
          99     22          end level 1
          99                 end level 0

function combine(object) {
    function c(part) {
        array[part.length].forEach(function (a) {
            var p = part.concat(a);
            if (p.length === array.length) {
                result.push(p.reduce(function (r, b, i) {
                    r[keys[i]] = b;
                    return r;
                }, {}));
                return;
            }
            c(p);
        });
    }

    var keys = Object.keys(object),
        array = keys.map(function (k) { return Array.isArray(object[k]) ? object[k] : [object[k]]; }),
        result = [];

    c([]);
    return result;
}

var data = { aa: "99", bb: ["11", "22"], cc: ["44", "55", "66"] },
    result = combine(data);

console.log(result);

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

Answer 2

如果可以使用ES6，可以使用生成器迭代所有层（不一定更好，不是最可读，但我只是喜欢迭代器:)）

function flatten(data) {
  const getArr = a => Array.isArray(a) ? a: [a],
    keyData = Object.keys(data).map(k=>({name:k,arr:getArr(data[k])})),
    getobj = function*(i)  {
      for(let p of keyData[i].arr)
          for(let o of i===keyData.length -1 ? [{}] : getobj(i+1)){
            	o[keyData[i].name] = p;
                yield o;
            }      		
      }
      return [...getobj(0)];    
}


let data = { aa: "99", bb: ["11", "22"], cc: ["44", "55", "66"] };

console.log(flatten(data));

将JavaScript对象转换为要插入关系数据库

2 个答案: