Emacs折腾日记(十四)——buffer操作 教程 中的下一节应该是正则表达式。但是我觉得目前来说正则表达式对我来说不是重点，而且正则表达式我还是比较了解，没必要专门去学习，在使用的时候看看相应的章节就好。况且现在有AI这个利器，在处理正则表达式应该问题不大。所以这里就略过这节，直接进入后面的学习截止到前面的一些文章，我觉得应该已经涉及到了emacs lisp中的语法要点，现在去看一些emacs配置中的代码不太会一头雾水了。离攒自己的配置又进了一步。期间我想过是不是可以跳过教程后面的内容直接进入配置的过程呢？仔细考虑了一下，我觉得还是有必要跟着教程深入了解一下操作emacs对象的一些API。就像我之前学习C/C++编程一样，如果只学语法部分，最多也就能写写基于链表等数据结构的黑框框的信息管理系统。如果想要写点带界面的或者带网络功能的或者稍微复杂点的程序就离不开操作系统，网络编程，数据库等等知识。emacs的学习可能也是这样，现在也只能写点算术运算或者say-hello 这样的玩具。想要跟emacs结合起来，真正流畅的操作emacs，还需要学一些emacs自身的知识。缓冲区名称在学习vim的时候已经很详细的了解过什么是缓冲区，以及缓冲区与文件有什么区别。在这里我想就没有必要再谈论了，如果有读者不太清楚这方面的内容，欢迎阅读我博客中关于vim缓冲区的部分。emacs中缓冲区的概念与vim基本没什么区别。唯一的区别可能是emacs中一些内置的缓冲区与vim的不太一样。emacs 里的所有缓冲区都有一个不重复的名字。所以和缓冲区相关的函数通常都是可以接受一个缓冲区对象或一个字符串作为缓冲区名查找对应的缓冲区。有一个习惯是名字以空格开头的缓冲区是临时的，用户不需要关心的缓冲区。所以现在一般显示缓冲区列表的命令都不会显示这样的变量，除非这个缓冲区关联一个文件。要得到缓冲区的名字，可以用 buffer-name 函数，它的参数是可选的，如果不指定参数，则返回当前缓冲区的名字，否则返回指定缓冲区的名字。更改一个缓冲区的名字用 rename-buffer，这是一个命令，所以你可以用 M-x 调用来修改当前缓冲区的名字。如果你指定的名字与现有的缓冲区冲突，则会产生一个错误，除非你使用第二个可选参数以产生一个不相同的名字，通常是在名字后加上 <序号> 的方式使名字变得不同。你也可以用 generate-new-buffer-name 来产生一个唯一的缓冲区名。它需要传入一个参数，表示buffer的名称，如果当前buffer有名称与指定名称冲突，它会在你提供的名称后面加一些后缀，否则就采用传入的名称;; scratch buffer 中 (buffer-name) ;; ==> *scratch* ;; 此时 *scratch* 已经被重命名成了 scratch (rename-buffer (generate-new-buffer-name "scratch")) ;; ==> scratch当前缓冲区可以使用 current-buffer 来获取当前缓冲区，需要注意的是当前缓冲区不一定是显示在当前屏幕上的那个缓冲区。这个跟工作目录有点像，当前目录并不一定就是程序所在的目录或者当前打开的文件所在的目录。我们可以使用 set-buffer 来设置当前缓冲区，但是前面我们说过当前缓冲区并不一定是显示在屏幕上的那个缓冲区，即使修改当前缓冲区，也不会改变当前窗口上显示的缓冲区(set-buffer "*Messages*") ;; ==> #<buffer *Messages*>，但是屏幕上显示的缓冲区没有变化如果要切换当前屏幕显示的缓冲区需要配置窗口相关的函数，例如我们可以使用 switch-to-buffer(switch-to-buffer "*Messages*")前面提到 set-buffer 可以改变当前缓冲区，但是我们调用 buffer-name 获取当前缓冲区的名称时得到还是 scratch buffer(set-buffer "*Messages*") ;; ==> #<buffer *Messages*> (buffer-name) ;; ==> #<buffer *scratch*> (buffer-name) ;; ==> "*scratch*"这是因为我们如果采用 C-x C-e 来分别执行，这就相当于在命令行执行命令一样，每次语句结束之后，emacs会重新刷新上下文环境。而 buffer-name获取的是当前上下文环境中的当前缓冲区名称。上下文环境随着上一条语句的结束而更新，这就导致了当前缓冲区变化。这个过程可以描述为如下的过程[主进程环境] │ ├── [逐行执行L1] → 创建临时子环境 → 执行set-buffer → 销毁子环境 └── [逐行执行L2] → 创建新子环境 → 读取buffer-name → 返回主环境值 所以如果要得到正确的结果，就是一次性执行完这两条语句，按照我当前的知识储备有三种办法：第一个办法就是使用 eval-buffer，从messages buffer 中获取输出信息第二个办法，使用 progn 将两条语句包含起来第三个办法就是将它包装成一个函数或者宏来执行(progn (set-buffer "*Messages*") (buffer-name)) ;; ==> "*Messages*"但是我们不能仅仅依靠这种包裹代码的方式来实现切换buffer的效果。因为这个命令很可以会被另一个程序员来调用。你也不能直接用 set-buffer 设置成原来的缓冲区，因为set-buffer不能处理错误或退出情况。正确的作法是使用 save-current-buffer、with-current-buffer 和 save-excursion 等方法save-current-buffer 能保存当前缓冲区，执行其中的表达式，最后恢复为原来的缓冲区。如果原来的缓冲区被关闭了，则使用最后使用的那个当前缓冲区作为语句返回后的当前缓冲区。lisp 中很多以 with 开头的宏，这些宏通常是在不改变当前状态下，临时用另一个变量代替现有变量执行语句。比如 with-current-buffer 使用另一个缓冲区作为当前缓冲区，语句执行结束后恢复成执行之前的那个缓冲区save-excursion 与 save-current-buffer 不同之处在于，它不仅保存当前缓冲区，还保存了当前的位置和 mark。在 scratch 缓冲区中运行下面两个语句就能看出它们的差别了(save-current-buffer (set-buffer "*scratch*") (goto-char (point-min)) (save-excursion (set-buffer "*scratch*") (goto-char (point-min))上面两段代码，都是先保存当前缓冲区，然后使用 set-buffer 保证当前缓冲区是 scratch buffer，接着调用goto-char移动鼠标光标到buffer最开始的位置。随着代码块的结束，会自动切换回对应的buffer。但是因为 save-excursion 会额外保存当前位置和 mark，所以我们发现第一段代码光标位置跑到缓冲区最开始的位置，而第二段代码光标位置不变在对比一下它们与 with-current-buffer 的区别，with-current-buffer 调用时已经帮我们使用 set-buffer设置好了当前缓冲区，而且也会保存当前缓冲区，在结束之后也会还原当前缓冲区。但是它使用的是 save-current-buffer。我们可以使用 C-h C-f 来查看并找到它的源代码(defmacro with-current-buffer (buffer-or-name &rest body) (declare (indent 1) (debug t)) `(save-current-buffer (set-buffer ,buffer-or-name) ,@body))我们发现它其实就是用 save-current-buffer 做了一次封装。如果我们对上面的测试代码稍加修改使用 with-current-buffer 实现，例如(with-current-buffer "*Messages*" (goto-char (point-min)))执行之后我们发现，它的光标位置也改变了。创建和关闭缓冲区产生一个缓冲区必须用给这个缓冲区一个名字，所以两个能产生新缓冲区的函数都是以一个字符串为参数：get-buffer-create 和 generate-new-buffer。这两个函数的差别在于前者如果给定名字的缓冲区已经存在，则返回这个缓冲区对象，否则新建一个缓冲区，名字为参数字符串，而后者在给定名字的缓冲区存在时，会使用加上后缀 （N 是一个整数，从2开始） 的名字创建新的缓冲区。(get-buffer-create "temp") (with-current-buffer "temp" (insert "this is temp buffer")) (switch-to-buffer "temp")上面的代码，我们先创建一个新的temp buffer，并且切换到这个buffer，然后在这个buffer中调用insert函数，插入一段话。最后可以让窗口显示这个buffer来验证结果关闭一个缓冲区可以用 kill-buffer。当关闭缓冲区时，如果要用户确认是否要关闭缓冲区，可以加到 kill-buffer-query-functions 里。如果要做一些善后处理，可以用 kill-buffer-hook。通常一个接受缓冲区作为参数的函数都需要参数所指定的缓冲区是存在的。如果要确认一个缓冲区是否依然还存在可以使用 buffer-live-p。要对所有缓冲区进行某个操作，可以用 buffer-list获得所有缓冲区的列表。如果你只是想使用一个临时的缓冲区，而不想先建一个缓冲区，使用结束后又需要关闭这个缓冲区，可以用 with-temp-buffer 这个宏。从这个宏的名字可以看出，它所做的事情是先新建一个临时缓冲区，并把这个缓冲区作为当前缓冲区，使用结束后，关闭这个缓冲区，并恢复之前的缓冲区为当前缓冲区。在缓冲区内移动在学会移动函数之前，先要理解两个概念：位置（position）和标记（mark）。位置是指某个字符在缓冲区内的下标，它从1开始。更准确的说位置是在两个字符之间，所以有在位置之前的字符和在位置之后的字符之说。但是通常我们说在某个位置的字符都是指在这个位置之后的字符。这点很符合我们的直觉，一般在编写代码或者文档的时候当前的光标就是在文本之间移动。标记和位置的区别在于位置会随文本插入和删除而改变位置。一个标记包含了缓冲区和位置两个信息。在插入和删除缓冲区里的文本时，所有的标记都会检查一遍，并重新设置位置。这对于含有大量标记的缓冲区处理是很花时间的，所以当你确认某个标记不用的话应该释放这个标记。创建一个标记使用函数 make-marker。这样产生的标记不会指向任何地方。你需要用 set-marker 命令来设置标记的位置和缓冲区。(setq foo (make-marker)) ; ==> #<marker in no buffer> (set-marker foo (point)) ; ==> #<marker at 195 in *scratch*>point 函数其实返回一个整数，表示当前光标在哪个位置，既然这里只用传入位置就可以正确的将foo这个标签绑定到对应的缓冲区，这里set-marker 应该是以当前缓冲区作为标签的缓冲区，我们可以使用下面的代码来验证(with-current-buffer "*Messages*" (set-marker foo (point))) ;; ==> #<marker at 477 in *Messages*>也可以用 point-marker 直接得到 point 处的标记。或者用 copy-marker 复制一个标记或者直接用位置生成一个标记(point-marker) ;; ==> #<marker at 211 in *scratch*> (copy-marker 20) ;; ==> #<marker at 20 in *scratch*> (copy-marker foo) ;; ==> #<marker at 195 in *scratch*>如果要得一个标记的内容，可以用 marker-position，marker-buffer(marker-position foo) ;; ==> 195 (marker-buffer foo) ;; ==> #<buffer *scratch*>位置就是一个整数，而标记在一般情况下都是以整数的形式使用，所以很多接受整数运算的函数也可以接受标记为参数。比如加减乘。(goto-char (+ (marker-position foo) 10)例如上面的代码我们移动光标到第205个字符的位置。和缓冲区相关的变量，有的可以用变量得到，比如缓冲区关联的文件名，有的只能用函数来得到，比如 point。point 是一个特殊的缓冲区位置，许多命令在这个位置进行文本插入。每个缓冲区都有一个 point 值，它总是比函数 point-min 大，比另一个函数 point-max 返回值小。注意，point-min 的返回值不一定是 1，point-max 的返回值也不定是比缓冲区大小函数 buffer-size 的返回值大 1 的数，因为 emacs 可以把一个缓冲区缩小（narrow）到一个区域，这时 point-min 和 point-max 返回值就是这个区域的起点和终点位置。所以要得到 point 的范围，只能用这两个函数，而不能用 1 和 buffer-size 函数。按单个字符位置来移动的函数主要使用 goto-char 和 forward-char、backward-char。前者是按缓冲区的绝对位置移动，而后者是按 point 的偏移位置移动比如(goto-char (point-min)) ; 跳到缓冲区开始位置 (forward-char 10) ; 向前移动 10 个字符 (forward-char -10) ; 向后移动 10 个字符 (backward-char 10) ; 向后移动 10 个字符 (backward-char -10) ; 向前移动 10 个字符按词移动使用 forward-word 和 backward-word。至于什么是词，这就要看语法表格的定义了。按行移动使用 forward-line。没有 backward-line。forward-line 每次移动都是移动到行首的。所以，如果要移动到当前行的行首，使用 (forward-line 0)。如果不想移动就得到行首和行尾的位置，可以用 line-beginning-position 和 line-end-position。得到当前行的行号可以用 line-number-at-pos。需要注意的是这个行号是从当前状态下的行号，如果使用 narrow-to-region 或者用 widen 之后都有可能改变行号。由于 point 只能在 point-min 和 point-max 之间，所以 point 位置测试有时是很重要的，特别是在循环条件测试里。常用的测试函数是 bobp（beginning of buffer predicate）和 eobp（end of buffer predicate）。对于行位置测试使用 bolp（beginning of line predicate）和 eolp（end of line predicate）缓冲区的内容要得到整个缓冲区的文本，可以用 buffer-string 函数。如果只要一个区间的文本，使用 buffer-substring 函数。point 附近的字符可以用 char-after 和 char-before 得到。point 处的词可以用 current-word 得到，其它类型的文本，比如符号，数字，S 表达式等等，可以用 thing-at-point 函数得到。ting-at-point 可以获取光标处的很多类型的内容，它需要传入一个符号作为类型，例如 'word、'symbol、'url。不同的类型包含有不同的文本属性，第二个参数表示是否去除文本属性。如果当前位置有内容，则返回内容，否则返回nil(defun show-current-word () (interactive) (let ((word (thing-at-point 'word t))) ;; 'word 类型，t 表示去除文本属性 (if word (message "当前单词: %s" word) (message "光标位置没有单词"))))修改缓冲区的内容要修改缓冲区的内容，最常见的就是插入、删除、查找、替换了。下面就分别介绍这几种操作。插入文本最常用的命令是 insert。它可以插入一个或者多个字符串到当前缓冲区的 point 后。也可以用 insert-char 插入单个字符。插入另一个缓冲区的一个区域使用 insert-buffer-substring。删除一个或多个字符使用 delete-char 或 delete-backward-char。删除一个区间使用 delete-region。如果既要删除一个区间又要得到这部分的内容使用 delete-and-extract-region，它返回包含被删除部分的字符串。最常用的查找函数是 re-search-forward 和 re-search-backward。这两个函数参数如下(re-search-forward REGEXP &optional BOUND NOERROR COUNT) (re-search-backward REGEXP &optional BOUND NOERROR COUNT)其中 BOUND 指定查找的范围，默认是 point-max（对于 re-search-forward）或 point-min（对于 re-search-backward），NOERROR 是当查找失败后是否要产生一个错误，一般来说在 elisp 里都是自己进行错误处理，所以这个一般设置为 t，这样在查找成功后返回区配的位置，失败后会返回 nil。COUNT 是指定查找匹配的次数。替换一般都是在查找之后进行，也是使用 replace-match 函数。和字符串的替换不同的是不需要指定替换的对象了。

Emacs折腾日记(十三)——函数、宏以及命令 之前在开篇介绍简单的elisp时候就提到过函数，后面的一些示例中也用到了一些函数，但是都是一些基本的概念，这篇将深入了解函数的一些特性。首先要判断一个符号是否是函数，可以使用 functionp 来判断。(defun foo() 1) (foo) (functionp 'foo) ;; ==> t (setq var 1) (functionp 'var) ;; ==> nil不光函数，以下几种functionp也返回t函数。这里的函数特指用 lisp 写的函数。原子函数（primitive）。用 C 写的函数，比如 car、append。lambda 表达式特殊表达式宏(macro)。宏是用 lisp 写的一种结构，它可以把一种 lisp 表达式转换成等价的另一个表达式。命令。命令能用 command-execute 调用。函数也可以是命令。参数列表的语法过去我们的所有函数都是定参的函数，也就是说是确定了参数个数的函数。但是实际使用中会大量使用不定参函数，也就是参数不确定的函数。在C/C++ 以及 Python中会大量使用。它的一个使用场景就是某些时候不传就采用默认值，否则就采用用户定义的值。另一个场景就是像printf这样事先无法确定到底要输出多少内容。elisp中的函数完整定义如下(defun func (REQUIRED-VARS... [&optional OPTIONAL-VARS...] [&rest REST-VAR]))前面是确定的参数列表，也就是说前面的参数在调用函数时必须传入，而&optional 之后是可选参数，如果要传入可选参数这个 &optional 关键字是必须写上的。这里的可选参数也是需要在定义时一个个的指定出来，但是&rest 之后定义的只用一个变量来使用，在传入的时候可以传入任意个参数。例如下面的例子(defun foo (var1 var2 &optional op1 op2 &rest rest) (list var1 var2 op1 op2 rest)) (foo 1 2) ;; ==> (1 2 nil nil nil) (foo 1 2 3) ;; ==> (1 2 3 nil nil) (foo 1 2 3 4) ;; ==> (1 2 3 4 nil) (foo 1 2 3 4 5) ;; ==> (1 2 3 4 (5)) (foo 1 2 3 4 5 6) ;; ==> (1 2 3 4 (5 6))从这个例子我们可以得出以下几个结论：当可选参数没有提供时，在函数体里，对应的参数值都是 nil。我们可以通过判断是否为nil来判断用户是否传了参&rest 要捕获后面所有传入的参数，所以它必须在参数列表的最后面,它的值是一个list当 &rest 与 &optional 共存时，优先匹配 &optional 参数，最后如果有剩余的参数则分配给 &rest教程原文中是有关于文档字符串的描述的。但是我想现在我作为一个菜鸟，将来要组织自己的配置也主要依靠拷贝粘贴别人现有的东西再组合，没有多少机会参与那种高大上的开源项目，自己将来弄的配置估计也没什么人用，而且我也会详细记录自己攒配置的过程，所以这里就不需要给函数写过于详细的文档说明。这里我就跳过这块了。如果有读者对这块感兴趣可以看原文。函数调用在编写程序的时候会有这种需求，一个框架负责处理大块的内容，比如数据解析、转发等等，它会预留一些接口来让用户在此基础之上处理自己的业务逻辑，比较典型的就是http server，或者gui程序框架。在C/C++ 中一般会预留一些函数指针类型的参数进行回调或者提供接口供使用方重载实现自己的逻辑。在elisp中也有这样的操作，但是它就没有虚函数、虚基类或者函数指针的概念。在elisp中通过符号调用一个函数使用的方法是 funcall 和 apply。它们都是通过符号来调用函数的，唯一的区别在于如何处理传入参数。我们通过一个例子来看看它们有什么不同。我们还是用上面定义的foo函数来测试(funcall 'foo 1 2 3 4 5 6) ;; ==> (1 2 3 4 (5 6)) (apply 'foo 1 2 3 4 5 6) ;; ==> error (apply 'foo 1 2 3 4 '(5 6)) ;; ==> (1 2 3 4 (5 6)) (apply 'foo 1 2) ;; ==> error (apply 'foo '(1 2)) ;; ==> (1 2 nil nil nil) (apply 'foo 1 2 3 4) ;; ==> error (apply 'foo 1 2 '(3 4)) ;; ==> (1 2 3 4 nil) (apply 'foo 1 2 3 4 5) ;; ==> error (apply 'foo 1 2 3 4 '(5)) ;; ==> (1 2 3 4 (5))从上面的结果可以看出，funcall 直接按照对应函数定义的参数列表进行传参即可。而apply在传参的时候最后一个参数必须是list，并且在嗲用时会自动将list参数给展开并传入各个参数。从上面的区别可以看出，如果在调用函数的时候，参数已经通过list进行了组织的话，那么使用apply更为合适，否则使用funcall。宏宏是lisp家族中一个非常重要，也非常灵活的内容，可以说宏是lisp的灵魂。之前在看到一些lisp相关的教程时都说，宏实现了利用代码生成代码，并且因为宏的存在导致lisp中扩展出了大量的方言。可以说没有宏，lisp就不是lisp了，或者说lisp就没这么灵活了。但是C/C++中也有宏的概念，C/C++中的宏是在预处理阶段进行简单的文本替换，然后编译替换之后的结果。虽然利用宏，C/C++中可以实现很多非常复杂的功能，但是它远远没有lisp的宏灵活。要详细了解宏的相关内容，我们先回忆一下之前介绍的elisp的知识。首先elisp或者lisp的代码本身就是一颗语法树。它被写作一个list。也就是说list既可以作为代码执行，也可以作为数据，例如 (setq x 1) 它是一段代码。而 '(setq x 1) 它是一个列表，列表中有3个元素，分别是 setq 、x、1 这么三个符号和数字。再者elisp特有的符号系统，例如 x 表示一个变量，可以对它进行求值，'x 代表一个符号，根据前面所学的，我们可以通过符号找到符号中记录的值、函数、属性等等。基于这两个内容，我们可以通过操作list来实现生成一段代码。例如下列的例子(defun my-inc (var) (list 'setq var (list '1+ var))) (setq x 0) (eval (my-inc 'x)) ;; ==> 1上面的其实就是返回了一个list， (setq var (1+ var))。后面我们通过 eval 来执行这个返回的list。需要注意的时，函数调用时会首先将变量进行求值，然后将值作为参数传入，但是这里我们希望并不希望传入一个具体的值，而是希望他能操作我们传入的变量值，并改变它，要做到这点需要传入一个符号。这里有点像C++ 中的引用传递定义宏其实跟定义函数非常相似。我们只需要将关键字由 defun 改为 defmacro。(defmacro my-inc(var) (list 'setq var (list '1+ var))) (setq x 0) (my-inc x) ;; ==> 1我们发现宏与函数的一个不同点，函数中代码在函数被调用时执行，并且参数是在调用时进行求值并传入。而宏调用时需要展开它返回的表达式(或者这里直接就是一个list)。然后将参数作为符号传入。宏最后需要返回一段可执行的list数据，如果没有返回，会影响展开执行，最终可能会报错，例如下面的例子(defmacro my-inc (var) (setq var (1+ var))) (setq x 0) (my-inc x) ;; ==> error这里的问题在于这个宏定义的代码是一个直接执行的代码，并不是一个list，所以在调用它的时候会直接执行，但是又需要将参数作为符号绑定，所以它在被调用的时候会执行(setq 'x (1+ 'x)) 这段代码，而这里的x是一个符号，无法直接对符号进行赋值，所以它会报x的类型错误。这里已经显示出了，elisp中的宏与C/C++中宏的不同。首先C/C++中的宏只是简单的字符串替换，可以将它理解为它生成了新的C/C++源码的代码，它在预处理阶段来执行代码的替换。而elisp中并没有简单的进行替换，根据之前介绍lisp表达式的解析，其实宏返回的是一颗抽象语法树。在扩展宏的时候不断的进行抽象语法树的修改和重建，最后在执行的时候将传入的参数作为符号放入到这颗树中的对应节点。我们可以使用 macroexpand 来查看宏展开的样子。(defmacro bad-inc (var) (setq var (1+ var))) (macroexpand '(bad-inc 0)) ;; ==> 1我们发现之前错误的实现并没有生成可执行的代码，而是直接返回一个常数。因为宏中的代码首先在展开的时候就已经执行了。相当于返回了 setq var (1+ 0) 的值，也就是1。(defmacro my-inc (var) (list 'setq var (list '1+ var))) (macroexpand '(my-inc x)) ;; ==> (setq x (1+ x))使用 macroexpand 可以使宏的编写变得容易一些。但是如果不能进行 debug 是很不方便的。在宏定义里可以引入 declare 表达式，它可以增加一些信息。目前只支持两类声明：debug 和 indent。debug 可选择的类型很多，具体参考 info elisp - Edebug 一章，一般情况下用 t 就足够了。indent 的类型比较简单，它可以使用这样几种类型：nil 也就是一般的方式缩进defun 类似 def 的结构，把第二行作为主体，对主体里的表达式使用同样的缩进整数 表示从第 n 个表达式后作为主体。比如 if 设置为 2，而 when 设置为 1符号 这个是最坏情况，你要写一个函数自己处理缩进。从前面的例子就可以看到，如果在定义宏的时候使用list cons 等来构建list是非常麻烦的，一旦要构造非常复杂的程序，可能直接就歇菜了。为了方便，elisp中提供了一些符号来简化操作。 ` 读作backquote，表示被它包裹的表达式都是quote，可以理解为它里面的直接构建了一个list如果希望它里面的某个位置不作为quote的一部分，而是直接作为列表的元素，可以使用 , , 也就是它会对后面的内容进行求值如果要让一个列表作为整个列表的一部分（slice），可以用 ",@"，它会将后面的内容作为列表参数依次添加到当前列表中。我想起来了之前接触过的quote，也就是 ' 。它表示后面的内容不进行求值，作为符号，虽然它也可以构造一个list，但是二者还是有些不同，例如'(list x (+ 1 2)) ;; ==> (list x (+ 1 2)) `(list x (+ 1 2)) ;; ==> (list x (+ 1 2)) '(list x ,(+ 1 2)) ;; ==> (list x (\, (+ 1 2))) `(list x ,(+ 1 2)) ;; ==> (list x 3) (setq var '(2 3)) '(list x ,@var) ;; ==> (list x (\,@ var)) `(list x ,@var) ;; ==> (list x 2 3)我们使用上面的方法稍微弄一个复杂一点的宏(defmacro max(a b) `(if (> ,a ,b) ,a ,b)) (max 4 5) (max (1+ 2) (+ 3 6)) '(macroexpand '(max (1+ 2) (+ 3 6))) ;; ==> (if (> (1+ 2) (+ 3 6)) (1+ 2) (+ 3 6))这里是一个经典的C/C++ 中的max宏。虽然实现不严谨，有一些副作用，但是可以从上面看到一些用法。首先使用 ` 表示返回一个列表，以供调用的时候进行展开。再者对于传入的a和b需要使用, 来表示需要求解它们的值，实现参数的绑定，否则将会得到一个错误，例如(defmacro max(a b) `(if (> a b) a b)) (macroexpand '(max 4 5))) ;; ==> (if (> a b) a + b)如果将上述的 , 全部替换成 ,@ 就不太合适了，因为 ,@ 是将列表中的值取出来组成新的列表，并不会想 , 那样进行求值。例如(defmacro max(a b) `(if (> ,@a ,@b) ,@a ,@b)) (macroexpand '(max (1+ 2) (+ 3 6))) ;; ==> (if (> 1+ 2 + 3 6) 1+ 2 + 3 6)命令emacs 运行时就是处于一个命令循环中，不断从用户那得到按键序列，然后调用对应命令来执行。emacs 中的命令可以说就是一个函数，它是一个特殊的函数，是里面包含了 interactive 表达式的函数。这个表达式指明了这个命令的参数。比如下面这个命令(defun say-hello (name) (interactive "swhat's your name:") (message "hello, %s" name))当解释器加载了该函数之后就可以使用 M-x 来调用这个函数。我们根据提示输入一个名字，emacs会在minibuffer中输出一段话。我们发现，在interactive 表达式后面跟的字符串前面多了一个 s 字符。我们可以通过这个多加的字符来控制命令参数的类型和行为，例如使用 s 表示字符串参数，n 表示数字参数，f 代表文件，r 代表区域。interactive 的字符十分复杂，而且繁多。用的时候看 interactive 函数的文档还是很有必要的。但是不是所有时候都参数类型都能使用代码字符，而且一个好的命令，应该尽可能的让提供默认参数以让用户少花时间在输入参数上，这时，就有可能要自己定制参数。首先学习和代码字符等价的几个函数。s 对应的函数是 read-string，n 代表的是 read-file，f代表的是 read-file-name。其实大部分代码字符都是有这样对应的函数或替换的方法。我们可以使用这些方法来替代前面的代码字符，假如传入的是一个表达式，那么对表达式进行计算之后返回的列表元素就是命令的参数，例如我们用 read-string 来代替之前例子中的s。(defun say-hello (name) (interactive (list (read-string "what's your name: "))) (message "hello, %s" name))教程 中还列举了一些常见的字符代表的函数，这里我就不列出来了。各位读者有兴趣的话也可以去看看。

Emacs 折腾日记（十二）——变量 本文是依据 emacs lisp 简明教程 而来在此之前我们已经了解了elisp中的全局变量和函数中的局部变量，也了解了elisp中各种数据类型。这一篇主要谈谈elisp中各种变量的生命周期和作用域let 绑定的变量使用let绑定的变量只在let范围内有效，如果是多层嵌套的let，只有最里层的那个变量是有效的，用 setq 改变的也只是最里层的变量，而不影响外层的变量。比如(progn (setq foo "I'm global variable!") (let ((foo 5)) (message "foo value is: %S" foo) ;; ==> "foo value is: 5" (let (foo) (setq foo "I'm local variable!") (message foo)) ;; ==> "i’m local variable!" (message "foo value is still: %S" foo)) ;; ==> "foo value is still: 5" (message foo)) ;; ==> "i’m global variable!"这个有点像C/C++中的{} 定义的语句块中的变量只在当前 {} 内有效，当内部变量与外部变量重名的时候只影响{}内，而不影响外部。我们可以给出这样的c++代码int n = 0; printf("n = %d\n", n); { int n = 10; printf("n = %d\n", n); } printf("n = %d\n", n);elisp中的let两边的括号就有点像这里的 {}，出了这个范围定义的变量就无效了。但是定义变量使用的是栈空间，而程序的栈空间是有大小限制的，一旦超过这个范围就会发生栈溢出。在C/C++程序中一般发生在递归层数过大。我们可以在编译时修改这个栈空间的大小。在elisp中也有变量控制递归层数，它就是 max-specpdl-size 但是在最新的29中已经将它弃用，新版的emacs可以使用 max-lisp-eval-depth 来限制specpdl堆栈的大小，该堆栈主要用于 存储动态变量绑定和 unwind-protect 激活等。buffer-local 变量顾名思义，它的值只在当前buffer中生效，在其他buffer中可能是另外的值。它有点像之前介绍的vim中的setlocal变量，仅在当前缓冲区内生效。该特性常用于实现缓冲区特定的配置和行为。声明一个 buffer-local 的变量可以用 make-variable-buffer-local 或用 make-local-variable。这两个函数的区别在于前者是在所有缓冲区都创建一个 buffer-local 的变量。而后者只在声明时所在的缓冲区内产生一个局部变量，而其它缓冲区仍然使用的是全局变量。一般来说推荐使用 make-local-variable。下面来举例说明它们的区别，在举例之前介绍例子中用到的函数或者宏with-current-buffer, 它的使用方式是(with-current-buffer buffer body)其中 buffer 可以是一个缓冲区对象，也可以是缓冲区的名字。它的作用是使其中的 body 表达式在指定的缓冲区里执行。default-value 可以访问符号所对应的全局变量下面是使用 make-local-variable 创建buffer-local变量的例子(setq foo "i'm a global variable!") (make-local-variable 'foo) foo ;; ==> "i'm a global variable!" (setq foo "i'm buffer-local variable in scratch buffer") foo ;; ==> "i'm buffer-local variable in scratch buffer" (with-current-buffer "*Messages*" (progn (message "%s" foo) ;; ==> "i'm a global variable!" (setq foo "i'm buffer-local variable in message buffer") (message "%s" foo))) ;; ==> "i'm buffer-local variable in message buffer" (default-value 'foo) ;; ==> i'm buffer-local variable in message buffer上述代码因为message buffer 中未定义foo的buffer-local 变量，所以它修改的是全局变量的值，我们使用 default-value 发现全局变量的值被修改了。(setq foo "i'm a global variable!") (make-variable-buffer-local 'foo) foo (setq foo "i'm buffer-local variable in scratch buffer") foo (with-current-buffer "*Messages*" (progn (message "%s" foo) (setq foo "i'm buffer-local variable in message buffer") (message "%s" foo))) (default-value 'foo) ;; ==> "i'm a global variable!"前面的结果都一样，但是我们关注一下最后输出的全局的 foo 变量，它的值没有被修改，而使用 make-local-variable 的时候它被修改了。这是因为 make-variable-buffer-local 会在每一个缓冲区内都创建一个 buffer-local 的拷贝，所以后面在 message 缓冲区中修改的是缓冲区内自己的 buffer-local 变量而不影响全局变量的值，而 make-local-variable则不同，它会在 message 缓冲区中为foo也创建一个buffer-local变量。message 缓冲区中修改的是 buffer-local 变量，不影响全局的foo变量。一般来说根据实际情况选择使用哪种，我并不是资深的elisp开发者，以我浅薄的认知，一般使用 make-local-variable情况较多，它影响面较小，仅仅影响当前缓冲区。而make-variable-buffer-local 影响面较大，一旦使用它设置了local-buffer 变量，那么在后面其他缓冲区中想要使用 setq 设置全局的值就没那么简单了。这种一般是需要隐藏起来的核心变量，例如某些功能依靠这个变量来驱动，一旦修改了可能导致后面的代码运行行为不准确。可能会使用 make-variable-buffer-local 定义，不让用户自己随便修改全局的值。我们可以使用 setq-default 来设置全局变量的值。这里的例子就不给出了，各位读者可以根据上面的例子稍加修改就可以了。测试一个变量是不是 buffer-local 可以用 local-variable-p。这里我们再介绍一个新的函数 get-buffer。它需要一个buffer的名称作为参数，返回这个buffer的对象，如果未找到对应的buffer，则返回nil。(setq foo 5) (make-local-variable 'foo) (local-variable-p 'foo) ;; ==> t (local-variable-p 'foo (get-buffer "*Messages*")) ;; ==> nil如果要在当前缓冲区里得到其它缓冲区的 buffer-local 变量的值可以用 buffer-local-value(setq foo "i'm a global variable!") (make-local-variable 'foo) (setq foo "i'm buffer-local variable in scratch buffer") (with-current-buffer "*Messages*" (buffer-local-value 'foo (get-buffer "*scratch*"))) ;; ==> "i'm buffer-local variable in scratch buffer"变量的作用域在之前我们已经介绍过几种变量，分别是使用 setq 或者 defvar 定义的变量，它们是全局变量，即使在一些语法块或者函数中定义的，在外围也可以正常访问使用 let 或者 let* 定义的变量，只在 let 语法块中有效使用 make-local-variable 或者 make-variable-buffer-local 定义的buffer-local 变量，在当前buffer中有效但是函数参数列表的变量生命周期与我们平常在C/C++、Java、Python等语言中有些不同。作用域（scope）是指变量在代码中能够访问的位置。emacs lisp 这种绑定称为 indefinite scope。indefinite scope 也就是说可以在任何位置都可能访问一个变量名。而 lexical scope（词法作用域）指局部变量只能作用在函数中和一个块里（block）。比如 let 绑定和函数参数列表的变量在整个表达式内都是可见的，这有别于其它语言词法作用域的变量。先看下面这个例子(defun foo(x) (getx)) (defun getx() x) (message "%s" (foo "hello,x")) ;; ==> "hello,x"我们可以看到最终成功输出了结果，而根据之前学习C/C++的经验，在C、C++等语言中，这样的代码是无法执行成功的，因为在getx中并未定义x的值。但是在elisp 中，foo函数执行期间，x变量的都是有效的且可以正常访问到的。当然，在elisp中，let也具有这一效果，在let的语法块中，定义的变量总是有效的。例如(let ((x "hello, x")) (message "%s" (getx))) (defun getx() x)在let语句块中 x 是一直有效的，如果脱离let，在最外层调用 getx 将会得到一个x未定义的错误需要注意的是，上面的例子无法再使用 C-x C-e 来一条条的执行了，这个时候需要使用 eval-buffer 来执行整个缓冲区的代码。emacs 从 24.1 版本开始，引入了 lexical binding 这一特性，在代码中如果启用这个属性，那么它将采用C/C++ 等普通编程语言的那种 lexical scope 的作用形式。官方文档中提到使用 lexical binding 特性可以提高代码的运行效率，并且鼓励使用。可以在代码文件最开始的位置添加这么一个注释 -*- lexical-binding: t -*- 来开启这一特性。上面的代码只要加上这一特性就能得到不一样的结果;; -*- lexical-binding: t -*- (let ((x "hello, x")) (message "%s" (getx))) (defun getx() x)这个时候执行将会得到一个错误信息 "Symbol’s value as variable is void: x"，x这个符号是一个未定义的变量。生存期是指程序运行过程中，变量什么时候是有效的。全局变量和 buffer-local 变量都是始终存在的，前者只能当关闭emacs 或者用 unintern 从 obarray 里除去时才能消除。而 buffer-local 的变量也只能关闭缓冲区或者用 kill-local-variable 才会消失。而对于局部变量，elisp 使用的方式称为动态生存期：只有当绑定了这个变量的表达式运行时才是有效的。在 emacs lisp 简明教程 中举了一个闭包的例子，在elisp中并不支持闭包，它采用的是与普通编程语言一样的变量生存周期，这里我就不列出来了。JavaScript等语言中是支持闭包的，有兴趣的读者可以去看看JavaScript中的闭包。其他函数一个符号如果值为空，直接使用可能会产生一个错误。可以用 boundp 来测试一个变量是否有定义。这通常用于 elisp 扩展的移植（用于不同版本或 XEmacs）。对于一个 buffer-local 变量，它的缺省值可能是没有定义的，这时用 default-value 函数可能会出错。这时就先用 default-boundp 先进行测试。使一个变量的值重新为空，可以用 makunbound。要消除一个 buffer-local 变量用函数 kill-local-variable。可以用 kill-all-local-variables 消除所有的 buffer-local 变量。但是有属性 permanent-local 的不会消除，带有这些标记的变量一般都是和缓冲区模式无关的，比如输入法。(setq foo "I'm local variable!") foo ; ==> "I'm local variable!" (boundp 'foo) ; ==> t (default-boundp 'foo) ; ==> t (with-current-buffer "*Messages*" (boundp 'foo)) ; ==> t (makunbound 'foo) ; ==> foo foo ; This will signal an error (boundp 'foo) ; ==> t (default-boundp 'foo) ; ==> t (kill-local-variable 'foo) ; ==> foo (with-current-buffer "*Messages*" (boundp 'foo)) ; ==> t上面的例子需要注意以下几点这里只是使变量的值为空，并没有消除这个变量的符号。所以在执行makunbound 之后，关于foo 是否绑定的测试都是tkill-local-variable 只是消除了foo作为buffer-local变量，并没有影响到全局变量，所以在messages-buffer中测试它仍然是有效的变量变量命名习惯对于变量的命名，有一些习惯，这样可以从变量名就能看出变量的用途：hook 一个在特定情况下调用的函数列表，比如关闭缓冲区时，进入某个模式时。function 值为一个函数functions 值为一个函数列表flag 值为 nil 或 non-nilpredicate 值是一个作判断的函数，返回 nil 或 non-nilprogram 或 -command 一个程序或 shell 命令名form 一个表达式forms 一个表达式列表。map 一个按键映射（keymap）

Emacs折腾日记（十一）——求值规则 截至到现在，我觉得我自己的elisp水平有了一定的提高，希望各位读者借助之前的文章也能有一些收获。现在已经可以尝试写一点elisp的程序了，但是如果想深入了解一下 lisp 是如何工作的，不妨先花些时间看看 lisp 的求值过程。对于我这样一个日常使用C/C++的程序员来说，习惯了C/C++的语法和写法，初次见到lisp这样使用括号并且主要是S-表达式的语言，开始总会有点不习惯，但是在尝试自己写了这么些文章之后，对lisp有那么一点感觉。这篇我想就着 求值规则 这篇文章以及自己的一些理解来尝试梳理一下自己是如何理解elisp表达式的。S表达式要理解S表达式，我们先从如何解析四则运算开始。在之前我鸽了一个系列就是使用C来实现C语言解析器的系列。在那个系列中提到，一个普通的4则运算最终会生成一个抽象语法树，例如 a * b - (c + d) 最终可以生成如下的抽象语法树 - / \ * + / \ / \ a b c d二叉树的每个节点，或者是叶节点，或者有2个子节点，叶节点可以用来存储数据。而每颗子树的根节点存储操作符，或者说表示要对数据进行的操作，而如果操作符需要一个或者多个操作数，那么可以对抽象语法树进行调整。可以用上面的图来表示树的话有些麻烦了，后来发明了点对表示法， 如果只关心叶子节点，每颗子树的根节点采用.来表示，那么这颗二叉树可以表示为 ((a . b) . (c . d)) 。看到这里各位读者想到了什么呢？cons cell。S表达式是点对表示法的形式定义：原子 -> 数字 | 符号 S表达式 -> 原子 | (S表达式 . S表达式)所以，S表达式或者是原子，或者是递归的由其他S表达式构成的点对。虽然抽象语法树可以使用这种点对来描述，但是语法树大了，点的数量大了，其实也挺麻烦的，所以lisp中有一些简单的写法。回顾一下之前学习列表和cons cell的知识，简化也就得到了列表，例如'((a . b) . (c . d)) ⇒ ((a . b) c . d) '((a . b) . (c . (d . nil))) ⇒ ((a . b) c d)如果我们考虑这颗树的根节点，并且采用先序遍历的方式访问，结果仍然采用点对来表示，那么将得到这样的结果 (- (* a b) (+ c d))。 这样我们得到了计算这个四则运算的lisp代码，这个它可以作为列表，也可以让lisp解释器来执行。到此为止，各位读者应该理解了S表达式。它其实就是对应了一颗语法树。现在看到S表达式也不那么恐惧了，解释器如何执行它似乎也慢慢的清晰起来了呢S表达式的求值理解了S表达式，再回过头来看看它的求值过程。所有的表达式可以分为三种：符号、列表和其它类型。我们来分别说明最简单的就是自求值表达式，前面说过数字、字符串、向量都是自求值表达式。还有两个特殊的符号 t 和 nil 也可以看成是自求值表达式。第二种表达式是符号。符号的求值结果就是符号的值。如果它没有值，就会出现 void-variable 的错误。第三种表达式是列表表达式。而列表表达式又可以根据第一个元素分为函数调用、宏调用和特殊表达式（special form）三种。根据上面对S表达式的理解，这里的第一个元素也就是放在语法树的每颗子树的根节点上，表示对它的子节点进行的操作，例如上面的加减乘除，或者使用car之类的函数。而它的子节点可以是一颗语法树，也可以是简单的值，对应在elisp中的话，就是这个操作可以针对上面两种自求值表达式或者符号值，也可以是另一个S表达式。整个求值过程就是不断的求子树然后使用根节点来对子树进行操作，例如针对上面的二叉树可以写下这么一段伪代码来实现求值float calc-ast(ast* pRoot) { switch(pRoot->eOprType) { case function: //函数调用 return function(calc-ast(pRoot->left), calc-ast(pRoot->right)); case math: // 数学计算 return calc-ast(pRoot->left) + calc-ast(pRoot->right); //这里以加法为例 .... default: calc-ast(pRoot->left); calc-ast(pRoot->right); break } }第一个元素如果是一个特殊表达式时，它的参数可能并不会全求值。这些特殊表达式通常是用于控制结构或者变量绑定。每个特殊表达式都有对应的求值规则。这个就根据具体的语法来定，例如 and 和 or 这些操作符具有短路的特性。本文内容到此就结束了，本文比较简单，算是对之前的一个总结，对lisp有一个大概的了解。最后，本文可能是年前最后一篇文章了，在这里提前祝各位读者新年快乐！

Emacs 折腾日记(十)——elisp符号 符号是有名字的对象，这么说可能有点抽象。我们先来回忆一下C/C++中关于符号的内容。C/C++ 最终被编译成机器码直接执行，在机器码中不存在变量名称，函数名称等字符，它只有一串地址。但是在写C/C++代码的时候有变量名，函数名，类名，对象名等等名称。编译器是如何做到将符号和地址关联起来的呢？答案是，编译器在编译阶段会提供一个符号表，符号表如何实现的我也不太清楚，但是它做到了关联一个地址和字符串符号的作用。在Windows平台的 vs下，debug版本一般会生成与exe同名的pdb文件，这个是调试文件，它里面保存了一些调试信息，包括符号表。这里的符号与C/C++中的符号表中的符号类似，可以通过它来找到具体的变量。可以理解成elisp提供了这么一种操作符号表的功能。首先必须知道的是符号的命名规则。符号名字可以含有任何字符。与之对应的，一般的编程语言在定义变量的时候有些特殊符号不能用，而且不能以数字开头，有些关键字也不能作为变量名。而elisp中没有这些限制，只是在使用特殊符号的时候需要使用转义字符。(symbolp '+1) ;; ==> nil (symbolp '\+1) ;; ==> t (symbol-name '+1) ;; error (symbol-name '\+1) ;; ==> "+1"上面的代码 symbolp 是在判断一个对象是否是一个符号的函数，symbol-name 用于取符号的名称，它会返回给定符号的名称的字符串。上面的代码说明了，elisp中符号没有什么特别要求，只是对于特定的字符需要使用转义字符。与c/c++中类似，elisp中的符号名也是区分大小写的。符号创建在C/C++中符号表由编译器来创建和操作。而elisp中则提供了操作符号表的方式。符号名要有唯一性，所以一定会有一个表与名字关联，这个表在 elisp 里称为 obarray。从这个名字可以看出这个表是用数组类型，事实上它是一个向量。对于一个新的符号，解释器会首先取字符串的hash值，根据hash值来放入数组对应的位置。同时我们也将这种保存符号的数据结构称之为obarray。也就是说obarray不仅是一个保存符号的变量，也是一种结构。我们也可以在符号上建立这么一个结构用来保存符号对应的属性。也可以作为参数传入emacs 相关函数中当 elisp 读入一个符号时，通常会先查找这个符号是否在 obarray 里出现过，如果没有则会把这个符号加入到 obarray 里。这样查找并加入一个符号的过程称为是 intern。intern 函数可以查找或加入一个名字到 obarray 里，返回对应的符号。默认是全局的obarray，也可以指定一个 obarray。intern-soft 与 intern 不同的是，当名字不在 obarray 里时，intern-soft 会返回 nil，而 intern 会加入到 obarray里。(setq foo (make-vector 10 0)) ;; ==> [0 0 0 0 0 0 0 0 0 0] (intern-soft "abc" foo) ;; ==> nil (intern "abc" foo) ;; ==> abc (intern-soft "abc") ;; ==> abc (intern-soft "abc") ;; ==> nillisp 每读入一个符号都会 intern 到 obarray 里，如果想避免，可以用在符号名前加上 #:(intern-soft "abc") ;; ==> nil 'abc (intern-soft "abc") ;; ==> abc '#:abcd ;; ==> abcd (intern-soft "abcd") ;; ==> nil可以使用 untern 从obarray中删除对应的符号，如果成功删除，会返回t，如果没有对应的符号，则会返回 nil(intern "abc") ;; ==> abc (intern-soft "abc") ;; ==> abc (unintern "abc") ;; ==> t (intern-soft "abc") ;; ==> nil(setq foo 1) (intern-soft "foo") (unintern "foo") (intern-soft "foo") (1+ foo) ;; error通过setq，我们让elisp将foo这个变量放入到obarray中，后续使用unintern 删除这个变量后再使用foo的时候就会报错，foo是一个空变量与hash-table一样，obarray 也提供一个mapatom 函数来遍历整个obarray，例如下面是一个计算所有符号数量的例子(setq count 0) (defun count-sys(s) (setq count (1+ count))) (mapatoms 'count-sys) count ;; ==> 95733 (length obarray) ;; ==> 15121这里我们看到，数组的长度小于符号的数量。这根hash-table的实现是一样的。各位读者在学习hash-table的时候应该了解过，hash-table 中 hash值不同的元素存储在数组的不同位置，相同的元素通过链表进行串联，一般的hash-table在内存中的结构如下图.符号的组成在计算机中，所有的内容都是使用二进制来进行存储的，我们人为的将二进制数据划分为代码和数据。如果单纯的给出一个内存的地址，如何知道它是数据还是代码呢？例如在C/C++中定义了一个int类型的变量a，为什么在后续使用a(1) 这样的语句会报错呢？又例如一个函数指针 pfn,使用 *pfn = 1 这样也会报错呢？编译器怎么知道哪个地址存的是变量，哪个地址存的是函数指针呢？还是通过符号表来解决，符号表中针对每个符号名称都会给定它的类型，例如这个符号对应的地址是一个整数，或者指针，又或者是函数指针。符号名称类比C/C++ 中的符号表，elisp中每个符号都可以有4个组成部分，一个是符号名称，它可以类比到符号表中的名称,可以用symbol-name 来访问。它返回一个符号的字符串名称，关于使用的例子在最开始已经给出了。符号值第二个组成部分是符号值，可以类比成普通变量的值，可以通过set函数来设置，通过 symbol-value 来获取。(set 'abc "i am abc") ;; ==> "i am abc" (symbol-value 'abc) ;; ==> "i am abc" abc ;; ==> "i am abc"set 以及 symbol-value 需要提供一个符号，表示对哪个符号进行操作。解释器执行第一行代码的时候未发现 abc 这个符号，那么它会将abc放入符号表中，然后这个符号就可以作为普通变量来使用了。最后一行代码我们直接将它作为普通变量那样使用，直接对它进行求值，发现它也可以获取到具体的值我们使用 setq 也可以达到这样的效果(setq val 123) ;; ==> 123 (symbol-value 'val) ;; ==> 123 val ;; ==>123 (set 'val 1234) ;; ==> 1234 (symbol-value 'val) ;; ==> 1234 val ;; ==> 1234从上面的代码中发现，setq 直接使用变量名来对变量进行赋值，而set 则需要对符号进行quote操作。我们可以将setq 看做是一个宏(至于宏是什么，会在后面进行介绍)，也就是 set quote，自动将后面的符号进行quote操作。但是setq只能对全局的obarray中的符号进行赋值，如果我们想放到指定的obarray中进行，此时就不能使用setq 了(setq foo (make-vector 10 0)) (set (intern "value" foo) 123) (symbol-value 'value) ;; ==> error (symbol-value (intern-soft "value" foo)) ;; ==> 123set 和 symbol-value 没有直接的参数来指定符号所在的obarray，如果想要使用自定义的obarray，那么就需要借助 intern、intern-soft、这样可以指定obarray 的函数来进行辅助操作。如果一个符号的值已经有设置过的话，则 boundp 测试返回 t，否则为 nil。对于 boundp 测试返回 nil 的符号，使用符号的值会引起一个变量值为 void 的错误(intern "null") (boundp 'null) ;; ==> nil null ;; error (set 'null 123) (boundp 'null) ;; ==> t null ;;==> 123函数第三个组成部分是函数,它可以类比成函数指针, 它可以用 symbol-function 来访问，用 fset 来设置。在之前一篇文章中，有知乎大牛指出我的问题，根据大牛的描述，在绑定lambda表达式时将函数部分绑定到符号的函数部分，使用funcall 调用的时候是在取函数部分的内容执行。这里详细了解符号相关的知识之后上述表达就很容易理解了。(setq foo (make-vector 10 0)) (fset (intern "abc" foo) (lambda (name) message "hello,%s" name)) (funcall (intern-soft "abc" foo) "Emacs") ;; ==> error上述的代码会报告一个错误，因为这里我们使用的obarray 是自定义的foo，它里面没有message这个符号，当然我们可以使用 intern来获取全局的 message 函数，并将它放入到foo中。这里的代码可以这么改(fset (intern "abc" foo) (lambda (name) (funcall (intern-soft "message") "hello,%s" name))) (funcall (intern-soft "abc" foo) "Emacs") ;; ==> "hello,Emacs"类似的，可以用 fboundp 测试一个符号的函数部分是否有设置。(fboundp 'message) (fboundp (intern-soft "message" foo)) ;; ==> nil (fset (intern "message" foo) (symbol-function 'message)) (fboundp (intern-soft "message" foo)) ;; ==>t属性列表第4个组成部分是属性列表，关于这部分我暂时还没想到该怎么用C/C++进行类比，如果非要一个类比的话，可以用这个类比。C/C++的编译器在看待变量的时候是将变量转变成对应的内存地址，操作变量实际上就是在操作变量所对应的内存。从CPU的角度来讲，CPU并没有规定哪些内存是只读的，哪些是数据，哪些是代码。编译器是如何做的呢？答案应该是编译器会在符号表中对各个符号做一些标记，例如const型变量所对应的内存不能修改。具体编译器是如何实现我也不太清楚，先这么生搬硬套吧，至少在了解elisp的符号这块，这么理解可能会稍微具体一点elisp中的属性列表，用于存储和符号相关的信息，比如变量和函数的文档，定义的文件名和位置，语法类型。属性名和值可以是任意的 lisp 对象，但是通常名字是符号，可以用 get 和 put 来访问和修改属性值，用 symbol-plist 得到所有的属性列表：(put (intern "abc" foo) 'doc "this is abc") (get (intern-soft "abc" foo) 'doc) ;; ==> "this is abc" (symbol-plist (intern-soft "abc" foo)) ;; ==> (doc "this is abc")符号的属性列表在内部表示上是用(prop1 value1 prop2 value2 ...) 的形式, 在存取上有点像C/C++中的map，但是在elisp中并不是所谓的map结构。另外还可以用 plist-get 和 plist-put 的方法来访问和设置属性列表，在上一段代码的基础之上(也就是设置了符号 abc 的 doc 属性的前提下)，使用如下代码来进行测试(plist-get (symbol-plist (intern-soft "abc" foo)) 'doc) ;; ==> "this is abc" (plist-put (symbol-plist (intern-soft "abc" foo)) 'foo 69) (get (intern-soft "abc" foo) 'foo) ;; ==> 69 (setq my-plist '(doc "this is abc")) ;; ==> "this is abc" (plist-put my-plist 'foo 89) (plist-get my-plist 'doc) ;; ==> "this is abc" (plist-get my-plist 'foo) (get (intern-soft "abc" foo) 'foo) ;; ==> 69从上面的代码来看，plist-get 和 plist-put 需要一个额外的属性列表的操作表示要操作的属性列表,但是它也可以通过传入符号的真实属性列表直接来操作符号的属性列表。

Emacs 折腾日记(九)——elisp 数组与序列 elisp 中序列是数组和列表的统称，序列的共性是内部数据有一个先后的顺序，它与C/C++ 中有序列表类似。elisp 中的数组包括向量、字符串、char-table 和布尔向量，它们的关系如下:在之前一章中已经介绍了序列中的一种类型——列表，本篇将介绍序列中的另外一种数据类型——数组数组简介与C/C++ 中的数组类似，elisp中的数组有如下特征在创建之初给定长度之后不允许后期修改长度数组中的每个元素都可以通过索引来获取，并且获取的算法时间复杂度为O(1)数组是自求值的数组中的的元素可以通过 aref 来获得，并且通过aset 来设置值根据上图，向量是数组中的一种。字符串也是特殊的数组，它是内部全部都是字符的数组(虽然elisp中没有字符这种数据类型)。教程中没有介绍 char-table 和 bool-vector，所以这里我也不打算介绍，后面要是真遇到了再看。测试函数测试函数是用同名带p的函数来进行测试，例如 sequencep 来测试是否是一个序列，stringp 测试是否是一个字符串, vectorp 测试是否是一个向量，arrayp 测试是否是一个数组。char-table-p 和 bool-vector-p 分别测试对象是否是 char-table、bool-vector(arrayp [1 2 3]) ;; ==> t (vectorp [1 2 3]) ;; ==> t (stringp [?A ?B ?C]) ;; ==> nil (stringp "ABC") ;; ==>t (vectorp "ABC") ;; ==> nil (arrayp "ABC") ;; ==> t通过上面的测试发现字符串和向量是不同的类型，但是字符串也是一种数组上述代码创建了一个向量，然后判断向量是否是一个数组。在elisp中向量也是数组的一种，所以这里返回t序列的通用函数在字符串中提到过，可以使用 length 来获取字符串的长度。其实它是一个序列的函数，它可以获取序列的长度。对于列表来说，它只能获取真列表的长度，对于点列表它会报错，而对于循环列表则会陷入死循环。它的算法应该是跟C/C++ 中获取链表的长度的算法一样，根据最后一个节点的next指针域是否为空来进行判断。对于点列表和循环列表，可以使用 safe-length 来获取，从名称上看，它是一个安全的获取长度的函数。(length [1 2 3 4]) ;; ==> 4 (safe-length '(1 2 3 4)) ;; ==> 4 (safe-length '(1 2 3 . 4)) ;; ==>3这里不要疑惑为什么第二个参数表达式返回的结果会是3，表达式中列表真正的表达形式应该是'(1 (2 (3 . 4)))虽然写法上使用 (1 2 3 . 4) 比较清爽干净也容易理解，但是要时刻记住它真正的形式应该是多个cons cell组成。插一个题外话，不知道各位读者还记不记得当初在学数据结构时，学到的如何判断环形链表的算法。那个算法被叫做两个指针跑步法，脱胎于小学时学的一道数学题；“在一个环形跑道，小明以每秒1米的速度匀速跑，小华以每秒2米的速度匀速跑，多久之后小明落后小华一圈”。这个算法也是这样的，一个慢指针每次往后移动一个节点，一个快指针一次移动两个节点，下一次两个指针能相遇，那么它就是一个环形列表。根据这个算法我们也可以提供一个lisp版本的判断环形列表的代码(defun circle-list-p (list) (and (consp list) (circle-list-p-1 (cdr list) (cdr (cdr list))))) (defun circle-list-p-1 (slow fast) (if (or (null slow) (null fast)) nil (if (not (consp slow)) nil (if (eq (car fast) (car slow)) t (circle-list-p-1 (cdr slow) (cdr (cdr fast))))))) (circle-list-p '(1 2 3 4)) ;; ==> nil (circle-list-p '#1=(1 2 . #1#)) ;; ==> t获取序列的第n个元素可以使用 elt,但是对于已知数据类型最好使用对应的函数，例如针对列表应该使用 nth，数组使用 aref。一来该对象是何种数据类型更加直观，二来省去了 elt 内部类型判断的操作。copy-sequence 在前面已经提到了。不过同样 copy-sequence 不能用于点列表和环形列表。对于点列表可以用 copy-tree 函数。环形列表就没有办法复制了。 好在这样的数据结构很少用到。数组操作创建向量可以使用 vector 函数，或者使用[], 来包裹一组数据，后者是向量的读入语法(vector 1 2 3) ;; ==> [1 2 3] (setq foo '(a b)) [foo] ;; ==> [foo] (vector 'foo) ;; ==> [foo] (vector foo 1 2 3) ;; ==> [(a b) 1 2 3]上述代码中我们使用两个方式分别构造一个向量。采用vector的时候会对其中的每个符号进行求值。而使用[]来构造时则没有进行求值，等效于使用 quote使用 make-vector 可以生成元素相同的向量(make-vector 9 "foo") ;; ==> ["foo" "foo" "foo" "foo" "foo" "foo" "foo" "foo" "foo"]fillarray 可以将数组的每个元素使用对应值进行填充(fillarray [1 2 3 4] 'foo) ;; ==> [foo foo foo foo]aref 和 aset 可以访问和设置数组中对应索引的元素。但是需要注意数组的长度，如果传入索引超过数组长度则会报错。可以使用 vconcat 可以将多个序列合并成一个向量，这里可以传入非向量，例如传入列表。针对列表仅限真列表。(vconcat [1 2 3] [3 4 5]) ;; ==> [1 2 3 3 4 5] (vconcat [1 2 3] '(3 4 5)) ;; ==> [1 2 3 3 4 5] (vconcat [1 2 3] '(4 . 5)) ;; ==> error将向量转化成列表可以使用 append函数(append [a b]) ;; ==> [a b] (append [a b] nil) ;; ==> (a b) (append [a b] '(c)) ;; ==> (a b c) (append [a b] "cd") ;; ==> (a b . "cd") (append [a b] "cd" nil) ;; ==> (a b "cd")在列表那一章中，append是将列表的最后一个节点的cdr替换为对应参数。在这里它可以将序列的元素转化为列表，但是需要注意，转换时同样需要两个参数。它会将第一个参数转化为列表，然后执行列表中添加元素的操作

Emacs 折腾日记(八)——CONS CELL和列表 本篇我们来介绍emacs lisp中的第一种复核结构——列表类型。cons cell从概念上讲 cons cell 非常简单，就是两个有顺序的元素。第一个元素叫 CAR、第二个元素叫 CDR。CAR 和 CDR 名字来自于 Lisp。根据 emacs lisp 简明教程 上的说法：它最初在IBM 704机器上的实现。在这种机器有一种取址模式，使人可以访问一个存储地址中的“地址（address）”部分和“减量（decrement）”部分。CAR 指令用于取出地址部分，表示(Contents of Address part of Register)，CDR 指令用于取出地址的减量部分(Contents of the Decrement part of Register)。cons cell 也就是 construction of cells。至于历史出处我们并不需要特别关心，也不用掌握，我们只需要掌握相关用法即可。其实我们可以将它想象成一个有两个抽屉的柜子，有一个抽屉叫 car 另一个叫cdr 。具体里面放什么东西没有限制，可以放基本的数据类型，也可以同样的放入这么一个柜子。首先使用 cons 来构建一个cons cell。例如(setq my-cons (cons 1 "hello")) ;; ⇒ (1 . "hello") (setq my-cons (cons 1 nil)) ;; ⇒ (1)因为一个cons cell 包含 car 和 cdr 两个元素，所以一般我们传入的时候需要两个参数。但是第二个参数可以为nil。根据emacs在mini-buffer上的输出，其实还可以使用另一种方式来构建一个cons cell(setq my-cons '(1 . "hello"))我们看到在前面的代码中我们带了一个单引号，这个单引号用于表示符号（symbol）或字面量（literal）。具体来说，它的作用是防止后面的表达式被求值。Lisp的语句是一个S-表达式，在解释器读到到一个S-表达式的时候会尝试对这个S-表达式求值。在出现括号的表达式的时候，会将括号内第一个元素作为函数进行调用，而将其他元素作为参数。如果不加引号，那么上面的代码就变成了(setq my-cons (1 . "hello"))这个表达式的含义就是调用1 这个函数，传入 "hello" 参数，并将函数的返回值设置成变量 my-cons 的值。因为没有这么一个函数，所以它执行会报错。这里的引号就是 quote 函数，它用来表示对后面的内容不求值，仅仅作为一个符号传入。上面的代码也可以改成(setq my-cons (quote (1 . "hello")))再举一个例子(setq my-cons '(a . b));; error上述的代码会报错，虽然我们指定了 (a . b) 是一个符号，是一个cons cell，但是对于里面的 a 和 b 却没有指定，因此解释器会尝试解释 a和b，然后发现a和b未定义，所以也会报错，我们可以使用单引号单独的指定a、b都是符号，或者给a、b变量设定值。虽然都不报错，但是它们的含义却是不同的。(setq my-cons ('a . 'b)) (let ((a 1) (b 2)) (setq my-cons '(a . b)))cons cell还有一个特殊的值，那就是 nil 它表示一个空的 cons cell。它可以使用如下形式来给出nil '()空表并不是一个真正的 cons cell , 但是为了编程方便，还是可以通过 car 和 cdr 来取值，结果都是空。(car '()) ;; ⇒ nil (cdr '()) ;; ⇒ nil (car nil) ;; ⇒ nil列表lisp的全程是 List Processing ，列表处理，从这点上看列表在lisp中的比重非常重，非常重要。列表可以看作一个特殊形式的cons cell。在上面的介绍中，cons cell有两个元素，car和cdr，列表第一个元素是car，其余的是cdr。以此规律往下递归。我们可以使用 list 函数来构建(list 1 2 3) ;; ⇒ (1 2 3)也可以使用上面的 quote 来构造'(1 2 3) ;; ⇒ (1 2 3)二者定义的时候有什么区别呢？quote 方式是直接将内容作为一个列表，而list 函数则是先解释执行后面的代码，再将结果构建成列表，下面是二者不同的一个例子(list (+ 1 2 ) 3) ;; ⇒ (3 3) '((+ 1 2) 3) ;; ⇒ '((+ 1 2) 3)再来看一个例子'(a b c) ;; ⇒ (a b c) (list a b c) ;; ⇒ error, 因为a b c都未定义，无法解释执行如果要使用 list 来生成类似于 (a b c) 这样的列表，关键点在于要告诉解释器a b c 它们不需要解释执行，可以使用 quote 来做到这点(list 'a 'b 'c) ;; ⇒ (a b c)测试函数可以使用 consp 来判断一个对象是否是cons cell。使用 listp 来判断对象是否是列表，但是我们说列表是特殊的 cons cell 所以使用 consp 来检测列表，也会返回真(consp '(1 2 3)) ⇒ t除此之外，elisp 将cons cell也视为一种特殊的列表，因此下面的代码也返回t(listp (cons 1 2)) ;; ⇒ t但是nil 或者 '() 它们不是cons cell 也不是 list，所以判断它们都会返回 nil(consp nil) (consp '())深入理解 cons cell 和列表上面提到我们可以使用 cons 和 list 来分别构造一个 cons cell 和列表，但是它们构造一个新的，不影响之前的，例如(setq my-cons (cons 1 2)) (cons my-cons my-cons) my-cons ;; ⇒ (1 . 2)同时 cons 也可以在列表前增加一个元素，例如(setq foo '(a b)) (cons 'x foo) ;; ⇒ (x a b) foo ;; ⇒ (a b)从上面返回的结果来看，cons 会创建一个新的列表，并且在新列表的最前面加上指定元素，但是它不会修改原有的列表。cons 会返回新元素，不修改老元素还可以理解，因为它本来就是用来构建新的 cons cell 的。那么还有一个问题需要解释，为什么这样一个用来构建cons cell的函数会用来添加列表元素呢？要回答这个问题，我们可以需要回归到列表的本质了。先看这么一个例子'(1 . (2 . (3 . nil))) ;; ⇒ (1 2 3)我们执行它，发现它会返回一个列表，从这个例子上看，列表本身就是一个cons cell。它是一个特殊的cons cell 。按照列表最后一个 cdr 来区分的话，可以分成三类：第一类就是上述例子这样的，它的最后一个cdr是nil，它也被叫做真列表第二类，既不是cons cell也不是nil，这种被称之为点列表第三类，最后一个cdr 指向之前一个cons cell'(1 . #1=(2 3 . #1#)) ; => (1 2 3 . #1)这个是教程中给出的环形列表的表示形式，它比较复杂。但是它的结构与当初学过的数据结构中的环形链表类似。'(1 . (2 . (3 . 4))) ;; ⇒ (1 2 3 . 4)上述代码是第二类列表的形式，它的最后一个cdr 是 4，既不是cons cell 也不是nil。上述的代码中也可以看出来，并不是说有 . 的都是 cons cell，没有. 的就是列表。还是以前面的抽屉来类比，第二个抽屉里放的是nil或者其他基本数据类型，那么它就是一个 cons cell。如果放的是另外一个同样类型的抽屉，那么它就是一个列表。用数据结构中的概念来类比的话，cons cell是一个不带指针的结构体，而列表就是一个带有指向自身结构体类型的指针域。即使它只有一个这种结构的对象也是一个列表的节点。(cons 1 nil) ;; ⇒ (1)上述代码就是这样的，第二节点域指向空，没有指向下一个节点，虽然只有一个节点，但它也是一个列表。我个人的理解是，不应该严格区分cons cell 和列表，就像C/C++中的struct 和list，struct是组成list的基础，而list中每个节点又都是一个struct， 所以前面使用 consp 和 listp 无法区分cons cell 和 lisp。而. 则可以看作是分隔符，分隔数据域和指针域的数据，指针域同样可以放入其他类型的数据，也可以放入 cons cell列表的操作函数添加列表元素如果希望修改原始列表可以使用 push ，与栈操作类似，它是将当前值添加到列表头，例如(setq foo '(a b)) (push 'x foo) foo ;; ⇒ (x a b)在列表前面添加元素使用 cons ，在列表后面添加元素可以使用 append。(setq foo '(a b)) (append foo '(x)) ;; ⇒ (a b x) foo ;; ⇒ (a b)(setq foo '(a b)) (append foo 'x) ;; ⇒ (a b . x) foo ;; ⇒ (a b)(setq foo '(a . b)) (append foo 'x) ;; error foo与cons 类似，它同样不修改原始列表的值。 用上面C/C++结构体和链表的类比话术来说的话，它的作用是将第一个参数的最后一个节点的指针域的空指针替换成第二个参数。上面的第一个例子，原本列表应该是 (a . (b . nil)) 它的最后一节点的指针域就是 nil，它被替换成了 (x), 可以写成 (x . nil) 。最后的结果就是 (a . (b . (x . nil))) 它是一个真列表，(a b x) 。第二个例子，还是先将列表展开 (a . (b . nil)) ，将nil替换成 x ，最后的结果就是 (a . (b . x)) 第三个例子，使用cdr 取出来的最后一个例子并不是空，所以它会报错与C中链表类似，采用头插法的速度要比使用尾插法快得多。即使用 cons 速度要比使用 append 快获取列表元素列表就是一个个cons cell 串起来组成的，可以使用 car 和 cdr 来获取元素，我们可以自己尝试仿照着C中对链表的操作来写一个函数获取列表中任意位置的元素(defun my-get-list-item(lst index) (let ((i 0)) (while (and (cdr lst) (< i index)) (setq lst (cdr lst)) (setq i (+ i 1))) (if (<= index i) (car lst) nil))) (my-get-list-item '(0 1 2 3 4 5) 2) ;; ⇒ 2当然也可以使用递归来完成(defun my-get-list-item(lst index) (if (or (not lst) (= 0 index)) (car lst) (my-get-list-item (cdr lst) (1- index)))) (my-get-list-item '(0 1 2 3 4 5) 2)递归版本相对于上面的循环来说要简单的多，代码量也少。递归版本中当列表为空或者当前索引为0时，停止递归并返回。利用空列表表的car 和 cdr 都是空这个特性，来将两种不同的情况使用同一操作进行处理。条件不满足时对cdr进行递归处理。虽然可以自己写这样的算法来取列表的第n个元素，但是elisp中也提供的对应的操作函数。使用 nth 来获取第n个元素，使用 nthcdr 来获取第n次调用cdr 的结果，也就是获取包含第n个元素的子列表(nth 2 '(0 1 2 3 4 5)) ;; ⇒ 2 (nthcdr 2 '(0 1 2 3 4 5)) ;; ⇒ (2 3 4 5)同时还提供了 last 来返回从右往左数第n个元素的子列表。和 butlast 来返回last之外的其它列表元素。(last '(0 1 2 3 4 5) 3) ;; ⇒ (3 4 5) (butlast '(0 1 2 3 4 5) 3) ;; ⇒ (0 1 2)利用这些函数可以实现取某一范围的子列表(defun my-get-sub-items (lst start end) (if (nthcdr start lst) (butlast (nthcdr start lst) (- (length lst) end)))) (my-get-sub-items '(0 1 2 3 4 5) 2 5) ;; ⇒ (2 3 4)上面的代码比较简单，首先使用 nthcdr 来取start后面的内容，然后使用 butlast 来去掉 end 后面的内容。不知道各位读者还记不记得 length 这个函数，前面我们用它来获取字符串的长度，这里我们用它来获取列表的长度。设置列表元素一般情况下，我们可以放心的递归和对列表进行操作，因为上述的一些函数都不会修改原列表的值，在递归或者循环的过程中我们使用的是产生的临时列表。但是有时候会希望修改列表的值，例如在将列表作为栈来使用的时候，就需要出栈和压栈的操作。设置元素的值，可以使用 setcar 和 setcdr 这两个函数。如果我想设置任意索引位置的值该怎么办呢？可以配合使用 nthcdr 和 setcar。(setq foo '(a b c)) (setcar foo 'x) foo ;; ⇒ (x b c) (setq foo '(a b c)) (setcdr foo '(x y)) foo ;; ⇒ (a x y) (setq foo '(a b c)) (setcdr foo 'x) foo ;; ⇒ (a . x) (setq foo '(a b c)) (setcar (nthcdr 1 foo) 'x) ;; ⇒ x foo ;; ⇒ (a x c)前面提到使用 push 在表头添加元素，这里再介绍一个 pop 函数，它用来删除表头元素，它们两个配合使用就能组成一个栈的数据结构(setq foo '(a b c)) (push 'x foo) ;; ⇒ foo (pop foo)列表排序将列表从尾到头进行反转可以使用 reverse ,例如(setq foo '(a b c)) (reverse foo) ;; ⇒ (c b a) foo ;; ⇒ (a b c)我们可以看到，reverse也是不修改原始的列表，而是返回一个新的列表。如果想要修改原始列表可以使用 nreverse(setq foo '(a b c)) (reverse foo) ;; ⇒ (c b a) foo ;; ⇒ (a)为什么这里foo 指向了列表的最后一个元素呢？使用当初学习C/C++链表操作时掌握的知识很好解释，原本foo指向的是列表头，但是反转之后，原来的链表头就变成最后一个元素，而没有修改foo指针指向的情况下，它就是指向链表的最后一个元素(这个原因是我猜的，不知道对不对)。我们还可以对列表进行排序，可以使用sort 函数进行排序，它接收一个列表，并且接收一个排序方式的函数。例如(setq foo '(3 4 5 1 2 0)) (sort foo '<) ;; ⇒ (0 1 2 3 4 5) foo ;; ⇒ (0 1 2 3 4 5)这里的 '< 是一个排序函数，有点像C++ 11 标准里面的 sort 函数，它可以传入一个函数用来表示排序时比较大小的一个过程。而且这里我们并不需要在这个时候调用 < 这个函数，所以先使用 quote 。在后续真正执行排序要比较大小的时候会调用它。这里我们可以自己定义比较函数，比如这里我们按照字符串长度进行排序(defun strlen-cmp (str1 str2) (< (length str1) (length str2))) (setq foo '("hello" "emacs" "aaa" "bbbbbb")) (sort foo 'strlen-cmp) ;; ⇒ ("aaa" "hello" "emacs" "bbbbbb") foo ;; ⇒ ("aaa" "hello" "emacs" "bbbbbb") ;; 这里也可以使用lambda表达式 (setq foo '("hello" "emacs" "aaa" "bbbbbb")) (sort foo (lambda (str1 str2) (< (length str1) (length str2)))) ;; ⇒ ("aaa" "hello" "emacs" "bbbbbb") foo ;; ⇒ ("aaa" "hello" "emacs" "bbbbbb")这里我们发现sort 已经将修改了原始列表，如果想要保留原始列表，可以使用 copy-sequence(setq foo '(3 4 5 1 2 0)) (let ((temp (copy-sequence foo))) (sort temp '<)) ;; ⇒ (0 1 2 3 4 5) foo ;; ⇒ (3 4 5 1 2 0)还有像 nconc 和 append 功能相似，但是它会修改除最后一个参数以外的所有的参数，nbutlast 和 butlast 功能相似，也会修改参数。这些函数都是在效率优先时才使用。总而言之，以 n 开头的函数都要慎用遍历列表前面我们已经使用 car 和 cdr 能做到遍历列表，这里再介绍一下专门用来遍历的函数 mapc 和 mapcar 。它们都可以遍历列表中的所有元素，它们的第一个参数是一个函数，每次遍历到一个元素的时候会调用这个函数并将元素作为参数传入这个函数。C++中没有提供这样的函数，但是也有类似的操作。例如使用 foreach 获取每个元素，然后根据元素来执行操作。(setq foo '(0 1 2 3 4)) (mapc '1+ foo) ;; ⇒ (0 1 2 3 4) foo ;; ⇒ (0 1 2 3 4) (setq foo '(0 1 2 3 4)) (mapcar '1+ foo) ;; ⇒ (1 2 3 4 5) foo ;; ⇒ (0 1 2 3 4)这两个遍历函数的区别就是，是否使用返回值来构建新的列表，其中 mapcar 会根据返回值构建新的列表，而 mapc 则返回原列表。我们发现无论是哪个函数都无法修改原始列表，要修改原始列表当然也有方法，我能想到的一个方法就是循环，然后配合 setcar 和 ntdcdr 根据索引来设置。好了，本篇的内容就到此为止了。本篇按照 emacs lisp 简明教程 的内容修改而来的。原教程还有好多其他数据结构的操作，但是我作为初学者还是希望本篇内容专注在列表上，至于教程中涉及的其他操作或者数据结构，等后面学到了再了解也不迟。

nvim番外之将配置的插件管理器更新为lazy 在很久以前我写过关于nvim配置的文章，里面推荐使用 packer作为插件管理器。但是在一年多以前，packer的仓库中出现这么一段文字This repository is currently unmaintained. For the time being (as of August, 2023), it is recommended to use one of the following plugin managers instead:lazy.nvim: Most stable and maintained plugin manager for Nvim.pckr.nvim: Spiritual successor of packer.nvim. Functional but not as stable as lazy.nvim.而且nvim相关的开源社区已经出现了 lazyVim 这样的配置。之前曾今考虑过更换自己的配置，但是秉持着代码能跑就不动的传统，一直没有动手。但是这个周末我游戏也不太想玩，学习elisp的动力也没那么足，那就决定来捣鼓一下之前使用的配置把。升级到lazy总的来说升级过程并不复杂，我之前的配置没有什么很深度的定制，基本都是在使用插件的基础功能。根据官方的文档，在升级的时候需要更改的代码在 plugins.lua 这个文件中。这个文件专门记录了我们安装了哪些插件。这个文件中主要做了以下几个修改在安装之前首先要安装 luarocks。在arch下，使用sudo pacman -S luarocks然后在plugins.lua 中添加安装 lazy 的代码-- 自动安装 lazy 插件管理器 local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim" if not vim.loop.fs_stat(lazypath) then vim.fn.system({ "git", "clone", "--filter=blob:none", "https://github.com/folke/lazy.nvim.git", "--branch=stable", lazypath, }) end vim.opt.rtp:prepend(lazypath)上述代码就是在检测在对应目录下是否存在 lazy.nvim ，没有则通过 git 进行安装。安装完成之后使用 vim.opt.rtp:prepend 来将lazy的路径添加到nvim的运行路径的最前面，保证在查找插件时有限在这个路径中查找。接着修改下面安装插件的代码，主要的修改就是去除 use ，并且将 require 修改为 dependencies 。具体修改的内容可以看这个 commit。这些工作都做完之后，重新打开nvim，可以发现 lazy 已经安装成功，并且它已经在为我们下载安装插件了插件安装成功之后，使用 check_health lazy 来检查插件是否有问题，第一次检查会得到几个错误因为现在 packer 和 lazy 安装的插件都存在，我们要根据提示删除 packer 的相关信息。删除完了之后，再次检查，发现已经不存在上面的错误了本篇就到这里了，后续每个插件是否都能正常工作我还没有测试，如果后续我发现错误，会在错误解决过后更新此文。如果有读者愿意使用我的配置，在使用过程中有错误请联系我，谢谢！

2024年回顾与2025年展望 本来打算元旦来做一下本人的年度总结的，但是元旦那天只有一天假，并且那天带孩子出去玩了，总结就耽搁了。这篇总结是自己断断续续靠晚上下班回来，老婆孩子睡着之后以及上班摸鱼时间写出来的2024年回顾本年度总结我继续从生活、学习以及工作上来进行回顾。首先是生活上，今天孩子开始在老家以及在我身边两边跑了。想想挺心酸的，这么小的孩子都开始做北漂。有孩子在身边的时候虽说学习以及更新博客的时间少了，但是陪孩子玩耍的时光却是很快乐的。看着孩子在地上跑跑跳跳，跟在她屁股后面追逐打闹，听着她那欢快的笑声，时间就过得特别快。这一年带孩子下来除了快乐，就是有点累。孩子的体力和精力似乎比我们这些久坐的程序员要强的多，最明显的一点就是如果出去玩，中午在外面的时候，我会困，但是孩子还特别有精力，到处跑，需要家长在后面跟着。商场里面会好的多，大不了摔倒了再爬起来，有时候在马路边上就得特别注意，附近是不是有车，即使在过马路的时候也要特别小心，有没有车闯红灯或者速度比较快的。既要关注孩子的位置，又要关注路边的车辆，有时候还要考虑根据天气添减衣服，或者注意时间要换尿布，喂水。虽然累但是孩子在身边的时候感觉整个人都开朗了不少，每次送回老家之后的几天总是要emo几天才能缓过劲来。闲暇的时间总喜欢隔着监控的屏幕看看她。有时候她给我打电话，电话里面说想爸爸妈妈了。心理挺难受的，都是自己没什么本事，想回老家，老家没有适合自己的岗位，留在北京，又没有户口，又没挣到买房的钱。现在还好还能常来，等到时候要上学了，要么在北京这边上私立，到时候老婆可能要离职看娃，又或者带回老家，那样就长期见不到人了，更难受了。工作上，目前已经慢慢爬到项目组的核心开发位置，这个应该不算是岗位，仅仅是负责的模块越来越核心，越来越重要了，照目前的发展看来，未来3到5年应该不愁饭碗。在我这年龄应该是程序员生涯的黄金年龄，既有能力、又有精力、还有经验，但是目前来说薪水只够大厂的白菜价，甚至白菜价都比我现在待遇要好。有时候也想过说不定可以靠着跳槽拿到更高的薪水，但是一来自己的学历不行，二来到现在几乎没有做过互联网相关的开发，做的都是常规的软件行业，缺乏相关经验。第三就是我自己是一个偏稳的性格，不喜欢冒险。而且这份工作虽然薪水不算太高，但是工作环境我认为比较好，而且工作强度不高，965，我可以兼顾工作和家庭。在大厂虽然薪水比较高，但是我估计扛不住那种高压力和快节奏的生活，所以就在这按部就班的干着，拿着一份不高不低的薪水先苟住在说。学习方面，我的博客今年又断更了，本来想写PDF相关的内容但是后来断了一断时间之后实在就提不起兴趣来。后来之前关注的 21天学会emacs系列 也更新完了。我就再想要不乘着这个时机再好好学习一下emacs。我按照视频教程一点点的配置自己的emacs，总感觉有那么点力不从心，按着视频的指示我能跟着一点点的配置，但是离开视频，比如我想加一些视频没有的功能，就感觉无从下手。考虑良久之后我觉得应该需要系统性的学习一下emacs知识和elisp，甚至要读一下emacs的官方文档。后来我回忆起自己当初更新vim配置相关文章的感觉，虽然我在之前已经有一套复制粘贴的配置，但是里面的代码有点乱，而且有些代码我也忘了是干嘛的，既然我之前已经写过使用neovim来演示的教程，那么何不使用neovim来进行配置呢？带着这个目的我开启了第二篇关于vim的教程。老实说这一系列教程算是一次大胆的尝试，过去我总是觉得应该在自己对某一事物有足够的了解的时候才能写相关内容，要保证自己产出的内容的准确和真实。但是这次的尝试我打破了这一原则，老实说在写配置相关教程的时候我对neovim的相关接口并不太了解，仗着有点vimscript的基础就开始了。后来甚至出现了部分插件需要更新的neovim，或者某些插件已经过时了，但是我并不知道的情况。这些相信各位一路跟着读过来的读者有这个印象，教程换过neovim版本，也换过插件。这些都是我后来发现并更改的。不知道各位读者读起来会不会觉得生气，或者觉得有点误人子弟。但是我一路更新下来的同时自己也学到不少东西，例如那些从来没有了解过的 neovim 的lua接口。那些完全是自己看着管饭的文档写出来的。有了这么一个经验(不知道读者看来算不算成功，但是我觉得对我来说还算比较成功)，我一合计，不如照搬以前的模式吧，写出一系列关于emacs的文章，在写作中学习。但是这次我就不敢管那些文章叫教程了，我管它们叫折腾日记，反正是折腾，愿意跟着一起折腾的读者就跟着一起来，后面如果发现之前出错了，在后面的文章中更新就好了。这样心理压力会少不少。这样年末的这一系列就诞生了。flag 回顾去年在总结里面我立下了一系列的TODO list，现在回过头来看，有些已经完成了，有些还处于未完成的状态。生活带老婆孩子出去旅游：这个今年完成了，而且去了两次，一次是国庆去香港，一次是跟随公司出国游春天带孩子去公园踏青：踏青去了无数次了，但是野生动物园是老婆带着去的，我那个时候上班去了健康关于健康的目标有点惭愧，一个都没实现，脂肪肝好在还是轻度的，但是腰围又大了一圈，说是要减肥但是仍然管不住嘴也迈不开腿。工作上去年说要记录一下工作的日志，作笔记。但是执行起来效果并不好，笔记写了一堆，但是无法跟代码结合起来，有时候明明知道代码改动了，但是不知道代码为什么改了。有时候明明知道这部分业务代码处理了，但是忘了在哪一块处理过了。二者没办法有效的结合起来，所以实际上跟记不记笔记没什么关系，可能要考虑一下如何使二者结合起来。个人学习方面之前主要的flag在博客和读书上面，读书这个算是勉强完成了目标(算上两本漫画书、刚好够)。虽然通勤时间长，但是还是还是抵御不了手机的诱惑，期间kindle还坏了，这样手机彻底放不下了。微信读书虽然也能看书，但是经常性的刚看的起劲，后面发现要会员，没办法只能去刷短视频了。博客方面 PDF相关的内容暂时要缓缓了，不管数量和质量都没达到理想中的状态。理财方面记账这个事后来总是忘了，总是差几笔，后来摆烂了，干脆放弃了。但是做到了每个月留出一笔钱作为定期。而且我完全放弃A股转投美股指数基金了，这一年收益还不错，虽然投入的不多，但是每周的定投，今年收益大概在8%左右。个人娱乐方面当初想着玩玩王国之泪的，但是后面越玩越感觉不如旷野之息，感觉没啥意思了。新鲜感过了，就放下了。2025年年度计划以前的年度计划总是太笼统，说一些自己都不怎么信的鬼话，在做2024年的计划时，我改变了策略，每方面列一些目标来完成。至于那些骗人的鬼话，我想我还是会写一些，不过不在年度计划里了。我想后面再考虑写一些5年计划，在那个里面写。今年的目标如下：生活还是出去旅游一次在孩子上学之前带着孩子多出去玩玩，也不说具体地点了，每个周末带着出去转转健康今年争取每周运动至少1小时。每天下班回来如果有时间和精力也运动一下今年改变晚餐结构，晚餐少吃，主要靠玉米。配合运动将体重和腰围减下来工作上为了将更改和代码结合起来，我决定改变策略，使用gitlab来记笔记。gitlab上每次merge request 提交的时候可以写一些备注，支持markdown语法。基于这点，我想采用这样的计划每次提交merge request 保证只包含一个功能或者一个bug进行更新每次提交 merge request 都写上对应的更新理由、更新内容、以及更新对应的测试用例代码中写上简短的注释，并配上 merge request 编号这样根据代码能找到提交记录以及更新的相关说明，根据merge request 的更新记录也能知道代码做了哪些变更个人学习方面首先还是更新博客，今年主要更新emacs系列，估计篇幅不会少，可能要花一年的时间来更新读书，今年我给自己找了些消费主义、经济、投资、和新的小说。每天抽出一段时间来摸摸鱼，看看一些论坛，github。看看老外那边现在流行什么。或者有什么提升效率的工具今年更新的平台主要有：CSDN、博客园、知乎、个人网站、头条、微信公众号。可能还会有我不知道什么时候开通了同步功能的平台个人娱乐方面Switch目前已经进入晚期了，之前在淘宝上看到又卖那种烧录卡的，不知道靠不靠谱，我想搞一个来玩玩。又想起了小时候买小霸王那种3合一、10合一游戏卡的日子，好了，今年的总结到此为止了。感谢各位读者能在这里看我碎碎念。

Emacs折腾日记(七)——布尔变量、逻辑运算符与位运算 通过前面的几节内容我们已经对elisp中基本类型有所了解了。emacs lisp 简明教程 中下一节开始就是讲相关容器。所以这一篇我将它作为基础类型的一个结尾，将平时会用到，但是之前没有涉及到的内容都包含进来。bool类型本篇首先要提到的就是bool类型，我们已经在前面几章中用到过它，但是没有具体提到它。像if，cond、while 中都有它的声影。有其他编程语言相关经验的读者对它应该不会陌生，而且使用起来应该也是手到擒来。elisp中bool变量的真和假分别用 t 和 nil 来表示。它只有 nil 表示假，其余都是真。在其他编程语言中，0表示假，但是elisp中0也是真，我们可以使用下列代码来验证(if 0 (message "0 is t") (message "0 is nil")) ;; ⇒ "0 is t"包括0、空字符串都是真，elisp中只有 nil 本身是假，其余都是真。与其他编程语言类似，bool变量主要使用逻辑运算符来进行运算。elisp中的逻辑运算符也是与或非，对应的操作符为 and、or、not ，它们中间也有短路性质，即and 语句中如果一条语句已经为假，则不执行后一条，而or 中一条语句为真，则不判断后一条语句。elisp中经常利用短路性质来执行一些特殊的操作，例如常常用 or 来设置函数参数的缺省值。例如(defun say-hello (&optional name) (or name (setq name "Emacs")) (message "Hello, %s" name)) (say-hello) ;; ⇒ "Hello, Emacs" (say-hello "Lisp") ;; ⇒ "Hello, Lisp"位运算当初在学习C、C++的时候就觉得它对二进制位的操作实在是比较精妙，例如TCP/IP协议中使用位域来定义相关结构体。或者Win32 API中关于flag的设计就是典型的位运算设计。利用位运算的相关内容，一个字节的数据就能存储8位的标志。虽然教程中没有提及位运算的内容，但是我实在是比较好奇elisp中的位运算，所以我加了这一部分的内容。内容也比较简单，位运算基本也就是那些操作，主要是 and、or、xor、not。以及左移右移的操作。elisp中提供了支持这些操作的一些函数，下面是一些位的逻辑运算的函数logand: 按位与运算logior: 按位或logxor: 按位异或lognot: 按位非;; 3 ⇒ 011 5⇒ 101 (logand 3 5) ;; ⇒ 1 (logior 3 5) ;; ⇒ 7 (logxor 3 5) ;; ⇒ 6 (lognot 5) ;; ⇒ -6下面是位移运算的函数ash: 位移操作elisp 中没有单独提供左移和右移的操作，上面的函数根据第二个参数来决定左移或者右移，正数代表左移，负数代表右移，例如(ash 3 1) ;; ⇒ 6 (ash 3 -1) ;; ⇒ 2本节到此就结束了。本节算是一个针对原来教程的补充，内容不多。