翻译: Emacs Lisp 编程入门 ¶

Next: 运行程序, Up: 列表处理   [Contents][Index]

1.1 Lisp 列表 ¶

在 Lisp 中，列表的形式如下：'(rose violet daisy buttercup)。 该列表以一个单引号开头。它也可以写成下面这种更符合你日常认知的形式：

'(rose
  violet
  daisy
  buttercup)

这个列表的元素是四种不同花卉的名称，它们由空白符分隔，并用括号包裹， 就像田野里的花朵被一圈石墙环绕。

• 数字、列表中的列表
• Lisp 原子
• 列表中的空白符
• GNU Emacs 辅助输入列表

'(this list has (a list inside of it))

'(this list includes "text between quotation marks.")

'(this list
   looks like this)

'(this list looks like this)

Next: 生成错误信息, Previous: Lisp 列表, Up: 列表处理   [Contents][Index]

1.2 运行程序 ¶

Lisp 中的列表 — 任何列表 — 都是一个可直接运行的程序。 如果你运行它（Lisp 术语称为求值(evaluate)）， 计算机会做三件事之一：直接返回列表本身；给出错误信息； 或将列表中的第一个符号当作执行命令。 （当然，通常你真正想要的是第三种结果。）

前面示例中某些列表前的单引号 ' 称为引用(quote)； 当它出现在列表前时，告诉 Lisp 直接原样保留该列表，不做任何处理。 但如果列表前没有引用标记，列表的第一个元素就具有特殊含义： 它是计算机要执行的命令。 （在 Lisp 中，这类命令称为函数。） 前面出现的列表 (+ 2 2) 没有前置引用， 因此 Lisp 将 + 理解为对后续数字执行加法操作的指令。

如果你正在 GNU Emacs 的 Info 中阅读本文，可以按如下方式对列表求值： 将光标放在下面列表的右括号紧右侧，然后输入 C-x C-e：

(+ 2 2)

你会在回显区看到数字 4 出现²。 （你刚刚执行的操作就是对列表求值。回显区是屏幕底部用于显示或回显文本的行。） 现在对带引用的列表做同样操作： 将光标放在下面列表末尾，输入 C-x C-e：

'(this is a quoted list)

你会在回显区看到 (this is a quoted list)。

两种操作中，你实际都是在向 GNU Emacs 内部名为Lisp 解释器的程序发送命令 — 让解释器对表达式求值。 Lisp 解释器的名称源自人类对表达式含义进行理解与阐释的行为。

你也可以对不属于任何列表、没有被括号包裹的原子求值； Lisp 解释器同样会将人类可读的表达式转换为计算机可执行的指令。 但在讨论这一点之前（see 变量）， 我们先介绍当你出现错误时 Lisp 解释器会如何处理。

Next: 符号名称与函数定义, Previous: 运行程序, Up: 列表处理   [Contents][Index]

1.3 生成错误信息 ¶

为了让你在不小心操作时不必担心，我们现在向 Lisp 解释器输入一个会生成错误信息的命令。 这一操作是无害的；事实上，我们经常会有意触发错误信息。 一旦你理解了相关术语，错误信息其实很有参考价值。 与其称其为 “错误(error)” 信息，不如称之为 “帮助(help)” 信息。 它们就像陌生国度里给旅行者指引方向的路标；读懂它们可能有些困难，但一旦理解，就能指明前进的方向。

错误信息由内置的 GNU Emacs 调试器生成。我们会进入调试器。 输入 q 即可退出调试器。

我们要做的是对一个未加引号、且首元素不是有效命令的列表进行求值。 下面这个列表与我们刚才使用的几乎完全相同，只是前面没有单引号。 将光标移到它的正后方，然后输入 C-x C-e：

(this is an unquoted list)

一个 *Backtrace* 窗口会打开，你应该能在其中看到如下内容：

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

光标会出现在这个窗口中（可能需要等待几秒才会显示）。 要退出调试器并关闭调试窗口，请输入：

q

请现在就输入 q，让自己确信可以顺利退出调试器。 然后再次输入 C-x C-e 重新进入。

根据我们已经掌握的知识，基本可以读懂这条错误信息。

*Backtrace* 缓冲区需要从下往上阅读；它会告诉你 Emacs 执行了哪些操作。 当你输入 C-x C-e 时，你是在交互式调用 eval-last-sexp 命令。 eval 是“evaluate（求值）”的缩写，sexp 是 “symbolic expression（符号表达式）” 的缩写。 该命令的含义是 “对光标前的最后一个符号表达式求值”。

上面的每一行都会告诉你 Lisp 解释器接下来求值的内容。 最近执行的操作位于最上方。 该缓冲区被称为 *Backtrace* 缓冲区，是因为它可以让你回溯 Emacs 的执行过程。

在 *Backtrace* 缓冲区的顶部，你会看到这一行：

Debugger entered--Lisp error: (void-function this)

Lisp 解释器尝试对列表的第一个原子 ‘this’ 进行求值。 正是这一操作触发了错误信息 ‘void-function this’。

该信息包含 ‘void-function’ 和 ‘this’ 两个部分。

‘function’ 一词我们之前已经提到过。这是一个非常重要的概念。 就本节而言，我们可以这样定义：函数 是一组告诉计算机执行特定操作的指令。

现在我们可以理解这条错误信息了：‘void-function this’。 该函数（即 ‘this’ 这个词）没有任何可供计算机执行的指令定义。

略显特殊的 ‘void-function’ 这一说法，是为了贴合 Emacs Lisp 的实现方式： 当一个符号没有附加函数定义时，本该存放指令的位置就是空的。

另一方面，我们之前通过求值 (+ 2 2) 成功计算了 2 加 2， 由此可以推断，符号 + 一定包含一组计算机可执行的指令， 这些指令的作用就是对 + 后面的数字进行加法运算。

在这类情况下，其实可以阻止 Emacs 进入调试器。 我们这里不讲解具体方法，但会说明出现的结果， 因为你在使用存在问题的 Emacs 代码时可能会遇到类似情况。 这种情况下，你只会在回显区看到一行错误信息，样式如下：

Symbol's function definition is void: this

只要按下任意按键，哪怕只是移动光标，这条信息就会消失。

我们知道 ‘Symbol’ 的含义。它指的是列表的第一个原子，也就是 ‘this’。 ‘function’ 指的是告诉计算机执行操作的指令。 （严格来说，符号是告诉计算机去哪里查找指令，不过这一细节我们暂时可以忽略。）

这条错误信息的含义可以理解为：‘Symbol's function definition is void: this’。 该符号（即 ‘this’ 一词）缺少可供计算机执行的指令。

Next: Lisp 解释器, Previous: 生成错误信息, Up: 列表处理   [Contents][Index]

1.4 符号名称与函数定义 ¶

根据目前的讨论，我们可以总结出 Lisp 的另一个重要特性： 像 + 这样的符号，其本身并不是计算机要执行的指令集。 相反，该符号（可能只是临时）被用来定位对应的定义或指令集。 我们看到的只是一个可以用来查找指令的名称。 人名的作用也是如此。我可以被称作 ‘Bob’，但我并不是字母 ‘B’、‘o’、‘b’ 的组合， 而是与某个生命体持续关联的意识。名字并不是我本人，只是可以用来指代我。

在 Lisp 中，同一组指令可以附加到多个名称上。 例如，实现加法运算的计算机指令既可以关联到符号 +，也可以关联到符号 plus （在某些 Lisp 方言中确实如此）。 在人类社会中，我既可以被称作 ‘Robert’，也可以被称作 ‘Bob’，还可以有其他称呼。

另一方面，一个符号同一时间只能附加一个函数定义。 否则计算机就会困惑该使用哪个定义。 如果人类社会也是如此，那全世界就只能有一个人叫 ‘Bob’。 不过，名称所指向的函数定义可以很方便地修改。(See Install a Function Definition.)

由于 Emacs Lisp 规模庞大，通常会按照功能模块为符号命名。 因此，所有处理 Texinfo 的函数名都以 ‘texinfo-’ 开头， 处理邮件阅读的函数名都以 ‘rmail-’ 开头。

Next: 求值, Previous: 符号名称与函数定义, Up: 列表处理   [Contents][Index]

1.5 Lisp 解释器 ¶

根据我们目前的观察，可以开始梳理 Lisp 解释器对列表求值时的工作流程。 首先，它会检查列表前面是否有引号；如果有，解释器会直接返回该列表。 如果没有引号，解释器会查看列表的第一个元素，判断其是否拥有函数定义。 如果有，解释器就执行该函数定义中的指令。 如果没有，解释器就会打印错误信息。

这就是 Lisp 的基本工作方式，非常简单。 后续会有一些更复杂的规则，但这些是核心原理。 当然，要编写 Lisp 程序，你需要学会如何编写函数定义并将其附加到名称上， 同时避免让自己或计算机产生困惑。

• 复杂情况
• 字节编译

Next: 变量, Previous: Lisp 解释器, Up: 列表处理   [Contents][Index]

1.6 求值 ¶

Lisp 解释器对表达式进行处理的这一行为，被称为 求值(evaluation)。 我们会说解释器 “对表达式求值”。这个词我之前已经用过多次。 根据《韦氏新大学词典》的释义，该词源自日常用语，意为 “确定价值或数量；评估”。

• Lisp 解释器的执行方式
• 嵌套列表求值

(+ 2 (+ 3 3))

(+ 2 (+ 3 3))

Next: 参数, Previous: 求值, Up: 列表处理   [Contents][Index]

1.7 变量 ¶

在 Emacs Lisp 中，一个符号既可以绑定函数定义，也可以绑定一个值，二者是相互独立的。函数定义是一组计算机可以执行的指令；而值则是数字、名称这类可以变化的内容（这也是这类符号被称为变量(variable)的原因）。符号的值可以是 Lisp 中的任意表达式，比如符号、数字、列表或字符串。拥有值的符号通常被称为变量(variable)。

一个符号可以同时绑定函数定义和值，也可以只拥有其中一项。二者相互独立。这有点类似于 “Cambridge” 这个名称既可以指代美国马萨诸塞州的一座城市，也可以附加 “优秀编程中心” 这类描述信息。

另一种理解方式是把符号想象成一个多格抽屉。函数定义放在一个抽屉里，值放在另一个抽屉里，以此类推。存放值的抽屉里的内容可以被修改，而不会影响存放函数定义的抽屉，反之亦然。

• 变量示例 fill-column
• 符号无函数定义时的错误信息
• 符号无值绑定时的错误信息

fill-column

(fill-column)

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function fill-column)
  (fill-column)
  eval((fill-column) nil)
  elisp--eval-last-sexp(nil)
  eval-last-sexp(nil)
  funcall-interactively(eval-last-sexp nil)
  call-interactively(eval-last-sexp nil nil)
  command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

(+ 2 2)

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-variable +)
  eval(+)
  elisp--eval-last-sexp(nil)
  eval-last-sexp(nil)
  funcall-interactively(eval-last-sexp nil)
  call-interactively(eval-last-sexp nil nil)
  command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

