GNU Emacs Lisp 学习笔记

一个 list 看起来像这样子:

'(rose violet daisy buttercup)

它是通过单引号开头的。它也可以写成下面这样子:

'(rose
violet
daisy
buttercup
)

list的元素是4种不同的花名，每个通过空格来分隔并且用括号包着。就像有个石头墙包围着它们一样。

在 Lisp 中的 list 或者任何的 list ，都是一个可以准备好执行的程序。计算机将做以下三件事之一:

• 仅返回 list 自身
• 给出一个错误
• 将第一个 symbol 作为命令来做一些事件（通常这个是你真正想要的）

单撇号, ' 表示一个引用。

• 当它在一个 list 前面时，它告诉 Lisp 不要处理那个 list ，仅仅只是当作 list 自身。
• 如果一个 list 前面没有这个单撇号，那 list 中的第一个项是特殊的 ，它是一个命令 （在 Lisp 里，这些命令称为 functions ）.比如 (+ 2 2) ，它前面没有单撇号，所以，Lisp 理解 + 是一个指令。

在 GNU Emacs 里，将光标放在下面的指令里，然后执行 C-x C-e 就表示执行当前光标所在的 lisp 代码：

(+ 2 2)

'(this is a quoted list)

我们将去 eval 一个没有单撇号并且第一个元素也是没有意义的命令的 list ，这时就会产生一个错误信息。在下面的代码里，将光标放在那里，然后按 C-x C-e :

