Question

我有一系列像这样的字符串（文件中的行）

[20150101] error a
details 1
details 2
[20150101] error b
details
[20150101] error c

我正在尝试将此映射到像这样的字符串序列（日志条目）

[20150101] error a details 1 details 2
[20150101] error b details
[20150101] error c

我可以通过命令式方式执行此操作（通过翻译我将在C＃中编写的代码） - 这可以工作，但它读起来像伪代码，因为我省略了引用的函数：

let getLogEntries logFilePath =  
    seq {
        let logEntryLines = new ResizeArray<string>()

        for lineOfText in getLinesOfText logFilePath do                        
            if isStartOfNewLogEntry lineOfText && logEntryLines.Any() then
                yield joinLines logEntryLines
                logEntryLines.Clear()  
            logEntryLines.Add(lineOfText)  

        if logEntryLines.Any() then
            yield joinLines logEntryLines             
    }

有没有更实用的方法呢？

我不能使用Seq.map，因为它不是一对一的映射，Seq.fold似乎不对，因为我怀疑它会在返回结果之前处理整个输入序列（不是很好）如果我有非常大的日志文件）。我假设上面的代码不是在F＃中执行此操作的理想方法，因为它使用的是ResizeArray<string>。

Answer 1

通常，当没有可以使用的内置函数时，解决问题的功能方法是使用递归。在这里，您可以递归地遍历输入，记住最后一个块的项目（自上一个[xyz] Info行以来）并在到达新的起始块时生成新结果。在F＃中，您可以使用序列表达式很好地编写它：

let rec joinDetails (lines:string list) lastChunk = seq {
  match lines with
  | [] -> 
      // We are at the end - if there are any records left, produce a new item!
      if lastChunk <> [] then yield String.concat " " (List.rev lastChunk)
  | line::lines when line.StartsWith("[") ->
      // New block starting. Produce a new item and then start a new chunk
      if lastChunk <> [] then yield String.concat " " (List.rev lastChunk)
      yield! joinDetails lines [line]
  | line::lines ->
      // Ordinary line - just add it to the last chunk that we're collection
      yield! joinDetails lines (line::lastChunk) }

以下示例显示了操作中的代码：

let lines = 
  [ "[20150101] error a"
    "details 1"
    "details 2"
    "[20150101] error b"
    "details"
    "[20150101] error c" ]

joinDetails lines []

Answer 2

Seq内置的内置功能不足以帮助您，因此您必须推出自己的解决方案。最终，解析这样的文件涉及迭代和维护状态，但F＃所做的是通过计算表达式封装该迭代和状态（因此使用seq计算表达式）。

你所做的一切都不错，但是你可以将你的代码提取到一个通用函数中，该函数在输入序列中计算块（即字符串序列）而不知道格式。其余的，即解析实际的日志文件，可以使其纯粹起作用。

我过去曾写过这个函数来帮助解决这个问题。

let chunkBy chunkIdentifier source = 
    seq { 
        let chunk = ref []
        for sourceItem in source do
            let isNewChunk = chunkIdentifier sourceItem
            if isNewChunk && !chunk <> [] then 
                yield !chunk
                chunk := [ sourceItem ]
            else chunk := !chunk @ [ sourceItem ] 

        yield !chunk
    }

如果输入是新块的开头，则需要chunkIdentifier函数返回true。

解析日志文件只是提取行，计算块和连接每个块的一种情况：

logEntryLines |> chunkBy (fun line -> line.[0] = '[')
    |> Seq.map (fun s -> String.Join (" ", s))

通过尽可能地封装迭代和变异，在创建可重用函数的同时，更多的是在函数式编程的精神中。

Answer 3

或者，另外两个变体：

let lst = ["[20150101] error a";
           "details 1";
           "details 2";
           "[20150101] error b";
           "details";
           "[20150101] error c";]

let fun1 (xs:string list) = 
    let sb = new System.Text.StringBuilder(xs.Head) 
    xs.Tail

    |> Seq.iter(fun x -> match x.[0] with
                         | '[' -> sb.Append("\n" + x) 
                         | _   -> sb.Append(" "  + x) 
                         |> ignore)
    sb.ToString()

lst  |> fun1 |> printfn "%s"

printfn "";

let fun2 (xs:string list) =  
    List.fold(fun acc (x:string) -> acc + 
                                    match x.[0] with| '[' -> "\n"  | _   -> " " 
                                    + x) xs.Head xs.Tail 

lst |> fun2 |> printfn "%s"

打印：

[20150101] error a details 1 details 2
[20150101] error b details
[20150101] error c

[20150101] error a details 1 details 2
[20150101] error b details
[20150101] error c

链接： https://dotnetfiddle.net/3KcIwv

F＃将seq映射到另一个较短长度的seq

3 个答案: