F# 等价于++ 运算符

Question

我正在将数组转换为记录类型。就像是:

let value = [|"1";"2";"3";"Not a number";"5"|]
type ValueRecord = {
  One: int32
  Two: int32
  Three: int32
  Four: string
  Five: int32 }

let convertArrayToRecord (x: string array) =
  { One = x.[0] |> Int.Parse
    Two = x.[1] |> Int.Parse
    Three = x.[2] |> Int.Parse
    Four = x.[3]
    Five = x.[4] |> Int.Parse }

let recordValue = convertArrayToRecord value

这有效，但有一个缺点，即在数组中间添加一个值会导致此后手动编辑所有索引引用，如下所示:

let value = [|"1";"Not a number - 6";"2";"3";"Not a number";"5"|]
type ValueRecord = {
  One: int32
  Six: string
  Two: int32
  Three: int32
  Four: string
  Five: int32 }

let convertArrayToRecord (x: string array) =
  { One = x.[0] |> Int.Parse
    Six = x.[1]
    Two = x.[2] |> Int.Parse //<--updated index
    Three = x.[3] |> Int.Parse //<--updated index
    Four = x.[4] //<--updated index
    Five = x.[5] |> Int.Parse } //<--updated index

let recordValue = convertArrayToRecord value

此外，很容易不小心弄错索引。

我想出的解决方案是:

let convertArrayToRecord (x: string array) =  
    let index = ref 0
    let getIndex () =
        let result = !index
        index := result + 1
        result
    { One = x.[getIndex ()] |> Int.Parse
      Six = x.[getIndex ()]
      Two = x.[getIndex ()] |> Int.Parse
      Three = x.[getIndex ()] |> Int.Parse
      Four = x.[getIndex ()]
      Five = x.[getIndex ()] |> Int.Parse }

这有效，但我真的不喜欢引用单元格的东西不是并发的。有没有更好/更清洁的方法来实现这一目标？

Answer 1

您可以使用模式匹配。

let convertArrayToRecord = function
    | [|one; two; three; four; five|] ->
        {
            One = int one
            Two = int two
            Three = int three
            Four = four
            Five = int five
        }
    | _ ->
        failwith "How do you want to deal with arrays of a different length"

向数组中添加另一个条目时，您可以通过将第一个匹配项编辑为 [|one; six; two; three; four; five|] 来调整它。 .

顺便说一句，对于像您在当前示例中使用的那样的可变索引，您可以通过使用 mutable 关键字来避免 ref ，就像这样；

let mutable index = -1
let getIndex =
    index <- index + 1
    index

如果我们将可变变量隐藏在 getIndex 函数中

let getIndex =
    let mutable index = -1
    fun () ->
        index <- index + 1
        index