使用 elisp 处理文本

Question

自从我转换到 Emacs 教会以来，我一直试图在它内部做所有事情，我想知道如何用它快速有效地进行一些文本处理。

作为一个例子，让我们以几分钟前我在 org-mode 上编辑的这个列表为例。

** Diego: b QI
** bruno-gil: b QI
** Koma: jo
** um: rsrs pr0n
** FelipeAugusto: esp
** GustavoPupo: pinto tr etc
** GP: lit gtk
** Alan: jo mil pc
** Jost: b hq jo 1997
** Herbert: b rsrs pr0n
** Andre: maia mil pseudo
** Rodrigo: c
** caue: b rsrs 7arte pseudo
** kenny: cri gif
** daniel: gtk mu pr0n rsrs b
** tony: an 1997 esp
** Vitor: b jo mimimi
** raphael: b rpg 7arte
** Luca: b lit gnu pc prog mmu 7arte 1997
** LZZ: an qt
** William: b an jo pc 1997
** Epic: gtk
** Aldo: b pseudo pol mil fur
** GustavoKyon: an gtk
** CarlosIsaksen : an hq jo 7arte gtk 1997
** Peter: pseudo pol mil est 1997 gtk lit lang
** leandro: b jo cb
** frederico: 7arte lit gtk
** rol: b an pseudo mimimi 7arte
** mathias: jo lit
** henrique: 1997 h gtk qt
** eumané: an qt
** walrus: cri de
** FilipePinheiro: lit pseudo
** Igor: pseudo b
** Erick: b jo rpg q 1997 gtk
** Gabriel: pr0n rsrs qt
** george: clo mimimi
** anão: hq jo 1997 rsrs clô b
** jeff: 7arte gtk
** davidatenas:  an 7arte 1997 esp qt
** HHahaah: b 
** Eduardo: b

它是与标签关联的名称列表，我想获取与名称关联的标签列表。

在 bash 中，我首先用单引号回显粘贴的整个内容，然后将其传输到 awk，循环遍历每一行并将其每个部分添加到正确的临时变量中，然后对其进行修改，直到它像我想要的那样。

echo '** Diego: b QI
** bruno-gil: b QI
** Koma: jo
** um: rsrs pr0n
** FelipeAugusto: esp
** GustavoPupo: pinto, tr etc
** GP: lit gtk
** Alan: jo mil pc
** Jost: b hq jo 1997
** Herbert: b rsrs pr0n
** Andre: maia mil pseudo
** Rodrigo: c
** caue: b rsrs 7arte pseudo
** kenny: cri gif
** daniel: gtk mu pr0n rsrs b
** tony: an 1997 esp
** Vitor: b jo mimimi
** raphael: b rpg 7arte
** Luca: b lit gnu pc prog mmu 7arte 1997
** LZZ: an qt
** William: b an jo pc 1997
** Epic: gtk
** Aldo: b pseudo pol mil fur
** GustavoKyon: an gtk
** CarlosIsaksen : an hq jo 7arte gtk 1997
** Peter: pseudo pol mil est 1997 gtk lit lang
** leandro: b jo cb
** frederico: 7arte lit gtk
** rol: b an pseudo mimimi 7arte
** mathias: jo lit
** henrique: 1997 h gtk qt
** eumané: an qt
** walrus: cri de
** FilipePinheiro: lit pseudo
** Igor: pseudo b
** Erick: b jo rpg q 1997 gtk
** Gabriel: pr0n rsrs qt
** george: clo mimimi
** anão: hq jo 1997 rsrs clô b
** jeff: 7arte gtk
** davidatenas:  an 7arte 1997 esp qt
** HHahaah: b
** Eduardo: b
' | awk '{sub(":","");for (i=3;i<=NF;i++) members[$i] = members[$i] " " $2}; END{for (j in members) print j ": " members[j]}' | sort

...还有TA-DA！不到 2 分钟的预期输出，以直观和增量的方式完成。你能告诉我如何在 elisp 中（最好是在 emacs 缓冲区中）优雅而简单地执行类似的操作吗？

谢谢！

Answer 1

我要做的第一件事就是利用 org-mode 的标签支持。而不是

** Diego: b QI

You 会使用

** Diego                          :b:QI:

Which org-mode 识别为标签“b”和“QI”。

要将当前格式转换为标准 org-mode 格式，您可以使用
以下内容（假设带有源的缓冲区称为“asdf”）

(with-current-buffer "asdf"
  (beginning-of-buffer)
  (replace-string " " ":")
  (beginning-of-buffer)
  (replace-string "**:" "** ")
  (beginning-of-buffer)
  (replace-string "::" " :")
  (beginning-of-buffer)
  (replace-string "\n" ":\n")
  (org-set-tags-command t t))

它并不漂亮或高效，但它可以完成工作。

之后，您可以使用以下命令生成具有以下格式的缓冲区
您想要从 shell 脚本中获取结果：

(let ((results (get-buffer-create "results"))
      tags)
  (with-current-buffer "asdf"
    (beginning-of-buffer)
    (while (org-on-heading-p)
      (mapc '(lambda (item) (when item (add-to-list 'tags item))) (org-get-local-tags))
      (outline-next-visible-heading 1)))
  (setq tags (sort tags 'string<))
  (with-current-buffer results
    (erase-buffer)
    (mapc '(lambda (item)
             (insert (format "%s: %s\n"
                             item
                             (with-current-buffer "asdf"
                               (org-map-entries '(substring-no-properties (org-get-heading t)) item)))))
          tags)
    (beginning-of-buffer)
    (replace-regexp "[()]" "")))

这会将结果放入名为“结果”的缓冲区中，如果没有，则创建它
已经存在。基本上，它正在收集缓冲区“asdf”中的所有标签，
对它们进行排序，然后循环遍历每个标签并搜索每个标题
该标签位于“asdf”中并将其插入到“结果”中。

经过一些清理，这可以变成一个函数；基本上只是
用参数替换“asdf”和“结果”。如果你需要这样做，我可以做
那。

Answer 2

有一个函数 shell-command-on-region 几乎可以完成它所说的功能。您可以突出显示一个区域，执行 M-|，键入 shell 命令的名称，然后数据就会通过管道传输到该命令。给它一个参数，该区域就会被命令的结果替换。

对于一个简单的示例，突出显示一个区域，输入 'Cu 0 M-| wc'（control-u、零、元管道，然后是'wc'），该区域将被替换为该区域的字符数、单词数和行数。

您可以做的另一件事是弄清楚如何操作一行，将其设为宏，然后重复运行该宏。例如，“Cx ( Cs foo Cg bar Cx )”将搜索单词“foo”，然后键入单词“bar”，将其更改为“foobar”。然后，您可以执行一次“Cu Cx e”，这将持续运行宏，直到找不到更多“foo”的出现。

Answer 3

好的，这是我在 elisp 中的第一次尝试：

1. 我使用 elisp 和 paredit 模式启动一个缓冲区，打开双引号并粘贴文本
2. 我使用 let 将其绑定到符号

(let ((foobar "** Diego: b QI
** bruno-gil: b QI
** Koma: jo
** um: rsrs pr0n
** FelipeAugusto: esp
** GustavoPupo: pinto, tr etc
** GP: lit gtk
** Alan: jo mil pc
** Jost: b hq jo 1997
** Herbert: b rsrs pr0n
** Andre: maia mil pseudo
** Rodrigo: c
** caue: b rsrs 7arte pseudo
** kenny: cri gif
** daniel: gtk mu pr0n rsrs b
** tony: an 1997 esp
** Vitor: b jo mimimi
** raphael: b rpg 7arte
** Luca: b lit gnu pc prog mmu 7arte 1997
** LZZ: an qt
** William: b an jo pc 1997
** Epic: gtk
** Aldo: b pseudo pol mil fur
** GustavoKyon: an gtk
** CarlosIsaksen : an hq jo 7arte gtk 1997
** Peter: pseudo pol mil est 1997 gtk lit lang
** leandro: b jo cb
** frederico: 7arte lit gtk
** rol: b an pseudo mimimi 7arte
** mathias: jo lit
** henrique: 1997 h gtk qt
** eumané: an qt
** walrus: cri de
** FilipePinheiro: lit pseudo
** Igor: pseudo b
** Erick: b jo rpg q 1997 gtk
** Gabriel: pr0n rsrs qt
** george: clo mimimi
** anão: hq jo 1997 rsrs clô b
** jeff: 7arte gtk
** davidatenas:  an 7arte 1997 esp qt
** HHahaah: b 
** Eduardo: b 
"))
  foobar)

现在我将 foobar 更改为一些奇特的东西。

3. 首先，我使用正则表达式删除符号，并使用 (split-string) 将文本拆分为字符串
4. 然后我使用 mapcar 将每一行转换为单词列表

(mapcar #'(lambda (y) (split-string y " " t)) (split-string (replace-regexp-in-string "[:\*]" "" foobar) "\n" t))

5. 然后我创建一个 hashmap 并将其绑定到temphash ((temphash (make-hash-table :test 'equal)))
6. 然后我循环到嵌套列表中以将元素添加到哈希表中。我认为我不应该使用 mapcar 进行非函数式编程，但没有人在看；）

(mapcar #'(lambda (l)
              (mapcar #'(lambda (m) (puthash m (format "%s %s" (car l) (let ((tempel (gethash m temphash)))
                                                            (if tempel tempel ""))) temphash)) (rest l)))
          (mapcar #'(lambda (y) (split-string y " " t)) (split-string (replace-regexp-in-string "[:\*]" "" foobar) "\n" t))) 

7. 最后，我使用从 Xah Lee 的网页窃取的便捷函数将哈希表中的元素提取到另一组嵌套列表中，
8. 最后我用 Mx pp-eval-last-sexp 将它打印到另一个缓冲区，

这有点令人费解，特别是双映射车，但它有点有效。这是完整的“代码”：

;; Stolen from Xah Lee's page


(defun hash-to-list (hashtable)
  "Return a list that represent the hashtable."
  (let (mylist)
    (maphash (lambda (kk vv) (setq mylist (cons (list kk vv) mylist))) hashtable)
    mylist
  )
)

;; Code

(let ((foobar "** Diego: b QI
** bruno-gil: b QI
** Koma: jo
** um: rsrs pr0n
** FelipeAugusto: esp
** GustavoPupo: pinto, tr etc
** GP: lit gtk
** Alan: jo mil pc
** Jost: b hq jo 1997
** Herbert: b rsrs pr0n
** Andre: maia mil pseudo
** Rodrigo: c
** caue: b rsrs 7arte pseudo
** kenny: cri gif
** daniel: gtk mu pr0n rsrs b
** tony: an 1997 esp
** Vitor: b jo mimimi
** raphael: b rpg 7arte
** Luca: b lit gnu pc prog mmu 7arte 1997
** LZZ: an qt
** William: b an jo pc 1997
** Epic: gtk
** Aldo: b pseudo pol mil fur
** GustavoKyon: an gtk
** CarlosIsaksen : an hq jo 7arte gtk 1997
** Peter: pseudo pol mil est 1997 gtk lit lang
** leandro: b jo cb
** frederico: 7arte lit gtk
** rol: b an pseudo mimimi 7arte
** mathias: jo lit
** henrique: 1997 h gtk qt
** eumané: an qt
** walrus: cri de
** FilipePinheiro: lit pseudo
** Igor: pseudo b
** Erick: b jo rpg q 1997 gtk
** Gabriel: pr0n rsrs qt
** george: clo mimimi
** anão: hq jo 1997 rsrs clô b
** jeff: 7arte gtk
** davidatenas:  an 7arte 1997 esp qt
** HHahaah: b 
** Eduardo: b 
")
      (temphash  (make-hash-table :test 'equal)))
  (mapcar #'(lambda (l)
              (mapcar #'(lambda (m) (puthash m (format "%s %s" (car l) (let ((tempel (gethash m temphash)))
                                                            (if tempel tempel ""))) temphash)) (rest l)))
          (mapcar #'(lambda (y) (split-string y " " t)) (split-string (replace-regexp-in-string "[:\*]" "" foobar) "\n" t)))
  (hash-to-list temphash)) 

这是输出：

(("clô" "anão ")
 ("clo" "george ")
 ("q" "Erick ")
 ("de" "walrus ")
 ("h" "henrique ")
 ("cb" "leandro ")
 ("lang" "Peter ")
 ("est" "Peter ")
 ("fur" "Aldo ")
 ("pol" "Peter Aldo ")
 ("qt" "davidatenas Gabriel eumané henrique LZZ ")
 ("mmu" "Luca ")
 ("prog" "Luca ")
 ("gnu" "Luca ")
 ("rpg" "Erick raphael ")
 ("mimimi" "george rol Vitor ")
 ("an" "davidatenas eumané rol CarlosIsaksen GustavoKyon William LZZ tony ")
 ("mu" "daniel ")
 ("gif" "kenny ")
 ("cri" "walrus kenny ")
 ("7arte" "davidatenas jeff rol frederico CarlosIsaksen Luca raphael caue ")
 ("c" "Rodrigo ")
 ("pseudo" "Igor FilipePinheiro rol Peter Aldo caue Andre ")
 ("maia" "Andre ")
 ("1997" "davidatenas anão Erick henrique Peter CarlosIsaksen William Luca tony Jost ")
 ("hq" "anão CarlosIsaksen Jost ")
 ("pc" "William Luca Alan ")
 ("mil" "Peter Aldo Andre Alan ")
 ("gtk" "jeff Erick henrique frederico Peter CarlosIsaksen GustavoKyon Epic daniel GP ")
 ("lit" "FilipePinheiro mathias frederico Peter Luca GP ")
 ("etc" "GustavoPupo ")
 ("tr" "GustavoPupo ")
 ("pinto," "GustavoPupo ")
 ("esp" "davidatenas tony FelipeAugusto ")
 ("pr0n" "Gabriel daniel Herbert um ")
 ("rsrs" "anão Gabriel daniel caue Herbert um ")
 ("jo" "anão Erick mathias leandro CarlosIsaksen William Vitor Jost Alan Koma ")
 ("QI" "bruno-gil Diego ")
 ("b" "Eduardo HHahaah anão Erick Igor rol leandro Aldo William Luca raphael Vitor daniel caue Herbert Jost bruno-gil Diego "))

Answer 4

如果您了解 *nix 管道，那么您就熟悉 函数式编程，因为函数式编程将程序视为使用函数应用程序对数据进行连续转换。还记得学校数学中的函数组合吗？基本上，g ∘ f 意味着您首先应用 f，然后立即应用 g：(g ∘ f)(x) = g(f(x))。。函数式程序是一个巨大的函数组合。而管道只是一个函数组合，只是方向相反：(g ∘数学中的 f)(x) 与 x | 相同f | g 在命令行中。

有一个第三方库 dash.el 提供了多种用于列表和树转换的函数以及简化函数方法的函数和宏。其中之一是线程宏 ->> ，它模仿命令行管道：

(->> '(1 2 3) (-map '1+) (-reduce '+)) ; returns 9
;; equivalent to (-reduce '+ (-map '1+ '(1 2 3)))

因此，如果我们想通过串行应用操作来操纵文本数据，我们的函数可能如下所示：

(defun key-value-swap (s)
  (->> s
       nil ; Split into lines
       nil ; Remove stars from each line
       nil ; Split each line
       nil ; Add 1st element as a value to each element starting from
           ; 2nd as keys
       nil ; Return a hash-table
       ))

完全执行您想要的操作的函数将如下所示：

(defun key-value-swap (s)
  (let ((h (make-hash-table :test 'equal)))
    (->> s
         s-lines ; split into lines
         (--map (s-split "\\(\\s-\\|:\\)" ; split each line
                         (s-chop-prefix "** " it) ; throw away stars
                         t))
         (--map (-each (cdr it) ; for every field in the line, except 1st
                  (lambda (k) ; append 1st line to value under key
                    (puthash k (cons (car it) (gethash k h)) h)))))
    h)) ; return hash-table

(puthash k (cons (car it) (gethash kh)) h) 看起来很神秘，但它只是意味着哈希表中的每个键下都有一个列表，每次找到新值时都会将其附加到该列表中。因此，如果在 b 下有 (Diego) 并且我们发现 bruno-gil 也应该在 b 下， b 下的值变为 (bruno-gil Diego)。

Answer 5

前面的替代方案很有趣，但我不认为捕获了问题的“作为最近的转换者，我将如何在 Emacs 中执行此操作”方面。我怀疑学习 Emacs 并着眼于使用 Emacs Lisp 完成整个工作的人可能会从以下内容开始：

(defun create-tags-to-name (buffer-name)
  "Create a buffer filled with lines containg `** TAG:
LIST-OF-NAMES' by transposing lines in the region matching the
format `** NAME: LIST-OF-TAGS' where the list items are white
space separated."
  (interactive)
  (let ((buf (get-buffer-create buffer-name))
    (tag-to-name-list (list))
    name tags element)
    ;; Clear the destination buffer
    (with-current-buffer buf
      (erase-buffer))
    ;; Build the list of tag to name associations.
    (while (re-search-forward "^** \\([-a-zA-Z0-9 ]+\\):\\(.+\\)$" (point-max) t)
      (setq name (buffer-substring (match-beginning 1) (match-end 1))
        tags (split-string (buffer-substring (match-beginning 2) (match-end 2))))
      ;; For each tag add the name to the tag's name list
      (while tags
    (let ((tag (car tags)))
      (setq element (assoc tag tag-to-name-list)
        tags (cdr tags))
      (if element
          (setcdr element (append (list name) (cdr element)))
        (setq tag-to-name-list (append (list (cons tag (list name))) tag-to-name-list))))))
    ;; Dump the associations to the target buffer
    (with-current-buffer buf
      (while tag-to-name-list
    (setq element (car tag-to-name-list)
          tag-to-name-list (cdr tag-to-name-list))
    (insert (concat "** " (car element) ":"))
    (let ((tag-list (cdr element)))
      (while tag-list
        (insert " " (car tag-list))
        (setq tag-list (cdr tag-list))))
    (insert "\n")))))

Answer 6

这是我的第二次尝试。我写了一个小宏和一些函数来处理这些数据。

(defun better-numberp (s)
  (string-match "^ *[0-9.,]* *$" s))

(defmacro awk-like (&rest args)
  (let ((arg (car (last args)))
        (calls (mapcar #'(lambda (l)
                           (cond
                            ((numberp (first l)) (cons `(lambda (f) (equal %r ,(first l))) (rest l)))
                            ((stringp (first l)) (cons `(lambda (f) (string-match ,(first l) %)) (rest l)))
                            (t l)))
                       (butlast args))))
    `(mapcar #'(lambda (%%)
                 (let ((%r 0))
                   (mapcar
                    #'(lambda (l)
                        (setq %r (1+ %r))
                        (let ((% l))
                          (dolist (tipo ',calls)
                            (progn
                              (setq % (cond
                                       ((funcall (first tipo) %) (eval (cadr tipo))) (t %)))
                              (set (intern (format "%%%d" %r)) %))) %)) %%)))
             (mapcar #'(lambda (y) (split-string y " " t))
                     (split-string ,arg "\n" t)))))

(defun hash-to-list (hashtable)
  "Return a list that represent the hashtable."
  (let (mylist)
    (maphash (lambda (kk vv) (setq mylist (cons (list kk vv) mylist))) hashtable)
    mylist
    )
  )

(defun append-hash (key value hashtable)
  (let ((current (gethash key hashtable)))
    (puthash key 
             (cond
              ((null current) (list value))
              ((listp current) (cons value current))
              (t current)) 
             hashtable)))

(let ((foohash (make-hash-table :test 'equal)))
  (awk-like
   (2 (replace-regexp-in-string ":" "" %))
   ((lambda (f) (> %r 2))  (append-hash % %2 foohash))
   "** Diego: b QI
** bruno-gil: b QI
** Koma: jo
** um: rsrs pr0n
** FelipeAugusto: esp
** GustavoPupo: pinto tr etc
** GP: lit gtk
** Alan: jo mil pc
** Jost: b hq jo 1997
** Herbert: b rsrs pr0n
** Andre: maia mil pseudo
** Rodrigo: c
** caue: b rsrs 7arte pseudo
** kenny: cri gif
** daniel: gtk mu pr0n rsrs b
** tony: an 1997 esp
** Vitor: b jo mimimi
** raphael: b rpg 7arte
** Luca: b lit gnu pc prog mmu 7arte 1997
** LZZ: an qt
** William: b an jo pc 1997
** Epic: gtk
** Aldo: b pseudo pol mil fur
** GustavoKyon: an gtk
** CarlosIsaksen: an hq jo 7arte gtk 1997
** Peter: pseudo pol mil est 1997 gtk lit lang
** leandro: b jo cb
** frederico: 7arte lit gtk
** rol: b an pseudo mimimi 7arte
** mathias: jo lit
** henrique: 1997 h gtk qt
** eumané: an qt
** walrus: cri de
** FilipePinheiro: lit pseudo
** Igor: pseudo b
** Erick: b jo rpg q 1997 gtk
** Gabriel: pr0n rsrs qt
** george: clo mimimi
** anão: hq jo 1997 rsrs clô b
** jeff: 7arte gtk
** davidatenas:  an 7arte 1997 esp qt
** HHahaah: b
** Eduardo: b
")
  (hash-to-list foohash))