翻译: Emacs Lisp ¶

Next: Lisp 历史, Up: 简介   [Contents][Index]

1.1 注意事项 ¶

本手册历经多次修订，内容已近乎完整，但仍非完美无缺。部分主题尚未覆盖，原因或是我们认为其属于次要内容（如多数独立模式），或是相关章节仍待撰写。因无法完整阐述，我们有意省略了若干部分。

手册中已覆盖的内容应完全准确，因此其中任何表述 — 从具体示例、描述文字，到章节与小节的编排顺序 — 都欢迎批评指正。若某处内容令人困惑，或是你必须查阅源码、动手实验才能了解手册未提及的知识，那么手册或许需要修正。敬请告知我们。

使用本手册时，若发现错误，恳请尽快提交更正。如果你为某个函数或一组函数想到了简洁、实用的示例，请尽力整理并发送过来。评论时请注明对应的节点名、函数名或变量名，并说明你所指正的版本号。

请通过 M-x report-emacs-bug 发送意见与更正。详情，See 报告错误 in The GNU Emacs Manual.

Next: 约定, Previous: 注意事项, Up: 简介   [Contents][Index]

1.2 Lisp 历史 ¶

Lisp（表处理语言，LISt Processing language）于 20 世纪 50 年代末在麻省理工学院首次开发，用于人工智能研究。Lisp 语言的强大能力使其同样适用于其他场景，例如编写编辑命令。

多年来已经出现了数十种 Lisp 实现，每种都有其独特之处。其中许多都受 Maclisp 启发 —Maclisp 是 20 世纪 60 年代麻省理工学院 MAC 项目所开发的。最终，Maclisp 后续分支的实现者们共同制定了一套 Lisp 系统标准，称为 Common Lisp。与此同时，麻省理工学院的 Gerry Sussman 与 Guy Steele 开发了一门简洁但功能强大的 Lisp 方言，名为 Scheme。

GNU Emacs Lisp 主要受 Maclisp 启发，也少量借鉴了 Common Lisp。如果你了解 Common Lisp，会发现许多相似之处。不过，为了降低 GNU Emacs 的内存占用，Common Lisp 的很多特性被省略或简化。这些简化有时幅度很大，可能会让 Common Lisp 用户感到困惑。我们会偶尔指出 GNU Emacs Lisp 与 Common Lisp 的区别。如果你不了解 Common Lisp，也无需担心：本手册内容是自包含的。

可以通过 cl-lib 库实现一定程度的 Common Lisp 模拟，See 概述 in Common Lisp Extensions.

Emacs Lisp 完全没有受到 Scheme 的影响；但 GNU 项目有一套 Scheme 实现，名为 Guile。我们在所有需要支持扩展的新 GNU 软件中都使用它。

Next: 版本信息, Previous: Lisp 历史, Up: 简介   [Contents][Index]

1.3 约定 ¶

本节说明本手册所使用的符号约定。你可以先跳过本节，需要时再回头查阅。

• 部分术语
• nil 和 t
• 求值表示法
• 打印表示法
• 错误信息
• 缓冲区文本表示法
• 描述格式