Next: 设置变量的值, Previous: 变量, Up: 列表处理   [Contents][Index]

1.8 参数 ¶

为了理解信息是如何传递给函数的，我们再来看熟悉的 2 加 2 示例。在 Lisp 中写法如下：

(+ 2 2)

如果对该表达式求值，回显区会显示数字 4。Lisp 解释器所做的就是对 + 后面的数字执行加法。

由 + 相加的这些数字被称为函数 + 的参数(arguments)。这些数字是提供给函数、或者说传递(passed)给函数的信息。

“参数（argument）”一词源自数学用法，并非指人与人之间的争论；而是指传递给函数（本例中是 +）的信息。在 Lisp 中，函数的参数就是跟在函数后面的原子或列表。这些原子或列表求值后返回的值会被传递给函数。不同函数需要的参数数量不同，有些函数甚至完全不需要参数。³

• 参数的数据类型
• 作为变量或列表值的参数
• 可变数量参数
• 使用类型错误的对象作为参数
• message 函数

(concat "abc" "def")

(substring "The quick brown fox jumped." 16 19)

(+ 2 fill-column)

(concat "The " (number-to-string (+ 2 fill-column)) " red foxes.")

(+)       ⇒ 0

(*)       ⇒ 1

(+ 3)     ⇒ 3

(* 3)     ⇒ 3

(+ 3 4 5) ⇒ 12

(* 3 4 5) ⇒ 60

(+ 2 'hello)

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error:
         (wrong-type-argument number-or-marker-p hello)
  +(2 hello)
  eval((+ 2 'hello) nil)
  elisp--eval-last-sexp(t)
  eval-last-sexp(nil)
  funcall-interactively(eval-print-last-sexp nil)
  call-interactively(eval-print-last-sexp nil nil)
  command-execute(eval-print-last-sexp)
---------- Buffer: *Backtrace* ----------

(message "This message appears in the echo area!")

(message "The name of this buffer is: %s." (buffer-name))

(message "The value of fill-column is %d." fill-column)

(message "There are %d %s in the office!"
         (- fill-column 14) "pink elephants")

(message "He saw %d %s"
         (- fill-column 32)
         (concat "red "
                 (substring
                  "The quick brown foxes jumped." 16 21)
                 " leaping."))

Next: 小结, Previous: 参数, Up: 列表处理   [Contents][Index]

1.9 设置变量的值 ¶

为变量赋值有多种方式，其中一种是使用特殊形式 setq，另一种是使用 let（see let）。该过程的专业术语是将变量绑定(bind)到一个值。

接下来的小节不仅会介绍 setq 的用法，还会演示参数的传递方式。

• 使用 setq
• 计数

(setq flowers '(rose violet daisy buttercup))

flowers

'flowers

(setq carnivores '(lion tiger leopard))

(setq trees '(pine fir oak maple)
      herbivores '(gazelle antelope zebra))

(setq counter 0)                ; 我们称之为初始化语句

(setq counter (+ counter 1))    ; 这是递增语句

counter                         ; 这是计数器本身

Next: 练习, Previous: 设置变量的值, Up: 列表处理   [Contents][Index]

1.10 小结 ¶

学习 Lisp 就像爬山，最初的一段最陡峭。你已经攻克了最难的部分，后续内容会越来越轻松。

总结如下：

• Lisp 程序由表达式构成，表达式可以是列表或单个原子。
• 列表由 0 个或多个原子或内层列表组成，以空白分隔并被括号包裹。列表可以为空。
• 原子可以是多字符符号（如 forward-paragraph）、单字符符号（如 +）、双引号字符串或数字。
• 数字求值结果为自身。
• 双引号字符串求值结果也为自身。
• 单独对符号求值时，会返回其绑定的值。
• 对列表求值时，Lisp 解释器会查看列表的第一个符号，找到该符号绑定的函数定义，然后执行其中的指令。
• 单引号 ‘'’ 告诉 Lisp 解释器直接原样返回后面的表达式，而不进行求值。
• 参数是传递给函数的信息。函数的参数通过对“以该函数为首个元素的列表”中其余元素求值得到。
• 函数求值后总会返回一个值（除非出错）；此外还可能执行某种动作，即副作用。很多函数的主要目的就是产生副作用。

Previous: 小结, Up: 列表处理   [Contents][Index]

1.11 练习 ¶

几个简单练习：

• 对一个不带括号的合适符号求值，触发错误信息。
• 对一个带括号的合适符号求值，触发错误信息。
• 创建一个每次递增 2 而非 1 的计数器。
• 编写一个表达式，求值时在回显区打印一条消息。

Next: 获取缓冲区, Previous: 如何执行求值, Up: 练习求值   [Contents][Index]

2.1 缓冲区名称 ¶

buffer-name 和 buffer-file-name 这两个函数展示了文件与缓冲区之间的区别。对以下表达式求值，(buffer-name) 会在回显区显示缓冲区的名称；而对 (buffer-file-name) 求值，会显示该缓冲区所引用文件的名称。通常，(buffer-name) 返回的名称与其引用的文件名称相同，而 (buffer-file-name) 返回的是文件的完整路径名。

文件和缓冲区是两种不同的实体。文件是永久记录在计算机中的信息（除非你删除它）；而缓冲区是 Emacs 内部的信息，会在编辑会话结束时（或你关闭缓冲区时）消失。通常，缓冲区包含你从文件中复制的信息，我们说这个缓冲区正在访问(visiting)该文件。你所编辑和修改的正是这份副本。对缓冲区的修改不会改变文件，直到你保存该缓冲区。保存时，缓冲区的内容会被复制到文件中，从而永久保存。

如果你正在 GNU Emacs 的 Info 中阅读本文，可以将光标放在以下每个表达式后面，输入 C-x C-e 来求值：

(buffer-name)

(buffer-file-name)

我在 Info 中执行后，(buffer-name) 的返回值是 "*info*"，而 (buffer-file-name) 的返回值是 nil。

另一方面，在我编写本文档时，(buffer-name) 的返回值是 "introduction.texinfo"，(buffer-file-name) 的返回值是 "/gnu/work/intro/introduction.texinfo"。

前者是缓冲区名称，后者是文件名。在 Info 中，缓冲区名为 "*info*"。Info 不关联任何文件，因此 (buffer-file-name) 的求值结果为 nil。符号 nil 源自拉丁语，意为“无(nothing)”；在这里表示缓冲区与任何文件都无关联。（在 Lisp 中，nil 也表示“假(false)”，是空列表 () 的同义词。）

在编写时，我的缓冲区名为 "introduction.texinfo"，它所指向的文件名为 "/gnu/work/intro/introduction.texinfo"。

（表达式中的括号告诉 Lisp 解释器将 buffer-name 和 buffer-file-name 视为函数；如果不带括号，解释器会尝试将这些符号作为变量求值。See 变量。）

尽管文件和缓冲区有区别，但你常会发现人们用“文件”指代“缓冲区”，反之亦然。事实上，大多数人会说“我正在编辑一个文件”，而不是“我正在编辑一个很快会保存到文件中的缓冲区”。在上下文清晰的情况下，这种说法通常不会造成歧义。但在处理计算机程序时，必须牢记这种区别，因为计算机不像人类那样聪明。

顺便一提，“缓冲区(buffer)”一词源自其“缓冲碰撞冲击力的垫子”这一含义。在早期计算机中，缓冲区起到了缓冲文件与中央处理器之间交互的作用。存储文件的鼓形存储器或磁带与中央处理器是两种差异很大的设备，各自以不同的速度间歇工作。缓冲区的存在使它们能够高效地协同工作。最终，缓冲区从一个中介、临时存放地，演变为了实际进行工作的场所。这种转变就像一个小型海港发展成大城市：起初，它只是货物在装船前临时仓储的地方；后来，它自身成为了商业和文化中心。

并非所有缓冲区都与文件关联。例如，*scratch* 缓冲区不访问任何文件。同样，*Help* 缓冲区也不与任何文件关联。

过去，当你没有 ~/.emacs 文件，仅输入命令 emacs 而不指定任何文件启动 Emacs 时，Emacs 会以可见的 *scratch* 缓冲区启动。如今，你会看到一个启动画面。你可以按照启动画面上的建议操作、访问一个文件，或按 q 退出启动画面，进入 *scratch* 缓冲区。

如果你切换到 *scratch* 缓冲区，输入 (buffer-name)，将光标放在后面并输入 C-x C-e 求值，会返回名称 "*scratch*"，显示在回显区。"*scratch*" 是缓冲区的名称。在 *scratch* 缓冲区中输入 (buffer-file-name) 并求值，回显区会显示 nil，与在 Info 中求值 (buffer-file-name) 的结果相同。

顺便一提，如果你在 *scratch* 缓冲区中，希望表达式的返回值显示在 *scratch* 缓冲区本身而非回显区，可以输入 C-u C-x C-e 代替 C-x C-e。这样返回值会显示在表达式后面。缓冲区会如下所示：

(buffer-name)"*scratch*"

你无法在 Info 中这样做，因为 Info 是只读的，不允许修改缓冲区内容。但你可以在任何可编辑的缓冲区中使用此功能；在编写代码或文档（如本书）时，这个特性非常实用。

Next: 切换缓冲区, Previous: 缓冲区名称, Up: 练习求值   [Contents][Index]

2.2 获取缓冲区 ¶

buffer-name 函数返回缓冲区的名称；要获取缓冲区本身，则需要另一个函数：current-buffer。在代码中使用此函数时，得到的是缓冲区本身。

名称与名称所指代的对象/实体是不同的。你不是你的名字，而是别人用名字称呼的一个人。如果你要求和 George 说话，有人递给你一张写着字母 ‘G’、‘e’、‘o’、‘r’、‘g’、‘e’ 的卡片，你可能会觉得有趣，但不会满意。你想交谈的不是这个名字，而是这个名字所指的人。缓冲区也是如此：临时缓冲区的名称是 *scratch*，但名称本身不是缓冲区。要获取缓冲区本身，需要使用 current-buffer 这样的函数。

不过，这里有个细微的复杂之处：如果像我们在这里所做的那样，在表达式中单独对 current-buffer 求值，你看到的是缓冲区名称的打印形式，而非缓冲区的内容。Emacs 这样做有两个原因：缓冲区可能有数千行 — 太长而不便显示；并且，另一个缓冲区可能内容相同但名称不同，区分它们很重要。

这是一个包含该函数的表达式：

(current-buffer)

在 Emacs 的 Info 中按常规方式对此表达式求值，回显区会显示 #<buffer *info*>。这种特殊格式表明返回的是缓冲区本身，而不仅仅是其名称。

顺便一提，虽然你可以在程序中输入数字或符号，但不能输入缓冲区的打印形式——获取缓冲区本身的唯一方法是使用 current-buffer 等函数。

相关的函数是 other-buffer。它返回除当前缓冲区之外最近选择的缓冲区，而不是其名称的打印形式。如果你最近在 *scratch* 缓冲区和其他缓冲区之间来回切换，other-buffer 会返回该缓冲区。

对以下表达式求值即可看到效果：

You can see this by evaluating the expression:

(other-buffer)

你应该会在回显区看到 #<buffer *scratch*>，或者你最近从其切换回来的其他缓冲区的名称。⁶

Next: 缓冲区大小与光标位置, Previous: 获取缓冲区, Up: 练习求值   [Contents][Index]

2.3 切换缓冲区 ¶

other-buffer 函数在作为需要缓冲区参数的函数的参数使用时，实际上会提供一个缓冲区。我们可以通过将 other-buffer 和 switch-to-buffer 配合使用来切换到不同缓冲区，以此观察其作用。

不过，先简要介绍一下 switch-to-buffer 函数。你之前在 Info 和 *scratch* 缓冲区之间来回切换以求值 (buffer-name) 时，很可能是在迷你缓冲区提示输入要切换的缓冲区名称时，输入了 C-x b，然后输入 *scratch*。⁷ 按键 C-x b 会让 Lisp 解释器对交互式函数 switch-to-buffer 求值。如前所述，Emacs 就是这样工作的：不同的按键会调用或运行不同的函数。例如，C-f 调用 forward-char，M-e 调用 forward-sentence，等等。

通过在表达式中编写 switch-to-buffer 并为其提供要切换到的缓冲区，我们可以像使用 C-x b 那样切换缓冲区：

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

符号 switch-to-buffer 是列表的第一个元素，因此 Lisp 解释器会将其视为函数并执行它所绑定的指令。但在执行之前，解释器会注意到 other-buffer 位于括号内，因此先处理该符号。other-buffer 是这个列表的第一个（在本例中也是唯一的）元素，所以 Lisp 解释器会调用或运行该函数，返回另一个缓冲区。接着，解释器运行 switch-to-buffer，将另一个缓冲区作为参数传递给它，这就是 Emacs 将要切换到的目标。如果你正在 Info 中阅读本文，现在可以试试这个。求值该表达式。（要返回，输入 C-x b RET。）⁸

在本文档后续章节的编程示例中，你会看到函数 set-buffer 比 switch-to-buffer 更常用。这是因为计算机程序和人类之间存在一个差异：人类有眼睛，希望在计算机终端上看到正在处理的缓冲区。这是显而易见的。然而，程序没有眼睛。当计算机程序处理一个缓冲区时，该缓冲区不需要在屏幕上可见。

switch-to-buffer 是为人类设计的，它做两件不同的事：切换 Emacs 关注的缓冲区；并将窗口中显示的缓冲区切换为新缓冲区。另一方面，set-buffer 只做一件事：切换计算机程序关注的缓冲区。屏幕上的缓冲区保持不变（当然，通常在命令运行完成之前，屏幕上不会有任何变化）。

此外，我们刚刚介绍了另一个专业术语：调用(call)。当你对一个列表求值，且该列表的第一个符号是函数时，你就是在调用这个函数。该术语源自“函数是一个可被调用的实体，能为你完成某些任务”的概念 — 就像水管工是一个可被你呼叫来修理漏水的实体。

Next: 练习, Previous: 切换缓冲区, Up: 练习求值   [Contents][Index]

2.4 缓冲区大小与光标位置 ¶

最后，我们来看几个相当简单的函数：buffer-size、point、point-min 和 point-max。它们提供有关缓冲区大小和光标（点）在缓冲区中位置的信息。

函数 buffer-size 会告诉你当前缓冲区的大小；也就是说，该函数返回缓冲区中字符的总数。

(buffer-size)

你可以按常规方式对此求值：将光标放在表达式后面，输入 C-x C-e。

在 Emacs 中，光标的当前位置被称为 点（point）。表达式 (point) 返回一个数字，该数字表示光标相对于缓冲区开头的位置，即从缓冲区开头到点的字符计数。

按常规方式对以下表达式求值，即可查看当前缓冲区中点的字符计数值：

(point)

在我编写本文时，点的值是 65724。point 函数在本书后面的一些示例中经常会用到。

当然，点的值取决于其在缓冲区中的位置。如果你在这个位置求值点，数字会更大：

(point)

对我来说，这个位置的点值是 66043，这意味着两个表达式之间有 319 个字符（包括空格）。（毫无疑问，你看到的数字会不同，因为我在首次求值点之后肯定已经编辑过本文。）

函数 point-min 与 point 有些相似，但它返回当前缓冲区中允许的点的最小值。除非启用了限制（narrowing），否则该值为 1。（限制是一种机制，允许你或程序将操作限制在缓冲区的某一部分。See 限制与扩展。）同样，函数 point-max 返回当前缓冲区中允许的点的最大值。

Previous: 缓冲区大小与光标位置, Up: 练习求值   [Contents][Index]

2.5 练习 ¶

找到一个你正在处理的文件，将光标移到其中间位置。查找其缓冲区名称、文件名、文件长度，以及你在文件中的位置。

Next: 安装函数定义, Previous: 关于原生函数的补充说明, Up: 如何编写函数定义   [Contents][Index]

3.1 defun 宏 ¶

在 Lisp 中，像 mark-whole-buffer 这样的符号会绑定一段代码，用于告诉计算机在调用该函数时执行什么操作。这段代码被称为函数定义(function definition)，通过对以符号 defun（是 define function 的缩写）开头的 Lisp 表达式求值来创建。

在后续小节中，我们会查看 Emacs 源码里的函数定义，例如 mark-whole-buffer。本节先介绍一个简单的函数定义，让你了解其基本结构。这个例子使用算术运算，因为它足够简洁。有些人不喜欢算术示例，不过不必担心，本入门教程后续几乎不会再涉及算术或数学相关代码，示例大多围绕文本操作展开。

在关键字 defun 之后，一个函数定义最多包含五个部分：

1. 要绑定函数定义的符号名称。
2. 传递给函数的参数列表。如果函数不需要参数，该列表为空列表 ()。
3. 描述函数的文档字符串。（技术上可选，但强烈建议编写。）
4. 可选的交互式声明表达式，让函数可以通过 M-x 加函数名调用，或绑定到快捷键/组合键使用。
5. 指示计算机执行操作的代码，即函数定义的函数体。

可以把函数定义的这五部分看作一个模板，每个部分对应一个位置：

(defun function-name (arguments...)
  "optional-documentation..."
  (interactive argument-passing-info)     ; optional
  body...)

下面举一个将参数乘以 7 的函数代码为例。（该示例非交互式，see 让函数支持交互。）

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

该定义以左括号和符号 defun 开头，后跟函数名。

函数名后面是包含函数参数的列表，称为参数列表(argument list)。本例中列表只有一个元素，即符号 number。调用函数时，该符号会绑定到传入的参数值。

参数名不一定非要用 number，也可以选其他名称，比如 multiplicand（被乘数）。用 “number” 是因为它直观地表明参数类型；用 “multiplicand” 则更能体现其在函数中的作用。当然也可以随便起一个无意义的名字如 foogle，但这会降低可读性。参数名由程序员决定，原则是清晰易懂。

实际上，参数列表中的符号可以任意命名，即使与其他函数中的符号重名也没关系——参数名只在当前函数定义内有效，属于局部名称。这就像你在家里昵称 “矮个子”，家人说这个名字指的是你，但在电影里同名角色指的就是另一个人。由于参数名是函数私有的，在函数体内修改它不会影响函数外部的同名符号，效果与 let 表达式类似。（See let。）

参数列表之后是描述函数的文档字符串。使用 C-h f 加函数名查看帮助时，显示的就是这段内容。顺便提醒，文档字符串的第一行最好写成完整句子，因为 apropos 等命令只会显示多行文档的第一行。此外，如果文档字符串有多行，第二行不要缩进，否则在 C-h f（describe-function）中显示会很奇怪。文档字符串虽然可选，但非常有用，几乎所有函数都应该加上。

示例的第三行是函数体。（当然，大多数函数的定义会比这更长。）该函数的函数体是列表 (* 7 number)，含义是将 number 的值乘以 7。（在 Emacs Lisp 中，* 是乘法函数，+ 是加法函数。）

使用 multiply-by-seven 时，参数 number 会被求值为实际传入的数字。下面是调用示例，但暂时不要尝试求值：

(multiply-by-seven 3)

函数定义中声明的符号 number，在实际调用时会绑定到值 3。注意，虽然 number 在函数定义中写在括号里，但调用 multiply-by-seven 时传入的参数并不需要括号。函数定义中的括号只是为了让计算机区分参数列表的结束位置和函数体的开始位置。

如果现在直接求值这个调用表达式，大概率会报错。（不妨试试！）原因是我们只写了函数定义，还没有把定义“告知”计算机——也就是还没有在 Emacs 中加载这个函数。安装函数的过程就是让 Lisp 解释器获知函数定义，下一节会详细说明。

Next: 让函数支持交互, Previous: defun 宏, Up: 如何编写函数定义   [Contents][Index]

3.2 安装函数定义 ¶

如果你正在 Emacs 的 Info 中阅读本文，可以先对函数定义求值，再对 (multiply-by-seven 3) 求值，以此测试 multiply-by-seven 函数。下面是函数定义，将光标放在最后一个括号后并输入 C-x C-e。执行后，回显区会出现 multiply-by-seven。（这表示：对函数定义求值时，返回值就是被定义函数的名称。）同时，该操作会完成函数定义的安装。

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

通过对这个 defun 求值，你已经在 Emacs 中安装了 multiply-by-seven。现在它和 forward-word 或其他编辑函数一样，成为 Emacs 的一部分。（multiply-by-seven 会一直有效直到退出 Emacs。如果希望每次启动 Emacs 都自动加载代码，见 永久安装代码。）

• 安装的效果
• 修改函数定义

(multiply-by-seven 3)

multiply-by-seven 是一个 Lisp 函数。

(multiply-by-seven NUMBER)

将 NUMBER 乘以 7。

(defun multiply-by-seven (number)       ; Second version.
  "Multiply NUMBER by seven."
  (+ number number number number number number number))

Next: interactive 的不同选项, Previous: 安装函数定义, Up: 如何编写函数定义   [Contents][Index]

3.3 让函数支持交互 ¶

要让函数支持交互，只需在文档字符串后紧跟一个以特殊形式 interactive 开头的列表。用户可以通过 M-x 加函数名调用交互式函数，也可以用绑定的快捷键，例如 C-n 对应 next-line，C-x h 对应 mark-whole-buffer。

有趣的是，以交互方式调用交互式函数时，返回值不会自动显示在回显区。因为我们通常使用交互式函数是为了其副作用，比如向前移动一个词或一行，而不是为了返回值。如果每次按键都在回显区显示返回值，会非常干扰操作。

• 交互式版本 multiply-by-seven 概述
• 交互式 multiply-by-seven 详解

(defun multiply-by-seven (number)       ; Interactive version.
  "Multiply NUMBER by seven."
  (interactive "p")
  (message "The result is %d" (* 7 number)))

(defun multiply-by-seven (number)       ; Interactive version.
  "Multiply NUMBER by seven."
  (interactive "p")
  (message "The result is %d" (* 7 number)))

(message "The result is %d" (* 7 number))

(message "The result is %d" (* 7 5))

Next: 永久安装代码, Previous: 让函数支持交互, Up: 如何编写函数定义   [Contents][Index]

3.4 interactive 的不同选项 ¶

在示例中，multiply-by-seven 使用 "p" 作为 interactive 的参数。该参数告知 Emacs 将你输入的 C-u 后接数字，或是 META 后接数字，解析为将该数字 作为参数传递给函数的指令。Emacs 内置了二十多个可用于 interactive 的字符。几乎在所有场景下，这些选项中的某一个 都能让你以交互方式向函数传递正确的信息。(See Code Characters for interactive in The GNU Emacs Lisp Reference Manual.)

以函数 zap-to-char 为例。其交互表达式为

(interactive "p\ncZap to char: ")

interactive 参数的第一部分是你已经熟悉的 ‘p’。 该参数告知 Emacs 将前缀参数解析为数字并传递给函数。 你可以通过输入 C-u 后接数字，或是输入 META 后接数字 来指定前缀参数。该前缀参数代表指定字符的个数。因此，若前缀参数为 3， 指定字符为 ‘x’，则会删除从当前位置到下第三个 ‘x’（含） 之间的所有文本。若未设置前缀参数，则删除从当前位置到指定字符（含） 之间的文本，不再多删。

‘c’ 用于告知函数需要删除到哪个字符。

更规范地说，带有两个及以上参数的函数，可以通过在 interactive 后的字符串中追加片段，为每个参数传递信息。这样做时，信息会按照 interactive 列表中的顺序依次传递给各个参数。在字符串中， 每个片段使用 ‘\n’（换行符）分隔。例如，你可以在 ‘p’ 后接 ‘\n’ 和 ‘cZap to char: ’。这会让 Emacs 传递前缀参数 （若存在）和指定字符。

在这种情况下，函数定义形如下面的示例，其中 arg 和 char 是 interactive 用于绑定前缀参数和指定字符的符号：

(defun name-of-function (arg char)
  "documentation..."
  (interactive "p\ncZap to char: ")
  body-of-function...)

（提示符中冒号后的空格会让提示显示更美观。 See The Definition of copy-to-buffer，可查看示例。）

当函数不需要参数时，interactive 也无需参数。 这类函数只需要简单的表达式 (interactive)。 mark-whole-buffer 就是这样的函数。

另外，如果专用字符码不适合你的使用场景，你也可以以列表形式 为 interactive 传递自定义参数。

See The Definition of append-to-buffer, 可查看示例。See Using Interactive in The GNU Emacs Lisp Reference Manual，可获取该用法的更完整说明。

Next: let, Previous: interactive 的不同选项, Up: 如何编写函数定义   [Contents][Index]

3.5 永久安装代码 ¶

通过求值来安装函数定义后，该函数会一直生效，直到退出 Emacs。 下次启动新的 Emacs 会话时，该函数不会自动加载，除非你再次对其定义求值。

在某些时候，你可能希望每次启动 Emacs 时都自动加载代码。 有几种实现方式：

• 如果代码仅供个人使用，可以将函数定义的代码放入 .emacs 初始化文件。 启动 Emacs 时，.emacs 文件会被自动求值，其中的所有函数定义都会被加载。 See Your .emacs File.
• 或者，你也可以将需要加载的函数定义单独放在一个或多个文件中， 使用 load 函数让 Emacs 求值并加载文件中的各个函数。 See Loading Files.
• 第三，如果代码供整个站点的用户使用，通常会将其放入名为 site-init.el 的文件，该文件会在 Emacs 构建时加载。 这样所有使用该机器的用户都能使用这段代码。（详见 Emacs 发行版中 附带的 INSTALL 文件。）

最后，如果你的代码可能对所有 Emacs 用户都有用， 可以将其发布到计算机网络，或是发送一份副本给自由软件基金会。 （这样做时，请为代码及其文档选择合适的许可协议，允许他人运行、复制、 学习、修改和重新分发代码，同时保护你的著作权不被侵占。） 如果你将代码发送给自由软件基金会，且做好了自身与他人的权益保护， 该代码可能会被加入下一版 Emacs。很大程度上，Emacs 正是依靠社区贡献 在过去多年中不断发展壮大。

Next: if 特殊形式, Previous: 永久安装代码, Up: 如何编写函数定义   [Contents][Index]

3.6 let ¶

let 表达式是 Lisp 中的一种特殊形式， 在绝大多数函数定义中都会用到。

let 用于将符号与值关联（绑定）， 从而避免 Lisp 解释器将该变量与函数外部同名变量混淆。

要理解 let 特殊形式的必要性，可以设想这样一个场景： 你有一套房子，平时称之为 “家”，比如句子“该给家刷漆了”。 当你拜访朋友时，主人提到“家”，他指的很可能是 他的 房子， 而不是你的，也就是另一处住所。

如果朋友指的是他的房子，而你以为是你的，就会产生混淆。 在 Lisp 中也会出现类似情况：一个函数内部使用的变量与另一个函数 内部的变量同名，而二者本意并不指向同一个值。 let 特殊形式可以避免这类混淆。

• let 避免命名冲突
• let 表达式的组成部分
• let 表达式示例
• let 语句中的未初始化变量
• let 绑定变量的方式

(let varlist body...)

(let ((variable value)
      (variable value)
      ...)
  body...)

(let ((zebra "stripes")
      (tiger "fierce"))
  (message "One kind of animal has %s and another is %s."
           zebra tiger))

"One kind of animal has stripes and another is fierce."

(let ((birch 3)
      pine
      fir
      (oak 'some))
  (message
   "Here are %d variables with %s, %s, and %s value."
   birch pine fir oak))

"Here are 3 variables with nil, nil, and some value."

;;; -*- lexical-binding: t -*-

;;; -*- lexical-binding: t -*-

(setq x 0)

(defun getx ()
  x)

(setq x 1)

(let ((x 2))
  (getx))
     ⇒ 1

;;; -*- lexical-binding: nil -*-

(setq x 0)

(defun getx ()
  x)

(setq x 1)

(let ((x 2))
  (getx))
     ⇒ 2

Next: If–then–else 表达式, Previous: let, Up: 如何编写函数定义   [Contents][Index]

3.7 if 特殊形式 ¶

另一种特殊形式是条件表达式 if。 该形式用于指示计算机进行逻辑判断。 编写函数定义时可以不使用 if， 但它使用频率高、重要性强，因此在此讲解。 例如，beginning-of-buffer 函数的代码中就用到了它。

if 的核心逻辑是：如果(if) 条件测试为真， 则(then) 对表达式求值。若测试不成立，则不执行该表达式。 比如你可以做出这样的判断：“如果天气温暖晴朗，就去海边！”

• if 详解
• type-of-animal 函数详解

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

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

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

(type-of-animal "fierce")

(type-of-animal "striped")

(defun name-of-function (argument-list)
  "documentation..."
  body...)

(defun type-of-animal (characteristic)
  "Print message in echo area depending on CHARACTERISTIC.
If the CHARACTERISTIC is the string \"fierce\",
then warn of a tiger."
  body: the if expression)

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

(if (equal characteristic "fierce")
    (message "It is a tiger!"))

(equal characteristic "fierce")

Next: Emacs Lisp 中的真与假, Previous: if 特殊形式, Up: 如何编写函数定义   [Contents][Index]

3.8 If–then–else 表达式 ¶

if 表达式可以带有一个可选的第三个参数，称为 否则部分(else-part)，用于真假判断返回假的情况。 当判断为假时，整个 if 表达式的第二个参数（即那么部分） 不会 被求值，而第三个参数（否则部分） 会 被求值。 你可以把它理解为阴天版的决策：“如果天气温暖晴朗，就去海边， 否则就在家看书！”。

Lisp 代码中并不会写出单词“else”；if 表达式的否则部分 直接写在那么部分之后。在 Lisp 代码书写中，否则部分通常 单独起一行，缩进比那么部分更少：

(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 is not greater than 5!’：

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

可以看到，不同层级的缩进让那么部分和否则部分很容易区分。 （GNU Emacs 提供了多个命令，可以自动为 if 表达式正确缩进。 See GNU Emacs Helps You Type Lists。）

我们可以扩展 type-of-animal 函数， 只需在 if 表达式中增加一个部分，即可加入否则分支。

你可以对下面这个版本的 type-of-animal 函数定义求值以安装它， 然后对后续两个表达式求值，传入不同参数，就能看到效果。

(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!")))

(type-of-animal "fierce")

(type-of-animal "striped")

对 (type-of-animal "fierce") 求值时，回显区会打印： "It is a tiger!"；而对 (type-of-animal "striped") 求值时，会打印 "It is not fierce!"。

（当然，如果 characteristic 是 "ferocious"， 同样会打印 "It is not fierce!"，这就会产生误导！ 编写代码时，需要考虑到 if 可能会测试到这类参数， 并相应地设计程序。）

Next: save-excursion, Previous: If–then–else 表达式, Up: 如何编写函数定义   [Contents][Index]

3.9 Emacs Lisp 中的真与假 ¶

if 表达式中的真假判断有一个重要特点。 到目前为止，我们把谓词返回的 “真(true)” 和 “假(false)” 当作一种新的 Emacs Lisp 对象。 实际上， “假(false)”就是我们熟悉的 nil。除此之外的任何值—— 任何东西 — 都是 “真(true)”。

一个用于判断真假的表达式，只要求值结果不是 nil， 就会被解释为真(true)。换句话说，只要测试返回的值是数字（如 47）、 字符串（如 "hello"）、符号（nil 除外，如 flowers）、 列表（只要非空），甚至是一个缓冲区，都会被视为真。

• nil 说明

(if 4
    'true
  'false)

(if nil
    'true
  'false)

(> 5 4)

(> 4 5)

Next: Review, Previous: Emacs Lisp 中的真与假, Up: 如何编写函数定义   [Contents][Index]

3.10 save-excursion ¶

save-excursion 是本章要讲解的最后一个特殊形式。

在用于编辑的 Emacs Lisp 程序中，save-excursion 非常常用。 它会保存光标位置，执行函数体，然后在位置发生改变时将光标恢复到原先位置。 它的主要作用是避免用户因光标意外移动而感到困惑和不适。

• 光标与标记
• save-excursion 表达式模板

(save-excursion
  body...)

(save-excursion
  first-expression-in-body
  second-expression-in-body
  third-expression-in-body
   ...
  last-expression-in-body)

(let varlist
  (save-excursion
    body...))

Next: 练习, Previous: save-excursion, Up: 如何编写函数定义   [Contents][Index]

3.11 Review ¶

在前面几章中，我们介绍了一个宏、相当多的函数和特殊形式。 这里对它们做简要说明，并补充几个尚未提到的同类函数。

eval-last-sexp

对光标当前位置前的最后一个符号表达式求值。 除非该函数带参数调用，否则值会打印在回显区； 带参数时输出会打印在当前缓冲区。该命令通常绑定到 C-x C-e。

defun

定义函数。该宏最多包含五部分：函数名、 传递给函数的参数模板、文档字符串、可选的交互式声明，以及定义体。

例如，Emacs 中 dired-unmark-all-marks 的函数定义如下。

(defun dired-unmark-all-marks ()
  "Remove all marks from all files in the Dired buffer."
  (interactive)
  (dired-unmark-all-files ?\r))

interactive

向解释器声明该函数可交互式使用。 该特殊形式后可接一个包含一个或多个片段的字符串， 按顺序向函数参数传递信息。这些片段也可以告知解释器提示用户输入信息。 字符串中的片段使用换行符 ‘\n’ 分隔。

常用代码字符如下：

b

现有缓冲区的名称。

f

现有文件的名称。

p

数字前缀参数。（注意这里的 p 是小写。）

r

光标和标记，以两个数字参数形式返回，较小值在前。 这是唯一一个指定连续两个参数而非一个参数的代码字母。

See Code Characters for ‘interactive’ in The GNU Emacs Lisp Reference Manual，可查看完整代码字符列表。

let

声明一组变量在 let 体内使用， 并为其赋予初始值（nil 或指定值）； 然后对 let 体内其余表达式求值，并返回最后一个表达式的值。 在 let 内部，Lisp 解释器不会访问 let 外部 同名变量的绑定值。

例如：

(let ((foo (buffer-name))
      (bar (buffer-size)))
  (message
   "This buffer is %s and has %d characters."
   foo bar))

save-excursion

在对该特殊形式的体求值前，记录光标和当前缓冲区的值， 之后恢复光标与缓冲区。

例如：

(message "We are %d characters into this buffer."
         (- (point)
            (save-excursion
              (goto-char (point-min)) (point))))

if

对函数的第一个参数求值；若为真则对第二个参数求值； 否则对第三个参数求值（如果存在）。

if 特殊形式被称为条件表达式(conditional)。 Emacs Lisp 中还有其他条件表达式，但 if 可能是最常用的。

例如：

(if (= 22 emacs-major-version)
    (message "This is version 22 Emacs")
  (message "This is not version 22 Emacs"))

<

>

<=

>=

< 函数判断第一个参数是否小于第二个参数。 对应的 > 判断第一个参数是否大于第二个。 同理，<= 判断是否小于等于，>= 判断是否大于等于。 在所有情况下，两个参数都必须是数字或标记（marker，标记表示缓冲区中的位置）。

=

= 函数判断两个同为数字或标记的参数是否相等。

equal

eq

判断两个对象是否相同。equal 和 eq 对“相同(same)”的定义不同：equal 在两个对象结构与内容相似时返回真， 如同同一本书的两个副本。而 eq 只有在两个参数 确实是同一个对象时才返回真。

string<

string-lessp

string=

string-equal

string-lessp 函数判断第一个参数字符串是否小于第二个。 该函数的简短别名（通过 defalias 定义）是 string<。

string-lessp 的参数必须是字符串或符号； 比较按字典序进行，区分大小写。使用符号的打印名而非符号本身进行比较。

空字符串 ‘""’（不含任何字符）小于任何非空字符串。

string-equal 用于对应的相等判断，其简短别名为 string=。 没有对应于 >、>= 或 <= 的字符串测试函数。

message

在回显区打印消息。第一个参数是字符串， 可包含 ‘%s’、‘%d’ 或 ‘%c’， 用于打印字符串后续参数的值。‘%s’ 对应的参数必须是字符串或符号； ‘%d’ 对应的参数必须是数字。‘%c’ 对应的参数必须是 ASCII 码数字， 会被打印为对应 ASCII 码的字符。（其他若干 % 格式序列未在此提及。）

setq

set

setq 特殊形式将第一个参数的值设为第二个参数的值。 第一个参数由 setq 自动引用。 它也可以对后续多对参数执行同样操作。

buffer-name

无参数时，以字符串形式返回当前缓冲区名称。

buffer-file-name

无参数时，返回当前缓冲区访问的文件名称。

current-buffer

返回 Emacs 当前活动的缓冲区；它不一定是屏幕上可见的缓冲区。

other-buffer

返回最近一次选中的缓冲区（排除作为参数传入的缓冲区和当前缓冲区）。

switch-to-buffer

选中一个缓冲区作为 Emacs 活动缓冲区，并在当前窗口显示，供用户查看。 通常绑定到 C-x b。

set-buffer

将 Emacs 的操作目标切换到指定缓冲区，但不改变窗口显示内容。

buffer-size

返回当前缓冲区中的字符总数。

point

以整数形式返回光标当前位置，从缓冲区开头算起计数字符。

point-min

返回当前缓冲区中光标的最小合法值。 若未启用缩进限制（narrowing），该值为 1。

point-max

返回当前缓冲区中光标的最大合法值。 若未启用缩进限制，该值为缓冲区末尾。

Previous: Review, Up: 如何编写函数定义   [Contents][Index]

3.12 练习 ¶

• 编写一个非交互式函数，使其将参数（一个数字）的值加倍。再将该函数改为可交互式调用。
• 编写一个函数，判断 fill-column 的当前值是否大于传递给该函数的参数，如果是，则输出一条合适的提示信息。

Next: 简化版 beginning-of-buffer 定义, Up: 几个与缓冲区相关的函数   [Contents][Index]

4.1 查找更多信息 ¶

在本次逐步解析中，遇到新函数时我会逐一讲解，有时详细，有时简略。如果你感兴趣，可以随时按下 C-h f 并输入函数名（再按 RET），查看任意 Emacs Lisp 函数的完整文档。同理，按下 C-h v 并输入变量名（再按 RET），即可查看变量的完整文档。

此外，describe-function 还会告知你函数定义所在的位置。

将光标移至包含该函数的文件名上并按下 RET。此处 RET 表示 push-button，而非 “return” 或 “enter”。Emacs 会直接跳转到该函数的定义处。

更一般地，如果你想在原始源文件中查看某个函数，可以使用 xref-find-definitions 函数进行跳转。xref-find-definitions 支持多种语言，不仅限于 Lisp 和 C，同时也适用于非程序文本。例如，xref-find-definitions 可以跳转到本文档 Texinfo 源文件中的各个节点（前提是你已运行 etags 工具，记录 Emacs 附带手册中的所有节点；see Create Tags Table in The GNU Emacs Manual）。

使用 xref-find-definitions 命令时，按下 M-.（即按住 META 键同时按句点键，或先按 ESC 再按句点键），然后在提示符下输入想要查看源代码的函数名，例如 mark-whole-buffer，再按 RET。（若该命令未出现提示符，可带参数调用：C-u M-.；see interactive 的不同选项。）Emacs 会切换缓冲区并在屏幕上显示该函数的源代码¹²。若要切回当前缓冲区，按下 M-, 或 C-x b RET。（部分键盘上 META 键标注为 ALT。）

顺便一提，包含 Lisp 代码的文件通常称为 库(libraries)。这一比喻源自专业类图书馆（如法律图书馆、工程图书馆），而非综合图书馆。每个库（即文件）都包含与特定主题或功能相关的函数，例如 abbrev.el 用于处理缩写及其他输入快捷方式，help.el 用于提供帮助功能。（有时多个库会为同一功能提供代码，例如多个 rmail… 文件共同实现电子邮件阅读功能。）在 The GNU Emacs Manual 中，你会看到类似“C-h p 命令允许按主题关键词搜索标准 Emacs Lisp 库”的语句。

Next: mark-whole-buffer 的定义, Previous: 查找更多信息, Up: 几个与缓冲区相关的函数   [Contents][Index]

4.2 简化版 beginning-of-buffer 定义 ¶

beginning-of-buffer 命令是一个很好的入门函数，因为你很可能已经熟悉它，且易于理解。作为交互式命令，beginning-of-buffer 会将光标移至缓冲区开头，并在原位置留下标记。该命令通常绑定到 M-<。

本节我们会讨论该函数的简化版本，展示其最常用的工作方式。该简化版本代码可正常运行，但不包含复杂选项的相关逻辑。后续章节我们会介绍完整的函数定义。(See Complete Definition of beginning-of-buffer.)

在查看代码之前，先思考函数定义需要包含哪些内容：必须包含使函数可交互的表达式，以便通过 M-x beginning-of-buffer 或 M-< 这类组合键调用；必须包含在缓冲区原位置留下标记的代码；还必须包含将光标移至缓冲区开头的代码。

以下是该简化版函数的完整代码：

(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)))

与所有函数定义一样，该定义在宏 defun 之后包含五个部分：

1. 函数名：本例中为 simplified-beginning-of-buffer。
2. 参数列表：本例中为空列表 ()。
3. 文档字符串。
4. 交互式表达式。
5. 函数体。

该函数定义的参数列表为空，意味着此函数不需要任何参数。（后续查看完整函数定义时，你会发现它可接收一个可选参数。）

交互式表达式告知 Emacs 该函数可交互式使用。本例中 interactive 没有参数，因为 simplified-beginning-of-buffer 不需要参数。

函数体由两行代码组成：

(push-mark)
(goto-char (point-min))

第一行是表达式 (push-mark)。当 Lisp 解释器执行该表达式时，会在光标当前位置设置一个标记。该标记的位置会保存在标记环中。

下一行是 (goto-char (point-min))。该表达式将光标跳转到缓冲区的最小光标位置，即缓冲区开头（若缓冲区已缩窄，则跳转到可访问区域的开头。See Narrowing and Widening。）

push-mark 命令会在 (goto-char (point-min)) 将光标移至缓冲区开头之前，在光标原位置设置标记。因此，你可以按需按下 C-x C-x 回到原先位置。

这就是该函数定义的全部内容！

阅读此类代码时，若遇到不熟悉的函数（如 goto-char），可使用 describe-function 命令查看其功能。使用该命令时，按下 C-h f 并输入函数名，再按 RET。describe-function 会在 *Help* 窗口中显示函数的文档字符串。例如，goto-char 的文档如下：

Set point to POSITION, a number or marker.
Beginning of buffer is position (point-min), end is (point-max).

该函数的唯一参数为目标位置。

（describe-function 的提示符会自动补全光标下方或前方的符号，你可以将光标移至函数上方或后方，直接按下 C-h f RET 以减少输入。）

end-of-buffer 函数定义与 beginning-of-buffer 写法基本一致，区别仅在于函数体中使用 (goto-char (point-max)) 替代了 (goto-char (point-min))。

Next: append-to-buffer 的定义, Previous: 简化版 beginning-of-buffer 定义, Up: 几个与缓冲区相关的函数   [Contents][Index]

4.3 mark-whole-buffer 的定义 ¶

mark-whole-buffer 函数的理解难度并不高于 simplified-beginning-of-buffer。不过本节我们会直接查看完整函数，而非简化版本。

mark-whole-buffer 函数的使用频率不如 beginning-of-buffer，但依然很实用：它会将光标置于缓冲区开头、标记置于结尾，从而将整个缓冲区选为区域。该命令通常绑定到 C-x h。

• mark-whole-buffer 概述
• mark-whole-buffer 的函数体

(defun mark-whole-buffer ()
  "将光标置于缓冲区开头，标记置于结尾。
你通常不应在 Lisp 程序中使用此函数；
Lisp 函数调用任何使用或设置标记的子程序，
一般都是不合适的。"
  (interactive)
  (push-mark (point))
  (push-mark (point-max) nil t)
  (goto-char (point-min)))

(defun name-of-function (argument-list)
  "documentation..."
  (interactive-expression...)
  body...)

(push-mark (point))
(push-mark (point-max) nil t)
(goto-char (point-min))

(push-mark (point-max) nil t)

Next: 内容回顾, Previous: mark-whole-buffer 的定义, Up: 几个与缓冲区相关的函数   [Contents][Index]

4.4 append-to-buffer 的定义 ¶

append-to-buffer 命令比 mark-whole-buffer 更为复杂。它的功能是将当前缓冲区中的区域（即光标与标记之间的文本）复制到指定缓冲区。

• append-to-buffer 概述
• append-to-buffer 的交互式表达式
• append-to-buffer 的函数体
• append-to-buffer 中的 save-excursion

(defun append-to-buffer (buffer start end)
  "将区域中的文本追加到指定缓冲区。
文本会插入到该缓冲区的光标之前。

从程序中调用时需传入三个参数：
BUFFER（或缓冲区名）、START 与 END。
START 与 END 指定当前缓冲区中要复制的部分。"
  (interactive
   (list (read-buffer "Append to buffer: " (other-buffer
                                            (current-buffer) t))
         (region-beginning) (region-end)))

  (let ((oldbuf (current-buffer)))
    (save-excursion
      (let* ((append-to (get-buffer-create buffer))
             (windows (get-buffer-window-list append-to t t))
             point)
        (set-buffer append-to)
        (setq point (point))
        (barf-if-buffer-read-only)
        (insert-buffer-substring oldbuf start end)
        (dolist (window windows)
          (when (= (window-point window) point)
            (set-window-point window (point))))))))

(defun append-to-buffer (buffer start end)
  "documentation..."
  (interactive ...)
  body...)

(interactive
 (list (read-buffer
        "Append to buffer: "
        (other-buffer (current-buffer) t))
       (region-beginning)
       (region-end)))

(other-buffer (current-buffer) t)

(interactive "BAppend to buffer: \nr")

(defun append-to-buffer (buffer start end)
  "documentation..."
  (interactive ...)
  (let ((variable value))
        body...))

(oldbuf (current-buffer))

(let ((oldbuf (current-buffer)))
  ... )

(defun ...
  ...
  ...
  (let...
    (save-excursion
      ...

(let ((oldbuf (current-buffer)))
  (save-excursion
    ...
    (set-buffer ...)
    (insert-buffer-substring oldbuf start end)
    ...))

(save-excursion
  first-expression-in-body
  second-expression-in-body
   ...
  last-expression-in-body)

(let* ((append-to (get-buffer-create buffer))
       (windows (get-buffer-window-list append-to t t))
       point)
  BODY...)

(set-buffer (get-buffer-create buffer))

(set-buffer append-to)

(insert-buffer-substring oldbuf start end)

(let (bind-oldbuf-to-value-of-current-buffer)
  (save-excursion                       ; Keep track of buffer.
    change-buffer
    insert-substring-from-oldbuf-into-buffer)

  change-back-to-original-buffer-when-finished
let-the-local-meaning-of-oldbuf-disappear-when-finished

Next: 练习, Previous: append-to-buffer 的定义, Up: 几个与缓冲区相关的函数   [Contents][Index]

4.5 内容回顾 ¶

以下是本章讨论的各类函数的简要总结。

describe-function

describe-variable

打印函数或变量的文档。常规绑定到 C-h f 与 C-h v。

xref-find-definitions

查找包含函数或变量源代码的文件并切换缓冲区，将光标定位到条目开头。常规绑定到 M-.（即 META 键加句点）。

save-excursion

保存光标位置，并在其参数表达式执行完毕后恢复；同时记录并返回原始缓冲区。

push-mark

在指定位置设置标记，并将上一个标记记录到标记环中。标记是缓冲区中的一个位置，即使缓冲区文本被增删，其相对位置也会保持不变。

goto-char

将光标设置为参数指定的位置，参数可以是数字、标记，或返回位置编号的表达式（如 (point-min)）。

insert-buffer-substring

从作为参数传入的缓冲区复制一段区域文本，并插入到当前缓冲区。

mark-whole-buffer

将整个缓冲区选为区域。通常绑定到 C-x h。

let*

声明变量列表并赋予初始值，随后执行 let* 函数体内的其余表达式。变量的值可用于设置列表中后续的变量。

set-buffer

将 Emacs 的操作目标切换到另一个缓冲区，但不改变显示窗口。用于程序而非用户操作其他缓冲区的场景。

get-buffer-create

get-buffer

查找指定名称的缓冲区，不存在则创建。get-buffer 在指定缓冲区不存在时返回 nil。

Previous: 内容回顾, Up: 几个与缓冲区相关的函数   [Contents][Index]

4.6 练习 ¶

• 编写你自己的 simplified-end-of-buffer 函数定义，并测试其是否正常工作。
• 使用 if 与 get-buffer 编写一个函数，打印信息提示某个缓冲区是否存在。
• 使用 xref-find-definitions 查找 copy-to-buffer 函数的源代码。

Next: insert-buffer 的定义, Up: 几个更复杂的函数   [Contents][Index]

5.1 copy-to-buffer 的定义 ¶

理解 append-to-buffer 之后，理解 copy-to-buffer 就很容易。该函数将文本复制到目标缓冲区，但不会追加内容，而是替换目标缓冲区中原有的全部文本。

copy-to-buffer 的函数体如下：

...
(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)))))

copy-to-buffer 的 interactive 表达式比 append-to-buffer 更简单。

定义接下来的语句是：

(with-current-buffer (get-buffer-create buffer) ...

首先看最内层的表达式，它会被优先执行。该表达式以 get-buffer-create buffer 开头，让计算机使用指定名称的缓冲区作为复制目标，不存在则创建。随后，with-current-buffer 函数会临时将该缓冲区设为当前缓冲区并执行其函数体，执行完毕后切回当前缓冲区¹³。

（这展示了另一种只切换程序操作目标、不改变用户显示窗口的方法。append-to-buffer 使用 save-excursion 与 set-buffer 实现了同样效果，而 with-current-buffer 是更新、更易用的机制。）

barf-if-buffer-read-only 函数会在缓冲区不可修改时，提示缓冲区为只读并报错。

下一行仅包含 erase-buffer 函数，该函数会清空缓冲区。

最后两行是 save-excursion 表达式，其函数体为 insert-buffer-substring。insert-buffer-substring 从你当前所在的缓冲区复制文本（你不会察觉到程序已切换缓冲区，该原始缓冲区已被记为 oldbuf）。

顺便一提，这就是 “替换(replacement)” 的含义：Emacs 先清空原有文本，再插入新文本。

框架结构上，copy-to-buffer 的函数体如下：

(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)))

Next: beginning-of-buffer 完整定义, Previous: copy-to-buffer 的定义, Up: 几个更复杂的函数   [Contents][Index]

5.2 insert-buffer 的定义 ¶

insert-buffer 是另一个与缓冲区相关的函数。该命令将另一个缓冲区的内容插入到当前缓冲区。它与 append-to-buffer 或 copy-to-buffer 作用相反，后两者是从当前缓冲区向其他缓冲区复制区域文本。

以下讨论基于早期原始代码。该代码在 2003 年被简化，反而更难理解。

（如需了解新版函数体，参见 See New Body for insert-buffer。）

此外，这段代码还展示了在可能为 只读(read-only) 的缓冲区中使用 interactive 的方式，以及对象名称与实际所指对象之间的重要区别。

• insert-buffer 的代码
• insert-buffer 中的交互式表达式
• insert-buffer 的函数体
• 用 if 替代 or 的 insert-buffer
• 函数体中的 or
• insert-buffer 中的 let 表达式
• insert-buffer 的新版函数体

(defun insert-buffer (buffer)
  "在光标后插入 BUFFER 的全部内容。
在插入文本后设置标记。
BUFFER 可以是缓冲区或缓冲区名称。"
  (interactive "*bInsert buffer: ")

  (or (bufferp buffer)
      (setq buffer (get-buffer buffer)))
  (let (start end newmark)
    (save-excursion
      (save-excursion
        (set-buffer buffer)
        (setq start (point-min) end (point-max)))

      (insert-buffer-substring buffer start end)
      (setq newmark (point)))
    (push-mark newmark)))

(defun insert-buffer (buffer)
  "documentation..."
  (interactive "*bInsert buffer: ")
  body...)

(defun insert-buffer (buffer)
  "documentation..."
  (interactive "*bInsert buffer: ")
  (or ...
      ...

  (let (varlist)
      body-of-let... )

(if (not (holding-on-to-guest))
    (find-and-take-arm-of-guest))

(if (not (bufferp buffer))              ; if-part
    (setq buffer (get-buffer buffer)))  ; then-part

(not (bufferp buffer))

(or (bufferp buffer)
    (setq buffer (get-buffer buffer)))

(or (holding-on-to-guest) (find-and-take-arm-of-guest))

(save-excursion
  (set-buffer buffer)
  (setq start (point-min) end (point-max)))

(save-excursion
  (inner-save-excursion-expression
     (go-to-new-buffer-and-set-start-and-end)
  (insert-buffer-substring buffer start end)
  (setq newmark (point)))

(let (start end newmark)
  (save-excursion
    (save-excursion
      (set-buffer buffer)
      (setq start (point-min) end (point-max)))
    (insert-buffer-substring buffer start end)
    (setq newmark (point)))
  (push-mark newmark))

  (push-mark
   (save-excursion
     (insert-buffer-substring (get-buffer buffer))
     (point)))

   nil

Next: 本章小结, Previous: insert-buffer 的定义, Up: 几个更复杂的函数   [Contents][Index]

5.3 beginning-of-buffer 完整定义 ¶

beginning-of-buffer 函数的基本结构已经介绍过。（参见 See A Simplified beginning-of-buffer Definition。）本节讲解其定义中较复杂的部分。

如前所述，不带参数调用时，beginning-of-buffer 会将光标移到缓冲区开头（准确说是可访问部分的开头），并将标记留在原位置。但如果调用时传入 1 到 10 之间的数字，函数会将该数字视为缓冲区长度的十分之几，并将光标移动到缓冲区开头对应比例的位置。因此，你可以用快捷键 M-< 将光标移到缓冲区开头，也可以用 C-u 7 M-< 将光标移到缓冲区 70% 的位置。如果参数大于 10，则直接跳到缓冲区末尾。

beginning-of-buffer 可以带参数或不带参数调用，参数是可选的。

• 可选参数
• 带参数的 beginning-of-buffer
• beginning-of-buffer 完整实现

(defun beginning-of-buffer (&optional arg)

(defun beginning-of-buffer (&optional arg)
  "documentation..."
  (interactive "P")
  (or (is-the-argument-a-cons-cell arg)
      (and are-both-transient-mark-mode-and-mark-active-true)
      (push-mark))
  (let (determine-size-and-set-it)
    (goto-char
      (if-there-is-an-argument
          figure-out-where-to-go
        else-go-to
        (point-min))))
  do-nicety

(if (> (buffer-size) 10000)
    ;; Avoid overflow for large buffer sizes!
    (* (prefix-numeric-value arg)
       (/ size 10))
  (/
   (+ 10
      (* size
         (prefix-numeric-value arg)))
   10))

(if (buffer-is-large
    divide-buffer-size-by-10-and-multiply-by-arg
  else-use-alternate-calculation

(if (> size 10000)

(*
  (prefix-numeric-value arg)
  (/ size 10))

(* numeric-value-of-prefix-arg
   number-of-characters-in-one-tenth-of-the-accessible-buffer)

(goto-char (* (prefix-numeric-value arg)
              (/ size 10)))

(/ (+ 10 (* size (prefix-numeric-value arg))) 10)

  (/
   (+ 10
      (*
       size
       (prefix-numeric-value arg)))
   10)

(* size (prefix-numeric-value arg))

(defun beginning-of-buffer (&optional arg)
  "将光标移至缓冲区开头；在原位置保留标记。
带 \\[universal-argument] 前缀时，不在原位置设置标记。
带数字参数 N 时，将光标置于距开头 N/10 处。

若缓冲区被缩窄，该命令会使用缓冲区可访问部分的开头与大小。

不要在 Lisp 程序中使用该命令！
\(goto-char (point-min)) 速度更快，且不会覆盖标记。"
  (interactive "P")
  (or (consp arg)
      (and transient-mark-mode mark-active)
      (push-mark))

  (let ((size (- (point-max) (point-min))))
    (goto-char (if (and arg (not (consp arg)))
                   (+ (point-min)
                      (if (> size 10000)
                          ;; 避免大缓冲区数值溢出！
                          (* (prefix-numeric-value arg)
                             (/ size 10))
                        (/ (+ 10 (* size (prefix-numeric-value arg)))
                           10)))
                 (point-min))))
  (if (and arg (not (consp arg))) (forward-line 1)))

\\[universal-argument]

(if (and arg (not (consp arg))) (forward-line 1))

Next: optional参数练习, Previous: beginning-of-buffer 完整定义, Up: 几个更复杂的函数   [Contents][Index]

5.4 本章小结 ¶

本章涉及的部分主题简要总结如下。

or

依次计算每个参数，返回第一个非 nil 的参数值；若所有参数均为 nil，则返回 nil。简言之，返回参数中第一个真值；只要任一参数为真，就返回真值。

and

依次计算每个参数，若任一参数为 nil，则返回 nil；若全部非 nil，返回最后一个参数的值。简言之，仅当所有参数均为真时返回真值。

&optional

用于标记函数定义中参数为可选的关键字；表示函数可在不传入该参数的情况下执行。

prefix-numeric-value

将 (interactive "P") 生成的原始前缀参数转换为数值。

forward-line

将光标移至下一行开头；若参数大于 1，则向后移动对应行数。若无法移动到指定位置，forward-line 会尽可能前移，并返回未能完成移动的剩余行数。

erase-buffer

删除当前缓冲区全部内容。

bufferp

若参数为缓冲区对象则返回 t，否则返回 nil。

Previous: 本章小结, Up: 几个更复杂的函数   [Contents][Index]

5.5 optional参数练习 ¶

编写一个带可选参数的交互式函数，判断其参数（数字）大于等于、还是小于 fill-column 的值，并通过消息提示结果。若未传入参数，则使用 56 作为默认值。

Next: what-line, Previous: 缩窄的优势, Up: 缩窄与扩宽   [Contents][Index]

6.1 save-restriction 特殊形式 ¶

在 Emacs Lisp 中，可使用 save-restriction 特殊形式记录当前生效的缩窄状态。当 Lisp 解释器遇到 save-restriction 时，会执行其主体内的代码，之后撤销代码对缩窄状态造成的任何修改。例如缓冲区已缩窄，而 save-restriction 后的代码取消了缩窄，save-restriction 会在之后恢复原有缩窄区域。在 what-line 命令中，save-restriction 之后紧跟的 widen 命令会取消缓冲区缩窄，而原始缩窄状态会在函数结束前恢复。

save-restriction 表达式的模板很简单：

(save-restriction
  body... )

save-restriction 的主体是一个或多个表达式，由 Lisp 解释器依次执行。

最后需要注意：若同时使用 save-excursion 和 save-restriction，应将 save-excursion 放在外层。若顺序相反，可能无法记录调用 save-excursion 后 Emacs 切换到的缓冲区的缩窄状态。因此，两者一起使用时应如下编写：

(save-excursion
  (save-restriction
    body...))

在其他不一起使用的场景中，save-excursion 与 save-restriction 需根据函数需求确定顺序。

For example,

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

Next: 缩窄相关练习, Previous: save-restriction 特殊形式, Up: 缩窄与扩宽   [Contents][Index]

6.2 what-line ¶

what-line 命令用于显示光标所在行的行号。该函数展示了 save-restriction 与 save-excursion 的用法。函数原始代码如下：

(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 中，what-line 函数已扩展，可同时显示缩窄后与扩宽后的行号。新版比此处示例更复杂。若你愿意，可在理解该版本后查看新版实现，大概率需要使用 C-h f（describe-function）。新版使用条件判断缓冲区是否缩窄。

另外，新版 what-line 使用了 line-number-at-pos，其中除 (goto-char (point-min)) 等简单表达式外，还使用 (forward-line 0) 而非 beginning-of-line 将光标移至当前行开头。）

此处展示的 what-line 函数包含文档字符串且为交互式，符合预期。接下来两行使用了 save-restriction 与 widen。

save-restriction 特殊形式会记录当前缓冲区的缩窄状态（如果有），并在主体代码执行完毕后恢复该状态。

save-restriction 之后是 widen。该函数会取消调用 what-line 时缓冲区可能存在的缩窄。（原有缩窄状态由 save-restriction 保存。）取消缩窄后，行统计命令可从缓冲区开头计数，否则只会在可访问区域内统计。函数结束前，save-restriction 会恢复原始缩窄状态。

widen 调用之后是 save-excursion，它会保存光标位置，并在主体代码使用 beginning-of-line 移动光标后恢复原位。

（注意 (widen) 表达式位于 save-restriction 与 save-excursion 之间。连续编写两个 save-… 表达式时，应将 save-excursion 放在外层。）

what-line 函数最后两行用于统计缓冲区行数，并在回显区显示行号。

(message "Line %d"
         (1+ (count-lines 1 (point)))))))

message 函数在 Emacs 屏幕底部显示单行消息。第一个参数位于引号内，会作为字符串直接打印。其中可包含 ‘%d’ 表达式，用于打印后续参数。‘%d’ 以十进制形式输出参数，因此最终会显示类似 ‘Line 243’ 的内容。

替换 ‘%d’ 打印的数值由函数最后一行计算：

(1+ (count-lines 1 (point)))

该代码从缓冲区起始位置（由 1 表示）统计到 (point) 处的行数，然后加一。（1+ 函数会给参数加一。）加一的原因是：第二行之前只有一行，而 count-lines 只统计当前行 之前 的行数。

count-lines 执行完毕、回显区显示消息后，save-excursion 恢复光标位置，save-restriction 恢复原始缩窄状态（如果有）。

Previous: what-line, Up: 缩窄与扩宽   [Contents][Index]

6.3 缩窄相关练习 ¶

编写一个函数，显示当前缓冲区前 60 个字符，即使你已将缓冲区缩窄到后半部分导致首行不可访问。执行后恢复光标、标记与缩窄状态。本练习需要综合使用多个函数，包括 save-restriction、widen、goto-char、point-min、message 与 buffer-substring。

（buffer-substring 是之前未提及的函数，需要自行查阅；也可使用 buffer-substring-no-properties 或 filter-buffer-substring 等其他函数。文本属性是本章未涉及的特性，参见 See Text Properties in The GNU Emacs Lisp Reference Manual。）

此外，思考：是否真的需要 goto-char 或 point-min？能否不使用它们实现该函数？

Next: cons, Previous: Strange Names, Up: car、cdr、cons：基础函数   [Contents][Index]

7.1 car 与 cdr ¶

一个列表的 CAR，简单来说就是列表中的第一个元素。因此列表 (rose violet daisy buttercup) 的 CAR 是 rose。

如果你正在 GNU Emacs 的 Info 中阅读本文，可以通过执行下面的表达式看到结果：

(car '(rose violet daisy buttercup))

执行该表达式后，rose 会出现在回显区。

car 并不会从列表中移除第一个元素，它只是返回该元素的值。对一个列表使用 car 之后，列表本身保持不变。用行话来说，car 是“非破坏性(non-destructive)”的。这一特性非常重要。

一个列表的 CDR 是列表除第一个元素外的剩余部分，也就是说，cdr 函数返回列表中紧跟在第一个元素之后的部分。因此，列表 '(rose violet daisy buttercup) 的 CAR 是 rose，而由 cdr 函数返回的列表剩余部分则是 (violet daisy buttercup)。

你可以照常执行下面的表达式来验证：

(cdr '(rose violet daisy buttercup))

执行后，回显区会显示 (violet daisy buttercup)。

和 car 一样，cdr 不会从列表中移除任何元素——它只返回第二个及后续元素组成的列表。

顺便一提，本例中的花卉列表被加了引用。如果不加引用，Lisp 解释器会尝试把 rose 当作函数调用，去执行整个列表，而这并不是我们想要的效果。

对于列表操作，first（第一个）和 rest（剩余部分）这两个名称比 car 和 cdr 更易懂。事实上，有些程序员会将 first 和 rest 定义为 car 和 cdr 的别名，然后在代码中使用 first 和 rest。

不过，Lisp 中的列表是通过一种更低层的结构 “序对节点(cons cells)”（see 列表的实现方式）构建的，在这种结构里并没有“第一个”或“剩余部分”的概念，CAR 与 CDR 是对称的。Lisp 不会隐藏序对节点的存在，程序也会将它们用于列表之外的用途。因此，这两个名称有助于提醒程序员：car 和 cdr 本质上是对称的，只是在列表用法上表现得不对称。

当把 car 和 cdr 应用到由符号组成的列表（例如 (pine fir oak maple)）时，car 返回的列表元素是不带任何括号的符号 pine，它是列表的第一个元素。而该列表的 CDR 本身仍是一个列表 (fir oak maple)，你可以照常执行下面的表达式观察结果：

(car '(pine fir oak maple))

(cdr '(pine fir oak maple))

而在由列表组成的列表中，第一个元素本身就是一个列表。car 会以列表形式返回这个第一个元素。例如，下面的列表包含三个子列表，分别是食肉动物、食草动物和海洋哺乳动物：

(car '((lion tiger cheetah)
       (gazelle antelope zebra)
       (whale dolphin seal)))

在本例中，列表的第一个元素（即 CAR）是食肉动物列表 (lion tiger cheetah)，而列表剩余部分是 ((gazelle antelope zebra) (whale dolphin seal))。

(cdr '((lion tiger cheetah)
       (gazelle antelope zebra)
       (whale dolphin seal)))

值得再次强调：car 和 cdr 都是非破坏性的 — 也就是说，它们不会修改所操作的列表。这对它们的使用方式至关重要。

另外，在第一章关于原子的讨论中提到过：在 Lisp 里，某些类型的原子（例如数组）可以被拆分成部分，但拆分机制与拆分列表不同。对 Lisp 而言，列表中的原子是不可拆分的。（See Lisp 原子。）car 和 cdr 用于拆分列表，被视为 Lisp 的基础操作。由于它们无法拆分或访问数组的内部组成，数组被看作原子。反过来，另一个基础函数 cons 可以拼接或构造列表，但不能构造数组。（数组由专门的数组函数处理。See Arrays in The GNU Emacs Lisp Reference Manual。）

Next: nthcdr, Previous: car 与 cdr, Up: car、cdr、cons：基础函数   [Contents][Index]

7.2 cons ¶

cons 函数用于构造列表，它的作用与 car 和 cdr 相反。例如，可以用 cons 从三元素列表 (fir oak maple) 构造出一个四元素列表：

(cons 'pine '(fir oak maple))

执行该表达式后，你会在回显区看到：

(pine fir oak maple)

cons 会创建一个新列表，新列表以指定元素开头，后跟原列表的所有元素。

我们常说 cons 将一个新元素放在列表开头，或者将元素附加、压入列表，但这种说法可能造成误解：cons 并不会修改已有列表，而是创建一个新列表。

和 car、cdr 一样，cons 也是非破坏性的。

• 构造列表
• 获取列表长度：length

(cons 'buttercup ())
     ⇒ (buttercup)

(cons 'daisy '(buttercup))
     ⇒ (daisy buttercup)

(cons 'violet '(daisy buttercup))
     ⇒ (violet daisy buttercup)

(cons 'rose '(violet daisy buttercup))
     ⇒ (rose violet daisy buttercup)

(length '(buttercup))
     ⇒ 1

(length '(daisy buttercup))
     ⇒ 2

(length (cons 'violet '(daisy buttercup)))
     ⇒ 3

(length ())
     ⇒ 0

(length )

Lisp error: (wrong-number-of-arguments length 0)

Next: nth, Previous: cons, Up: car、cdr、cons：基础函数   [Contents][Index]

7.3 nthcdr ¶

nthcdr 函数与 cdr 相关，它的作用是对列表重复执行 CDR 操作。

对列表 (pine fir oak maple) 执行 CDR，会返回列表 (fir oak maple)。对返回结果再次执行 CDR，会返回 (oak maple)。（当然，对原列表重复执行 CDR 只会得到原列表的 CDR，因为函数不会修改列表。需要对 CDR 的结果再执行 CDR，依此类推。）继续执行下去，最终会返回空列表，在本例中不会显示为 ()，而是显示为 nil。

作为回顾，下面是一系列重复执行 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

你也可以连续执行多次 CDR 而不打印中间结果，例如：

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

在本例中，Lisp 解释器先求值最内层列表。该列表被引用，因此直接原样传给内层的 cdr。这个 cdr 将原列表第二个及后续元素组成的列表传给外层 cdr，后者再返回原列表第三个及后续元素组成的列表。本例中 cdr 被重复执行，返回的列表去掉了原列表的前两个元素。

nthcdr 函数的效果等同于重复调用 cdr。下面的例子中，数字 2 和列表一起传给 nthcdr，返回的列表去掉了前两个元素，与对列表执行两次 cdr 的结果完全相同：

(nthcdr 2 '(pine fir oak maple))
     ⇒ (oak maple)

使用最初的四元素列表，我们可以观察向 nthcdr 传入不同数字参数（包括 0、1 和 5）的效果：

;; 保持列表不变
(nthcdr 0 '(pine fir oak maple))
     ⇒ (pine fir oak maple)

;; 返回去掉第一个元素的列表副本
(nthcdr 1 '(pine fir oak maple))
     ⇒ (fir oak maple)

;; 返回去掉前三个元素的列表副本
(nthcdr 3 '(pine fir oak maple))
     ⇒ (maple)

;; 返回去掉全部四个元素的结果
(nthcdr 4 '(pine fir oak maple))
     ⇒ nil

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

Next: setcar, Previous: nthcdr, Up: car、cdr、cons：基础函数   [Contents][Index]

7.4 nth ¶

nthcdr 函数对列表重复执行 CDR。而 nth 函数会对 nthcdr 返回的结果再执行 CAR，它返回列表的第 N 个元素。

因此，如果不是为了效率用 C 语言重新实现，nth 的定义大致如下：

(defun nth (n list)
  "返回列表 LIST 的第 N 个元素。
N 从 0 开始计数。若列表长度不足，返回 nil。"
  (car (nthcdr n list)))

（最初 nth 是在 Emacs Lisp 的 subr.el 中定义的，后来在 1980 年代改用 C 语言重新实现。）

nth 函数返回列表中的单个元素，使用起来非常方便。

注意元素编号从 0 开始，而非从 1 开始。也就是说，列表的第一个元素（CAR）是第 0 个元素。这种从 0 开始的计数方式，常常让习惯从 1 开始计数的人感到不适。

例如：

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

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

值得一提的是，nth 与 nthcdr、cdr 一样，不会修改原列表——该函数是非破坏性的。这与 setcar 和 setcdr 函数形成鲜明对比。

Next: setcdr, Previous: nth, Up: car、cdr、cons：基础函数   [Contents][Index]

7.5 setcar ¶

从名称不难猜到，setcar 和 setcdr 函数用于将列表的 CAR 或 CDR 设置为新值。它们会真正修改原列表，这与 car 和 cdr 保留原列表不变的行为不同。想要理解其工作方式，最好的方法是动手实验。我们先从 setcar 开始。

首先，可以创建一个列表，并用 setq 特殊形式将其赋值给变量。因为我们打算用 setcar 修改这个列表，所以这个 setq 不应使用引用形式 '(antelope giraffe lion tiger)，否则得到的列表会是程序的一部分，运行时尝试修改程序片段可能导致异常。通常来说，Emacs Lisp 程序的组成部分在运行时应是常量（不可修改）。因此我们改用 list 函数构造动物列表，写法如下：

(setq animals (list 'antelope 'giraffe 'lion 'tiger))

如果你正在 GNU Emacs 的 Info 中阅读本文，可以照常执行该表达式：将光标移到表达式末尾并按 C-x C-e。（我写这段内容时也正在这样操作。这也是将解释器内置在运行环境中的优势之一。顺便一提，如果最后一个括号后面没有注释等内容，光标可以放在下一行。也就是说，即使光标位于下一行的第一列，也无需移动。实际上，Emacs 允许最后一个括号后有任意数量的空白字符。）

当我们对变量 animals 求值时，可以看到它绑定到列表 (antelope giraffe lion tiger)：

animals
     ⇒ (antelope giraffe lion tiger)

换句话说，变量 animals 指向列表 (antelope giraffe lion tiger)。

接下来，执行 setcar 函数并传入两个参数：变量 animals 和被引用的符号 hippopotamus；只需写出三元素列表 (setcar animals 'hippopotamus) 并照常执行即可：

(setcar animals 'hippopotamus)

执行该表达式后，再次对变量 animals 求值，你会发现动物列表已经改变：

animals
     ⇒ (hippopotamus giraffe lion tiger)

列表的第一个元素 antelope 被替换成了 hippopotamus。

由此可见，setcar 并不会像 cons 那样向列表添加新元素，而是将 antelope 替换为 hippopotamus — 它 修改 了列表。

Next: 练习, Previous: setcar, Up: car、cdr、cons：基础函数   [Contents][Index]

7.6 setcdr ¶

setcdr 函数与 setcar 函数类似，区别在于它替换列表的第二个及后续元素，而非第一个元素。

（若想了解如何修改列表的最后一个元素，可提前参阅 The kill-new function，该函数同时使用了 nthcdr 和 setcdr。）

要观察其工作方式，先执行下面的表达式，将变量设为家养动物列表：

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

现在对该列表求值，会返回列表 (horse cow sheep goat)：

domesticated-animals
     ⇒ (horse cow sheep goat)

接下来，对 setcdr 传入两个参数：值为列表的变量名，以及要设置为该列表 CDR 的新列表：

(setcdr domesticated-animals '(cat dog))

执行该表达式后，回显区会出现列表 (cat dog)，这是函数的返回值。我们真正关心的是它的副作用，再次对变量 domesticated-animals 求值即可看到：

domesticated-animals
     ⇒ (horse cat dog)

可以看到，列表从 (horse cow sheep goat) 被修改为 (horse cat dog)。列表的 CDR 从 (cow sheep goat) 变为了 (cat dog)。

Previous: setcdr, Up: car、cdr、cons：基础函数   [Contents][Index]

7.7 练习 ¶

通过多次使用 cons 求值，构造一个包含四种鸟类的列表。观察将一个列表 cons 到自身上会发生什么。将该鸟类列表的第一个元素替换为一种鱼，再将列表剩余部分替换为其他鱼类组成的列表。

Next: kill-region, Previous: 将文本存储在列表中, Up: 文本剪切与存储   [Contents][Index]

8.1 zap-to-char ¶

我们来看交互式函数 zap-to-char。

• zap-to-char 完整实现
• interactive 表达式
• zap-to-char 函数体
• search-forward 函数
• progn 特殊形式
• zap-to-char 总结

(defun zap-to-char (arg char)
  "删除至第 ARG 次出现的 CHAR 字符（含该字符）。
若当前缓冲区中 `case-fold-search' 非空，则忽略大小写。
ARG 为负时反向搜索；未找到 CHAR 则报错。"
  (if (char-table-p translation-table-for-input)
      (setq char (or (aref translation-table-for-input char) char)))
  (kill-region (point) (progn
                         (search-forward (char-to-string char)
                                         nil nil arg)
                         (point))))

(interactive "p\ncZap to char: ")

(if (char-table-p translation-table-for-input)
    (setq char (or (aref translation-table-for-input char) char)))
(kill-region (point) (progn
                       (search-forward (char-to-string char) nil nil arg)
                       (point)))

(search-forward (char-to-string char) nil nil arg)

(search-forward "target-string"
                limit-of-search
                what-to-do-if-search-fails
                repeat-count)

(progn
  body...)

Next: copy-region-as-kill, Previous: zap-to-char, Up: 文本剪切与存储   [Contents][Index]

8.2 kill-region ¶

zap-to-char 函数内部使用了 kill-region 函数。 该函数会从指定区域剪切文本，并将文本复制到剪切环中， 后续可从中取回文本。

Emacs 22 版本中的该函数使用了 condition-case 和 copy-region-as-kill，这两者我们都会进行讲解。 condition-case 是一种重要的特殊形式。

本质上，kill-region 函数会调用 condition-case，它接收三个参数。在本函数中， 第一个参数不执行任何操作。第二个参数包含 一切正常时执行实际工作的代码。第三个参数包含 发生错误时会被调用的代码。