Question

我正在尝试使用Clojure逐行读取（可能或不可能）YAML frontmatter的文件，并返回带有两个向量的散列映射，一个包含前端行，另一个包含其他所有内容（即身体）。

示例输入文件如下所示：

---
key1: value1
key2: value2
---

Body text paragraph 1

Body text paragraph 2

Body text paragraph 3

我有能够执行此操作的功能代码，但对于我（对Clojure来说没有经验）鼻子，它充满了代码味道。

(defn process-file [f]
  (with-open [rdr (java.io.BufferedReader. (java.io.FileReader. f))]
    (loop [lines (line-seq rdr) in-fm 0 frontmatter [] body []]
      (if-not (empty? lines)
        (let [line (string/trim (first lines))]
          (cond
            (zero? (count line))
              (recur (rest lines) in-fm frontmatter body)
            (and (< in-fm 2) (= line "---")) 
              (recur (rest lines) (inc in-fm) frontmatter body)
            (= in-fm 1)  
              (recur (rest lines) in-fm (conj frontmatter line) body)
            :else          
             (recur (rest lines) in-fm frontmatter (conj body line))))
        (hash-map :frontmatter frontmatter :body body)))))

有人能指出我更优雅的方式吗？我将在这个项目中进行大量的逐行解析，如果可能的话，我想要一种更惯用的方法来解决它。

Answer 1

首先，我将线处理逻辑放在自己的函数中，以便从实际读取文件的函数中调用。更好的是，你可以让处理IO的函数采用函数来映射作为参数的行，也许是沿着以下几行：

(require '[clojure.java.io :as io])

(defn process-file-with [f filename]
  (with-open [rdr (io/reader (io/file filename))]
    (f (line-seq rdr))))

请注意，这种安排使得f有责任在返回之前尽可能多地实现行seq（因为之后with-open将关闭行seq的基础读取器）。

考虑到这种责任划分，线处理函数可能看起来像这样，假设第一个---必须是第一个非空行，并且要跳过所有空行（就像使用时一样）问题文本中的代码）：

(require '[clojure.string :as string])

(defn process-lines [lines]
  (let [ls (->> lines
                (map string/trim)
                (remove string/blank?))]
    (if (= (first ls) "---")
      (let [[front sep-and-body] (split-with #(not= "---" %) (next ls))]
        {:front (vec front) :body (vec (next sep-and-body))})
      {:body (vec ls)})))

请注意vec的调用会导致所有行被读入并在向量或向量对中返回（这样我们就可以process-lines使用process-file-with而无需读者太快关闭了。）

因为磁盘上实际文件的读取行现在与处理seq行分离，我们可以在REPL中轻松测试进程的后半部分（当然这可以进行单元测试）：< / p>

;; could input this as a single string and split, of course
(def test-lines
  ["---"
   "key1: value1"
   "key2: value2"
   "---"
   ""
   "Body text paragraph 1"
   ""
   "Body text paragraph 2"
   ""
   "Body text paragraph 3"])

立即调用我们的功能：

user> (process-lines test-lines)
{:front ("key1: value1" "key2: value2"),
 :body ("Body text paragraph 1"
        "Body text paragraph 2"
        "Body text paragraph 3")}

Answer 2

实际上，使用clojure执行此操作的惯用方法是避免返回“带有两个向量的散列映射”并将该文件视为（懒惰）行序列

然后，处理行序列的函数决定文件是否具有YAML前端

类似的东西：

(use '[clojure.java.io :only (reader)])
(let [s (line-seq (reader "YOURFILENAMEHERE"))]
  (if (= "---\n" (take 1 (line-seq (reader "YOURFILENAMEHERE"))))
    (process-seq-with-frontmatter s)
    (process-seq-without-frontmatter s))

顺便说一句，这是一个戒烟和肮脏的解决方案;要改进的两件事：

注意我正在为同一个文件创建两个seqs，最好只创建一个并对第一行进行检查，这样它就不会遍历seq的第一个元素（就像偷看一样）一个流行音乐）
我认为拥有一个基于seq第一行内容的多方式'process-seq'（当然有一个更好的名称）会更清晰

在Clojure中更加惯用的逐行文件处理

2 个答案: