ramda js 在第二和第三级更新深度嵌套的数组

Question

const items ={
  "costList":[
     {
       "cost": [10, 20],
       "order":20
     } ,
    {
      "cost": [20, 30],
      "order":20
    }
  ],
  "testObject3":[{
    "testArray":[
      {
        testInnerArray:[10,20,30,40],
        testNumber:30
      },
     {
        testInnerArray:[10,20,30,40],
        testNumber:30
      }
    ]
  }
  ]
}

我正在尝试使用 ramda 并更新 json 文档中向下 2 级或 3 级的数组。

一个。对于第一个，我试图更新成本数组并乘以一个因子。 我使用了以下 ramda 函数，它给了我 Nan 作为值，而我期望在第一个数组索引的情况下为 [20,40] 和在第二个数组索引的情况下为 [40, 60] 。 我使用以下 ramda 语句进行转换：

const costListLens = R.lensProp('costList');

const costLens = R.lensProp('cost');

var convertedData = R.over(costListLens, R.map(R.over(costLens, R.multiply(2))
                                                          ))(items);

b.在第二种情况下，我正在尝试更新向下 3 级的数组。

---

const firstLevelLens = R.lensProp('testObject3');
const secondLevelLens = R.lensProp('testArray');
const thirdLevelLens = R.lensProp('testInnerArray');
R.over(firstLevelLens, R.map(R.over(secondLevelLens, R.map(R.over(thirdLevelLens, R.multiply(2))                                                         ))))(items)*

---

在这两种情况下，数组都设置为 Nan。你能建议错误是什么吗？

Answer 1

您缺少一些 map 语句。您的镜头具有属性；但是那些不是对象而是数组。您（大概）想要使用数组的元素。所以你需要穿插map语句：

const {lensProp, over, map, multiply} = R

const items ={"costList": [{"cost": [10, 20], "order": 20}, {"cost": [20, 30], "order": 20}], "testObject3": [{"testArray": [{"testInnerArray": [10, 20, 30, 40], "testNumber": 30}, {"testInnerArray": [10, 20, 30, 40], "testNumber": 30}]}]}

const costListLens = lensProp('costList')
const costLens = lensProp('cost')

const updateCosts = over(costListLens, map(over(costLens, map(multiply(2)))))

console.log(updateCosts(items))

const firstLevelLens = lensProp('testObject3')
const secondLevelLens = lensProp('testArray')
const thirdLevelLens = lensProp('testInnerArray')

const updateInner = over(
  firstLevelLens, 
  map(over(secondLevelLens, map(over(thirdLevelLens, map(multiply(2))))))
)

console.log(updateInner(items)) 

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.js"></script>

请注意，尽管如果您有这样的结构，但没有阵列，则镜头组成：

const {lensProp, over, compose, map, multiply} = R

const costListLens = lensProp('costList')
const costLens = lensProp('cost')

const simplerItems = {
  costList: {
    cost: [10, 20],
    order: 20
  }
}

const updateSimplerCosts = over(
  compose(costListLens, costLens), 
  map(multiply(2))
)

console.log(updateSimplerCosts(simplerItems))

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>

您同样可以compose 多个镜头。请注意，合成的顺序似乎倒退了。这就是它的工作原理，尽管有很多参考资料可以解释为什么如果您搜索 lens+compose+backward。