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);

湾在第二种情况下，我试图更新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。

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

1 个答案: