javascript - 如何使用Ramda.js在Javascript中动态插入2d数组

Question

我有以下状态

{
  "array": [
    [
      "Name",
      "Phone",
      "Email"
    ]
  ],
  "indexes": {
    "Name": 0,
    "Phone": 1,
    "Email": 2
  },
  "tempInput": ["test@test.com","test2@test.com"],
  "tempDestination": "Email"
}

现在，我想创建一个函数，该函数接收对象并将输入值作为新行动态插入到2d数组中，并位于指定的目标位置，最终返回

{
  "array": [
    [
      "Name",
      "Phone",
      "Email"
    ],
    [
      "",
      "",
      "test@test.com"
    ],
    [ 
      "",
      "",
      "test2@test.com"
    ]
  ],
  "indexes": {
    "Name": 0,
    "Phone": 1,
    "Email": 2
  }
}

为了解决这个问题，我一直在研究文档并发现

R.lensProp和R.view。这种组合为我提供了起点（即为所提供的目的地获取正确的索引，但我从那以后一直受困。

const addInputToArray = ({ array, indexes, tempDestination, tempInput, }) => {
  // Use Lense and R.view to get the correct index
  const xLens = R.lensProp(tempDestination);
  R.view(xLens, indexes), // contains index

  // Insert the 2 Rows into newArray - I'm lost on this part.
  const newArray = array.push( // newRows )

  return {
    array: newArray,
    indexes: indexes
  }
}

我知道我必须以某种方式遍历输入，例如使用map函数。但是我不知道应该执行什么map函数来获得正确的数组结果。

如果您能在这里帮助我，那将太好了？

Answer 1

更新资料

评论要求提供其他要求（我确实期望过。）这需要稍微不同的方法。这是我的看法：

const addInputToArray = (
  { array, indexes, tempDestination, tempInput, ...rest},
  index = indexes[tempDestination]
) => ({
  array: tempInput .reduce (
    (a, v, i) =>
      (i + 1) in a
        ? update ( (i + 1), update (index, v, a [i + 1] ), a)
        : concat (a, [update (index, v, map (always(''), array[0]) )] ),
    array
  ),
  indexes,
  ...rest
})

const state = {array: [["Name", "Phone", "Email"]], indexes: {Name: 0,
Phone: 1, Email: 2}, tempInput: ["test@test.com","test2@test.com"],
tempDestination: "Email"}

const state2 = addInputToArray (state)

console .log (
  state2
)

const state3 = addInputToArray({
  ...state2,
  tempInput: ['Wilma', 'Fred', 'Betty'],
  tempDestination: 'Name'
})

console .log (
  state3
)

const state4 = addInputToArray({
  ...state3,
  tempInput: [123, , 456],
  //              ^------------- Note the gap here
  tempDestination: 'Phone'
})

console .log (
  state4
)

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.js"></script>
<script> const {update, concat, map, always} = R;                    </script>

请注意，在原始版本（如下）中，我发现不需要Ramda函数。在这里， update使它更整洁，如果我使用Ramda，我也可以在任何简化的地方使用它，因此我也可以使用 concat代替 Array.prototype.concat并使用 map（always （''），array [0]）代替Array (array [0] .length) .fill ('')之类的东西。我发现这些使代码更易于阅读。

您可以很容易地删除那些最后的代码，但是如果您要在没有库的情况下编写代码，我建议您编写类似于update的代码，因为调用该代码可以使代码比使用此内联代码的代码更干净。

替代API

在这里我可能会偏离基础，但是我确实怀疑您尝试在此处编写的API仍然比您的基本要求所暗示的更为复杂。索引列表让我感到代码味，这是一种解决方法，而不是解决方案。 （实际上，它很容易从数组的第一行派生。）

例如，我可能更喜欢这样的API：

const addInputToArray = ({ array, changes, ...rest}) => ({
  array: Object .entries (changes) .reduce ((a, [k, vs], _, __, index = array [0] .indexOf (k)) =>
    vs.reduce(
      (a, v, i) =>
        (i + 1) in a
          ? update ((i + 1), update (index, v, a [i + 1] ), a)
          : concat (a, [update (index, v, map (always (''), array [0]) )] ),
      a),
    array
  ),
  ...rest
})

const state = {
  array: [["Name", "Phone", "Email"]], 
  changes: {Email: ["test@test.com","test2@test.com"], Name: ['Wilma', 'Fred', 'Betty']}
}

const state2 = addInputToArray (state)

console .log (
  state2
)

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.js"></script>
<script> const {update, concat, map, always} = R;                    </script>

但是无论如何，它仍然导致了一个有趣的问题，非常感谢！

说明

注释询问此版本中reduce的参数。为解释起见，我将首先退后一步。我是函数式编程的忠实粉丝。这有很多含义，也有很多含义，但是这里相关的是我更喜欢用表达式而不是语句来编写。诸如foo = 1或if (a) {doB()}之类的语句不容易进行分析，因为它们为分析引入了时间和顺序，否则可能会以数学方式进行。

为此，我会编写一些函数，这些函数的主体由单个表达式组成，即使它相当复杂。我不能总是以可读的方式执行此操作，在这种情况下，我选择了可​​读性。我通常可以这样做，但是为了支持这一点，我可能会向函数添加默认参数以支持原本是赋值语句的函数。纯功能语言Haskell具有用于此类临时分配的便捷语法：

let two = 2; three = 3 
    in two * three  -- 6

Javascript不提供这种语法。 （或者实际上该语法有it's been deprecated这样的问题。）在参数中添加具有默认值的变量是一种合理的解决方法。它允许我做等同于定义局部变量的操作，以避免重复的表达式。

如果我们有这个：

const foo = (x) =>
  (x + 1) * (x + 1) 

我们在这里重复计算（x + 1）。显然，这是次要的，但是在其他情况下，它们可能会很昂贵，因此我们可以编写以下替换：

const foo = (x) => {
  const next = x + 1
  return next * next
}

但是，现在我们有多个语句，在可能的情况下，我想避免这样做。如果相反，我们这样写：

const foo = (x, next = x + 1) =>
  next * next

我们仍然保存重复的计算，但是使代码更易于进行更直接的分析。 （我知道在这些简单的情况下，分析仍然很简单，但是很容易想到它会变得越来越复杂。）

回到实际问题。我写了这样的代码：

<expression1> .reduce ((a, [k, vs], _, __, index = array [0] .indexOf (k)) => <expression2>

如您所指出的，Array.prototype.reduce最多包含四个参数，即累加器，当前值，当前索引和初始数组。我将index添加为新的默认参数，以避免计算多次或添加临时变量。但是我不在乎当前索引或初始数组。我可以将其写为((a, [k, vs], ci, ia, index = <expression>)（“ ci”表示“当前索引”，而“ ia”表示“初始数组”）或类似内容。如果要添加index作为第五个参数，则必须提供这些参数，但是我不在乎它们。我不会使用这些变量。

某些具有模式匹配语法的语言在这里提供下划线作为有用的占位符，表示由调用方提供但未使用的变量。虽然JS在语法上不支持该功能，但下划线（_）和两个对（__）都是合法的变量名称。进行函数式编程的人们经常像在模式匹配语言中那样使用它们。他们只是宣布将在此处传递某些内容，但我不再关心它。有提案1为JS添加类似的语法功能，如果通过了，我可能会改用它。

因此，如果将_作为参数或__或（很少）_1，_2，_3等，它们通常是一个简单的解决方法，因为JS中没有占位符。 _的其他用途：如您所述，有一种约定，使用它为私有对象属性添加前缀。它也是库Underscore及其成长的克隆lodash的默认变量名。但是它们之间几乎没有混淆的余地。可以想像，虽然可以将Underscore作为参数传递给函数，但是您可以将其用作正文中的变量，并且应该清楚含义是什么。

（想想我本来打算在评论中写这个解释！）



1如果您有兴趣，可以查看各种建议中的a discussion

原始答案

如果没有更多有关基本要求的信息，我将简单地开始。此功能似乎可以满足您的要求：

const addInputToArray = (
  { array, indexes, tempDestination, tempInput, ...rest}, 
  index = indexes[tempDestination]
) => ({
  array: [
    array [0], 
    ...tempInput .map (v => array [0] .map ((s, i) => i == index ? v : ''))
  ],
  indexes,
  ...rest
})

const state = {array: [["Name", "Phone", "Email"]], indexes: {Name: 0, Phone: 1, Email: 2}, tempInput: ["test@test.com","test2@test.com"], tempDestination: "Email"}

console .log (
  addInputToArray(state)
)

但是，发现还有更多要求尚未表达，我不会感到惊讶。此版本从头开始构建其他元素，但您似乎可能想使用不同的tempInput和tempDestination再次调用它，然后附加到这些元素上。如果真是这样，那就不会了。但这可能是一个很好的起点。