(this is an unquoted list

这时在 *Bracktrace* 窗口将会打开并且你会看到如下的信息:

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function this)
(this is an unquoted list)
eval((this is an unquoted list))
eval-last-sexp-1(nil)
eval-last-sexp(nil)
call-interactively(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

在该窗口中，按 q 即可退出。

sexp 它是 symbol expression 的缩写

Debugger entered–Lisp error: (void-function this) 表示没有 this 这个函数，上面说了，如果一个list开头没有单撇号，那么 Lisp 会将第一个元素当作是命令（或称为 function）来处理。

从技术上讲，*symbol* 告诉计算机去查找指令。

symbol ，可能是临时地，是定义的地方或者是指令集。与人们起名字类似。 在 Lisp 中，同一个指令集可以附加在几个不同的名字上。比如两个数相加的指令集，它被同时链接到 symbol 中的 plus 与 + .

在另一方面，一个 symbol 在同一时间，仅仅只有一个函数定义附于它。否则，计算机不知道到底使用哪一个定义。

由于 Emacs Lisp 是非常大的，习惯上命名 symbol 的方式是标识这些 function 是属于 Emacs 哪部分的。因此，所有处理 Textinfo 的函数都以 textinfo- 开头来命名。

解析器所做的事：

1. 首先查看 list 开头是否有一个引号。
2. 如果有，则将这个 list 返回给我们
3. 如果没有这个引号，解析器则查找 list 中的第一个元素，并且查看是否有一个与之相关联的 function 定义。如果有该函数的定义的话，则执行这些指令；否则打印出错误信息。

这就是 Lisp 的工作方式。

当 Lisp 解析器在一个 expression 上工作时，这些活动的术语就称为 evaluation 。 这个词的意思是 评估它，以查明值或数量

在 Emacs Lisp 中， 一个 symbol 可以有一个 value 附于它，就像有一个 function 定义附于它一样。它们是不同的, function 定义是一个指令集；一个 value ，是一些东西，例如是 number 或 name ，它们是多样的，这就是为什么叫它做 variable 的原因。

symbol 的 value 可以是任何 Lisp 的 expression ，比如 number , list 或 string . 一个 symbol 有一个 value 通常称为 variable .

一个 symbol 可以同时拥有 function 定义和 value 附于它，又或者是它们之一。这有点类似 Cambridge 可以指 Massachusetts 的一个城市，并且也带有一些附加信息到这个名字上，例如是伟大的编程中心。 另一种思考的方式是，想像 symbol 是一堆抽屉， function 定义放在其中一个抽屉中，而 value 放在另一个抽屉，以此类推。

下面的例子:

(+ 2 2)

Lisp 解析器做的是，将 + 后面的 number 进行相加。这些通过 + 相加的 number 称为 function 的 arguments 在 Lisp 里，*function* 的 arguments 是 atoms 或 list .

方式:

1. 使用 set function
2. 使用 setq function
3. 使用 let

• Lisp 程序是由 expression 组成的，它们是 list 或 atoms
• List 是由0个或多个 atoms 或内部 list 组成的，通过空格分隔并且用括号包着的。一个 list 可以为空。
• Atoms 是多个字符的 symbol ，例如: forward-paragraph ；或单个字符的 symbol ，例如: + ；或是在双引号之间字符串的字符，如 "hello world"；或者是 numbers ，如：1,2,3。
• 一个 number evaluate 后是它自身
• 一个由双引号包着的字符串进行 evaluate 后，也是它自身
• 当你进行 symbol 的 evaluate 后，它会返回它的 value
• 当你 evaluate 一个 list 时， Lisp解析器会查找 list 中的第一个 symbol ，然后查找该 symbol 所绑定到的 function 定义。然后执行这些 function 定义的指令集
• 一个单引号 ' 告诉 Lisp 解析器应该返回该 expression 自身，而不是进行 evaluate
• Arguments 是传递给 function 的信息。参数是 list 中第一个元素的 function 的其余元素。如 (+ 2 2 ) ，第一个元素为 + , 并且没有引号，那么它就会看作是 function , 后面两个2就是该 function 的参数。
• 一个 function 进行 evaluate 后总是返回一个 value （除非它产生了一个错误）。另外，它也会执行一些动作，称为 side effect 。通常情况下，一个 function 的主要目的就是产生一个 side effect

无论何时给出一个编辑的命令到 Emacs Lisp ，例如这些命令：移动光标或滚动屏幕，你都是正在进行 evaluating 一个 expression ，它的第一个元素是一个 function 。这就是 Emacs 如何工作的。 当你输入按键时，你会导致 Lisp 解析器去 evaluate 一个 expression 然后你就获得你的结果。甚至输入纯文本时也需要 evaluate 一个 expression ，在这个例子里，就是 self-insert-command ，它只是简单地插入你输入的字符。 那些通过输入按键来进行 evaluate 的 function 称为 interactive function 或 command.

有两个 function ： buffer-name 和 buffer-file-name ，区别了 file 和 buffer 之间的不同。 通常情况下， (buffer-name) 与文件的名字相同. (buffer-file-name) 返回的是文件的绝对路径。

file 和 buffer 是两个不同的实体。*file* 是计算机持久化记录的。 buffer 是 Emacs 内部的信息，它会在结束一个 session 时（或 kill 掉 buffer）而消失。 通常，一个 buffer 包含了一份已经从 file 里 copy 的信息了的，这时我们说，该 buffer 正访问该 file 。这份 copy 就是你工作或修改的。对 buffer 进行修改，并不会改变 file ，除非你保存该 buffer 。 当你保存 buffer 时，该 file 的 copy 就会持久化到 file 里。

(buffer-name)
(buffer-file-name)

nil 对应的拉丁文是 nothing 。在 Lisp中， nil 也用作 false 的意思，它的同义词是空 list，即 ()

单词 buffer ，来自生活中的减弱碰撞力的词：*cushion* （垫子）的意思。在早期的计算机中，缓冲器缓冲了文件和计算机的中央处理单元之间的交互。 保持文件的鼓或磁带和中央处理单元是彼此非常不同的设备，它们以自己的速度以喷射工作。 缓冲区使他们能够有效地协同工作。

并不所有的 buffer 都会关联 file 的。比如 scratch buffer 就没有访问任何文件。同样地， Help buffer 也没有。

• 如果你想将 evaluate 的结果显示在 buffer 自身里面，而不是显示在 echo area ，你可以使用 C-u C-x C-e 来代替 C-x C-e

为了获取 buffer 自身而不是 buffer 的名字，可以使用 current-buffer function 。 但是，如果你 evaluate 该 expression : (current-buffer) ，你会看到，它也是打印该 buffer 的名字在 echo area 中。 Emacs 这样子做的原因有2：

1. buffer 可能有成千上万行，太长的话，不方便显示
2. 可能有相同的内容，但不同的名字。区别它们是非常重要的。

(current-buffer)#<buffer GNU emacs lisp学习笔记.org>
(buffer-name)"GNU emacs lisp学习笔记.org"
(other-buffer)#<buffer org-blog>

可以看到，如果是 (current-buffer) 返回的话，它显示的是 #<buffer GNU emacs lisp学习笔记.org> 而 (buffer-name) 返回的是 GNU emacs lisp学习笔记.org

另一个相关的 function 是 (other-buffer) 。它返回的是最近选择过的非当前的 buffer .

other-buffer function 可以用在一个 function 中需要 buffer 作为参数时，提供一个 buffer 。我们可以看到使用 other-buffer 和 switch-to-buffer 来进行切换 buffer . 通常按 C-x b 然后在提示框中输入 scratch 来切换 buffer 。*C-x b* 会导致 Lisp 解析器去 evaluate 一个 interactive function : switch-to-buffer 。正如之前说过，这就是 Emacs 的工作方式，不同的按键会调用或执行不同的 function 。例如 C-f 调用 forward-char ， M-e 调用 forward-sentence 等等

下面是一个进行切换的例子:

(switch-to-buffer (other-buffer))

evaluate 上面的例子，就可发现 emacs 进行了切换 buffer 了。

buffer-size function ，它告诉你当前 buffer 的大小。它返回的是 buffer 当字符的总数。

在 Emacs 中，光标的当前位置称为 point 。*(point)* 返回的是从当前 buffer 中距离整个 buffer 最开始的位置到当前光标所在的位置的字符数。

point-mini 与 point 类似，但是，它返回的是当前 buffer 允许的最小的 point 值。它的值是1，除非 narrowing 是生效的。（narrowing，它是一种机制，允许你限制自己或程序，仅仅能操作 buffer 其中的一部分）

point-max 与 point-min 类似，只是它返回的是最大的 point 值。

(buffer-size)16365
(point)16363
(point-min)1
(point-max)16716

它们是用 C 语言写的函数。

重新强调一次：当你用 Emacs Lisp 写代码时，你不用区分这些 function 是用 C 语言写的，还是用 Emacs Lisp 写的。这些差别是无关紧要的。

在 Lisp 中，比如 mark-whole-buffer 有附于它的代码，它告诉计算机当调用该 function 时要做的是什么。这些代码，就称为 function 定义，它是通过 evaluate 一个 Lisp 的以 defun （它是 define function 的缩写） 开始的 symbol 的 expression 来创建的。

function 的定义在单词 defun 后面有以下5部分：

1. symbol 的 name
2. 一个 argument 列表。如果不需要的话，这部分为空list，即： ()
3. 描述该 function 的文档（技术上是可选的，但强烈建议写）
4. 可选的。一个 expression ，它使该 function 变成一个 interactive function ，因此，你可以通过 M-x 来调用该 function 或输入适合的按键来调用。
5. 计算机要进行操作的指令代码，即该 function 的 body

下面是一个伪代码:

(defun function-name (arguments…)
"optional-documentation…" ;; 文档会在 C-h f 查看时显示
(interactive argument-passing-info)     ; optional
body…)

下面是一个具体的例子，该 function 是将 argument 乘以 7 :

(defun multiply-by-seven (number)
"Multiply NUMBER by seven."
(* 7 number)
)

下面展示了如何使用上面例子的 function ，但是不要尝试进行 evaluate 它！

(multiply-by-seven 3)

注意，传递 argument 时，是不需要括号的，虽然在 function 定义时使用了括号，但调用时并不需要。定义时需要，是因为要告诉计算机 argument 从哪里开始以及结束。

安装一个 function 定义，你可以在该 function 定义的最后一个括号后面，按下 C-x C-e 来进行 evaluate 它，这时你可以看到 multiply-by-seven 会出现在 echo area 里。同时，该动作会进行安装该 function 的定义了。

function 必须要先安装后才能使用。

通过这种方式安装的 function 定义，但当你退出 Emacs 时，就不会保留了。

你可以使一个 function 变成 interactive 的，通过在 function 文档后面的 list 中，以特殊的 form interactive 开始。这样子，就可以在 M-x 中调用该 function ，或者通过按下绑定到该 function 的按键来调用，像 C-n 是调用 next-line 或 C-x h 是调用 mark-while-buffer 一样。

当你调用一个 interactive function 时，返回的 value 并不会自动显示在 echo area 。这是因为你会经常调用一个 interactive function 来作为一个 side effect ，比如将光标移动到下一个单词或下一行，并没有 value 返回。如果返回的 value 每次都显示在 echo area ，这会使你分心的。

思考一下 zap-to-char function，它的 interactive 部分的 expression 为:

(interactive "p\ncZap to char: ")

"p"

该 argument 告诉 Emacs 解析它个前缀 argument ，并作为一个 number 传递给该 function 。

"c"

告诉该 function 要删除的字符的名字

更多的形式地，它可以传递多个这些选项给 interactive ，每一个之间，是通过 \n 来分隔的。

当你是通过 evaluate 来安装 function 时，它会一直保留直到退出 Emacs 。下次打开 Emacs 时，该 function 并不会被安装，再到再次进行 evaluate 当你想要在启动 Emacs 时，自动安装这些 function ，你可以有以下几种方式来达到目的

• 如果你的这些 code 仅是为你自己工作的，你可以将它们放到 .emacs 初始化文件中。该文件会在 Emacs 启动时，自动地进行 evaluate 的
• 或者，你可以将这些 function 定义放到一个或多个文件中，然后使用 load function 来使 Emacs 进行 evaluate
• 如果你想你的代码，在整个 site 中都可用，你可以将它们放到一个名为 site-init.el 的文件中，该文件会在 Emacs 构建时加载。这可使这些 code 在你的计算机中每个人都是可用的。

let expression 是一个特别的 form ，你将会在 function 定义时经常使用它。

let 用于附加或绑定一个*value* 到一个 symbol 中。

理解它是必须的。考虑一下以下这情况，你有一个自己的家，在语句 The house needs painting ，你通常用 the house 来引用它。如果你正在你的一个朋友的家中进行拜访，然后你再次说 "the house* ，他会认为正在引用的是你朋友的 house ，而不是你自己的 house .

除了 defun 和 let 之外，第三个特殊的 form 是条件 if .它是用于训练计算机进行决定的。 if 的基本思想是， if 测试为 true ，则 evaluate then 的 expression 。如果测试为 not true ，则不进行 evaluate

if expression 有一个可选的第三部分，称为 else-part ，它是在 test-part 为 false 时才调用的。下面是伪代码:

(if true-or-false-test
    action-to-carry-out-if-the-test-returns-true
  action-to-carry-out-if-the-test-returns-false)

具体例子:

 (if (> 4 5)                               ; if-part
  (message "4 falsely greater than 5!") ; then-part
(message "4 is not greater than 5!"))   ; else-part

为 type-of-animal 添加 else-part

(defun type-of-animal (characteristic)  ; Second version.
"Print message in echo area depending on CHARACTERISTIC.
If the CHARACTERISTIC is the string \"fierce\",
then warn of a tiger; else say it is not fierce."
(if (equal characteristic "fierce")
   (message "It is a tiger!")
 (message "It is not fierce!")))

false 与 nil （空 list 也是 nil 的一种） 在 test-part 里，都是 false 。除此之外，其他的都是 true

save-excursion ，它用于保存 point 的位置，*function* 的执行 body ，和 当它的位置变了的时候，可以恢复该 point 之前的位置。（即执行完 body 后，又将光标恢复到之前的位置）

• eval-last-sexp
• defun
• interactive ，它的常用选项（选项之间通过 \n 来分隔）有：

  b

  一个存在的 buffer 名字

  f

  一个存在的 file 名字

  p

  前缀的数字 argument （它是小写的 "p"）

  r

  point 和 mark , 作为2个数字 argument ，最小的在最开头。

• let
• save-excursion
• if
  • <
  • >
  • <=
  • >=
  • =
  • equal
  • eq
  • string<
  • string-lessp
  • string=
  • string-equal
• message
• message
• setq
• set
• buffer-name
• buffer-file-name
• current-buffer
• other-buffer
• switch-to-buffer
• set-buffer
• buffer-size
• point
• point-min
• point-max

C-h f function-name RET ： 查看 function-name 的详细文档

C-h v variable-name RET ： 查看 variable-name 的详细说明

describe-function ：查看 function 的定义

C-h p 查看 Emacs Lisp libraries

它将光标移动到 buffer 的开头。通常绑定到 M-< 首先，它必须是 interactive 的，这样我们才可以通过 M-x beginning-of-buffer 来调用或者使用快捷键 M-< 来调用；必须离开 buffer 中的 mark 的原始位置；并且它必须移动光标到 buffer 的开头。 下面是完整的精简版代码:

(defun simplified-beginning-of-buffer ()
"Move point to the beginning of the buffer;
leave mark at previous position."
(interactive)
(push-mark)
(goto-char (point-min)))

(push-mark) 它会将当前光标的位置设置一个 mark ，该位置会保存到 mark ring 中。这样子，当你跳转到 buffer 的开头的时候，这时再按 C-x C-x 就可以恢复原来的位置了。

以后，当你遇到没有见过的 function 时，你可以通过 describe-function 来详细了解它，或者用 C-h f

它通常绑定到 C-x h

• describe-function
• describe-variable
• find-tag
• save-excursion
• push-mark
• goto-char
• insert-buffer-substring
• mark-whole-buffer
• set-buffer
• get-buffer-create
• get-buffer

理解了 append-to-buffer 之后，再理解 copy-to-buffer 就容易了。它 copy 文本到一个 buffer ，但它不是添加到第二个 buffer 中，而是代替第二个 buffer 的之前的所有文本。它的 body 部分看起来是这样子:

...
(interactive "BCopy to buffer: \nr")
(let ((oldbuf (current-buffer)))
  (with-current-buffer (get-buffer-create buffer)
    (barf-if-buffer-read-only)
    (erase-buffer)
    (save-excursion
      (insert-buffer-substring oldbuf start end)))))

get-buffer-create buffer 它告诉计算机使用指定名的 buffer 来准备 copy ，如果该 buffer 不存在，则创建一个。然后 with-current-buffer evaluate 它的 body 。

barf-if-buffer-read-only 如果 buffer 是 read-only 的话，就给出一条错误信息

erase-buffer 即擦掉整个 buffer 的内容

save-excursion 上面也详细说明了。

这就是 replacement 的意思， Emacs 擦除掉原来的文本，然后插入新的文本。

在 copy-to-buffer 的 body 看起来像这样子:

(let (bind-oldbuf-to-value-of-current-buffer)
 (with-the-buffer-you-are-copying-to
   (but-do-not-erase-or-copy-to-a-read-only-buffer)
   (erase-buffer)
   (save-excursion
     insert-substring-from-oldbuf-into-buffer)))

它做的事就是，从其他的 buffer copy 文本到当前 buffer 。它是 append-to-buffer 或 copy-to-buffer 的相反操作，它们是从当前 buffer copy 到另一个 buffer 。

如果没有带 argument 来调用它，则将光标移动到整个 buffer 的开头。如果带有一个 1~10 的 argument ，则会将光标移动到整个buffer 的 argument/10 的位置。如果大于10，再是到 buffer 的最后。 比如，想移动到整个 buffer 的 70% 的位置: C-u 7 M-<

• or
• and
• &optional
• prefix-numeric-value
• forward-line
• erase-buffer
• bufferp

在 Narrowing 中，*buffer* 剩余的其他部分是不可见的，就像它不存在一样。例如，你仅想在 buffer 的一部分中进行单词替换时，narrowing 就有个好处了，它可以允许你仅替换 narrowing 的部分，而不包括其他部分。搜索也同样如此。

由于 narrowing 会使 buffer 的剩余部分不可见，这可能会使一些人感到害怕，他们会认为已经删除了文件的这些部分，然后调用 undo 命令，但并没有关闭 narrowing , 因此，人们可能变得绝望了，如果不知道让这些部分变得可见是通过 widen （通常绑定以 C-x n w ）来返回可见性的话的。

你可以使用 save-restriction 这个特殊的 form 来跟踪 narrowing 中做了些什么。当 Lisp 解析器遇到 save-restriction 时，它会执行 save-restriction 的 body 代码，然后撤消这些代码导致的所有更改。 save-restriction 的模板如下:

(save-restriction
  body… )

body 部分会被 Lisp 解析器按顺序地进行 evaluate 。

如果你同时连着使用 save-excursion 和 save-restriction ，你应该在最外面使用 save-excursion 。如果弄反了顺序的话，你可能会导致记录 narrowing 失败。所以，当它们一起用时，模板应该是这样子:

(save-excursion
  (save-restriction
    body…))

其他情况下，当并不是连着用时，它们的顺序应该为: save-restriction 再到 save-excursion

(save-restriction
 (widen)
 (save-excursion
 body…))

它告诉你当前光标在哪一行上。源码如下:

 (defun what-line ()
"Print the current line number (in the buffer) of point."
(interactive)
(save-restriction
  (widen)
  (save-excursion
    (beginning-of-line)
    (message "Line %d"
             (1+ (count-lines 1 (point)))))))

这个版本是比较旧的代码，最近版本的 GNU Emacs 则不太同，你可以通过 C-h f 来查看。

count-lines 它返回的是在当前行之前一共有多少行。所以这里要 +1

cons

它是单词 construct 的缩写。

car

这是下面的首字母缩写： Contents of the Address part of the Register

cdr

这是下面的首字母缩写：*Contents of the Decrement part of the Register*

这些用语是在早期开发 Lisp 的计算机硬件的一部分的。所以一直沿用至今。

car list 是非常简单的，即获取list的第一个元素。因此 ，*car* 这个 list: (rose violet daisy buttercup) 的结果就是 rose .

(car '(rose violet daisy buttercup))

所以，一个更合理的 car function 的名字，应该是叫 first 。它并不会移除list的第一个元素，仅仅是报告第一个元素是什么。用术语来说，*car* 是非破坏性的。

cdr list 则是list的剩余部分（即除了第一个元素之外的部分），因此 cdr 这个 list：*(rose violet daisy buttercup)* 的结果就是 (violet daisy buttercup)

(cdr '(rose violet daisy buttercup))

同样地，*cdr* 也是不具破坏性的。一个更合理的 cdr 的名字，应该为 rest .

所以说， 一个好的 function 名字是非常重要的。

它用来构建 list 。它与 car 和 cdr 是相反的。例如下面:

(cons 'pine '(fir oak maple))

它会得到一个 list :

(pine fir oak maple)

它不会影响已经存在的 list ，而是创建一个新的 list .

nthcdr 与 cdr 是相关联的。它做的事就是重复 n 次 cdr 的操作。下面是一系列的 cdr 操作:

(cdr '(pine fir oak maple))
⇒(fir oak maple)

(cdr '(fir oak maple))
⇒ (oak maple)

(cdr '(oak maple))
⇒(maple)

(cdr '(maple))
⇒ nil

(cdr 'nil)
⇒ nil

(cdr ())
⇒ nil

你也可以通过 nthcdr 来直接指定进行重复 n 次的 cdr 操作。例如:

;; Leave the list as it was.
(nthcdr 0 '(pine fir oak maple))
⇒ (pine fir oak maple)

;; Return a copy without the first element.
(nthcdr 1 '(pine fir oak maple))
⇒ (fir oak maple)

;; Return a copy of the list without three elements.
(nthcdr 3 '(pine fir oak maple))
⇒ (maple)

;; Return a copy lacking all four elements.
(nthcdr 4 '(pine fir oak maple))
⇒ nil

;; Return a copy lacking all elements.
(nthcdr 5 '(pine fir oak maple))
⇒ nil

nth 将 nthcdr 返回的结果进行 car 操作。它返回的是第 N 个元素。下面是 nth 可能的代码（实际上，它是用 C 写的，这里只是显示个 lisp 版本的）:

(defun nth (n list)
  "Returns the Nth element of LIST.
N counts from zero.  If LIST is not that long, nil is returned."
  (car (nthcdr n list)))

下面是一些例子：

(nth 0 '("one" "two" "three"))
⇒ "one"

(nth 1 '("one" "two" "three"))
⇒ "two"

正如从名字猜测他们的意思一样， setcar 和 setcdr 会将 car 或 cdr 部分的 list 设置为一个新的 value 。它不像 car 或 cdr ，它会改变原来的 list 的。

首先，我们用创建一个 list ，例如:

(setq animals '(antelope giraffe lion tiger)) 

(setcar animals 'hippopotamus) 

animals

这时，*animals* 为 (hippopotamus giraffe lion tiger) 了。

它与 setcar 类似，但它是代替 list 的除了第一个元素的后面的部分的。例如:

(setq domesticated-animals '(horse cow sheep goat))

domesticated-animals => (horse cow sheep goat)

(setcdr domesticated-animals '(cat dog)) 

domesticated-animals => (horse cat dog)

当从 buffer 中 cut 掉一段文本时，它其实是保存在一个 list 中。看起来像这样子:

("a piece of text" "previous piece")

cons 可以用来创建一个新的 list 。像这样子:

(cons "another piece"
  '("a piece of text" "previous piece"))

如果你 evaluate 上面的例子，你可以在 echo area 显示这些元素:

("another piece" "a piece of text" "previous piece")

通过 car 和 nthcdr ，你可以从 list 中获取任意的文本片段。例如:

(car (nthcdr 1 '("another piece"
             "a piece of text"
             "previous piece")))
 ⇒ "a piece of text"

例如，一个 list (rose violet buttercup) 有三个元素, 'rose', 'violet', 'buttercup' 。在计算机里，'rose' 的 electronic address 就是用一段(segment)计算机 memory 的 address 来记录了 atom violet 所在的 electronic address 。同样地, violet 的 electronic address 记录了 atom buttercup 所在的 electronic address . 我们用个示意图来更明了:

___ ___      ___ ___      ___ ___
|___|___|--> |___|___|--> |___|___|--> nil
  |            |            |
  |            |            |
  --> rose     --> violet   --> buttercup

在示意图中，每一个 box 代表一个计算机 memory 持有的 Lisp Object 的单词，通常是一个 memory address 。Boxes ，例如，该 addresses 是成对出现的。每一个箭头指向下一个 address ，该 address 可以为 atom 或另一对 address 。第一个 box 就是 'rose' 的 electronic address ，并且箭头指向 'rose' ；第二个 box 是下一对 boxes 的 address 。如果最后一个 box 是指向 nil 则表示结束。

当使用 setq 这样子的 function 来设置一个 variable 时，它保存了第一个 box 的 address 到 variable 中。因此， evaluate 下面的 expression 会创建这样的情况：

(setq bouquet '(rose violet buttercup))

bouquet
  |
  |     ___ ___      ___ ___      ___ ___
   --> |___|___|--> |___|___|--> |___|___|--> nil
         |            |            |
         |            |            |
          --> rose     --> violet   --> buttercup

在这个例子里，symbol bouquet 拥有第一对 boxes 的 address 。同样的 list ，可以用不种类型的 box 来加以说明，比如这：

bouquet
 |
 |    --------------       ---------------       ----------------
 |   | car   | cdr  |     | car    | cdr  |     | car     | cdr  |
  -->| rose  |   o------->| violet |   o------->| butter- |  nil |
     |       |      |     |        |      |     | cup     |      |
      --------------       ---------------       ----------------

如果一个 symbol 是由 cdr 设置的话，list 自身并不会导致改变；该 symbol 只是简单地拥有list剩余的部分的 address 。因此 evaluate 下面的 expression ,

(setq flowers (cdr bouquet))

会产生：

bouquet        flowers
  |              |
  |     ___ ___  |     ___ ___      ___ ___
  --> |   |   |  --> |   |   |    |   |   |
      |___|___|----> |___|___|--> |___|___|--> nil
        |              |            |
        |              |            |
        --> rose       --> violet   --> buttercup

一对 boxes 的 address 就称为一个 cons cell 或 dotted pair 。*cons* function 会添加一对新的 addresses 到这一系列的 addresses 前面。例如，evaluate 下面的 expression：

(setq bouquet (cons 'lily bouquet))

会产生:

bouquet                       flowers
  |                             |
  |    ___ ___        ___ ___  |     ___ ___       ___ ___
  --> |   |   |      |   |   |  --> |   |   |     |   |   |
      |___|___|----> |___|___|----> |___|___|---->|___|___|--> nil
        |              |              |             |
        |              |              |             |
        --> lily      --> rose       --> violet    --> buttercup

然而，这并不会改变 symbol flowers 的 value ，例如 :

(eq (cdr (cdr bouquet)) flowers)

它会返回 t ，表示 true.

除非 reset ，否则 flowers 会一直拥有 (violet buttercup) 的 value 。

因此，在 Lisp 中，当你 cdr 一个 list 时，你只是获取了下一个 cons cell 的 address 。 car 一个 list 时，你只是获取了 list 中第一个元素的 address 。 使用 cons 添加一个新的元素时，你只是添加了一个新的 cons cell 到 list 的前面。

这就是它们操作的全部！

在之前部分里，我建议你把 symbol 想象为一个抽屉柜。function 定义放在其中一个，value 放在另一个等等。放到抽屉里，持有的 value 的抽屉可以在不影响持有 function 定义抽屉的内容下被更改。反之亦然。 实际上，每个放到抽屉里的是 value 或 function 定义的 address 。就像你在一个旧的楼阁里的柜子中，在其中一个抽屉里，你发现了一张藏宝图一样。

除了 name ，symbol 的定义 和 variable 的 value 之外，*symbol* 还有一个 property list 的抽屉，它用于记录其他的信息。下面是一张假设图：

    Chest of Drawers            Contents of Drawers

    __   o0O0o   __
  /                 \
 ---------------------
|    directions to    |            [map to]
|     symbol name     |             bouquet
|                     |
+---------------------+
|    directions to    |
|  symbol definition  |             [none]
|                     |
+---------------------+
|    directions to    |            [map to]
|    variable value   |             (rose violet buttercup)
|                     |
+---------------------+
|    directions to    |
|    property list    |             [not described here]
|                     |
+---------------------+
|/                   \|

kill ring 是一个文本 string 的 list。看起来像这样子：

("some text" "a different piece of text" "yet more text")

如果你的 kill ring 是这些内容的话，并且我按下 C-y ，则字符串 "some text" 会插入到当前光标所在的位置的 buffer 中。 yank command 也用于 copy 中的文本，被 copy 的文本并不会从 buffer 中 cut 掉，但是 copy 的文本也会放到 kill ring 中，然后通过 yank 插入回来。

yank （C-y) 用于从 kill ring 中返回文本。 yank-pop (M-y) ，从 kill ring 中弹出第一个元素（即所谓第二个元素，替代了第一个元素） rotate-yank-pointer ，通常是上面两个来调用的。

引用到 kill ring 的 functions 都是通过一个称为 kill-ring-yank-pointer 的 variable 来处理的。的确，从 yank 和 yank-pop functions 中插入的源码为 :

(insert (car kill-ring-yank-pointer))

不过，在 GNU Emacs 22 中就不再是这样子了。这个 function 已经被 insert-for-yank 替代了 。

就像 kill-ring 作为一个 variable 一样。如果有一个 kill ring 的 value 为:

("some text" "a different piece of text" "yet more text")

并且 kill-ring-yank-pointer 指向第二句的话，则 kill-ring-yank-pointer 的 value 为:

("a different piece of text" "yet more text")

正如之前解释的一样，计算机并不会保持两分这些 text 的 copy (kill-ring 和 kill-ring-yank-pointer) ，而是有两个 Lisp variable ，它们都指向同一份文本。这是示意图:

kill-ring     kill-ring-yank-pointer
 |               |
 |      ___ ___  |     ___ ___      ___ ___
  ---> |   |   |  --> |   |   |    |   |   |
       |___|___|----> |___|___|--> |___|___|--> nil
         |              |            |
         |              |            |
         |              |             --> "yet more text"
         |              |
         |               --> "a different piece of text"
         |
          --> "some text"

kill-ring 和 kill-ring-yank-pointer 两个 variable 都是 pointer 。但是 kill ring 自身才是我们实际上指的 kill ring 。*kill-ring* 我们通常指的是它自身 kill ring ，而不是一个指向 list 的 pointer 。相反地， kill-ring-yank-pointer 通常是作为一个 pointer 来指向一个 list .

即 kill-ring 通常想像为一个完整的数据结构，而 kill-ring-yank-pointer 则是作为一个 pointer 指向将会被插入的元素的位置。

while 中，如果第一个 argument 返回的是 false， 则 Lisp 解析器会忽略之后的 expression （即 while 的 body 部分）。如果返回的是 true ，则它会 evaluate 它的 body 部分，然后再一次判断它的第一个 argument 是否是 true 还是 false 。如果又是 true ，则又会进行 evaluate 。它的模板如下:

(while true-or-false-test
       body…)

symbol sentence-end 是绑定到一个 pattern ，它是标记 sentence 结束的。 显然，一个 sentence 应该是以句号，或问号或叹号结尾的。这意味着这个 pattern 应该包括这些字符集：

[.?!]

然而，我们并不想 forward-sentence 仅仅跳到一个句号，或一个问号或一个叹号处，因为这些字符可以在 sentence 的中间使用。比如句号，可以用在缩写字符后。所以这里需要其他额外的信息。 根据惯例，你会在每个 sentence 后面输入2个空格，仅在句号或问号或叹号后面有一个空格。所以，这些字符后跟着2个空格的就可以指明是一个 sentence 了。然而在文件中，2个空格可以用 tab 或换行来表示结束。所以，这个 regular expression 可以为修改为:

\\($\\| \\|  \\)
       ^   ^^
      TAB  SPC

在这里， "$" 表示行尾。

2条斜线，=\\= 在括号和垂直线之前是必须的：第一条斜线引用第二条斜线；并且第二条斜线显示接下来的字符，括号或垂直线是特殊字符。一个 sentence 也可能跟在一个或多个中括号，例如:

[
]*

像 tabs 和 空格 ， 一个中括号可以直接写字面值到 regular expression 中。星号表示重复0或多次。 但一个 sentence 不仅是以以上字符结尾的，也可能是引号 " 或一个关闭的大括号 } 。所以 regexp 为:

[]\"')}]*

所以，完整的 pattern 为:

sentence-end
  ⇒ "[.?!][]\"')}]*\\($\\|     \\|  \\)[
]*"

它与 search-foward 是非常相似的。当搜索成功时，它会立即离开当前光标位置到 target 的最后一个字符后面。如果是向 backward 搜索的话，则是放到 target 的第一个字符的前面。与 search-foward 类似，*re-search-foward* 有4个 argument ：

1. 第一个为 regular expression 用来搜索的。它是一个用双引号引起的 string
2. 可选的第二个 argument ，表示限制该搜索可以搜索多远。即 buffer 的 position
3. 可选的第三个 argument ，表示如果搜索失败时，要做些什么。*nil* 的话，表示导致一个错误信号并打印错误消息。
4. 可选的第四个 argument ，表示重复的次数。如果为负，则表示是向 backward 搜索 。

模板如下:

(re-search-forward "regular-expression"
             limit-of-search
             what-to-do-if-search-fails
             repeat-count)

通常，它绑定到 M-e 快捷键中。

它也是用 regexp 来处理的。

标准的 Emacs 发行版里已经有在一个 region 中统计行和单词的 functions 了。*count-words-region*

默认情况下，它会根据你的文件后缀来打开相应的 mode ，如果找不到的话，就会使用 Fundamental mode

Emacs 会自动加载这些 site-wide 初始化文件的，你的 .emacs 文件是仅为你加载的，但这个是加所有人都会加载的。

这里有2个 site-wide 的初始化文件： site-load.el 和 site-init.el 。（编译和构建 Emacs 时使用）

当你每次启动 Emacs ，有3个其他的 site-wide 初始化文件会自动地被加载，如果存在的话。

1. site-start.el 会在你的 .emacs 文件之前加载
2. default.el 会在你的 .emacs 文件之后加载
3. terminal type 文件，会在你的 .emacs 文件之后加载

之后，你就可以在 Emacs's 的 customize 功能里设置它们的 value 了。

defcustom （前三个与 defvar 是一样的）

1. 第一个 argument 为 variable 的 name 。
2. 第二个为 variable 的初始 value ，并且这个 value 仅在原来没有 value 的情况下才会 set的
3. 第三部分是 documentation
4. 第四和剩余部分是指明类型和选项 （可选）。这些 argument 是由一个 keyword 然后接着一个 value 组成的。每个 keyword 是由分号 ":" 开始的。例如:

(defcustom text-mode-hook nil
  "Normal hook run when entering Text mode and many related modes."
  :type 'hook
  :options '(turn-on-auto-fill flyspell-mode)
  :group 'wp)

当你启动 Emacs 时，它会加载你的 .emacs 文件，除非你通过 "-q" 选项来告诉它不要加载，

开始 Text mode 和 *Auto fill mode*：

   ;;; Text mode and Auto Fill mode
;; The next two lines put Emacs into Text mode
;; and Auto Fill mode, and are for writers who
;; want to start writing prose rather than code.
(setq-default major-mode 'text-mode)
(add-hook 'text-mode-hook 'turn-on-auto-fill)

'text-mode 告诉 Emacs 直接处理 text-mode symbol ，无论它代表的是什么。

(add-hook 'text-mode-hook 'turn-on-auto-fill) 表示每次开启 Text mode 的时候，Emacs 都会执行所有与 text-mode-hook 相关的 commands 。

(setq colon-double-space t) 表示在每个分号后都插入2个空格。

   ;;; Mail mode
                                        ; To enter mail mode, type 'C-x m'
                                        ; To enter RMAIL (for reading mail),
                                        ; type 'M-x rmail'
(setq mail-aliases t)

setq 将 mail-aliases 的 value 设置为 t 。表示 true ，即表示: "Yes, use mail aliases"

这里可以在 ~/.mailrc 中加上 aliases 了：内容类似：

alias geo george@foobar.wiz.edu

默认情况下，当 format 一个 region 时 Emacs 将会多个空格替换为 tab 。以下是关闭这个mode的代码:

;;; Prevent Extraneous Tabs
(setq-default indent-tabs-mode nil)

注意，这里使用 setq-default 而不是 setq 。*setq-default* 仅在 buffer 中没有他们自己的 local values 时，才设置它的 values .

Emacs 中使用 Keymaps 来记录哪些键绑定了哪些 commands 。当你用 global-set-key 时，会修改 current-global-map 。每一种 mode 都有它们自己的 keymaps 。 mode 指定的 keymap 会覆盖 global map 的。

你可以使用 load command 来 evaluate 一个完整的文件：

(load "~/emacs/slowsplit")

通过 load 或 evaluate 是会实际就安装好了的。但 autoloading 则是在第一次调用的时候才会安装的。（这可以让 Emacs 启动得更快）。例如:

(autoload 'html-helper-mode
"html-helper-mode" "Edit HTML documents" t)

autoload 有5个 argument：

1. function name
2. 要加载的 fien name
3. documentation
4. 是否可以通过 interactively 来调用
5. 告诉 autoload 什么类型的对象可以处理一个 keymap 或 macro 以及一个 function （默认为 function)

指定入口来进行 debug M-x debug-on-entry RET function-name RET