如何将flattenObj函数从ramda cookbook转换为迭代函数

Question

我正在处理测试环境nodejs / sequelize / mocha / chai。我发现这个flattenObj在测试对象时非常有用，例如由sequelize生成。 它使这些结构易于消化，结果变得更加简洁 太糟糕了，它以递归的方式实现:(。 特别是在Javascript中，这意味着厄运，因为总是存在潜伏的调用堆栈限制。 喜欢在setTimeout中包装递归函数的黑客似乎对我不起作用并且有些难看。 我目前正试图想要以迭代的方式重写它，但这是一个很好的脑筋急转弯，至少对我而言。 处理ramda函数内的while循环感觉不对。 有没有办法在不违反ramda约定的情况下以调用堆栈友好的方式执行此操作？

const go = obj_ => chain(([k, v]) => {
  if (type(v) === 'Object' || type(v) === 'Array') {
    return pipe( 
        tap(console.log),            
        map(([k_, v_]) => [`${k}.${k_}`, v_]) 
     )(go(v))
  } else {
    return [[k, v]]
  }
}, toPairs(obj_))

const flattenObj = obj => {
  return fromPairs(go(obj))
}

flattenObj({a:1, b:{c:3}, d:{e:{f:6}, g:[{h:8, i:9}, 0]}})

{
  "a": 1,
  "b.c": 3,
  "d.e.f": 6,
  "d.g.0.h": 8,
  "d.g.0.i": 9,
  "d.g.1": 0
}

这可以按预期工作，但由于递归go函数，当对象变得太复杂时，它会导致调用堆栈超出错误。 如果它也适用于更复杂的结构，这将是非常有用的。

Answer 1

我不认为以递归方式实现它是一件坏事。这是处理递归数据结构（如JS对象）的最佳方法。

但是，如果要管理自己的堆栈，可以随时将递归解决方案转换为迭代解决方案。这是一个相当丑陋的方法，但它似乎适用于这个简单的测试用例：

const flattenObj = (obj) => {
  const results = [];
  const steps = Object.entries(obj)
  while (steps.length) {
    const [key, val] = steps.splice(0, 1)[0]
    if (typeof val == 'object') {
      Array.prototype.push.apply(steps, Object.entries(val).map(
        ([k, v]) => [key + '.' + k, v]
      ))
    } else {
      results.push([key, val])
    }
  }
  return results.reduce((a, [k, v]) => ({...a, [k]: v}), {})
}


const foo = {a:1, b:{c:3}, d:{e:{f:6}, g:[{h:8, i:9}, 0]}}

console.log(flattenObj(foo))

这不适用于周期性结构，但据推测，食谱版本也不会。

我最初使用一些Ramda函数（toPairs代替Object.entries，is(Object, val)代替typeof val == 'object'和return fromPairs(results)代替return results.reduce(...)）写了这个。但是随着所有的突变（splice和push），它感觉非常unRamda-ish解决方案，我删除了它们。 （Ramda函数，你明白，不想与gauche的可变性联系起来！）

我不知道这是否能解决你的问题。虽然我可以在测试中看到实用程序，但我只使用了几次flattenObj。但令我印象深刻的是，如果这导致递归问题，周期性数据结构比实际深度更可能是问题。但当然我不知道你的数据，所以谁知道呢？