(cons 'foo ())                ; 强调空列表
(setq foo-flag nil)           ; 强调布尔值 false

(car '(1 2))
     ⇒ 1

(third '(a b c))
     → (car (cdr (cdr '(a b c))))
     ⇒ c

(make-sparse-keymap) ≡ (list 'keymap)

(progn (prin1 'foo) (princ "\n") (prin1 'bar))
     ⊣ foo
     ⊣ bar
     ⇒ bar

(+ 23 'x)
error→ Wrong type argument: number-or-marker-p, x
error→ 参数类型错误：应为数值或标记类型，实际为 x

---------- Buffer: foo ----------
This is the ∗contents of foo.
---------- Buffer: foo ----------

(insert "changed ")
     ⇒ nil
---------- Buffer: foo ----------
This is the changed ∗contents of foo.
---------- Buffer: foo ----------

Next: 致谢, Previous: 约定, Up: 简介   [Contents][Index]

1.4 版本信息 ¶

以下这些功能可以提供当前所使用的 Emacs 版本信息。

Command: emacs-version &optional here ¶

此函数返回一个字符串，描述正在运行的 Emacs 版本。在错误报告中包含该字符串会很有用。

(emacs-version)
  ⇒ "GNU Emacs 26.1 (build 1, x86_64-unknown-linux-gnu,
             GTK+ Version 3.16) of 2017-06-01"

如果 here 非 nil，该函数会将文本插入到缓冲区中光标之前，并返回 nil。当以交互式方式调用此函数时，它会在回显区打印相同信息；若提供前缀参数，则会使 here 为非 nil。

Variable: emacs-build-time ¶

该变量的值表示 Emacs 的编译时间。其格式与 current-time 相同（see 时刻）；如果信息不可用，则为 nil。

emacs-build-time
     ⇒ (25194 55894 8547 617000)

（如果编译 Emacs 时 current-time-list 为 nil，则该时间戳为 (1651169878008547617 . 1000000000)。）

Variable: emacs-version ¶

该变量的值是正在运行的 Emacs 版本字符串，例如 "26.1"。若值包含三个数字部分（如 "26.0.91"），表示这是一个未发布的测试版。（在 Emacs 26.1 之前，版本字符串末尾会多一个数字，该数字现在存放在 emacs-build-number 中，例如 "25.1.1"。）

Variable: emacs-major-version ¶

Emacs 的主版本号，为整数类型。例如 Emacs 23.1 中，该值为 23。

Variable: emacs-minor-version ¶

Emacs 的次版本号，为整数类型。例如 Emacs 23.1 中，该值为 1。

Variable: emacs-build-number ¶

一个整数，每次在同一目录下（不清理）编译 Emacs 时都会递增。该变量仅在开发 Emacs 时有用。

Variable: emacs-repository-version ¶

字符串类型，表示编译此 Emacs 所依据的代码仓库修订号。如果 Emacs 是在版本控制系统之外编译的，该值为 nil。

Variable: emacs-repository-branch ¶

字符串类型，表示编译此 Emacs 所依据的代码仓库分支。绝大多数情况下为 "master"。如果 Emacs 是在版本控制系统之外编译的，该值为 nil。

Previous: 版本信息, Up: 简介   [Contents][Index]

1.5 致谢 ¶

本手册最初由 Robert Krawitz、Bil Lewis、Dan LaLaiberte、Richard M. Stallman 与 Chris Welty 编写，他们是 GNU 手册小组的志愿者，这项工作历时数年完成。Robert J. Chassell 协助审阅与编辑本手册，工作得到美国国防部高级研究计划局（DARPA）ARPA 第 6082 号订单的支持，该项目由计算逻辑公司的 Warren A. Hunt, Jr. 负责协调。此后新增的章节由 Miles Bader、Lars Brinkhoff、Chong Yidong、Kenichi Handa、Lute Kamstra、Juri Linkov、Glenn Morris、Thien‑Thi Nguyen、Dan Nicolaescu、Martin Rudalics、Kim F. Storm、Luc Teirlinck、Eli Zaretskii 及其他人士撰写。

感谢以下人士提供修正意见：Drew Adams, Juanma Barranquero, Karl Berry, Jim Blandy, Bard Bloom, Stephane Boucher, David Boyes, Alan Carroll, Richard Davis, Lawrence R. Dodd, Peter Doornbosch, David A. Duff, Chris Eich, Beverly Erlebacher, David Eckelkamp, Ralf Fassel, Eirik Fuller, Stephen Gildea, Bob Glickstein, Eric Hanchrow, Jesper Harder, George Hartzell, Nathan Hess, Masayuki Ida, Dan Jacobson, Jak Kirman, Bob Knighten, Frederick M. Korz, Joe Lammens, Glenn M. Lewis, K. Richard Magill, Brian Marick, Roland McGrath, Stefan Monnier, Skip Montanaro, John Gardiner Myers, Thomas A. Peterson, Francesco Potortì, Friedrich Pukelsheim, Arnold D. Robbins, Raul Rockwell, Jason Rumney, Per Starbäck, Shinichirou Sugou, Kimmo Suominen, Edward Tharp, Bill Trost, Rickard Westman, Jean White, Eduard Wiebe, Matthew Wilding, Carl Witty, Dale Worley, Rusty Wright, and David D. Zuhn.

如需更完整的贡献者名单，请查阅 Emacs 源代码仓库中对应的变更日志条目。

Next: 特殊读取语法, Up: Lisp 数据类型   [Contents][Index]

2.1 打印表示与读入语法 ¶

对象的 打印表示(printed representation)，是 Lisp 打印器（函数 prin1）为该对象生成的输出格式。每种数据类型都有唯一的打印表示。对象的 读入语法(read syntax)，是 Lisp 读取器（函数 read）对该对象所接受的输入格式。这一格式不一定唯一：很多对象都支持多种语法。See Lisp 对象的读取与打印。

在大多数情况下，一个对象的打印表示形式同时也是该对象的读取语法。不过，某些类型并没有对应的读取语法，因为在 Lisp 程序中把这类对象当作常量输入是没有意义的。这类对象会以 井号表示法(hash notation) 打印：由字符 ‘#<’ 开头，接着是一段描述性字符串（通常是类型名后跟对象名），最后以 ‘>’ 结尾。（之所以称为 “井号表示法(hash natation)”，是因为它以字符 ‘#’ 开头，该字符也叫 “井号(hash)” 或 “数字符号”。）例如：

(current-buffer)
     ⇒ #<buffer objects.texi>

井号表示法完全无法被读取，因此 Lisp 读取器只要遇到 ‘#<’，就会报 invalid-read-syntax（非法读入语法）错误。

在本章后续各节中，我们会在介绍每种 Lisp 数据类型时，同时说明它的读取语法与打印表示形式。例如， 参见 字符串类型 及其子小节可了解字符串的读取语法与打印表示；参见 向量类型 可获取向量的相关信息，依此类推。

在其他语言中，表达式就是文本，没有别的形态。而在 Lisp 中，表达式首先是一个 Lisp 对象，其次才是作为该对象读入语法的文本。通常不必刻意强调这一区别，但你必须心里有数，否则偶尔会非常困惑。

当你交互式求值一个表达式时，Lisp 解释器会先读取它的文本表示，构造出一个 Lisp 对象，然后再对这个对象求值（see Evaluation）。但读取与求值是两个独立的过程：读取只是根据文本返回对应的 Lisp 对象；这个对象之后可能被求值，也可能不会。关于基本读取函数 read 的说明，see 输入函数。

Next: 注释, Previous: 打印表示与读入语法, Up: Lisp 数据类型   [Contents][Index]

2.2 特殊读取语法 ¶

Emacs Lisp 通过特殊井号表示法表示许多特殊对象和结构。

‘#<…>’

不具备读取语法的对象会以这种形式展示（see 打印表示与读入语法）。

‘##’

名称为空字符串的内部符号的打印表示形式（see 符号类型）。

‘#'’

这是 function 的简写形式，见 匿名函数。

‘#:’

名称为 foo 的未内部化符号，其打印表示为 ‘#:foo’（see 符号类型）。

‘#N’

打印循环结构时，用于表示结构自引用的位置，‘N’ 是起始列表编号：

(let ((a (list 1)))
  (setcdr a a))
=> (1 . #0)

‘#N=’

‘#N#’

‘#N=’ 为一个对象命名，‘#N#’ 表示该对象。这样在重新读取时，它们会是同一个对象而非副本（see 循环对象的读取语法）。

‘#xN’

以十六进制表示 ‘N’（如 ‘#x2a’）。

‘#oN’

以八进制表示 ‘N’（如 ‘#o52’）。

‘#bN’

以二进制表示 ‘N’（如 ‘#b101010’）。

‘#(…)’

字符串的文本属性（see 字符串中的文本属性）。

‘#^’

字符表（see 字符表类型）。

‘#s(hash-table …)’

哈希表（see 哈希表类型）。

‘?C’

字符（see 基本字符语法）。

‘#$’

字节编译文件中的当前文件名（see 文档字符串与编译）。不建议在 Emacs Lisp 源文件中使用。

‘#@N’

跳过接下来的 ‘N’ 个字符（see 注释）。用于字节编译文件，不建议在 Emacs Lisp 源文件中使用。

‘#f’

表示后续的表达式无法被 Emacs Lisp 读取器读取。该标记仅用于显示文本（当它比其他表示不可读表达式的方式更美观时），绝不会出现在任何 Lisp 文件中。

Next: 编程类型, Previous: 特殊读取语法, Up: Lisp 数据类型   [Contents][Index]

2.3 注释 ¶

注释(comment) 是程序中仅供阅读程序的人理解所写的文本，对程序的含义没有任何影响。在 Lisp 中，未转义的分号（‘;’） 只要不在字符串或字符常量内部，就表示开始一段注释，注释持续到本行末尾。Lisp 读取器会忽略注释，它们不会成为 Lisp 系统中表示程序的 Lisp 对象的一部分。

‘#@count’ 结构会跳过接下来的 count 个字符，常用于由程序自动生成、包含二进制数据的注释。Emacs Lisp 字节编译器会在其输出文件中使用该结构（see 字节编译），但它并不适用于源文件。

关于注释的排版规范，See 注释编写技巧。

Next: 编辑类型, Previous: 注释, Up: Lisp 数据类型   [Contents][Index]

2.4 编程类型 ¶

Emacs Lisp 中的类型分为两大类：一类与 Lisp 编程相关，另一类与 编辑功能相关。前者以各种形式存在于众多 Lisp 实现中，而后者是 Emacs Lisp 所独有的。

• 整数类型
• 浮点类型
• 字符类型
• 符号类型
• 序列类型
• Cons 单元与列表类型
• 数组类型
• 字符串类型
• 向量类型
• 字符表类型
• 布尔向量类型
• 哈希表类型
• 函数类型
• 宏类型
• 原语函数类型
• 闭包函数类型
• 记录类型
• 类型描述符
• 类型说明符
• 自动加载类型
• 终结器类型

-1               ; 整数 −1.
1                ; 整数 1.
1.               ; 同样是整数 1.
+1               ; 同样是整数 1.

?Q ⇒ 81     ?q ⇒ 113

?\a ⇒ 7                 ; control-g, C-g
?\b ⇒ 8                 ; 退格 backspace, BS, C-h
?\t ⇒ 9                 ; 制表符 tab, TAB, C-i
?\n ⇒ 10                ; 换行 newline, C-j
?\v ⇒ 11                ; 垂直制表符 vertical tab, C-k
?\f ⇒ 12                ; 换页符 formfeed character, C-l
?\r ⇒ 13                ; 回车符 carriage return, RET, C-m
?\e ⇒ 27                ; 转义符 escape character, ESC, C-[
?\s ⇒ 32                ; 空格 space character, SPC
?\\ ⇒ 92                ; 反斜杠 backslash character, \
?\d ⇒ 127               ; 删除符 delete character, DEL

?\^I ⇒ 9     ?\C-I ⇒ 9

?\^? ⇒ 127     ?\C-? ⇒ 127

foo                 ; 符号名称为 ‘foo’
FOO                 ; 符号名称为 ‘FOO’，与 ‘foo’ 不同

1+                  ; 符号名称为 ‘1+’
                    ;   (而非 ‘+1’ — 后者是整数)。

\+1                 ; 符号名称为 ‘+1’
                    ;   (可读性较差)。

\(*\ 1\ 2\)         ; 符号名称为 ‘(* 1 2)’ (更差的名称)。
+-*/_~!@$%^&=:<>{}  ; 符号名称为 ‘+-*/_~!@$%^&=:<>{}’.
                    ;   这些字符无需转义。

(A 2 "A")            ; 包含三个元素的列表
()                   ; 不含元素的列表（空列表）
nil                  ; 不含元素的列表（空列表）
("A ()")             ; 只有一个元素的列表：字符串 "A ()"
(A ())               ; 包含两个元素的列表：A  和空列表
(A nil)              ; 与上一行等价
((A B C))            ; 只有一个元素的列表
                     ;   (该元素本身是一个含三个元素的列表)。

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

 ---------------       ----------------       -------------------
| car   | cdr   |     | car    | cdr   |     | car       | cdr   |
| rose  |   o-------->| violet |   o-------->| buttercup |  nil  |
|       |       |     |        |       |     |           |       |
 ---------------       ----------------       -------------------

    --- ---      --- ---
   |   |   |--> |   |   |--> nil
    --- ---      --- ---
     |            |
     |            |
      --> A        --> nil

    --- ---      --- ---      --- ---
   |   |   |--> |   |   |--> |   |   |--> nil
    --- ---      --- ---      --- ---
     |            |            |
     |            |            |
     |             --> oak      --> maple
     |
     |     --- ---      --- ---
      --> |   |   |--> |   |   |--> nil
           --- ---      --- ---
            |            |
            |            |
             --> pine     --> needles

 --------------       --------------       --------------
| car   | cdr  |     | car   | cdr  |     | car   | cdr  |
|   o   |   o------->| oak   |   o------->| maple |  nil |
|   |   |      |     |       |      |     |       |      |
 -- | ---------       --------------       --------------
    |
    |
    |        --------------       ----------------
    |       | car   | cdr  |     | car     | cdr  |
     ------>| pine  |   o------->| needles |  nil |
            |       |      |     |         |      |
             --------------       ----------------

    --- ---
   |   |   |--> violet
    --- ---
     |
     |
      --> rose

    --- ---      --- ---
   |   |   |--> |   |   |--> buttercup
    --- ---      --- ---
     |            |
     |            |
      --> rose     --> violet

    --- ---      --- ---
   |   |   |--> |   |   |--> nil
    --- ---      --- ---
     |            |
     |            |
      --> rose     --> violet

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

(setq alist-of-colors
      '((rose . red) (lily . white) (buttercup . yellow)))

"It is useful to include newlines
in documentation strings,
but the newline is \
ignored if escaped."
     ⇒ "It is useful to include newlines
in documentation strings,
but the newline is ignored if escaped."

#("characters" property-data...)

beg end plist

#("foo bar" 0 3 (face bold) 3 4 nil 4 7 (face italic))

[1 "two" (three)]      ; 包含三个元素的向量
     ⇒ [1 "two" (three)]

(make-bool-vector 3 t)
     ⇒ #&3"^G"
(make-bool-vector 3 nil)
     ⇒ #&3"^@"

(equal #&3"\377" #&3"\007")
     ⇒ t

(make-hash-table)
     ⇒ #s(hash-table)

(symbol-function 'car)          ; 访问符号的函数单元。即获取符号绑定的函数

     ⇒ #<subr car>             ; 输出：#<subr car>
(subrp (symbol-function 'car))  ; 这是一个原始函数吗？
     ⇒ t                       ; 是。

Next: 循环对象的读取语法, Previous: 编程类型, Up: Lisp 数据类型   [Contents][Index]

2.5 编辑类型 ¶

上一节介绍的类型用于通用编程，其中大多数在各 Lisp 方言中都很常见。Emacs Lisp 还提供了若干专门用于编辑操作的额外数据类型。

• 缓冲区类型
• 标记类型
• 窗口类型
• 框架类型
• 终端类型
• 窗口配置类型
• 框架配置类型
• 进程类型
• 线程类型
• 互斥锁类型
• 条件变量类型
• 流类型
• 按键映射类型
• 覆盖层类型
• 字体类型
• 组件部件类型

(current-buffer)
     ⇒ #<buffer objects.texi>

(point-marker)
     ⇒ #<marker at 10779 in objects.texi>

(selected-window)
     ⇒ #<window 1 on objects.texi>

(selected-frame)
     ⇒ #<frame [email protected] 0xdac80>

(get-device-terminal nil)
     ⇒ #<terminal 1 on /dev/tty>

(process-list)
     ⇒ (#<process shell>)

(all-threads)
    ⇒ (#<thread 0176fc40>)

(make-mutex "my-mutex")
    ⇒ #<mutex my-mutex>
(make-mutex)
    ⇒ #<mutex 01c7e4e0>

(make-condition-variable (make-mutex))
    ⇒ #<condvar 01c45ae8>

Next: 类型谓词, Previous: 编辑类型, Up: Lisp 数据类型   [Contents][Index]

2.6 循环对象的读取语法 ¶

要在一组 Lisp 对象中表示共享或循环结构，你可以使用读取器构造符 ‘#n=’ 和 ‘#n#’。

在一个对象前使用 #n= 可为其添加标签，以便后续引用；之后，你可以在其他位置使用 #n# 来引用同一个对象。其中 n 是某个整数。例如，以下写法可创建一个列表，使其第一个元素同时作为第三个元素出现：

(#1=(a) b #1#)

这与如下普通语法不同：

((a) b (a))

后者生成的列表中，第一个和第三个元素看起来相同，但并非同一个 Lisp 对象。以下代码可体现这种差异：

(prog1 nil
  (setq x '(#1=(a) b #1#)))
(eq (nth 0 x) (nth 2 x))
     ⇒ t
(setq x '((a) b (a)))
(eq (nth 0 x) (nth 2 x))
     ⇒ nil

你也可以使用相同的语法创建循环结构（即对象自身包含自身作为元素）。示例如下：

#1=(a #1#)

这会创建一个列表，其第二个元素就是该列表本身。可通过以下方式验证其效果：

(prog1 nil
  (setq x '#1=(a #1#)))
(eq x (cadr x))
     ⇒ t

若将变量 print-circle 绑定为非-nil 值，Lisp 打印器会生成此类语法，以记录 Lisp 对象中的循环和共享结构。See 影响输出的变量。

Next: 相等性谓词, Previous: 循环对象的读取语法, Up: Lisp 数据类型   [Contents][Index]

2.7 类型谓词 ¶

Emacs Lisp 解释器本身不会在函数调用时，对传递给函数的实际参数执行类型检查。这是因为 Lisp 中的函数参数不像其他编程语言那样有声明的数据类型，因此解释器无法完成这类检查。故而，需要由各个函数自行检验每个实际参数是否属于该函数可处理的类型。

所有内置函数都会在适当时机检查其实际参数的类型；若参数类型错误，会触发 wrong-type-argument 错误。例如，向 + 函数传入其无法处理的参数时，会出现如下情况：

(+ 2 'a)
     error→ Wrong type argument: number-or-marker-p, a  

若希望程序根据不同类型执行不同逻辑，必须显式进行类型检查。检查对象类型最常用的方式是调用 type predicate类型谓词 函数。Emacs 为每种类型都提供了对应的类型谓词，同时也包含一些针对类型组合的谓词。

类型谓词函数接收一个参数：若该参数属于对应类型，则返回 t，否则返回 nil。遵循 Lisp 谓词函数的通用约定，大多数类型谓词的名称以 ‘p’ 结尾。

以下示例使用谓词 listp 检查列表类型、symbolp 检查符号类型：

(defun add-on (x)
  (cond ((symbolp x)
         ;; If X is a symbol, put it on LIST.
         (setq list (cons x list)))
        ((listp x)
         ;; If X is a list, add its elements to LIST.
         (setq list (append x list)))
        (t
         ;; We handle only symbols and lists.
         (error "Invalid argument %s in add-on" x))))

下表按字母顺序列出了预定义的类型谓词，并标注了进一步说明的引用位置：

atom

See atom.

arrayp

See arrayp.

bignump

See bignump.

bool-vector-p

See bool-vector-p.

booleanp

See booleanp.

bufferp

See bufferp.

byte-code-function-p

See byte-code-function-p.

case-table-p

See case-table-p.

char-or-string-p

See char-or-string-p.

char-table-p

See char-table-p.

closurep

See closurep.

commandp

See commandp.

compiled-function-p

See compiled-function-p.

condition-variable-p

See condition-variable-p.

consp

See consp.

custom-variable-p

See custom-variable-p.

fixnump

See fixnump.

floatp

See floatp.

fontp

See 底层字体表示.

frame-configuration-p

See frame-configuration-p.

frame-live-p

See frame-live-p.

framep

See framep.

functionp

See functionp.

hash-table-p

See hash-table-p.

integer-or-marker-p

See integer-or-marker-p.

integerp

See integerp.

interpreted-function-p

See interpreted-function-p.

keymapp

See keymapp.

keywordp

See 永不改变的变量.

listp

See listp.

markerp

See markerp.

mutexp

See mutexp.

nlistp

See nlistp.

number-or-marker-p

See number-or-marker-p.

numberp

See numberp.

obarrayp

See obarrayp.

overlayp

See overlayp.

processp

See processp.

recordp

See recordp.

sequencep

See sequencep.

string-or-null-p

See string-or-null-p.

stringp

See stringp.

subrp

See subrp.

symbolp

See symbolp.

syntax-table-p

See syntax-table-p.

threadp

See threadp.

vectorp

See vectorp.

wholenump

See wholenump.

window-configuration-p

See window-configuration-p.

window-live-p

See window-live-p.

windowp

See windowp.

检查对象类型最通用的方式是调用 type-of 函数。需注意，每个对象仅属于一种原始类型； type-of 会返回该对象所属的原始类型（see Lisp 数据类型）。但 type-of 无法识别非原始类型，因此在大多数情况下，使用类型谓词比 type-of 更合适。

Function: type-of object ¶

该函数返回一个符号，代表 object 的原始类型。返回值为以下符号之一： bool-vector, buffer, char-table, compiled-function, condition-variable, cons, finalizer, float, font-entity, font-object, font-spec, frame, hash-table, integer, marker, mutex, obarray, overlay, process, string, subr, symbol, thread, vector, window, or window-configuration。 但如果 object 是记录（record），则返回其第一个槽位指定的类型；记录。

(type-of 1)
     ⇒ integer

(type-of 'nil)
     ⇒ symbol
(type-of '())    ; () is nil.
     ⇒ symbol
(type-of '(x))
     ⇒ cons
(type-of (record 'foo))
     ⇒ foo

Function: cl-type-of object ¶

该函数返回一个符号，代表 object 的类型。其行为通常与 type-of 一致，但会保证返回尽可能精确的类型 — 这也意味着，它返回的具体类型可能随 Emacs 版本变化。因此，原则上不应将其返回值与固定的类型集合做比较。

(cl-type-of 1)
     ⇒ fixnum

(cl-type-of 'nil)
     ⇒ null
(cl-type-of (record 'foo))
     ⇒ foo

Next: 可变性, Previous: 类型谓词, Up: Lisp 数据类型   [Contents][Index]

2.8 相等性谓词 ¶

本节介绍用于检验两个对象是否相等的函数。另有一些函数用于检验特定类型对象（如strings字符串）的内容是否相等，相关谓词可参见对应数据类型的说明章节。

Function: eq object1 object2 ¶

若 object1 和 object2 是同一个对象，该函数返回 t，否则返回 nil。

如果 object1 和 object2 是名称相同的符号，它们通常是同一个对象 — 但存在例外情况（创建与编入符号）。对于其他非数值类型（如列表、向量、字符串），即便内容或元素完全相同，它们也不一定满足 eq 相等：只有当它们是同一个对象时才会 eq 相等，这意味着修改其中一个的内容，另一个的内容也会同步发生相同的变化。

如果 object1 和 object2 是类型或数值不同的数字，那么它们不可能是同一个对象，eq 返回 nil。如果它们是值相同的定点数（fixnum），那么它们是同一个对象，eq 返回 t。如果它们是分别计算得到，但恰好值相同且属于非定点数类型，那么它们可能是同一个对象，也可能不是；eq 会返回 t 或 nil，取决于 Lisp 解释器创建的是一个对象还是两个对象。

如果 object1 或 object2 是带位置信息的符号，当 symbols-with-pos-enabled 为非-nil 时，eq 会将其视为无附加信息的原始符号（see 带位置信息的符号）。

(eq 'foo 'foo)
     ⇒ t

(eq ?A ?A)
     ⇒ t

(eq 3.0 3.0)
     ⇒ t or nil
;; 数值相等的浮点数可能是、也可能不是同一个对象

(eq (make-string 3 ?A) (make-string 3 ?A))
     ⇒ nil

(eq "asdf" "asdf")
     ⇒ t or nil
;; 内容相等的字符串常量可能是、也可能不是同一个对象

(eq '(1 (2 (3))) '(1 (2 (3))))
     ⇒ nil

(setq foo '(1 (2 (3))))
     ⇒ (1 (2 (3)))
(eq foo foo)
     ⇒ t
(eq foo '(1 (2 (3))))
     ⇒ nil

(eq [(1 2) 3] [(1 2) 3])
     ⇒ nil

(eq (point-marker) (point-marker))
     ⇒ nil

make-symbol 函数会返回一个未存入（uninterned）的符号，它与直接书写符号名得到的符号是不同的对象。即便名称相同，不同的符号也不会是 eq 的。See 创建与编入符号。

(eq (make-symbol "foo") 'foo)
     ⇒ nil

Emacs Lisp 字节编译器可能会把完全相同的字面量对象（比如字面字符串）合并成指向同一个对象的引用。这会导致一个结果：经过字节编译的代码里这些对象用 eq 比较会相等，而同样代码在解释执行时却不相等。 因此，你的代码永远不应该依赖“内容相同的字面量对象用 eq 比较是否相等” 这一点，而应该使用下文介绍的、用于比较对象内容的函数，例如 equal。 同理，你的代码不应该修改字面量对象（比如给字面字符串添加文本属性），因为如果字节编译器把它们合并了，这样的修改可能会影响到其他内容相同的字面量对象。

Function: equal object1 object2 ¶

如果 object1 和 object2 的组成部分相等，该函数返回 t，否则返回 nil。eq 用于判断参数是否为同一个对象，而 equal 会深入不同对象的内部，检查它们的元素或内容是否相同。 因此：如果两个对象满足 eq，则一定满足 equal；但反过来不一定成立。

(equal 'foo 'foo)
     ⇒ t

(equal 456 456)
     ⇒ t

(equal "asdf" "asdf")
     ⇒ t

(eq "asdf" "asdf")
     ⇒ nil

(equal '(1 (2 (3))) '(1 (2 (3))))
     ⇒ t

(eq '(1 (2 (3))) '(1 (2 (3))))
     ⇒ nil

(equal [(1 2) 3] [(1 2) 3])
     ⇒ t

(eq [(1 2) 3] [(1 2) 3])
     ⇒ nil

(equal (point-marker) (point-marker))
     ⇒ t

(eq (point-marker) (point-marker))
     ⇒ nil

equal 函数按值比较字符串和布尔向量。数值则使用 eql，同时比较类型和数值。list(列表)、cons 单元、vector(向量)、record(记录)、marker(标记)、char-table(字符表)、font object(字体对象)以及function object(函数对象)（闭包）² 会通过对其组成部分递归调用 equal 来进行比较。

字符串的比较区分大小写，但不考虑文本属性 — 它只比较字符串里的字符。See 文本属性。若要同时比较文本属性，请使用 equal-including-properties。出于技术原因，单字节字符串与多字节字符串 equal 相等的充要条件是：它们包含完全相同的字符编码序列，并且所有编码都在 0～127（ASCII）范围内。

(equal "asdf" "ASDF")
     ⇒ nil

如果 object1 或 object2 包含带位置信息的符号，当 symbols-with-pos-enabled 为非-nil 时，equal 会将它们当作普通裸符号处理。否则，equal 会通过比较各个组成部分来判断两个带位置信息的符号是否相等。See 带位置信息的符号。

其他对象只有在满足 eq 时，才会被认为是 equal。例如，两个不同的缓冲区（buffer）即使文本内容相同，也永远不会被视为相等。

equal 的相等性是递归定义的；例如，给定两个 cons 单元 x 和 y，(equal x y) 返回 t，当且仅当下面两个表达式都返回 t：

(equal (car x) (car y))
(equal (cdr x) (cdr y))

因此，比较循环列表可能会引发深层递归并导致报错，还可能出现违反直觉的行为 — 例如 (equal a b) 返回 t，而 (equal b a) 却触发错误。

Function: equal-including-properties object1 object2 ¶

该函数在所有场景下的行为均与 equal 一致，但额外要求：若两个字符串要判定为相等，必须具备完全相同的文本属性。

(equal "asdf" (propertize "asdf" 'asdf t))
     ⇒ t

(equal-including-properties "asdf"
                            (propertize "asdf" 'asdf t))
     ⇒ nil

Next: Emacs Lisp 对象的类型层次, Previous: 相等性谓词, Up: Lisp 数据类型   [Contents][Index]

2.9 可变性 ¶

有些 Lisp 对象永远不应该被修改。例如，Lisp 表达式 "aaa" 会生成一个字符串，但你不应该修改它的内容。还有一些对象本身就无法被修改；例如，虽然你可以通过计算得到一个新的数字，但 Lisp 不提供任何操作来修改一个已存在数字的值。

另一些 Lisp 对象是 可变的(mutable)：通过带有副作用的破坏性操作来修改它们的值是安全的。例如，一个已存在的标记（marker）可以通过移动到其他位置来被修改

虽然数字永远不可变、所有标记都是可变的，但某些类型既有可变成员，也有不可变成员。这些类型包括：点对（cons）、向量和字符串。例如：尽管 "cons" 和 (symbol-name 'cons) 都生成不应该被修改的字符串，但 (copy-sequence "cons") 和 (make-string 3 ?a) 都会生成可变字符串，后续可以通过 aset 来修改。

如果一个可变对象成为了被 eval 求值的表达式的一部分，它就不再是可变的。示例：

(let* ((x (list 0.5))
       (y (eval (list 'quote x))))
  (setcar x 1.5) ;; 程序不应该这么做
  y)

虽然列表 (0.5) 在创建时是可变的，但因为它被传给了 eval，就不应该再用 setcar 修改。反向情况不会发生：本就不应该被修改的对象，之后永远不会变成可变对象。

如果程序试图修改不应该被修改的对象，其行为是未定义的：Lisp 解释器可能会抛出错误，也可能崩溃，或以其他不可预测的方式运行。³

当相似的常量作为程序的一部分出现时，Lisp 解释器可能会为了节省时间或空间，复用已有的常量或其组成部分。例如：(eq "abc" "abc") 在解释器只创建一个字符串字面量 "abc" 实例时返回 t，创建两个实例时返回 nil。编写 Lisp 程序时，应保证无论是否启用这类优化，程序都能正常运行。

Previous: 可变性, Up: Lisp 数据类型   [Contents][Index]

2.10 Emacs Lisp 对象的类型层次 ¶

Lisp 对象类型按层次结构组织，这意味着类型可以从其他类型派生而来。派生自类型 A 的类型 B 的对象，会继承类型 A 的所有特性。这也表示：每个类型 B 的对象，同时也是它所派生自的类型 A 的对象。

所有类型都派生自类型 t。

用户可以通过 defclass 或 cl-defstruct 定义新类型。

原始类型的 Lisp 类型层次结构可表示如下：

例如，list列表 类型派生自 sequence序列 类型，而序列类型本身又派生自 t。

Next: 浮点数基础, Up: 数值   [Contents][Index]

3.1 整数基础 ¶

Lisp 读取器将整数解析为非空十进制数字序列，可带可选的正负号，以及可选的末尾句点。

 1               ; The integer 1.
 1.              ; The integer 1.
+1               ; Also the integer 1.
-1               ; The integer −1.
 0               ; The integer 0.
-0               ; The integer 0.

非十进制进制的整数语法为：以 ‘#’ 开头，后跟进制标识，再跟一位或多位数字。进制标识：‘b’ 为二进制、‘o’ 为八进制、‘x’ 为十六进制、‘radixr’ 为自定义 radix 进制。因此，‘#binteger’ 按二进制读取 integer，‘#radixrinteger’ 按 radix 进制读取 integer。radix 的值合法进制范围：2～36。合法数字：从 ‘0’–‘9’、‘A’–‘Z’ 中取前 radix 个字符。字母大小写不敏感，不能带符号或末尾句点。 示例：

#b101100 ⇒ 44
#o54 ⇒ 44
#x2c ⇒ 44
#24r1k ⇒ 44

要理解各类整数相关函数，尤其是按位运算符（see 整数的按位运算），通常需要以二进制形式看待数值。

十进制整数 5 的二进制形式：

...000101

（省略号 ‘…’ 表示理论上无限多的前导相同位，这里是无限个 0。后续示例也会使用此 ‘…’ 写法。）

整数 −1 的二进制形式：

...111111

−1 表示为全 1，这称为 two’s complement二进制补码 表示法。

从 −1 减去 4 得到负整数 −5。十进制 4 的二进制是 100，因此 −5 的二进制为：

...111011

本章介绍的许多函数可以接受标记（marker） 代替数值作为参数。（See 标记。）由于这类函数的实参可以是数值或标记，我们常将参数命名为 number-or-marker。当参数是标记时，使用其位置值，忽略其所在缓冲区。

在 Emacs Lisp 中，文本字符用整数表示。0 到 (max-char)（包含）之间的任意整数都可作为合法字符。See 字符编码。

Emacs Lisp 的整数不受机器字长限制。但底层实现上，整数分为两类：较小的整数为 fixnums定长数、较大的整数为 bignum大数。 通常 Emacs Lisp 代码不应依赖整数是 fixnum 还是 bignum。但旧版 Emacs 只支持 fixnum，部分函数仍只接受 fixnum，旧代码在使用 bignum 时可能出错。例如：旧代码可用 eq 判断整数相等；但引入 bignum 后，应使用 eql 或 = 比较整数。

bignum 的取值范围受以下因素限制：主存大小、机器特性（如表示 bignum 指数的字长）、integer-width 变量。 其限制通常比 fixnum 宽松得多。bignum 与 fixnum 不会数值相等：在 fixnum 范围内的整数，Emacs 永远用 fixnum 表示，而非 bignum。

fixnum 的范围取决于机器。最小范围：−536,870,912 ～ 536,870,911（30 位，即 −2**29 到 2**29 − 1）， 但很多机器支持更宽范围。

Variable: most-positive-fixnum ¶

该变量的值是 Emacs Lisp 能处理的最大 “samll(小整数)”。典型值： 32 位平台为 2**29 − 1 和64 位平台为 2**61 − 1

Variable: most-negative-fixnum ¶

该变量的值是 Emacs Lisp 能处理的最小 “samll(小整数)”，为负数。典型值： 32 位平台为 −2**29 和64 位平台为 −2**61

Variable: integer-width ¶

该变量为非负整数，用于控制：当计算出超大整数时，Emacs 是否抛出范围错误。绝对值小于 2**n， （n 为该变量值）的整数不会抛出范围错误。尝试创建更大的整数时通常会报错，除非能低成本生成。将此变量设得很大，在生成超大整数时可能代价很高。

Next: 数值类型谓词, Previous: 整数基础, Up: 数值   [Contents][Index]

3.2 浮点数基础 ¶

浮点数适用于表示非整数数值。其取值范围与你所用机器上 C 语言的 double 数据类型一致。在几乎所有 Emacs 支持的计算机上，浮点数均采用 IEEE binary64（双精度）浮点格式—— 该格式由 IEEE Std 754-2019 标准化，David Goldberg 的论文 “What Every Computer Scientist Should Know About Floating-Point Arithmetic” 也对其有深入探讨。现代平台上的浮点运算基本遵循 IEEE-754 标准，但部分系统（尤其是 32 位 x86 架构）的运算结果可能无法保证正确舍入。

在某些老旧计算机系统上，Emacs 可能不使用 IEEE 浮点数。我们已知有一个这样的系统：运行 NetBSD 并使用 GCC 10.4.0 的 VAX 计算机，Emacs 可以正常运行，但不遵循 IEEE-754，而是改用 VAX 的 ‘D_Floating’ 格式。基于 IBM System/370 的大型机及其 XL/C 编译器也支持十六进制浮点数格式，但 Emacs 尚未在这类配置下编译构建过。

浮点数的读取语法要求必须包含小数点、指数，或两者同时具备。数值及其指数前可添加可选符号（‘+’ 或 ‘-’）。例如，‘1500.0’、‘+15e2’、‘15.0e+2’、‘+1500000e-3’ 和 ‘.15e4’ 是表示数值 1500 的五种浮点数写法，它们完全等价。与 Common Lisp 一致，Emacs Lisp 规定：对于不含指数的浮点数，小数点后必须至少有一位数字；因此 ‘1500.’ 会被解析为整数，而非浮点数。

在 = 等数值比较操作中，Emacs Lisp 将 -0.0 视为与普通零在数值上相等。这一行为遵循 IEEE 浮点标准 —— 该标准规定，即便其他操作可区分 -0.0 和 0.0，二者在数值层面仍相等。

IEEE 浮点标准支持将正无穷和负无穷作为浮点值，还定义了一类名为 NaN （即 “not a number非数值”）的值；当数值函数无合法计算结果时，会返回此类值。例如，(/ 0.0 0.0) 会返回 NaN。NaN 在数值上永不等于任何值，甚至不等于其自身。NaN 包含符号和尾数，若两个 NaN 的符号与尾数均一致，非数值函数会将它们判定为相等。NaN 的尾数及其字符串表示形式均依赖于具体机器。

当涉及 NaN 和带符号零（0.0 或 −0.0）时，eql、equal、sxhash-eql、sxhash-equal 和 gethash 这类非数值函数判断的是值是否不可区分，而非数值上是否相等。例如：当 x 和 y 是同一个 NaN 时，(equal x y) 返回 t，而 (= x y) 进行数值比较，返回 nil；反之，(equal 0.0 -0.0) 返回 nil，而 (= 0.0 -0.0) 返回 t。

以下是这些特殊浮点值的读取语法：

infinity

无穷大：‘1.0e+INF’ 和 ‘-1.0e+INF’

not-a-number

非数值（NaN）：‘0.0e+NaN’ 和 ‘-0.0e+NaN’

在不支持 IEEE 浮点运算的老旧系统中，无穷大和 NaN 不可用。例如在 1980 年左右的 VAX 机器上，Lisp 会将 ‘1.0e+INF’ 解析为一个很大但有限的浮点数，将 ‘0.0e+NaN’ 解析为其他非数值型 Lisp 对象，若将其用于数值运算会触发错误。

以下是专门用于处理浮点数的函数：

Function: isnan x ¶

该谓词函数的返回值规则：若浮点类型参数 x 是 NaN，返回 t；否则返回 nil。

Function: frexp x ¶

该函数返回一个 cons 单元格 (s . e)，其中 s 和 e 分别是浮点数 x 的尾数（significand）和指数（exponent）。

若 x 是有限值：s 是介于 0.5（包含）和 1.0（不包含）之间的浮点数，e 是整数，且满足 x = s * 2**e。 若 x 是 0 或无穷大：s 与 x 相等。 若 x 是 NaN：s 也为 NaN。 若 x 是 0，e 为 0。

Function: ldexp s e ¶

给定数值型尾数 s 和整数型指数 e，该函数返回浮点数结果为 s * 2**e。

Function: copysign x1 x2 ¶

该函数将 x2 的符号复制到 x1 的数值上，并返回结果。x1 和 x2 必须均为浮点类型。

Function: logb x ¶

该函数返回 x 的二进制指数。更精确地说： 若 x 是有限非零值，返回值为 \(|x|\) 以 2 为底的对数，向下取整为整数； 若 x 是 0 或无穷大，返回值为无穷大； 若 x 是 NaN，返回值为 NaN。

(logb 10)
     ⇒ 3
(logb 10.0e20)
     ⇒ 69
(logb 0)
     ⇒ -1.0e+INF

Next: 数值比较, Previous: 浮点数基础, Up: 数值   [Contents][Index]

3.3 数值类型谓词 ¶

本节中的函数用于检测一个对象是否为数值，或是某一特定类型的数值。函数 integerp 和 floatp 可以接受任意类型的 Lisp 对象作为参数（否则它们就没太大用处了），但谓词 zerop 要求参数必须是数值。另见 标记判断函数 一节中的 integer-or-marker-p 和 number-or-marker-p。

Function: bignump object ¶

该谓词检测参数是否为大数（大整数），是则返回 t，否则返回 nil。 与小整数不同，大数即使不满足 eq 相等，也可能满足 = 或 eql 相等。

Function: fixnump object ¶

该谓词检测参数是否为定长数（小整数），是则返回 t，否则返回 nil。小整数可以用 eq 进行比较。

Function: floatp object ¶

该谓词检测参数是否为浮点数，是则返回 t，否则返回 nil。

Function: integerp object ¶

该谓词检测参数是否为整数（包含大数与定长数），是则返回 t，否则返回 nil。

Function: numberp object ¶

该谓词检测参数是否为数值（整数或浮点数均可），是则返回 t，否则返回 nil。

Function: natnump object ¶

该谓词（名称来自 “natural number自然数”）检测参数是否为非负整数，是则返回 t，否则返回 nil。0 被视为非负整数。

wholenump 是 natnump 的同义词。

Function: zerop number ¶

该谓词检测参数是否为零，是则返回 t，否则返回 nil。参数必须是数值。

(zerop x) 等价于 (= x 0)。

Next: 数值转换, Previous: 数值类型谓词, Up: 数值   [Contents][Index]

3.4 数值比较 ¶

要判断数值是否相等，通常应使用 =，而不是 eq、eql、equal 这类非数值比较谓词。不同的浮点数对象或大整数对象，在数值上可能相等。如果用 eq 比较，判断的是它们是否为同一个 对象；如果用 eql 或 equal，判断的是它们的值是否 indistinguishable不可区分；而 = 采用纯数值比较，有时会在非数值比较返回 nil 时返回 t，反之亦然。See 浮点数基础。

在 Emacs Lisp 中，如果两个定长数（fixnum）数值相等，它们就是同一个 Lisp 对象。也就是说，对定长数而言，eq 等价于 =。有时用 eq 把未知值与定长数比较会更方便，因为即使未知值不是数字，eq 也不会报错 —— 它接受任意类型的参数。相比之下，如果参数不是数字或标记（marker），= 会抛出错误。不过，只要可以，即使是比较整数，更好的编程习惯仍是使用 =。

有时用 eql 或 equal 比较数字会很有用：只有当两个数类型相同（同为整数或同为浮点数）且值相同时，它们才被视为相等。而 = 可以把一个整数和一个浮点数视为相等。See 相等性谓词。

还有一个细节：由于浮点数运算不精确，直接判断浮点数是否相等通常是不合适的。一般更好的做法是判断近似相等。下面是实现这一功能的函数：

(defvar fuzz-factor 1.0e-6)
(defun approx-equal (x y)
  (or (= x y)
      (< (/ (abs (- x y))
            (max (abs x) (abs y)))
         fuzz-factor)))

Function: = number-or-marker &rest number-or-markers ¶

该函数判断所有参数是否数值上都相等，是则返回 t，否则返回 nil。

Function: eql value1 value2 ¶

该函数行为与 eq 基本一致，仅当两个参数都是数字时例外。它会同时按类型和数值比较数字： (eql 1.0 1) 返回 nil，但 (eql 1.0 1.0) 和 (eql 1 1) 都返回 t。 它可用于比较小整数和大整数。符号、指数、尾数都相同的浮点数才满足 eql。这与数值比较不同：(eql 0.0 -0.0) 返回 nil，(eql 0.0e+NaN 0.0e+NaN) 返回 t，而 = 的结果正好相反。

Function: /= number-or-marker1 number-or-marker2 ¶

该函数判断两个参数是否数值不相等，不相等返回 t，相等返回 nil。

Function: < number-or-marker &rest number-or-markers ¶

判断每个参数是否严格小于后一个参数，是则返回 t，否则返回 nil。

Function: <= number-or-marker &rest number-or-markers ¶

判断每个参数是否小于等于后一个参数，是则返回 t，否则返回 nil。

Function: > number-or-marker &rest number-or-markers ¶

判断每个参数是否严格大于后一个参数，是则返回 t，否则返回 nil。

Function: >= number-or-marker &rest number-or-markers ¶

判断每个参数是否大于等于后一个参数，是则返回 t，否则返回 nil。

Function: max number-or-marker &rest numbers-or-markers ¶

返回所有参数中的最大值。

(max 20)
     ⇒ 20
(max 1 2.5)
     ⇒ 2.5
(max 1 3 2.5)
     ⇒ 3

Function: min number-or-marker &rest numbers-or-markers ¶

返回所有参数中的最小值。

(min -4 1)
     ⇒ -4

Function: abs number ¶

返回 number 的绝对值。

Next: 算术运算, Previous: 数值比较, Up: 数值   [Contents][Index]

3.5 数值转换 ¶

要将整数转换为浮点数，使用函数 float。

Function: float number ¶

返回将 number 转换为浮点数后的结果。如果 number 已经是浮点数，float 原样返回。

有四个函数可将浮点数转换为整数，它们的舍入方式不同。所有这些函数都接受参数 number 和可选参数 divisor。两个参数都可以是整数或浮点数，divisor 也可以是 nil。 如果 divisor 为 nil 或被省略，这些函数将 number 转换为整数；若已是整数则直接返回。 如果 divisor 非-nil，它们会将 number 除以 divisor，再把结果转为整数。 如果 divisor 为 0（整数或浮点数），Emacs 会抛出 arith-error 错误。

Function: truncate number &optional divisor ¶

通过向零舍入，将 number 转换为整数并返回。

(truncate 1.2)
     ⇒ 1
(truncate 1.7)
     ⇒ 1
(truncate -1.2)
     ⇒ -1
(truncate -1.7)
     ⇒ -1

Function: floor number &optional divisor ¶

通过向下舍入（向负无穷方向），将 number 转换为整数并返回。

如果指定了 divisor，该函数使用与 mod 对应的除法方式，向下舍入。

(floor 1.2)
     ⇒ 1
(floor 1.7)
     ⇒ 1
(floor -1.2)
     ⇒ -2
(floor -1.7)
     ⇒ -2
(floor 5.99 3)
     ⇒ 1

Function: ceiling number &optional divisor ¶

通过向上舍入（向正无穷方向），将 number 转换为整数并返回。

(ceiling 1.2)
     ⇒ 2
(ceiling 1.7)
     ⇒ 2
(ceiling -1.2)
     ⇒ -1
(ceiling -1.7)
     ⇒ -1

Function: round number &optional divisor ¶

通过四舍五入到最近整数，将 number 转换为整数并返回。若数值恰好处于两个整数中间，会舍入到偶数。

(round 1.2)
     ⇒ 1
(round 1.7)
     ⇒ 2
(round -1.2)
     ⇒ -1
(round -1.7)
     ⇒ -2

Next: 舍入运算, Previous: 数值转换, Up: 数值   [Contents][Index]

3.6 算术运算 ¶

Emacs Lisp 提供传统的四种算术运算（addition加、subtraction减、multiplication乘、division除），以及取余、取模、自增 1 和自减 1 函数。除 % 外，这些函数均接受整数和浮点数参数，只要任意一个参数是浮点数，就返回浮点数。

Function: 1+ number-or-marker ¶

返回 number-or-marker 加 1。 示例：

(setq foo 4)
     ⇒ 4
(1+ foo)
     ⇒ 5

该函数不等价于 C 语言的 ++ — 它不会修改变量，只做加法计算。因此继续执行：

foo
     ⇒ 4

若要真正修改变量，必须配合 setq，如下：

(setq foo (1+ foo))
     ⇒ 5

Function: 1- number-or-marker ¶

返回 number-or-marker 减 1。

Function: + &rest numbers-or-markers ¶

对所有参数求和。无参数时返回 0。

(+)
     ⇒ 0
(+ 1)
     ⇒ 1
(+ 1 2 3 4)
     ⇒ 10

Function: - &optional number-or-marker &rest more-numbers-or-markers ¶

- 有两个作用：取负、减法。 单个参数：返回其相反数； 多个参数：从第一个数 number-or-marker 中依次减去后面所有数 more-numbers-or-markers； 无参数：返回 0。

(- 10 1 2 3 4)
     ⇒ 0
(- 10)
     ⇒ -10
(-)
     ⇒ 0

Function: * &rest numbers-or-markers ¶

对所有参数求积。无参数时返回 1。

(*)
     ⇒ 1
(* 1)
     ⇒ 1
(* 1 2 3 4)
     ⇒ 24

Function: / number &rest divisors ¶

有一个或多个 divisors除数：将 number 依次除以每个 divisors除数，返回商； 无除数：返回 1/number（即倒数）。每个参数都可以是数值或标记（marker）

若所有参数均为整数，结果为整数，每次除法后向零取整。

(/ 6 2)
     ⇒ 3

(/ 5 2)
     ⇒ 2

(/ 5.0 2)
     ⇒ 2.5

(/ 5 2.0)
     ⇒ 2.5

(/ 5.0 2.0)
     ⇒ 2.5

(/ 4.0)
     ⇒ 0.25

(/ 4)
     ⇒ 0

(/ 25 3 2)
     ⇒ 4

(/ -17 6)
     ⇒ -2

如果将整数除以整数 0，Emacs 会抛出 arith-error 错误（see 错误）。 在使用 IEEE-754 浮点数的系统上，非零浮点数除以 0 会得到正无穷或负无穷（see 浮点数基础）；否则，会照常抛出 arith-error 错误。

Function: % dividend divisor ¶

该函数返回 dividend被除数除以 divisor除数 后的整数余数。参数必须是整数或标记（marker）。

对于任意两个整数 dividend被除数 和 divisor除数，当除数非零时：

(+ (% dividend divisor)
   (* (/ dividend divisor) divisor))

在 divisor除数 不为零时，结果恒等于 dividend被除数。

(% 9 4)
     ⇒ 1
(% -9 4)
     ⇒ -1
(% 9 -4)
     ⇒ 1
(% -9 -4)
     ⇒ -1

Function: mod dividend divisor ¶

该函数返回 dividend被除数 对 divisor除数 取模的结果；换句话说，是 dividend被除数 除以 divisor除数 的余数，但符号与除数相同。参数必须是数值或标记。

与 % 不同，mod 允许浮点数参数；它会将商向下取整（向负无穷方向），再用该商计算余数。

若 divisor除数 为 0，如果两个参数都是整数，mod 抛出 arith-error 错误，否则返回 NaN。

(mod 9 4)
     ⇒ 1

(mod -9 4)
     ⇒ 3

(mod 9 -4)
     ⇒ -3

(mod -9 -4)
     ⇒ -1

(mod 5.5 2.5)
     ⇒ .5

对于任意两个数值 dividend被除数 和 divisor除数，

(+ (mod dividend divisor)
   (* (floor dividend divisor) divisor))

恒等于 dividend被除数；若任一参数为浮点数，则可能存在舍入误差；若 dividend被除数 是整数且 divisor除数 为 0，则抛出 arith-error。关于 floor，见 数值转换。

Next: 整数的按位运算, Previous: 算术运算, Up: 数值   [Contents][Index]

3.7 舍入运算 ¶

函数 ffloor、fceiling、fround 和 ftruncate 接收一个浮点型参数，并返回一个值为邻近整数的浮点型结果。ffloor 返回不大于参数的最接近整数；fceiling 返回不小于参数的最接近整数；ftruncate 向零方向取最接近的整数；fround 返回最接近的整数。

Function: ffloor float ¶

该函数将 float 向下取整至紧邻的更小整数，并以浮点数形式返回该值。

Function: fceiling float ¶

该函数将 float 向上取整至紧邻的更大整数，并以浮点数形式返回该值。

Function: ftruncate float ¶

该函数将 float 向零方向取整为整数，并以浮点数形式返回该值。

Function: fround float ¶

该函数将 float 取整至最接近的整数，并以浮点数形式返回该值。若数值恰好处于两个整数的正中间，则返回偶数。

Next: 标准数学函数, Previous: 舍入运算, Up: 数值   [Contents][Index]

3.8 整数的按位运算 ¶

在计算机中，整数以二进制数表示，即由若干 bits位（取值为 0 或 1 的数字）组成的序列。从概念上讲，该位序列在左侧是无限延伸的，最高位全为 0 或全为 1。按位运算会对该序列中的每一位单独操作。例如， shifting移位 操作会将整个序列向左或向右移动一位或多位，并保持原有模式。 Emacs Lisp 中的按位运算仅适用于整数。

Function: ash integer count ¶

ash（arithmetic shift算术移位）将整数 integer 的二进制位向左移动 count 位；若 count 为负数，则向右移动。左移会在右侧补 0；右移会丢弃最右侧的位。从整数运算角度看，ash 等价于将 integer 乘以 2**count， 然后向下取整（向负无穷方向）得到整数结果。

下面是 ash 分别左移、右移一位的示例。示例只展示低位二进制位，高位均与所示最高位保持一致。可以看到，左移一位等价于乘以 2，右移一位等价于除以 2 并向负无穷取整。

(ash 7 1) ⇒ 14
;; Decimal 7 becomes decimal 14.
...000111
     ⇒
...001110

(ash 7 -1) ⇒ 3
...000111
     ⇒
...000011

(ash -7 1) ⇒ -14
...111001
     ⇒
...110010

(ash -7 -1) ⇒ -4
...111001
     ⇒
...111100

左移或右移两位的示例：

                  ;         binary values
(ash 5 2)         ;   5  =  ...000101
     ⇒ 20         ;      =  ...010100
(ash -5 2)        ;  -5  =  ...111011
     ⇒ -20        ;      =  ...101100

(ash 5 -2)
     ⇒ 1          ;      =  ...000001

(ash -5 -2)
     ⇒ -2         ;      =  ...111110

Function: lsh integer count ¶

lsh 是 logical shift逻辑移位的缩写，将整数 integer 向左移动 count 位；若 count 为负数，则向右移动，空出的位一律补 0。若 count 为负，则 integer 必须是定长数（fixnum）或正的大数（bignum），且 lsh 会将负定长数视为无符号数处理：先减去两倍的 most-negative-fixnum 再移位，结果非负。这种特殊行为源于早期 Emacs 仅支持定长数的时代；现在更推荐使用 ash。

除了 integer 与 count 同时为负的情况外，lsh 与 ash 行为一致。下面示例聚焦这些例外情况，并假设使用 30 位定长数。

                 ;      binary values
(ash -7 -1)      ; -7 = ...111111111111111111111111111001
     ⇒ -4        ;    = ...111111111111111111111111111100
(lsh -7 -1)
     ⇒ 536870908 ;    = ...011111111111111111111111111100

(ash -5 -2)      ; -5 = ...111111111111111111111111111011
     ⇒ -2        ;    = ...111111111111111111111111111110
(lsh -5 -2)
     ⇒ 268435454 ;    = ...001111111111111111111111111110

Function: logand &rest ints-or-markers ¶

该函数返回所有参数的按位与结果：当且仅当所有参数的第 n 位都为 1 时，结果的第 n 位为 1。

例如，用 4 位二进制数表示，13 与 12 的按位与结果是 12：1101 与 1100 运算得到 1100。两个数最左侧两位都为 1，因此结果最左侧两位为 1；而最右侧两位至少有一个参数为 0，因此结果最右侧两位为 0。

所以，

(logand 13 12)
     ⇒ 12

若 logand 无参数，返回 −1。该 logand 数是按位与的单位元，因为其二进制全为 1。若 logand 只传入一个参数，直接返回该参数。

                   ;        binary values

(logand 14 13)     ; 14  =  ...001110
                   ; 13  =  ...001101
     ⇒ 12         ; 12  =  ...001100

(logand 14 13 4)   ; 14  =  ...001110
                   ; 13  =  ...001101
                   ;  4  =  ...000100
     ⇒ 4          ;  4  =  ...000100

(logand)
     ⇒ -1         ; -1  =  ...111111

Function: logior &rest ints-or-markers ¶

该函数返回所有参数的按位或结果：当且仅当至少一个参数的第 n 位为 1时，结果的第 n 位为 1。无参数时返回 0，是该运算的单位元。logior 只传入一个参数时，直接返回该参数。

                   ;        binary values

(logior 12 5)      ; 12  =  ...001100
                   ;  5  =  ...000101
     ⇒ 13         ; 13  =  ...001101

(logior 12 5 7)    ; 12  =  ...001100
                   ;  5  =  ...000101
                   ;  7  =  ...000111
     ⇒ 15         ; 15  =  ...001111

Function: logxor &rest ints-or-markers ¶

该函数返回所有参数的按位异或结果：当且仅当该位为 1 的参数个数是奇数时，结果的第 n 位为 1。无参数时返回 0，是该运算的单位元。logxor 只传入一个参数时，直接返回该参数。

                   ;        binary values

(logxor 12 5)      ; 12  =  ...001100
                   ;  5  =  ...000101
     ⇒ 9          ;  9  =  ...001001

(logxor 12 5 7)    ; 12  =  ...001100
                   ;  5  =  ...000101
                   ;  7  =  ...000111
     ⇒ 14         ; 14  =  ...001110

Function: lognot integer ¶

该函数返回参数的按位取反结果：当且仅当 integer 的第 n 位为 0时，结果的第 n 位为 1，反之亦然。结果等于：−1 − integer。

(lognot 5)
     ⇒ -6
;;  5  =  ...000101
;; becomes
;; -6  =  ...111010

Function: logcount integer ¶

该函数返回 integer整数 的 Hamming weight汉明重量：即 integer 二进制表示中 1 的个数。若 integer 为负数，则返回其二进制补码表示中 0 的个数。结果始终非负。

(logcount 43)     ;  43 = ...000101011
     ⇒ 4
(logcount -43)    ; -43 = ...111010101
     ⇒ 3

Next: 随机数, Previous: 整数的按位运算, Up: 数值   [Contents][Index]

3.9 标准数学函数 ¶

这些数学函数允许整数和浮点数作为参数。

Function: sin arg ¶

Function: cos arg ¶

Function: tan arg ¶

这是基础三角函数，参数 arg 的单位为弧度。

Function: asin arg ¶

(asin arg) 的返回值是介于 −pi/2 和 pi/2 （包含边界）之间的数值，其正弦值等于 arg。若 arg 超出范围（不在 [−1, 1] 区间内），asin 返回 NaN（非数值）。

Function: acos arg ¶

(acos arg) 的返回值是介于 0 到 pi （包含边界）之间的数值，其余弦值等于 arg。若 arg 超出范围（不在 [−1, 1] 区间内），acos 返回 NaN。

Function: atan y &optional x ¶

(atan y) 的返回值是介于 −pi/2 到 pi/2 （不含边界）之间的数值，其正切值等于 y。若传入可选的第二个参数 x，则 (atan y x) 返回向量 [x, y] 与 X 轴之间的夹角（单位：弧度）。

Function: exp arg ¶

这是指数函数，返回自然常数 \(e\) 的 arg 次幂（即 \(e^{arg}\)）。

Function: log arg &optional base ¶

该函数返回 arg 以 base 为底的对数值。若未指定 base，则使用自然底数 \(e\)。若 arg 或 base 为负数，log 返回 NaN。

Function: expt x y ¶

该函数返回 x 的 y 次幂（即 \(x^y\)）。 若两个参数均为整数且 y 非负，结果为整数；此场景下若发生溢出会触发错误，需注意。 若 x 是有限负数且 y 是有限非整数，expt 返回 NaN。

Function: sqrt arg ¶

该函数返回 arg 的平方根。若 arg 是有限数且小于 0，sqrt 返回 NaN。

此外，Emacs 还定义了以下常用数学常量：

Variable: float-e ¶

数学常量 \(e\)（值为 2.71828…）。

Variable: float-pi ¶

数学常量 \(pi\)（值为 3.14159…）。

Previous: 标准数学函数, Up: 数值   [Contents][Index]

3.10 随机数 ¶

确定性的计算机程序无法生成真正意义上的随机数。对绝大多数用途而言 pseudo-random numbers伪随机数 已经足够。伪随机数序列以确定性方式生成：这些数并非真正随机，但具备模仿随机序列的若干特性。例如，所有可能的取值在伪随机序列中出现的频率大致均等。

伪随机数由 seed value种子值 生成。从任意给定种子出发，random 函数总会生成相同的数值序列。默认情况下，Emacs 会在启动时初始化随机种子，使得每次运行 Emacs 得到的 random 序列（极大概率）互不相同。随机种子通常从系统熵源初始化；但在缺少熵池的旧平台上，种子会取自随机性较弱的易变数据（如当前时间）。

有时你希望随机数序列可复现。例如，调试行为依赖随机序列的程序时，让程序每次运行行为一致会很有帮助。要让序列可复现，执行 (random "")。这会将种子设为当前 Emacs 可执行文件对应的固定值（不同编译版本可能不同）。你也可以使用其他字符串来指定不同的种子。

Function: random &optional limit ¶

该函数返回一个伪随机整数。重复调用会生成一系列伪随机整数。

如果 limit 是正整数：返回非负且小于 limit 的整数。否则：返回值可以是任意定长整数（fixnum），即从 most-negative-fixnum 到 most-positive-fixnum 之间的任意整数（see 整数基础）。

如果 limit 是字符串：根据字符串内容设置新种子，后续 random 调用将返回可复现的结果序列。

如果 limit 是 t：按 Emacs 重启的方式重新选取种子，后续 random 调用将返回不可预测的结果序列。

如果你需要用于密码学场景的随机数（nonce），通常不建议使用 random，原因如下：

• 即便可以用 (random t) 读取系统熵，这也可能影响程序中依赖结果可复现性的其他部分。
• random 使用的、与系统相关的伪随机数生成器（PRNG）不一定适合密码学安全场景。
• (random t) 不会直接访问系统熵，熵会经过系统相关的 PRNG 处理，可能导致结果存在偏差。
• 常见平台上随机种子仅为 32 位，通常窄于 Emacs 定长整数，远不足以满足密码学安全要求。
• (random t) 会将相关信息散布在 Emacs 内部状态中，扩大内部攻击面。
• 在缺少熵池的旧平台上，(random t) 的种子来自密码学强度较弱的数据源。

Next: 字符串判断函数, Up: 字符串与字符   [Contents][Index]

4.1 字符串与字符基础 ¶

字符是一种 Lisp 对象，用于表示文本中的单个字符。在 Emacs Lisp 中，字符本质上就是整数；一个整数是否被当作字符，仅取决于它的使用方式。关于 Emacs 中字符的具体表示，see 字符编码。

字符串是固定长度的字符序列。它属于 array数组 类型的序列，意味着其长度在创建后就固定不可修改（see 序列、数组与向量）。与 C 语言不同，Emacs Lisp 字符串 不以 特殊字符码作为结束标志。

因为字符串是数组，同时也是序列，所以你可以使用《序列、数组与向量》中介绍的通用数组与序列函数来操作它们。例如，可以使用 aref 函数访问字符串中的单个字符（see 操作数组的函数）。

在 Emacs 字符串（以及缓冲区）中，非-ASCII 字符有两种文本表示方式：单字节（unibyte） 和多字节（multibyte）。对于大多数 Lisp 编程场景，你无需关心这两种表示方式的区别。详情 see 文本表示方式。

有时按键序列会用单字节字符串表示。当单字节字符串用作按键序列时，取值在 128～255 范围内的字符串元素代表元字符（meta 字符）（本身是大整数），而非 128～255 范围内的字符编码。字符串无法存储带有 hyper、super 或 alt 修饰键的字符；可以保存 ASCII 控制字符，但不支持其他控制字符，且不区分 ASCII 控制字符的大小写。如果你需要存储这类字符（比如按键序列），必须使用向量而非字符串。有关键盘输入字符的更多信息，see 字符类型。

字符串很适合用来存放正则表达式。你还可以用 string-match 将正则表达式与字符串进行匹配（see 正则表达式搜索）。match-string（see 简单匹配数据访问）和 replace-match（see 替换匹配的文本）这两个函数，常用于在正则匹配后对字符串进行拆分与修改。

与缓冲区类似，字符串除了保存字符本身，还可以为其中的字符附加文本属性。See 文本属性。所有将文本从字符串复制到缓冲区或其他字符串的 Lisp 原语，都会同时复制对应字符的文本属性。

有关显示字符串或将字符串复制到缓冲区的函数，see 文本。有关字符和字符串语法的说明，分别见 《字符类型》和《字符串类型》。有关文本表示方式转换、字符编码和解码的函数，see 非 ASCII 字符。另外注意：不应使用 length 计算字符串在屏幕上的显示宽度，应改用 string-width（see 显示文本尺寸）。

Next: 创建字符串, Previous: 字符串与字符基础, Up: 字符串与字符   [Contents][Index]

4.2 字符串判断函数 ¶

关于通用序列与数组判断函数的更多信息，参见《序列、数组与向量》和《数组》。

Function: stringp object ¶

如果 object 是字符串，该函数返回 t，否则返回 nil。

Function: string-or-null-p object ¶

如果 object 是字符串或 nil，该函数返回 t，否则返回 nil。

Function: char-or-string-p object ¶

如果 object 是字符串或字符（即整数），该函数返回 t，否则返回 nil。

Next: 修改字符串, Previous: 字符串判断函数, Up: 字符串与字符   [Contents][Index]

4.3 创建字符串 ¶

下面这些函数用于创建字符串：可以从零新建、拼接字符串，或是拆分字符串。（有关基于其他字符串修改内容来创建新字符串的函数，如 string-replace 和 replace-regexp-in-string，请参见 “搜索与替换”。）

Function: make-string count character &optional multibyte ¶

本函数返回一个由 character 重复 count 次构成的字符串。如果 count 为负数，会抛出错误。

(make-string 5 ?x)
     ⇒ "xxxxx"
(make-string 0 ?x)
     ⇒ ""

通常情况下，如果 character 是 ASCII 字符，结果为单字节字符串。但如果可选参数 multibyte 非 nil，函数会生成多字节字符串。这在后续需要与非-ASCII 字符串拼接，或将部分字符替换为非-ASCII 字符时很有用。

可与此函数对比的其他函数包括 make-vector（see 向量）和 make-list（see 构建 cons 单元与列表）。

Function: string &rest characters ¶

返回由给定字符 characters 组成的字符串。

(string ?a ?b ?c)
     ⇒ "abc"