Eric's Blog

别拿 X 当创作主阵地：被幽灵禁言后我才明白

Tue, 14 Jul 2026 00:00:00 +0000

X 的 ghost ban 悄无声息，非登录状态下内容完全不可见，搜索引擎收录归零。别把创作主阵地放在别人的平台上。

chat.nvim v1.8.0：自动重试、用户画像与定时任务重写

Fri, 10 Jul 2026 00:00:00 +0000

chat.nvim v1.8.0 正式发布，新增 LLM 请求自动重试、用户画像、Markdown 渲染、定时任务架构重写等重大更新。

chat.nvim 定时任务的设计与实现

Sat, 27 Jun 2026 00:00:00 +0000

chat.nvim 定时任务功能的设计思路与实现方案，让 AI 助手具备主动执行任务的能力。

回乡记：老学校与旧友

Wed, 24 Jun 2026 00:00:00 +0000

一座被时间封存的老学校，一段寻访旧友的意外旅程。

AI 越狱新姿势：当 Makefile 成为沙箱逃逸的后门

Tue, 16 Jun 2026 00:00:00 +0000

AI 通过 Makefile 绕过沙箱限制的安全分析，揭示 Tool Use 中的潜在风险。

Learn Vim 第二十四章：Vim Runtime

Sat, 16 May 2026 00:00:00 +0000

Vim会自动查找一些特殊的路径，这些都是Vim runtime路径的例子。本章向您展示它们什么时候被调用，帮助您更进一步理解和定制Vim。

Runtime路径

在Unix机器中，vim runtime路径是 ~/.vim/。运行 :h runtimepath 查看不同操作系统的路径。

Plugin脚本

~/.vim/plugin/ 中的脚本每次Vim启动时都会执行，可用于执行初始化脚本。

文件类型检测

确保 vimrc 中包含：

filetype plugin indent on

文件名检测

使用 ftdetect/ 目录：

" ~/.vim/ftdetect/chocodonut.vim
autocmd BufNewFile,BufRead *.chocodonut set filetype=chocodonut

或使用 filetype.vim 文件：

" ~/.vim/filetype.vim
if exists("did_load_filetypes")
  finish
endif

augroup donutfiletypedetection
  autocmd! BufRead,BufNewFile *.plaindonut setfiletype plaindonut
augroup END

基于文件内容检测

使用 scripts.vim：

" ~/.vim/scripts.vim
if did_filetype()
  finish
endif

if getline(1) =~ '^\\<donutify\\>'
  setfiletype donut
endif

文件类型插件

~/.vim/ftplugin/ 中的脚本仅在打开对应文件类型时执行。例如 ~/.vim/ftplugin/chocodonut.vim 仅在打开 chocodonut 文件时运行。

缩进文件

~/.vim/indent/ 存储缩进相关代码，工作方式与ftplugin类似。

颜色

~/.vim/colors/ 存储颜色主题。此目录中的文件会在 :color 命令中显示。

语法高亮

~/.vim/syntax/ 定义语法高亮：

" ~/.vim/syntax/chocodonut.vim
syntax keyword donutKeyword donut
highlight link donutKeyword Keyword

推荐 vim-polyglot 插件提供多语言语法高亮。

文档

~/.vim/doc/ 存储文档。运行 :helptags ~/.vim/doc/ 生成帮助入口。

延时加载脚本

~/.vim/autoload/ 中的脚本仅在被显式调用时才加载：

" ~/.vim/autoload/tasty.vim
function tasty#donut()
  echo "tasty#donut"
endfunction

调用：:call tasty#donut() 命名惯例：fileName#functionName()，井号(#)是必须的。

After脚本

~/.vim/after/ 的结构是 ~/.vim/的镜像，其中的脚本最后执行，用于重载脚本。

$VIMRUNTIME

Vim有环境变量 $VIMRUNTIME 用来加载默认脚本和支持文件。运行 :e $VIMRUNTIME 查看。

Runtimepath选项

运行 :set runtimepath? 查看runtime路径。插件管理器会将每个插件添加到runtime路径中。添加自定义目录到runtime路径：

set rtp+=$HOME/box/of/donuts/

聪明地学习Runtime

浏览您最喜欢的Vim插件仓库，仔细研究一下它的目录结构。现在您已经理解了Vim的目录结构，您可以准备学习Vimscript了。

Learn Vim 第二十三章：Vim 软件包

Fri, 15 May 2026 00:00:00 +0000

从Vim 8开始，Vim自带了一个内置的插件管理器，名叫 软件包（packages）。在本章，您将学习如何使用Vim软件包来安装插件。要查看是否支持软件包，运行 :echo has('packages')（返回1表示支持）。

包目录

在 ~/.vim/ 中创建 pack/ 子目录（~/.vim/pack/）。Vim会在这个子文件夹内自动搜索插件。

两种加载方式

自动加载

将插件放置在 start/ 子目录中：

~/.vim/pack/*/start/

* 可以是任意名字。例如 packdemo/：

~/.vim/pack/packdemo/start/

克隆插件：

cd ~/.vim/pack/packdemo/start/
git clone https://github.com/preservim/nerdtree.git

下一次启动Vim时，插件自动可用。

手动加载

将插件放置在 opt/ 目录中：

~/.vim/pack/packdemo/opt/

需要手动加载：

:packadd killersheep

手动加载适用于不是所有时候都在用的插件，避免拖慢Vim启动。也可以有条件地加载：

if has('nvim')
  packadd! neovim-only-plugin
else
  packadd! generic-vim-plugin
endif

组织管理软件包

* 可以用来按类型分组：

~/.vim/pack/colors/start/
~/.vim/pack/syntax/start/
~/.vim/pack/games/start/

聪明地添加插件

如果您是极简主义者，可以尝试Vim软件包。如果您是一名插件重度使用者，可能仍需要插件管理器（如vim-plug），因为它可以方便地批量更新插件。

Learn Vim 第二十二章：Vimrc

Thu, 14 May 2026 00:00:00 +0000

在先前的章节中，您学习了如何使用Vim。在本章，您将学习如何组织和配置Vimrc。

Vim如何找到Vimrc

Vim在以下路径按顺序查找vimrc文件：

$VIMINIT
$HOME/.vimrc
$HOME/.vim/vimrc
$EXINIT
$HOME/.exrc
$VIMRUNTIME/default.vim

第一个被找到的vimrc文件将被加载，其余的被忽略。

应该把什么放在Vimrc中？

答案是，”任何您想放的东西”。直接复制粘贴别人的vimrc文件的确是一个诱惑，但您应当抵制这个诱惑。确保您知道这个vimrc干了什么，以及它是否符合你的实际需要。

Vimrc基础内容

一个vimrc是以下内容的集合：

插件
设置
自定义函数
自定义命令
键盘映射

插件

使用 vim-plug 管理插件：

call plug#begin('~/.vim/plugged')
  Plug 'mattn/emmet-vim'
  Plug 'preservim/nerdtree'
call plug#end()

运行 :PlugInstall 安装插件，:PlugClean 删除不使用的插件。

设置

set relativenumber number
set tabstop=2
set nocompatible

自定义命令

:command! GimmeDate echo call("strftime", ["%F"])

使用 -nargs 限定参数数目，<args>、<f-args>、<q-args> 传递参数。

键盘映射

nnoremap <silent> <C-f> :GFiles<CR>
inoremap jk <esc>

n 表示普通模式。
nore 表示禁止递归。
map 是键盘映射命令。

务必使用 nnoremap 而非 nmap，以避免无限循环。设置 leader 键：

let mapleader = "\<space>"

组织管理Vimrc

划分您的vimrc

source $HOME/.vim/settings/plugins.vim
source $HOME/.vim/settings/configs.vim
source $HOME/.vim/settings/functions.vim
source $HOME/.vim/settings/mappings.vim

折叠您的vimrc文件

使用标志折叠（}）保持单个文件有序。

启动Vim时加载/不加载Vimrc

vim -u NONE          " 不加载vimrc和插件
vim -u NORC          " 不加载vimrc，但加载插件
vim --noplugin       " 加载vimrc，但不加载插件
vim -u ~/.vimrc-backup  " 加载其他vimrc

聪明地配置Vimrc

学习构建您的Vimrc最好是首先阅读他人的vimrc文件，然后逐渐地建立自己的。最好的vimrc是最适合您的工作需要和编辑风格的。

Learn Vim 第二十一章：多文件操作

Wed, 13 May 2026 00:00:00 +0000

多文件编辑更新是一个值得掌握、非常有用的编辑工具。本章，您将学到如何在Vim中进行多文件编辑的更多不同方法。

在多个文件中执行命令的几种方法

要在多个文件中执行命令，Vim有8种方法：

参数列表 (argdo)
缓冲区列表 (bufdo)
窗口列表 (windo)
tab 列表(tabdo)
快速修复列表 (cdo)
文件方式的快速修复列表 (cfdo)
位置列表 (ldo)
文件方式的位置列表 (lfdo)

实际上，大部分时间您可能只会用到1种或2种。它们的运行方式都大体相同：分别创建一个列表，然后向列表传递一个您想执行的命令。

参数列表

:args file1 file2 file3
:args *.js
:args **/*.js

遍历：

:first 跳至第一个文件
:last 跳到最后一个文件
:next / :prev 向前/向后移动

在所有匹配文件中执行替换：

:args **/*.yml
:argdo %s/donut/pancake/g | update

使用 :arga 添加文件到现有列表（不会覆盖）。

缓冲区列表

:buffers          " 显示缓冲区列表
:bufdo %s/donut/pancake/g | update

窗口列表和选项卡列表

:windo <command>    " 在每个窗口执行
:tabdo <command>    " 在每个选项卡执行

快速修复列表

:vimgrep /donut/ **/*.js
:copen              " 打开快速修复窗口
:cclose             " 关闭
:cnext / :cprev     " 遍历

cdo 和 cfdo 的区别：

cdo 在修复列表中的每一个元素上执行命令。
cfdo 在修复列表中的每一个文件上执行命令。

如果命令作用域是整个文件（如 :%s），使用 cfdo。如果命令作用域是某一行（如 :s），使用 cdo。

位置列表

位置列表和快速修复列表很像，区别在于：任何时候都只能有1个快速修复列表，而位置列表每个窗口可以有一个。

:lvimgrep /bagel/ **/*.md
:lopen

:ldo 对位置列表中每一个元素执行命令，:lfdo 对位置列表中每一个文件执行命令。

在Vim中运行多文件操作命令

当您需要在多个文件中改变一个变量名字的时候，您肯定想一个操作就全部搞定。建议从参数列表 :argdo 开始并掌握它，然后再学下一个。

Learn Vim 第二十章：视图、会话和 Viminfo

Tue, 12 May 2026 00:00:00 +0000

当您做了一段时间的项目后，您可能会发现这个项目逐渐形成了自己的设置、折叠、缓冲区、布局等。问题是，关闭 Vim 后，所有的这些更改都会丢失。本章中，您将学习如何使用视图、会话和 Viminfo 来保存项目的”快照”。

视图

视图是这三个部分中的最小子集，它是单个窗口相关设置的集合。如果您长时间在一个窗口上工作，并且想要保留其映射和折叠，您可以使用视图。

配置视图属性

:set viewoptions?

默认显示 viewoptions=folds,cursor,curdir。添加 localoptions：

:set viewoptions+=localoptions

保存和加载视图

:mkview    " 保存视图
:loadview  " 加载视图

Vim 允许您保存 9 个编号的视图（1-9）：

:mkview 1
:loadview 1

自动创建视图

autocmd BufWinLeave *.txt mkview
autocmd BufWinEnter *.txt silent loadview

会话

如果说视图保存了某个窗口的设置，那么会话则保存了所有窗口（包括布局）的信息。

创建和加载会话

:mksession              " 保存会话到 Session.vim
:source Session.vim     " 加载会话

从终端加载：

vim -S Session.vim

配置会话属性

:set sessionoptions?

默认值：blank,buffers,curdir,folds,help,tabpages,winsize,terminal 可存储的属性：

blank 存储空窗口
buffers 存储缓冲区
folds 存储折叠
globals 存储全局变量
options 存储选项和映射
winsize 存储窗口大小
tabpages 存储选项卡

Viminfo

Viminfo 存储着：

命令行历史记录。
字符串搜索历史记录。
输入行历史记录。
非空寄存器的内容。
多个文件的标记。
文件标记，它指向文件中的位置。
上次搜索 / 替换模式。
缓冲区列表。
全局变量。

通常，会话存储”外部”属性，Viminfo 存储”内部”属性。每个项目可以有一个会话文件，而 Viminfo 通常每台计算机只使用一个。

读写 Viminfo

:wv ~/.viminfo_extra    " 写入
:rv ~/.viminfo_extra    " 读取

使用不同的 Viminfo 文件来启动 Vim：

vim -i viminfo_extra

配置 Viminfo 属性

:set viminfo?

默认值 !,'100,<50,s10,h 分解如下：

! 保存以大写字母开头、却不包含小写字母的全局变量。
'100 保存最近 100 个文件的本地标记。
<50 每个寄存器最多保存 50 行。
s10 为寄存器设置大小限制（10kb）。
h 禁用高亮显示。

聪明地使用视图、会话和 Viminfo

对于微型项目，可以使用视图；对于大型项目，可以使用会话。为您的编辑风格创建属于您自己的视图、会话和 Viminfo。如果您要换台计算机使用 Vim，只需加载您的设置，立刻就会感到就像在家里的工作环境一样！

Learn Vim 第十九章：编译

Mon, 11 May 2026 00:00:00 +0000

编译是许多编程语言的重要主题。在本章中，您将学习如何在 Vim 中编译。此外，您将看到如何利用好 Vim 的 :make 命令。

从命令行编译

您可以使用叹号运算符（!）进行编译：

:!g++ hello.cpp -o hello

Make命令

Vim 有运行 makefile 的 :make 命令。当您运行它时，Vim 会在当前目录查找 makefile 并执行它。 :make 命令也接受终端中 make 命令的参数：

:make foo
:make list_pls

如果命令执行异常，:make 命令将使用 Vim 的 quickfix 来存储这些错误。运行 :copen 可以打开 quickfix 窗口来查看错误。

使用 Make 编译

创建 hello.cpp 文件和 makefile：

all:
	echo "build, run"
build:
	g++ hello.cpp -o hello
run:
	./hello

运行 :make build 编译，:make run 执行。

不同的Make程序

当您运行 :make 时，Vim 实际上会执行 makeprg 选项所设置的任何命令：

:set makeprg=g++\ %

\ 用于转义空格。Vim 中 % 符号代表当前文件。使用去掉扩展名的原始文件名来命名编译后的输出：

:set makeprg=g++\ %\ -o\ %<

%< 代表没有扩展名的当前文件名。

保存时自动编译

:autocmd BufWritePost *.cpp make

切换编译器

Vim 有一个 :compiler 命令可以快速切换编译器：

:compiler ruby

Vim 执行 $VIMRUNTIME/compiler/ruby.vim 脚本，并将 makeprg 更改为使用 ruby 命令。

创建自定义编译器

创建 ~/.vim/compiler/typescript.vim：

CompilerSet makeprg=tsc
CompilerSet errorformat=%f:\ %m

第一行将 makeprg 设置为运行 tsc 命令。第二行将错误格式设置为显示文件（%f），后跟冒号和空格，最后是错误消息（%m）。

异步编译器

有时编译可能需要很长时间。有插件来运行异步进程：

异步Make

Vim-dispatch 的 :Make 命令与 Vim 的 :make 相似，但以异步方式运行。

异步调度（Dispatch）

:Dispatch 命令可以在Vim中运行任意外部命令：

:Dispatch rspec %

自动调度

autocmd BufEnter *_spec.rb let b:dispatch = 'bundle exec rspec %'

每当进入一个以 _spec.rb 结尾的文件，运行:Dispatch 将自动执行 bundle exec rspec。

聪明地学习编译

在本章中，您了解到可以使用 make 和 compiler 命令从Vim内部异步运行任何进程，以完善您的编程工作流程。Vim 拥有通过其他程序来扩展自身的能力，这使其变得强大。

Learn Vim 第十八章：Git

Sun, 10 May 2026 00:00:00 +0000

Vim 和 Git 是两种实现不同功能的伟大工具。Vim 用于文本编辑，Git 用于版本控制。在本章中，您将学习如何将 Vim 和 Git 集成在一起。

差异比较

若要查看两个文件之间的差异，请运行：

vimdiff file1.txt file2.txt

vimdiff 并排显示两个缓冲区。不同的行会被高亮显示。

]c 跳转到下一处差异（[c 跳回上一处差异）。
:diffput 将文本从当前缓冲区输出到另一个缓冲区。
:diffget 从另一个缓冲区获取文本到当前缓冲区。

使用 Vim 作为合并工具

将默认合并工具更改为 vimdiff：

git config merge.tool vimdiff
git config merge.conflictstyle diff3
git config mergetool.prompt false

运行 git mergetool 后，Vim 显示四个窗口：

LOCAL 包含本地的变化。
BASE 包含 LOCAL 和 REMOTE 的共同祖先。
REMOTE 包含要被合并的内容。

使用 :diffget LOCAL、:diffget BASE、:diffget REMOTE 来获取相应变化。完成后 :wqall 保存退出。

在 Vim 中使用 Git

使用 ! 叹号运算符运行 Git 命令：

:!git status
:!git commit
:!git diff
:!git add %         " git add current file

添加不同Vim窗口中的多个文件：

windo !git add %

插件

流行的 Git 相关插件：

Vim-Fugitive

Git Status

运行 :Git 显示 git 概要窗口：

- 暂存或取消暂存文件。
s 暂存文件。
u 取消暂存文件。

Git Blame

运行 :Git blame 显示拆分的问责窗口：

q 关闭。
A 调整作者列大小。
C 调整提交列大小。

Gdiffsplit

运行 :Gdiffsplit 执行 vimdiff，比对索引或工作树中的版本与当前文件最新更改的区别。

Gwrite 和 Gread

:Gwrite 暂存更改（类似 git add）。
:Gread 还原文件至更改前的状态（类似 git checkout），且操作可撤销。

Gclog

运行 :Gclog 显示提交历史记录，使用 quickfix 遍历。

聪明地学习 Vim 和 Git

每个人都有不同的 git 工作流，强烈建议试试上面列出的所有插件。要让 Vim-git 的集成工作得更好，一个显而易见的办法就是去深入了解 git。

Learn Vim 第十七章：折叠

Sat, 09 May 2026 00:00:00 +0000

在阅读文件时，经常会有一些不相关的文本会妨碍您理解。使用 Vim 折叠可以隐藏这些不必要的信息。本章中，您将学习如何使用不同的折叠方法。

手动折叠

想象您正在折叠一张纸来覆盖一些文本，实际的文本不会消失，它仍在那儿。Vim 折叠的工作方式与此相同，它折叠一段文本，在显示时会隐藏起来，但实际上并不会真的删除它。折叠操作符是z。假设有如下文本：

Fold me
Hold me

把光标放在第一行，输入 zfj。Vim 将这两行折叠成一行。上面的命令分解如下：

zf 是折叠操作符。
j 是用于折叠操作符的动作。

您可以使用 zo 打开/展开已折叠文本，使用 zc 关闭/收缩文本。折叠是一个操作符，所以它遵循语法规则（动词+名词）。例如，使用 zfip 可以折叠内部段落；使用 zfG 可以折叠至文件末尾。最有用的一些命令是：

zR 展开所有折叠。
zM 收缩所有折叠。
za 切换折叠状态。

不同的折叠方法

Vim 有六种不同的折叠方法：

手动折叠
缩进折叠
表达式折叠
语法折叠
差异折叠
标志折叠

缩进折叠

:set foldmethod=indent

Vim 将会查看每行的开头有多少空格，并将它与 'shiftwidth' 选项进行比较，以此来决定该行可折叠性。

表达式折叠

:set foldmethod=expr
:set foldexpr=getline(v:lnum)[0]==\\"p\\"

Vim 会计算每行的 'foldexpr' 值。如果返回 0，则不折叠行。如果返回 1，则该行的折叠级别为 1。

语法折叠

:set foldmethod=syntax

语法折叠是由Vim的语法高亮决定的。如果您使用了语法高亮插件，装上插件就可以直接使用语法折叠。

差异折叠

运行 vimdiff file1.txt file2.txt 时，Vim 会自动使用 foldmethod=diff。

标志折叠

:set foldmethod=marker

Vim 会寻找由 'foldmarker' 选项定义的特殊标志（默认 }），并标记折叠区域。

持久化折叠

要在关闭文件后保留折叠信息：

:mkview

重新打开后加载：

:loadview

自动保存和加载：

autocmd BufWinLeave *.txt mkview
autocmd BufWinEnter *.txt silent loadview

聪明地学习折叠

当您学习折叠时，请从手动折叠开始，然后逐渐学习不同的技巧来使用缩进和标志折叠。最后，学习如何使用语法和表达式折叠。

Learn Vim 第十六章：标签

Fri, 08 May 2026 00:00:00 +0000

快速转到任意定义处，是文本编辑中一个非常有用的特性。在本章中，您将学习如何使用 Vim 标签来做到这一点。

标签概述

假设有人给了您一个新的代码库：

one = One.new
one.donut

One？donut？跟随有One 和 donut定义的源代码，是帮助您理解的一个有效方法。您可以使用fzf 或 grep来搜索它们，但使用标签将更快。把标签想象成地址簿，它存储的不是”姓名-地址”对，而是”定义-地址”对。在普通模式下，您可以使用Ctrl-]跳转到定义。

标签生成器

现代 Vim 不自带标签生成器，您需要额外下载它。推荐使用 Universal ctags。生成一个基本的标签文件：

ctags -R .

R 选项告诉 ctags 从当前位置 (.) 递归扫描文件。稍后，您应该在当前文件夹看到一个tags 文件。

解剖标签文件

来看看donut 标签项：

donut	one.rb	/^  def donut$/;"	f	class:One

上面的标签项由四个部分组成：一个tagname、一个tagfile、一个tagaddress，以及标签选项。

donut 是 tagname。
one.rb 是 tagfile。
/^ def donut$/ 是 tagaddress。
f class:One 是标签选项，它告诉 Vim，donut 是一种函数 (f)，并且是 One 类的一部分。

标签文件

如果运行 :set tags?，您可能会看见 tags=./tags,tags。Vim 会在当前文件所在路径和当前目录中查找标签文件。要添加标签文件位置：

:set tags+=path/to/my/tags/file

为大型项目生成标签

如果要排除 node_modules 后执行 ctags：

ctags -R --exclude=node_modules .

可以多次使用 exclude 选项：

ctags -R --exclude=.git --exclude=vendor --exclude=node_modules --exclude=db --exclude=log .

标签导航

Ctrl-] 跳转到光标下的定义。还有命令行模式：:tag my-tag。您还可以使用 <Tab> 来自动补全参数：

:tag d<Tab>

标签优先级

如果有重复的标签项，Vim 会检查关键词的优先级。顺序是：

当前文件中完全匹配的静态标签。
当前文件中完全匹配的全局标签。
其他文件中完全匹配的全局标签。
其他文件中完全匹配的静态标签。
当前文件中不区分大小写匹配的静态标签。
当前文件中不区分大小写匹配的全局标签。
其他文件中区分大小写匹配的全局标签。
当前文件中不区分大小写匹配的静态标签。

选择性跳转标签

使用 :tselect 选择要跳转到哪个标签：

:tselect pancake

:tjump 方法仅在有多个匹配项时才提示标签列表：

:tjump pancake

tjump 在普通模式下有一个快捷键：g Ctrl-]。

标签的自动补全

在插入模式中输入Ctrl-x Ctrl-]，Vim 将使用标签文件来自动补全。

标签堆栈

Vim 维持着一个标签堆栈。使用 :tags 可以看到这个堆栈。要”弹出”堆栈，运行:pop，或按下 Ctrl-t。

自动生成标签

在保存时生成标签

:autocmd BufWritePost *.rb silent !ctags -R .

autocmd 是 Vim 的自动命令方法。
BufWritePost 是保存缓冲区时的一个事件。
.rb 是 ruby 文件的一种文件模式。
silent 避免每次触发时提示。
!ctags -R . 是要执行的命令。

使用插件

推荐使用 vim-gutentags，它的使用方法很简单，装上就可以直接使用。

聪明地学习标签

只要配置得当，标签是非常有用的。假设在一个新的代码库中，您想要搞清楚 functionFood 干了什么，您可以通过跳转到它的定义来搞懂它们。在那儿可以看到，它又调用了 functionBreakfast。继续跟踪，发现还调用了 functionPancake。进一步可以知道，这段代码和早餐吃煎饼有关。现在您已经知道如何使用标签，通过 :h tags 可以学习更多有关标签的知识。

Learn Vim 第十五章：命令行模式

Thu, 07 May 2026 00:00:00 +0000

在前三章中，您已经学习了如何使用搜索命令(/, ?)、替换命令(:s)、全局命令(:g)，以及外部命令(!)。这些都是命令行模式命令的一些例子。在本章中，您将学习命令行模式的更多技巧。

进入和退出命令行模式

命令行模式本身也是一种模式，就像普通模式、输入模式、可视模式一样。在这种模式中，光标将转到屏幕底部，此时您可以输入不同的命令。有 4 种进入命令行模式的方式：

搜索命令 (/, ?)
命令行指令 (:)
外部命令 (!)

您可以从正常模式或可视模式进入命令行模式。若要离开命令行模式，您可以使用 <esc>、Ctrl-c、Ctrl-[。

重复上一个命令

您可以用 @: 来重复上一个命令行指令或外部命令。如果您刚运行 :s/foo/bar/g，执行 @: 将重复该替换。如果您刚运行 :.!tr '[a-z]' '[A-Z]'，执行 @: 将重复上一次外部命令转换过滤。

命令行模式快捷键

在命令行模式中，您可以使用 Left 或 Right 方向键，来左右移动一个字符。如果需要移动一个单词，使用 Shift-Left 或 Shift-Right。使用 Ctrl-b移动到该行的开始，使用 Ctrl-e移动到该行的结束。和输入模式类似，在命令行模式中，有三种方法可以删除字符：

Ctrl-h    删除一个字符
Ctrl-w    删除一个单词
Ctrl-u    删除一整行

最后，如果您想像编辑文本文件一样来编辑命令，可以使用 Ctrl-f。这样还可以查看过往的命令，并在这种”命令行编辑的普通模式”中编辑它们，同时还能按下 Enter 来运行它们。

寄存器和自动补全

当处于命令行模式时，您可以像在插入模式中一样使用 Ctrl-r 从Vim寄存器中插入文本。如果您在寄存器 a 中存储了字符串 “foo” ，您可以执行 Ctrl-r a 从寄存器a中插入该文本。另外，您也可以按 Ctrl-r Ctrl-w 获取当前光标下的单词（按 Ctrl-r Ctrl-A 获取当前光标下的词组）。还可以按 Ctrl-r Ctrl-l 获取当前光标所在行。按 Ctrl-r Ctrl-f 获取光标下的文件名。您也可以对已存在的命令使用自动补全。要自动补全 echo 命令，当处于命令行模式时，首先输入 “ec”，接着按下 <Tab>，此时您应该能在左下角看到一些 “ec” 开头的 Vim 命令。按下 <Tab> 或 Ctrl-n 可以跳到下一个选项。按下 <Shift-Tab> 或 Ctrl-p 可以回到上一个选项。

历史记录窗口

您可以查看命令行指令和搜索项的历史记录。运行 :his : 来查看命令行指令的历史记录。默认情况下，Vim 存储最后 50 个命令。运行 :set history=100 可以将 Vim 记住的条目总数更改为 100。一个更有用的做法是使用命令行历史记录窗口，按q:将会打开一个可搜索、可编辑的历史记录窗口。如果您当前任务是执行 s/verylongsubstitutionpattern/donut/g，在历史记录中找到 s/verylongsubstitutionpattern/pancake/g，然后直接编辑它！将 “pancake” 改为 “donut” ，然后按 <Enter>。Vim立刻执行 s/verylongsubstitutionpattern/donut/g 命令。类似地，运行 :his / 或 :his ? 可以查看搜索记录。要想打开搜索历史记录窗口，您可以运行 q/ 和 q?。要退出这个窗口，按 Ctrl-c, Ctrl-w c, 或输入 :quit。

聪明地学习命令行模式

对比其他三种模式，命令行模式就像是文本编辑中的瑞士军刀。寥举几例，您可以编辑文本、修改文件和执行命令。本章是命令行模式的零碎知识的集合。同时，Vim 模式的介绍也走向尾声。现在，您已经知道如何使用普通、输入、可视以及命令行模式，您可以比以往更快地使用 Vim 来编辑文本了。

手机移动端 AI 助手：Termux + chat.nvim + Nova

Wed, 06 May 2026 00:00:00 +0000

在 Android 手机上通过 Termux 安装 chat.nvim 和 Nova，打造移动端 AI 编程环境。

Learn Vim 第十四章：外部命令

Wed, 06 May 2026 00:00:00 +0000

在Unix系统内部，您会发现许多小型的，超专业化命令，每个命令只做一件事（而且能很好地完成）。您可以将这些命令链接在一起以共同解决一个复杂的问题。如果可以从Vim内部使用这些命令，那不是很好吗？答案是肯定的!在本章中，您将学习如何扩展Vim以使其与外部命令无缝协作。

Bang 命令

Vim有一个Bang(!)命令，可以执行三件事：

将外部命令的STDOUT读入当前缓冲区。
将缓冲区的内容作为STDIN写入外部命令。
从Vim内部执行外部命令。

将外部命令的标准输出STDOUT读入Vim

将外部命令的STDOUT读入当前缓冲区的语法为：

:r !{cmd}

要获取ls命令的结果，请运行：

:r !ls

您可以从curl命令读取数据：

:r !curl -s 'https://jsonplaceholder.typicode.com/todos/1'

r命令也接受一个地址：

:10r !cat file1.txt

将缓冲区内容写入外部命令

语法为：

:w !cmd

如果您具有以下表达式：

console.log("Hello Vim");
console.log("Vim is awesome");

确保在计算机中安装了node，然后运行：

:w !node

:w !node和:w! node形式上区别很小，但功能上相隔千里。使用:w !node，您是将当前缓冲区中的文本”写入”到外部命令node中。用:w! node，则您将强制保存文件并将其命名为”node”。

执行外部命令

语法为：

:!cmd

要以长格式查看当前目录的内容，请运行：

:!ls -ls

要终止在PID 3456上运行的进程，可以运行：

:!kill -9 3456

过滤文本

如果给!范围，则可用于过滤文本。假设您有：

hello vim
hello vim

让我们使用tr (translate)命令将当前行大写。运行：

:.!tr '[:lower:]' '[:upper:]'

结果：

HELLO VIM
hello vim

命令分解：

.! 在当前行执行filter命令。
!tr '[:lower:]' '[:upper:]' 调用tr外部命令将所有小写字符替换为大写字符。

假设您需要使用awk命令删除两行的第二列：

:%!awk "{print $1}"

结果：

hello
hello

您可以使用管道运算符（|）链接多个命令，就像在终端中一样。假设您有一个包含这些美味早餐的文件：

name price
chocolate pancake 10
buttermilk pancake 9
blueberry pancake 12

如果您需要根据价格对它们进行排序，并且仅以均匀的间距显示菜单，则可以运行：

:%!awk 'NR > 1' | sort -nk 3 | column -t

结果：

buttermilk pancake 9
chocolate pancake 10
blueberry pancake 12

普通模式命令

在普通模式下，Vim有一个过滤运算符（!）。如果您有以下问候：

hello vim
hola vim
bonjour vim
salve vim

要大写当前行和下面的行，可以运行：

!jtr '[a-z]' '[A-Z]'

命令分解：

!j 运行常规命令过滤器运算符（!），目标是当前行及其下方的行。
tr '[a-z]' '[A-Z]'将小写字母替换为大写字母。

聪明地学习外部命令

Vim不是IDE。它是一种轻量级的模式编辑器，通过设计可以高度扩展。由于这种可扩展性，您可以轻松访问系统中的任何外部命令。这样，Vim离成为IDE仅一步之遥。有人说Unix系统是有史以来的第一个IDE。 Bang 命令的有用程度与您知道多少个外部命令相关。如果您的外部命令知识有限，请不要担心。以此作为持续学习的动力。每当您需要过滤文本时，请查看是否存在可以解决问题的外部命令。

Learn Vim 第十三章：全局命令

Tue, 05 May 2026 00:00:00 +0000

到目前为止，您已经了解了如何使用点命令(.)重复上一次更改，如何使用宏(q)重复动作以及将文本存储在寄存器中(")。在本章中，您将学习如何在全局命令中重复命令行命令。

全局命令概述

Vim的全局命令用于同时在多行上运行命令行命令。全局命令具有以下语法：

:g/pattern/command

pattern匹配包含该模式串的所有行，类似于替代命令中的模式串。command可以是任何命令行命令。全局命令通过对与pattern匹配的每一行执行command来工作。如果您具有以下表达式：

const one = 1;
console.log("one: ", one);

const two = 2;
console.log("two: ", two);

const three = 3;
console.log("three: ", three);

要删除所有包含”console”的行，可以运行：

:g/console/d

结果：

const one = 1;

const two = 2;

const three = 3;

全局命令在与”console”模式串匹配的所有行上执行删除命令(d)。

逆向匹配

要在不匹配的行上运行全局命令，可以运行：

:g!/{pattern}/{command}

或者

:v/{pattern}/{command}

如果运行:v/console/d，它将删除不包含”console”的所有行。

模式串

全局命令使用与替代命令相同的模式串系统。要删除包含”one”或”two”的行，请运行：

:g/one\|two/d

要删除包含任何一位数字的行，请运行：

:g/\d/d

传递范围参数

您可以在g命令之前传递一个范围：

:1,5g/console/d 删除第1行和第5行之间匹配字符串”console”的行。
:,5g/console/d 如果逗号前没有地址，则从当前行开始。
:3,g/console/d 如果逗号后没有地址，则在当前行结束。
:3g/console/d 如果只传递一个地址而不带逗号，则仅在第3行执行命令。

除了数字，您还可以将这些符号用作范围：

. 表示当前行。
$ 表示文件的最后一行。
+n 表示当前行之后的n行。

普通模式命令

您可以将全局命令和:normal命令行命令一起运行。如果您有以下文字：

const one = 1
console.log("one: ", one)

const two = 2
console.log("two: ", two)

要添加”;”运行到每一行的末尾：

:g/./normal A;

:g 是全局命令。
/./ 是”非空行”的模式。它匹配至少包含1个字符的行。
normal A; 运行:normal命令行命令。 A; 是普通模式命令，用于在该行的末尾插入”;”。

执行宏

您也可以使用全局命令执行宏。如果您有以下表达式：

const one = 1
console.log("one: ", one);

const two = 2
console.log("two: ", two);

创建一个宏，以在寄存器”a”的这些行的末尾添加分号：

qa0A;<esc>q

现在运行：

:g/const/normal @a

所有带有”const”的行的末尾将带有”;”。

递归全局命令

全局命令本身是命令行命令的一种，因此您可以从技术上在全局命令中运行全局命令。

:g/console/g/two/d

首先，g将查找包含模式”console”的行。然后，第二个”g”将从那三个匹配项中查找包含模式”two”的行。最后，它将删除该匹配项。您也可以将g与v结合使用以找到正负模式：

:g/console/v/two/d

它将查找不包含”two”的行。

更改定界符

您可以像替代命令一样更改全局命令的定界符。规则是相同的：您可以使用任何单字节字符，但字母，数字，", |, 和 \除外。要删除包含”console”的行：

:g@console@d

如果在全局命令中使用替代命令，则可以有两个不同的定界符：

g@one@s+const+let+g

默认命令

如果在全局命令中未指定任何命令行命令，全局命令将使用打印(:p)命令来打印当前行的文本。

:g/console

它将在屏幕底部打印所有包含”console”的行。顺便说一句，这是一个有趣的事实。因为全局命令使用的默认命令是p，所以这使g语法为：

:g/re/p

g = 全局命令
re = 正则表达式模式
p = 打印命令

这三个元素连起来拼写为 “grep”，与命令行中的grep 相同。g/re/p命令最初来自Ed编辑器。

反转整个缓冲区

要翻转整个文件，请运行：

:g/^/m 0

如果只需要反转几行，请将其传递一个范围。要将第5行到第10行之间的行反转，请运行：

:5,10g/^/m 0

汇总所有待办事项

要将所有TODO复制到文件末尾以便于自省，请运行：

:g/TODO/t $

如果不想复制，而是将所有的 TODO 移动到末尾，可以使用移动命令 m：

:g/TODO/m $

黑洞删除

为了避免删除的行存储到寄存器中，您可以使用黑洞寄存器（"_）：

:g/console/d _

将多条空行减少为一条空行

:g/^$/,/./-1j

/^$/ 表示一个空行。
/./ 表示一个非空行。-1 意思是向上偏移1行。
j 是联接命令。

如果想要将多个空行全部删去：

:g/^$/,/./j

高级排序

如果需要排序数组中的元素，而不是数组本身，可以运行以下命令：

:g/\[/+1,/\]/-1sort

/\[/+1 匹配左方括号”[“的下面1行。
/\]/-1 匹配右方括号”]”的上面1行。
sort 是命令行命令：排序。

聪明地学习全局命令

全局命令针对所有匹配的行执行命令行命令。有了它，您只需要运行一次命令，Vim就会为您完成其余的工作。要精通全局命令，需要做两件事：良好的命令行命令词汇表和正则表达式知识。每当需要在多个位置应用命令时，请暂停并查看是否可以使用g命令。寻找最适合工作的命令，并编写一个模式串以同时定位多个目标。

Learn Vim 第十二章：搜索和替换

Mon, 04 May 2026 00:00:00 +0000

本章涵盖两个独立但相关的概念:搜索和替代。很多时候，您得基于文本的共同模式搜索大量的内容。通过学习如何在搜索和替换中使用正则表达式而不是字面字符串，您将能够快速定位任何文本。附带说明一下，在本章中，当谈论搜索时，我将主要使用/。您使用/进行的所有操作也可以使用?完成。

智能区分大小写

尝试匹配搜索词的大小写可能会很棘手。如果要搜索文本”Learn Vim”，则很容易把字母的大小写输错，从而得到错误的搜索结果。如果可以匹配任何情况，会不会更轻松，更安全？这是选项ignorecase闪亮的地方。只需在 vimrc 中添加set ignorecase，所有搜索词就不区分大小写。但是，有时您需要搜索特定大小写的短语。为避免反复开关ignorecase选项，Vim 有一个smartcase选项。您可以将ignorecase和smartcase选项结合起来，当您输入的搜索词全部是小写时，进行大小写不敏感搜索；而当搜索词 至少有1个大写字母时，进行大小写敏感搜索。在您的 vimrc 中，添加:

set ignorecase smartcase

如果您有这些文字:

hello
HELLO
Hello

/hello 匹配”hello”，”HELLO”和”Hello”。
/HELLO 仅匹配”HELLO”。
/Hello 仅匹配”Hello”。

有一个缺点。如果只需要搜索小写字符串怎么办？您可以在搜索词前使用\C模式来告诉 Vim，后续搜索词将区分大小写。如果执行/\Chello，它将严格匹配”hello”，而不是”HELLO”或”Hello”。

一行中的第一个和最后一个字符

您可以使用^匹配行中的第一个字符，并使用$匹配行中的最后一个字符。如果您有以下文字:

hello hello

您可以使用/^hello来定位第一个”hello”。要定位最后一个”hello”，请运行/hello$。如果您有以下文字:

hello hello friend

运行/hello$将匹配不到任何内容，因为”friend”是该行的最后一项，而不是”hello”。

重复搜索

您可以使用//重复上一个搜索。如果您只是搜索/hello，则运行//等同于运行/hello。另外，回想一下前面的章节，您还可以使用n和N分别以相同方向和相反方向重复上一次搜索。如果您想快速回忆起第n个最近使用的搜索字怎么办？您可以先按/，然后按up/down方向键（或Ctrl-N/Ctrl-P），快速遍历搜索历史，直到找到所需的搜索词。要查看所有搜索历史，可以运行:history /。在搜索过程中到达文件末尾时，Vim 会抛出一个错误。您可以使用set wrapscan选项使 Vim 在到达文件末尾时回到文件顶部进行搜索。

使用候选词搜索

一次搜索多个单词属于日常操作。如果您需要搜索”hello vim”或”hola vim”，则可以使用|或运算符。给予这样一段文本:

hello vim
hola vim
salve vim
bonjour vim

要同时匹配”hello”和”hola”，可以执行/hello\|hola。您必须使用（\）转义（|）或运算符，否则 Vim 将按字面意义搜索字符串” “。

如果您不想每次都输入\|，则可以在搜索开始时使用magic语法（\v）:/\vhello|hola。有了\v，您就不必再转义特殊字符了。

设置模式匹配的开始位置和结束位置

也许您需要搜索的文本是复合词的一部分。如果您有这些文字:

11vim22
vim22
11vim
vim

如果您仅需要选择以”11”开始、以”22”结束的”vim”，您可以使用\zs（开始匹配）和\ze（结束匹配）运算符。执行:

/11\zsvim\ze22

Vim仍然会匹配整个模式”11vim22”，但是仅高亮显示介于\zs和\ze之间的内容。

搜索字符组

最基本的模式是字符组[ ]。如果您需要搜索任何数字，可以使用/[0-9]来匹配一位数字。/[a-z]来搜索小写字母，/[A-Z]来搜索大写字母。您可以将这些范围组合在一起。如果您需要搜索数字 0-9 以及从 a 到 f（十六进制）的小写字母和大写字母，可以执行/[0-9a-fA-F]。要进行否定搜索，可以在字符范围括号内添加^。要搜索非数字，请运行/[^0-9]。

搜索重复字符

您可以将count传递给您的搜索。它具有以下语法:

{n,m}

这些count周围的花括号需要被转义。这是count语法的四种不同变体:

{n}是精确匹配。 /[0-9]\{2\}匹配两个数字。
{n,m}是范围匹配。 /[0-9]\{2,3\}匹配 2 到 3 位数字。
{,m}是上限匹配。 /[0-9]\{,3\}匹配最多 3 个数字。
{n,}是下限匹配。 /[0-9]\{2,\}匹配最少 2 个或多个数字。

计数参数\{0,\}（零或多个）和\{1,\}（一个或多个）是最常见的搜索模式，Vim 为它们提供了特殊的操作符:*和+。

预定义的字符组

Vim 为常见字符组提供了简写:

\d    数字[0-9]
\D    非数字[^0-9]
\s    空格字符（空格和制表符）
\S    非空白字符
\w    单词字符[0-9A-Za-z_]
\l    小写字母[a-z]
\u    大写字符[A-Z]

搜索示例：在一对相似字符之间捕获文本

如果要搜索由双引号引起来的短语:

"Vim is awesome!"

运行这个:

/"[^"]\+"

这是一个通用模式用于捕获 由一对类似的定界符包围的短语。

搜索示例：捕获电话号码

如果要匹配以连字符(-)分隔的美国电话号码，例如123-456-7890，则可以使用:

/\v\d{3}-\d{3}-\d{4}

基本替换

Vim 的替代命令语法为:

:s/{old-pattern}/{new-pattern}/

替换范围

:[range]s/old/new/

:,3s/let/const/ - 从当前行替换到第 3 行。
:1,s/let/const/ - 从第 1 行替换到当前行。
:3s/let/const/ - 仅在第3行进行替换。
:%s/let/const/ - 在所有行上进行替换。

模式匹配

要交换”let”和变量名位置:

:%s/\v(\w+) (\w+)/\2 \1/

\1, \2, \3等代表捕获的分组。

替换标志

g    替换行中的所有匹配项。
c    要求替代确认。
e    防止替换失败时显示错误消息。
i    执行不区分大小写的替换
I    执行区分大小写的替换

特殊替换

\U    将后面跟着的字符变为大写
\u    将后面跟着的第一个字符变为大写
\L    将后面跟着的字符变为小写
\l    将后面跟着的第一个字符变为小写

贪婪与非贪婪

*表示贪婪匹配，而{-}表示非贪婪匹配。

:s/a.*1/\U&/g     " 贪婪模式，得到 ABC1DE1
:s/a.\{-}1/\U&/g  " 非贪婪模式，得到 ABC1de1

跨多个文件替换

:args *.txt
:argdo %s/dog/chicken/
:argdo update

用宏跨多个文件替换

:args *.txt
qq
:%s/dog/chicken/g
:wnext
q
99@q

以聪明的方式学习搜索和替换

良好的搜索能力是编辑的必要技能。掌握搜索功能使您可以利用正则表达式的灵活性来搜索文件中的任何模式。花些时间学习这些。要想掌握正则表达式，您必须在实践中去不断地使用它。

Nova v1.0.0 正式发布

Sun, 03 May 2026 00:00:00 +0000

Nova v1.0.0 正式发布，chat.nvim 的 Android 客户端迎来首个稳定版本。

Learn Vim 第十一章：可视模式

Sun, 03 May 2026 00:00:00 +0000

高亮显示文本块并对其进行更改，是很多文本编辑器中的常见功能。 Vim也可以使用可视模式实现这一功能。在本章中，您将学习如何使用可视模式来有效地处理文本块。

三种可视模式

Vim有三种可视模式，分别是：

v         逐字符可视模式
V         逐行可视模式
Ctrl-v    逐块可视模式

如果您有下列文字：

one
two
three

逐字符可视模式用于选择单个字符。在第一行的第一个字符上按v。然后使用j跳转至下一行。它高亮显示从”one”到光标位置的所有文本。现在，如果您按gU，Vim将高亮显示的字符转为大写。逐行可视模式适用于整行。按V并观看Vim选择光标的所在行。就像逐字符可视模式一样，如果您运行gU，Vim将高亮显示的字符转为大写。逐块可视模式适用于行和列。与其他两种模式相比，它为您提供了更大的移动自由度。按Ctrl-V，Vim像逐字符可视模式一样高亮显示光标下的字符，但向下移动时，除非光标已经在行尾，否则不会高亮显示光标上方的整行，它跳转至下一行时高亮显示尽可能少的字符。尝试用h/j/k/l移动，并观察光标的移动。在Vim窗口的左下方，您会看到显示-- VISUAL --，-- VISUAL LINE --或-- VISUAL BLOCK --以提示您所处的可视模式。当您处于可视模式时，可以通过按v，V或Ctrl-V键切换到另一种可视模式。例如，如果您处于逐行可视模式，并且想要切换为逐块可视模式，请运行Ctrl-V。试试吧！有三种退出可视模式的方法：esc，Ctrl-C和与当前可视模式相同的键。后者的意思是，如果您当前处于逐行可视模式(V)，则可以通过再次按V退出它。如果您处于字符可视模式，则可以通过按v退出它。如果您处于逐块可视模式，请按Ctrl-V。实际上，还有另一种进入可视模式的方式：

gv    转到上一个可视模式

它将在与上次相同的高亮显示的文本块上启动相同的可视模式。

可视模式导航

在可视模式下，您可以使用Vim动作(motion)扩展高亮显示的文本块。让我们使用之前使用的相同文本：

one
two
three

这次让我们从”two”行开始。按v进入字符可视模式(这里的方括号[]表示高亮显示的字符)：

one
[t]wo
three

按j，Vim将高亮显示从”two”行到”three”行的第一个字符的所有文本。

one
[two
t]hree

假设您刚刚意识到还需要高亮显示”one”行，因此按k。令您沮丧的是，它现在排除了”three”高亮。

one
[t]wo
three

有没有一种方法可以自由地扩展视觉选择范围，以向您想要的任何方向发展？答案是肯定的。高亮区域跟随光标移动。如果要将其向上扩展到行”one”，则需要将光标移动到”two”，现在您的光标在”three”行上。这时可以用o或O切换光标位置。在可视模式中使用o或O，光标会在高亮选择区域的开头和结尾跳转，以便与您扩展高亮区域。

可视模式语法

可视模式与普通模式使用相同的操作符(operations)。例如，如果您有以下文字，然后您想在可视模式中删除前两行：

one
two
three

用逐行可视模式(V)高亮显示”one”和”two”行：

[one
two]
three

按下d键将删除选择，类似于普通模式。请注意，与普通模式的语法规则有所不同，动词+名词不适用可视模式。虽然存在相同的动词(d)，但在可视模式下没有名词。可视模式下的语法规则是名词+动词(反过来了)，其中名词是高亮显示的文本。首先选择文本块，然后进行操作。在普通模式下，有一些命令不需要名词(motion)，例如x删除光标下方的单个字符，还有r替换光标下方的字符(rx将当前光标下的字符替换为x)。在可视模式下，这些命令现在将应用于整个高亮显示的文本，而不是单个字符。回到高亮显示的文本：

[one
two]
three

运行x会删除所有高亮显示的文本。您可以使用此行为在markdown文本中快速创建标题。假设您需要快速下面的文本转换为一级markdown标题(“===”):

Chapter One

首先，您使用yy复制文本，然后使用p粘贴文本：

Chapter One
Chapter One

现在转到第二行，以逐行可视模式选择它：

Chapter One
[Chapter One]

在markdown中，您可以通过在文本下方添加一系列=来创建标题，因此您可以通过运行r=来替换整个高亮显示的文本：

Chapter One
===========

要了解有关可视模式下的运算符的更多信息，请查看:h visual-operators。

可视模式和Ex命令

您可以有选择地在高亮显示的文本块上应用Ex命令。如果您具有以下表达式,并想将前两行的”const”替换为”let”：

const one = "one";
const two = "two";
const three = "three";

用任意可视模式高亮显示前两行，然后运行替换命令:s/const/let/g：

let one = "one";
let two = "two";
const three = "three";

请注意，我说过您可以使用任何可视模式执行此操作。您不必高亮显示整个行即可在该行上运行Ex命令。只要您在每行上至少选择一个字符，就会应用Ex命令。

跨多行编辑

您可以使用逐块可视模式在Vim中跨多行编辑文本。如果需要在每行末尾添加分号：

const one = "one"
const two = "two"
const three = "three"

将光标放在第一行上：

进入逐块可视模式，并向下两行(Ctrl-V jj)。
高亮显示到行尾($)。
按(A) ，然后键入”;”。
退出可视模式(esc)。

您应该看到在每一行后面附加的 “;”。有两种方法可以从逐块可视模式进入输入模式：可以使用A在光标后输入文本，也可以使用I在光标前输入文本。请勿将它们与普通模式下的A和I混淆。另外，您也可以使用:normal命令在多行添加内容：

高亮显示所有3行(vjj)。
输入:normal! A;。

记住，:normal命令执行普通模式命令。您可以指示它运行A;在该行的末尾添加文本”;”。

递增数字

Vim有Ctrl-X和Ctrl-A命令来减少和增加数字。与可视模式一起使用时，可以跨多行递增数字。如果您具有以下HTML元素：

<div id="app-1"></div>
<div id="app-1"></div>
<div id="app-1"></div>
<div id="app-1"></div>
<div id="app-1"></div>

有多个具有相同名称的id是一个不好的做法，因此让我们对其进行递增以使其唯一：

将光标移动到 第二行的 “1”。
启动逐块可视模式，并向下移动3行(Ctrl-V 3j)。这高亮显示剩余的”1”，现在除了第一行，所有的”1”应该已经高亮。
运行g Ctrl-A。

您应该看到以下结果：

<div id="app-1"></div>
<div id="app-2"></div>
<div id="app-3"></div>
<div id="app-4"></div>
<div id="app-5"></div>

g Ctrl-A在多行上递增数字。 Ctrl-X/Ctrl-A也可以增加字母。如果您运行：

:set nrformats+=alpha

nrformats选项指示Vim将哪个基数视为Ctrl-A和Ctrl-X递增和递减的”数字”。通过添加alpha，现在将字母字符视为数字。

选择最后一个可视模式区域

前面章节中我提到了gv可以快速高亮显示上一个可视模式选择的内容。您还可以使用以下两个特殊标记转到最后一个可视模式的开始和结束位置：

'<    转到上一个可视模式高亮显示的第一个位置（行）
'>    转到上一个可视模式高亮显示的最后位置（行）

之前，我提到过您可以在高亮显示的文本上有选择地执行Ex命令，例如：:s/const/let/g。当您这样做时，您应该看到以下内容：

:'<,'>s/const/let/g

您实际上是在使用('<, '>) 标记作为范围来执行 s/const/let/g命令。您随时可以随时编辑这些标记。比如，如果您需要从高亮显示的文本的开头到文件的末尾进行替换，则只需将命令行更改为：

:'<,$s/const/let/g

从插入模式进入可视模式

您也可以从插入模式进入可视模式。在插入模式下进入字符可视模式：

Ctrl-O v

回想一下，在插入模式下运行Ctrl-O可以使您执行普通模式命令。在普通模式命令挂起模式下，运行v进入逐字可视模式。请注意，在屏幕的左下方，它显示为--(insert) VISUAL--。该技巧适用于任何可视模式运算符：v，V，和Ctrl-V。

选择模式

Vim具有类似于可视模式的模式，称为选择模式。与可视模式一样，它也具有三种不同的模式：

gh         逐字符选择模式
gH         逐行选择模式
gCtrl-h    逐块选择模式

选择模式比Vim的可视模式更接近常规编辑器的文本高亮显示行为。在常规编辑器中，高亮显示文本块并键入字母（例如字母”y”）后，它将删除高亮显示的文本并插入字母”y”。如果您使用逐行选择模式(gH)高亮显示一行文本并键入”y”，它将删除高亮显示的文本并插入字母”y”，这与常规文本编辑器非常相似。将此行为与可视模式进行对比：如果您使用逐行可视模式(V)高亮显示一行文本并键入”y”，则高亮显示的文本不会被删除且被字母”y”代替，而是仅将其复制(yank)。在选择模式中，你不能执行对高亮文本执行普通模式的命令。我个人从未使用过选择模式，但是很高兴知道它的存在。

以聪明的方式学习可视模式

可视模式是Vim高亮显示文本的过程。如果发现使用可视模式操作的频率比正常模式操作的频率高得多，请当心。我认为这是一种反模式。运行可视模式操作所需的击键次数要多于普通模式下的击键次数。假设您需要删除一个内部单词(inner word)，如果可以只用三个按键(diw)，为什么要使用四个按键viwd呢？前者更为直接和简洁。当然，有时使用可视模式是合适的，但总的来说，更倾向于直接的方法。

Learn Vim 第十章：撤销

Sat, 02 May 2026 00:00:00 +0000

所有人都会犯各种各样的输入错误。因此对于任何一个现代的软件来说，撤销都是一个很基本的功能。 Vim 的撤销系统不仅支持撤销和取消撤销任何修改，而且支持存取不同的文本形态，让你能控制你输入的所有文本。在本章中，你将会学会如何执行撤销和取消撤销文本，浏览撤销分支，反复撤销, 以及浏览改动时间线。

撤销(undo)，重做和行撤销(UNDO)

对于一个基本的 undo 操作，你可以执行 u 或者 :undo。假设你有如下文本(注意”one”下面有一个空行)：

one

然后添加另一个文本：

one
two

如果你执行 u，Vim 会删除 “two”。 Vim 是如何知道应该恢复多少修改呢？答案是，Vim每次仅恢复一次修改，这有点类似于点命令的操作（和点命令不同之处在于，命令行命令也会被算作一次修改）。要取消上一次的撤销，可以执行 Ctrl-r 或者 :redo。例如上面的例子中，当你执行撤销来删除 “two” 以后，你可以执行 Ctrl-r 来恢复被删除掉的文本。 Vim 也有另一个命令 U 可以实现行撤销 (UNDO) 的功能，执行这个命令会撤销所有最新的修改。那么，U 和 u 的区别是什么呢？首先，U 会删除 最近修改的行中所有的 的修改，而 u 一次仅删除一次修改。其次，执行u 不会被算作一次修改操作，而执行 U 则会被算作一次修改。让我们回到之前的例子：

one
two

修改第二行的内容为 “three” (ciwthree<esc>):

one
three

再次修改第二行的例子为 “four” (ciwfour<esc>):

one
four

此时，如果你按下 u，你会看到 “three”。如果你再次按下 u，你会看到 “two”。然而，在第二行仍为 “four” 的时候，如果你按下 U，你会看到

one

执行 U 会跳过中间所有修改，直接恢复到文件最初的状态（第二行为空）。另外，由于 UNDO 实际上是执行了一个新的修改，因此你可以 UNDO 执行过的 UNDO。执行 U 后再次执行 U 会撤销自己。假如你连续执行 U，那么你将看到第二行的文本不停地出现和消失。就我个人而言，我几乎不会使用 U，因为很难记住文本最初的样子。 Vim 可以通过变量 undolevels 来选择最多可执行 undo 的次数。你可以通过 :echo &undolevels 来查看当前的配置。我一般设置为 1000。如果你也想设置为 1000 的话，你可以执行 :set undolevels=1000。

断点插入操作

在上文中我提到，u 每次恢复一个修改，类似于点命令。在每次进入插入模式和退出插入模式之间的任何修改都被定义为一次修改。如果你执行 ione two three<esc> 之后，按下 u，Vim 会同时删除 “one two three”，因为这是一笔修改。如果你每次只输入较短的文本，那这是可接受的；可假设你在一次插入模式中输入了大量的文本，而后退出了插入模式，可很快你意识到这中间有部分错误。此时，如果你按下 u，你会丢失上一次输入的所有内容。因此，假设你按下 u 只删除你上一次输入的一部分文本岂不是会更好。幸运的是，你可以拆分它。当你在插入模式时，按下 Ctrl-G u 会生成一个断点。例如，如果你执行 ione <Ctrl-G u>two <Ctrl-G u>three<esc>，之后你按下u，你仅会失去文本 “three”，再次执行 u，会删除 “two”。当你想要输入一长段内容时，应该有选择性地执行断点插入操作。在每一句话的末尾，两个段落的中间，或者每一行代码结束时插入断点是一个很好的选择，这可以帮助你快速从错误中恢复出来。在插入模式中，执行删除操作时插入断点也非常有用。例如通过 Ctrl-W 删除光标前的单词时，以及 Ctrl-U删除光标前的所有文本时。一个朋友建议我使用如下的映射：

inoremap <c-u> <c-g>u<c-u>
inoremap <c-w> <c-g>u<c-w>

通过上述命令，你可以很轻松地恢复被删除的文本。

撤销树

Vim 将每一次修改存储在一个撤销树中。你打开一个空白文件，然后添加一段新文本:

one

再插入一段新文本：

one
two

undo一次:

one

插入一段不同的话：

one
three

再次 undo

one

再次插入另一段话：

one
four

现在如果你执行 undo,您将丢失刚刚添加的文本 “four” :

one

如果你再次执行 undo 操作：

文本 “one” 也会丢失。对于大部分编辑器来说，找回文本 “two” 和 “three” 都是不可能的事情，但是对于 Vim 来说却不是这样。执行 g+，你会得到：

one

再次执行 g+ ，你将会看到一位老朋友:

one
two

让我们继续执行 g+:

one
three

再一次执行 g+ :

one
four

在 Vim 中，你每一次执行 u 去做一次修改时，Vim都会通过创建一个”撤销分支”来保存之前的文本内容。在本例中，你输入”two”后, 执行 u，然后输入”three”，你就创建了一个叶子分支,保存了含有”two”的文本状态。此时，撤销树已经包含了至少两个叶子节点，主节点包含文本”three”（最新），而另一undo分支节点包含文本”two”。假如你执行了另一次撤销操作并且输入了”four”，那么此时会生成三个节点，一个主节点包含文本”four”, 以及另外两个节点分别存储了”three”和”two”。为了在几个不同的节点状态间进行切换，你可以执行 g+ 去获取一个较新的状态，以及执行 g- 去获取一个教旧的状态。 u， Ctrl-R， g+，和 g- 之间的区别是，u and Ctrl-R 只可以在 main 节点之间进行切换，而g+ 和 g- 可以在所有节点之间进行切换。 Undo 树并不可以很轻松地可视化。我发现一个插件 vim-mundo 对于理解 undo 树很有帮助。花点时间去与它玩耍吧。

保存撤销记录

当你通过 Vim 打开一个文件，并且立即按下 u，Vim 很可能会显示 “Already at oldest change” 的警告。要想从最近的一次编辑工作中（在vim关闭文件再打开，算做一次新的编辑工作），在撤销历史中回滚，可以通过 :wundo命令使Vim 保存一份你的 undo 历史记录。创建一个文件 mynumbers.txt. 输入:

one

插入另一行文件 (确保你要么退出并重新进入插入模式，要么创建了断点):

one
two

插入新的一行:

one
two
three

现在，创建你的撤销记录文件。语法为 :wundo myundofile。如果你需要覆盖一个已存在的文件，在 wundo 之后添加 !.

:wundo! mynumbers.undo

退出 Vim。此时，在目录下，应该有mynumbers.txt 和 mynumbers.undo 两个文件。再次打开 mynumbers.txt 文件并且按下 u，这是没有响应的。因为自打开文件后，你没有执行任何的修改。现在，通过执行 :rundo 来加载 undo 历史。

:rundo mynumbers.undo

此时，如果你按下 u，Vim 会删除 “three”。再次按下 u可以删除 “two”。这就好像你从来没有关闭过 Vim 一样。如果你想要自动加载 undo 历史文件，你可以通过在你的 .vimrc 文件中添加如下代码：

set undodir=~/.vim/undo_dir
set undofile

我认为将所有的 undo 文件集中保存在一个文件夹中最好，例如在 ~/.vim 目录下。 undo_dir 是随意的。 set undofile 告诉 Vim 打开 undofile 这个特性，因为该特性默认是关闭的。现在，无论你何时保存，Vim 都会自动创建和保存撤销的历史记录（在使用undo_dir目录前，请确保你已经创建了它）。

时间旅行

是谁说时间旅行不存在。 Vim 可以通过 :earlier 命令将文本恢复为之前的状态。假如有如下文本:

one

之后你输入了另一行:

one
two

如果你输入 “two” 的时间少于10秒，那么你可以通过如下命令恢复到 “two” 还没被输入前的状态:

:earlier 10s

你可以使用 :undolist 去查看之前所做的修改。 :earlier 可以加上分钟 (m), 小时 (h), and 天 (d) 作为参数。

:earlier 10s    恢复到10秒前的状态
:earlier 10m    恢复到10分钟前的状态
:earlier 10h    恢复到10小时前的状态
:earlier 10d    恢复到10天前的状态

另外，它同样接受一个计数作为参数，告诉vim恢复到老状态的次数。比如，如果运行:earlier 2,Vim将恢复到2次修改前的状态。功能类似于执行g-两次。同样，你可以运行:earlier 10f命令告诉vim恢复到10次保存前的状态。这些参数同样作用于:earlier命令的对应版本::later。

:later 10s    恢复到10秒后的状态
:later 10m    恢复到10分钟后的状
:later 10h    恢复到10小时后的状
:later 10d    恢复到10天后的状态
:later 10     恢复到新状态10次
:later 10f    恢复到10次保存后的状态

聪明地学习撤销操作

u 和 Ctrl-R 是两个不可缺少的 Vim 参数。请先学会它们。在我的工作流中，我并不使用 UNDO，然而我认为承认它存在是很好的。下一步，学会如何使用:earlier 和 :later，以及时间参数。在这之后，请花些时间理解 undo 树。插件 vim-mundo 对我的帮助很大。单独输入本章中展示的文本，并且查看撤销树的每一次改变。一旦你掌握它，你看待撤销系统的眼光一定不同。在本章之前，你学习了如何在项目内查找任何文本，配合撤销，你可以在时间维度上查找任何一个文本。你现在可以通过位置和写入时间找到任何一个你想找的文本。你已经对 Vim 无所不能了。

Learn Vim 第九章：宏命令

Fri, 01 May 2026 00:00:00 +0000

在编辑文件的时候，你会发现有时候你在反复地做一些相同的动作。如果你仅做一次，并在需要的时候调用这些动作岂不是会更好吗。通过 Vim 的宏命令，你可以将一些动作记录到 Vim 寄存器。在本章中，你将会学习到如何通过宏命令自动完成一些普通的任务（另外，看你的文件在自动编辑是一件很酷的事情）。

基本宏命令

宏命令的基本语法如下：

qa                     开始记录动作到寄存器 a
q (while recording)    停止记录

你可以使用小写字母（a-z）去存储宏命令。并通过如下的命令去调用：

@a    Execute macro from register a
@@    Execute the last executed macros

假设你有如下的文本，你打算将每一行中的所有字母都变为大写。

hello
vim
macros
are
awesome

将你的光标移动到 “hello” 栏的行首，并执行：

qa0gU$jq

上面命令的分解如下：

qa 开始记录一个宏定义并存储在 a 寄存器。
0 移动到行首。
gU$ 将从光标到行尾的字母变为大写。
j 移动到下一行。
q 停止记录。

调用 @a 去执行该宏命令。就像其他的宏命令一样，你也可以为该命令加一个计数。例如，你可以通过 3@a 去执行 a 命令3次。你也可以执行 3@@ 去执行上一次执行过的宏命令3次。

安全保护

在执行遇到错误的时候，宏命令会自动停止。假如你有如下文本：

a. chocolate donut
b. mochi donut
c. powdered sugar donut
d. plain donut

你想将每一行的第一个词变为大写，你可以使用如下的宏命令：

qa0W~jq

上面命令的分解如下：

qa 开始记录一个宏定义并存储在 a 寄存器。
0 移动到行首。
W 移动到下一个单词。
~ 将光标选中的单词变为大写。
j 移动到下一行。
q 停止记录。

我喜欢对宏命令进行超过所需次数的调用，所以我通常使用 99@a 命令去执行该宏命令99次。使用该命令，Vim并不会真正执行这个宏99次，当 Vim 到达最后一行执行j时，它会发现无法再向下了，然后会抛出一个错误，并终止宏命令的执行。实际上，遇到错误自动停止运行是一个很好的特性。否则，Vim 会继续执行该命令99次，尽管它已经执行到最后一行了。

命令行执行宏

在正常模式执行 @a 并不是宏命令调用的唯一方式。你也可以在命令行执行 ：normal @a 。：normal 会将任何用户添加的参数作为命令去执行。例如添加 @a，和在 normal mode 执行 @a 的效果是一样的。 :normal 命令也支持范围参数。你可以在选择的范围内去执行宏命令。如果你只想在第二行和第三行执行宏命令，你可以执行 ：2,3 normal @a。

在多个文件中执行宏命令

假如你有多个 .txt 文件，每一个文件包含不同的内容。并且你只想将包含有 “donut” 单词的行的第一个单词变为大写。假设，您的寄存器a中存储的内容是0W~j(就是前面例子中用到的宏命令),那么，您该如何快速完成这个操作呢？第一个文件:

## savory.txt
a. cheddar jalapeno donut
b. mac n cheese donut
c. fried dumpling

第二个文件:

## sweet.txt
a. chocolate donut
b. chocolate pancake
c. powdered sugar donut

第三个文件:

## plain.txt
a. wheat bread
b. plain donut

你可以这么做:

:args *.txt 查找当前目录下的所有 .txt 文件。
:argdo g/donut/normal @a 在 :args 中包含的每一个文件里执行一个全局命令 g/donut/normal @a。
:argdo update 在 :args 中包含的每一个文件里执行 update 命令,保存修改后的内容。

也许你对全局命令 :g/donut/normal @a 不是很了解，该命令会执行 /donut/搜索命令，然后在所有匹配的行中执行normal @a 命令。我会在后面的章节中介绍全局命令。

递归执行宏命令

你可以递归地执行宏命令，通过在记录宏命令时调用相同的宏寄存器来实现。假如你有如下文本，你希望改变第一个单词的大小写：

a. chocolate donut
b. mochi donut
c. powdered sugar donut
d. plain donut

如下命令会递归地执行:

qaqqa0W~j@aq

上面命令的分解如下：

qaq 记录一个空白的宏命令到 “a” 。把宏命令记录在一个空白的命令中是必须的，因为你不会想将该命令包含有任何其他的东西。
qa 开始录入宏命令到寄存器 “a”。
0 移动到行首。
W 移动到下一个单词。
~ 改变光标选中的单词的大小写。
j 移动到下一行。
@a 执行宏命令 “a”。当你记录该宏命令时，@a 应该是空白的，因为你刚刚调用了 qaq。
q 停止记录。

现在，让我们调用 @a 来查看 Vim 如何递归的调用该宏命令。宏命令是如何知道何时停止呢？当宏执行到最后一行并尝试 j 命令时，发现已经没有下一行了，就会停止执行。

增添一个已知宏

如果你想在一个已经录制好的宏定义中添加更多的操作，与其重新录入它，不如选择修改它。在寄存器一章中，你学习了如何使用一个已知寄存器的大写字母来想该寄存器中添加内容。同样的，为了在寄存器”a”中添加更多的操作，你也可以使用大写字母”A”。假设寄存器a中已经存储了这个宏命令:qa0W~q(该宏命令将某行的第二个词组的头一个字母执行改变大小写操作)，假设你想在这个基础上添加一些操作命令序列，使得每一行末尾添加一个句点，运行：

qAA.<esc>q

分解如下:

qA 开始在寄存器 “A” 中记录宏命令。
A.<esc> 在行的末尾加上一个句点(这里的A是进入插入模式，不要和宏A搞混淆)，然后退出插入模式。
q 停止记录宏命令。

现在，当你执行@a时，它不仅将第二个词组的首字母转变大小写，同时还在行尾添加一个句点。

修改一个已知宏

如果想在一个宏的中间添加新的操作该怎么办呢？假设您在寄存器a中已经存有一个宏命令0W~A.<Esc>，即改变首字母大小写，并在行尾添加句号。如果您想在改变首字母大小写和行尾添加句号之间，在单词”dount”前面加入”deep fried”。（因为唯一比甜甜圈好的东西就是炸甜甜圈）。我会重新使用上一节使用过的文本:

a. chocolate donut
b. mochi donut
c. powdered sugar donut
d. plain donut

首先，让我们通过 :put a 调用一个已经录制好的宏命令（假设你上一节中保存在寄存器a中的宏命令还在）：

0W~A.^[

^[ 是什么意思呢？不记得了吗，你之前执行过 0W~A.<esc>。 ^[ 是 Vim 的 内部指令，表示 <esc>。通过这些指定的特殊键值组合，Vim 知道这些是内部代码的一些替代。一些常见的内部指令具有类似的替代，例如 <esc>，<backspace>，<enter>。还有一些其他的键值组合，但这不是本章的内容。回到宏命令，在改变大小写之后的键后面（~），让我们添加（$）来移动光标到行末，回退一个单词（b），进入插入模式（i），输入”deep fried “ （别忽略”fried “后面的这个空格），之后退出插入模式（<esc>）。完整的命令如下:

0W~$bideep fried <esc>A.^[

这里有一个问题，Vim 不能理解 <esc>。您不能依葫芦画瓢输入”"，所以你需要将``写成内部代码的形式。在插入模式，在按下`Ctrl-v`后按下``，Vim 会打印 `^[`。 `Ctrl-v` 是一个插入模式的操作符，可以逐字地插入一个非数字字符。你的宏命令应该如下:

0W~$bideep fried ^[A.^[

为了在寄存器”a”中添加修改后的指令，你可以通过在一个已知命名寄存器中添加一个新条目的方式来实现。在一行的行首，执行 "ay$，使用寄存器 “a”来存储复制的文本。现在，但你执行 @a 时，你的宏命令会自动改变第一个单词的大小写，在”donut”前面添加”deep fried “，之后在行末添加”.”。另一个修改宏命令的方式是通过命令行表达式。执行 :let @a="，之后执行 Ctrl-r a，这会将寄存器”a”的命令逐字打印出来。最后，别忘记在闭合的引号（"）。如果你希望在编辑命令行表达式时插入内部码来使用特定的字符，你可以使用 Ctrl-v。

拷贝宏

你可以很轻松的将一个寄存器的内容拷贝到另一个寄存器。例如，你可以使用 :let @z = @a 将寄存器”a” 中的命令拷贝到寄存器”z”。 @a 表示寄存器”a”中存储的内容，你现在执行 @z，将会执行和 @a 一样的指令。我发现对常用的宏命令创建冗余是很有用的。在我的工作流程中，我通常在前7个字母（a-g）上创建宏命令，并且我经常不加思索地把它们替换了。因此，如果我将很有用的宏命令移动到了字母表的末尾，就不用担心我在无意间把他们替换了。

串行宏和并行宏

Vim 可以连续和同时运行宏命令，假设你有如下的文本：

import { FUNC1 } from "library1";
import { FUNC2 } from "library2";
import { FUNC3 } from "library3";
import { FUNC4 } from "library4";
import { FUNC5 } from "library5";

假如你希望把所有的 “FUNC” 字符变为小写，那么宏命令为如下：

qa0f{gui{jq

分解如下：

qa 开始记录宏命令到 “a” 寄存器。
0移动到第一行。
f{ 查找第一个 “{“ 字符。
gui{ 把括号内的文本（i{）变为小写（gu）。
j 移动到下一行。
q 停止记录宏命令。

现在，执行 99@a 在剩余的行修改。然而，假如在你的文本里有如下 import 语句会怎么样呢？

import { FUNC1 } from "library1";
import { FUNC2 } from "library2";
import { FUNC3 } from "library3";
import foo from "bar";
import { FUNC4 } from "library4";
import { FUNC5 } from "library5";

执行 99@a，会只在前三行执行。而最后两行不会被执行，因为在执行第四行（包含”foo”）时f{命令会遇到错误而停止，当宏串行执行时就会发生这样的情况。当然，你仍然可以移动到包含（”FUNC4”）的一行，并重新调用该命令。但是假如你希望仅调用一次命令就完成所有操作呢？你可以并行地执行宏命令。如本章前面所说，可以使用 :normal 去执行宏命令，（例如： :3,5 normal @a 会在 3-5行执行 a 寄存器中的宏命令）。如果执行 :1,$ normal @a，会在所有除了包含有 “foo” 的行执行，而且它不会出错。尽管本质上来说，Vim 并不是在并行地执行宏命令，但表面上看，它是并行运行的。 Vim 会独立地在从第一行开始（1,$）每一行执行 @a 。由于 Vim 独立地在每一行执行命令，每一行都不会知道有一行（包含”foo”）会遇到执行错误。

聪明地学习宏命令

你在编辑器里做的很多事都是重复的。为了更好地编辑文件，请乐于发现这些重复性的行为。执行宏命令或者点命令，而不是做相同的动作两次。几乎所有你在 Vim 所作的事情都可以变为宏命令。刚开始的时候，我发现宏命令时很棘手的，但是请不要放弃。有了足够的练习，你可以找到这种文本自动编辑的快乐。使用某种助记符去帮助你记住宏命令是很有帮助的。如果你有一个创建函数（function）的宏命令，你可以使用 “f” 寄存器去录制它(qf)。如果你有一个宏命令去操作数字，那么使用寄存器 “n” 去记住它是很好的(qn)。用你想执行的操作时想起的第一个字符给你的宏命令命名。另外，我发现 “q” 是一个很好的宏命令默认寄存器，因为执行 qq 去调用宏命令是很快速而简单的。最后，我喜欢按照字母表的顺序去添加我的宏命令，例如从 qa 到 qb 再到 qc。去寻找最适合你的方法吧。

Learn Vim 第八章：寄存器

Thu, 30 Apr 2026 00:00:00 +0000

学习Vim中的寄存器就像第一次学习线性代数一样，除非你学习了他们，否则你会觉得自己根本不需要它们。你可能已经在复制或删除文本并用p或P粘贴它们到别处的时候使用过Vim的寄存器了。但是，你知道Vim总共有10种不同类型的寄存器吗？如果正确地使用Vim寄存器，将帮助您从重复的输入中解放出来。在这一章节中，我会介绍Vim的所有寄存器类型，以及如何有效地使用它们。

寄存器的10种类型

下面是Vim所拥有的10种寄存器类型：

匿名寄存器（""）.
编号寄存器("0-9).
小删除寄存器 ("-).
命名寄存器 ("a-z).
只读寄存器 (":, "., and "%).
Buffer交替文件寄存器 ("#).
表达式寄存器 ("=).
选取和拖放寄存器("* and "+).
黑洞寄存器 ("_).
搜索模式寄存器 ("/).

寄存器命令

要使用寄存器，您必须先使用命令将内容存储到寄存器，以下是一些存值到寄存器中的操作：

y    复制
c    删除文本并进入输入模式
d    删除文本

其实还有更多的寄存器写入操作（比如s或x），但是上面列出的是最常用的一些。根据经验看来，如果一个操作删除了文本，那么很有可能这个操作将移除的文本存入寄存器中了。想要从寄存器中取出（粘贴）文本，你可以用以下的命令：

p    在光标位置之后粘贴文本
P    在光标位置之前粘贴文本

p和P都可以接受计数和一个寄存器标志作为参数。比如，想要把最近复制的文本粘贴10次的话可以用10p。想粘贴寄存器”a”中的文本，可以用"ap。想将寄存器”a”中的文本粘贴10次的话，可以使用10"ap。注意，从技术层面讲，命令p实际上表示的是”put”(放置)，而不是”paste”(粘贴)，使用粘贴只是因为它更符合传统习惯。从某个特定寄存器中读取文本的通用语法是"x，其中x是这个寄存器的标志。

在输入模式中使用寄存器

在这一章节中你学到的东西在输入模式中也同样适用。想要获取寄存器”a”中的文本，通常可以使用"ap来进行。不过当你在输入模式下时，你需要运行Ctrl-r a。在输入模式下使用寄存器的语法是：

Ctrl-r x

其中x是寄存器标志。既然你现在已经知道如何存储和访问寄存器了，让我们学点更深入的吧。

匿名寄存器(`""`)

想从匿名寄存器中获取文本，可以使用""p。匿名寄存器默认存储着你最近一次复制，修改或删除的文本。如果再进行另一次复制，修改或删除，Vim会自动替换匿名寄存器中的文本。匿名寄存器和电脑上粘贴板的功能很接近。默认情况下，p(或者P)是和匿名寄存器相关联的（从现在起我将使用p而不是""p来指代匿名寄存器）。

编号寄存器(`"0-9`)

编号寄存器会自动以升序来进行填充。一共有两种不同的编号寄存器：复制寄存器(0)和其他编号寄存器(1-9)。让我们先来讨论复制寄存器。

复制寄存器 (`"0`)

如果你使用yy来复制一整行文本，事实上Vim会将文本存放两个寄存器中：

匿名寄存器 (p).
复制寄存器 ("0p).

在你又复制其他不同的文本后，Vim会自动替换匿名寄存器和复制寄存器(0)中的内容。其他的任何操作都不会被存放在0号寄存器中。这可以为你提供方便，因为除非你再进行另一次复制，否则你已经复制的内容会一直在寄存器中，无论你进行多少次修改和删除。比如，如果你：

复制一整行 (yy)
删除一整行(dd)
再删除另一行 (dd)

复制寄存器中的文本仍然是第一步中复制的文本。如果你:

复制一整行 (yy)
删除一整行 (dd)
复制另一行 (yy)

复制寄存器中的内容则是第三步中复制的内容。还有一个小技巧，在输入模式下，你可以使用Ctrl-r 0快速地粘贴你刚才复制的内容。

编号寄存器 (`"1-9`)

当你修改或者删除至少一整行的文本时，这部分文本会按时间顺序被存储在1-9号编号寄存器中。（编号越小时间距离越近）比如，你有以下这些文本：

line three
line two
line one

当你的光标在文本”line three”上时,使用dd来一行一行地删除这些文本。在所有文本都已经删除后，1号寄存器中的内容应该是”line one”（时间上最近的文本）， 2号寄存器则包含”line two”(时间上第二近的文本)，3号寄存器中则包含”line three”（最早删除的文本）。普通模式下可以使用"1p来获取1号寄存器中的内容。编号寄存器的编号在使用点命令时会自动增加。比如，如果你的1号编号寄存器（"1）中的内容为”line one”， 2号寄存器（"2）为”line two”, 三号寄存器（"3）”line three”,你可以使用以下的技巧来连续地粘贴他们：

使用"1p来粘贴1号寄存器中的内容。
使用. (点命令)来粘贴2号寄存器（"2）中的内容。
使用. (点命令)来粘贴3号寄存器（"3）中的内容。

在连续地使用点命令时，Vim会自动的增加编号寄存器的编号。这个技巧对于所有的编号寄存器都适用。如果你从5号寄存器开始("5P), 点命令.会执行"6P,再次使用.则会执行"7P,等等。小型的删除比如单词删除（dw)或者单词修改(cw)不会被存储在编号寄存器中，它们被存储在小删除寄存器("-)中，我将在接下来的一小节讨论小删除寄存器。

小删除寄存器(`"-`)

不足一行的修改或者删除都不会被存储在0-9号编号寄存器中，而是会被存储在小删除寄存器 ("-)中。比如:

删除一个单词 (diw)
删除一行文本 (dd)
删除一行文本 (dd)

"-p 会给你第一步中删除的单词。另一个例子:

删除一个单词(diw)
删除一行文本 (dd)
删除一个单词 (diw)

"-p 会给出第三步中删除的单词。类似地, "1p 会给出第二步中删除的一整行文本。不幸的是我们没有办法获取第一步中删除的单词，因为小删除寄存器只能存储一个文本。然而，如果你想保存第一步中删除的文本，你可以使用命名寄存器来完成。

命名寄存器 (`"a-z`)

命名寄存器是Vim中用法最丰富的寄存器。a-z命名寄存器可以存储复制的，修改的和被删除的文本。不像之前介绍的3种寄存器一样，它们会自动将文本存储到寄存器中，你需要显式地告诉Vim你要使用命名寄存器，你拥有完整的控制权。为了复制一个单词到寄存器”a”中，你可以使用命令"ayiw。

"a告诉Vim下一个动作（删除/修改/复制）会被存储在寄存器”a”中
yiw复制这个单词

为了从寄存器”a”中获取文本，可以使用命令"ap。你可以使用以26个字母命名的寄存器来存储26个不同的文本。有时你可能会想要往已有内容的命名寄存器中继续添加内容，这种情况下，你可以追加文本而不是全部重来。你可以使用大写版本的命名寄存器来进行文本的追加。比如，假设你的”a”寄存器中已经存有文本”Hello”，如果你想继续添加”world”到寄存器”a”中，你可以先找到文本”world”然后使用"Aiw来进行复制,即可完成追加。

只读寄存器(`":`, `".`, `"%`)

Vim有三个只读寄存器：.,:和%，它们的用法非常简单：

.    存储上一个输入的文本
:    存储上一次执行的命令
%    存储当前文件的文件名

如果你写入”Hello Vim”,之后再运行".p就会打印出文本”Hello Vim”。如果你想要获得当前文件的文件名，可以运行命令"%p。如果你运行命令:s/foo/bar/g，再运行":p的话则会打印出文本”s/foo/bar/g”。

Buffer交替文件寄存器 (`"#`)

在Vim中，#通常代表交替文件。交替文件指的是你上一个打开的文件，想要插入交替文件的名字的话，可以使用命令"#p。

表达式寄存器 (`"=`)

Vim有一个表达式寄存器，"=,用于计算表达式的结果。你可以使用以下命令计算数学表达式1+1的值：

"=1+1<Enter>p

在这里，你在告诉Vim你正在使用表达式寄存器"=，你的表达式是（1+1），你还需要输入p来得到结果。正如之前所提到的，你也可以在输入模式中访问寄存器。想要在输入模式中计算数学表达式的值，你可以使用：

Ctrl-r =1+1

你可以使用@来从任何寄存器中获取表达式并用表达式寄存器计算其值。如果你希望从寄存器”a”中获取文本：

"=@a

之后输入<enter>，再输入p。类似地，想在输入模式中得到寄存器”a”中的值可以使用：

Ctrl-r =@a

表达式是Vim中非常宏大的一个话题，所以我只会在这里介绍一些基础知识，我将会在之后的VimScript章节中进一步讲解更多关于表达式的细节。

选取和拖放寄存器 (`"*`, `"+`)

你难道不觉得有些时候你需要从某些外部的程序中复制一些文本并粘贴到Vim中吗，或者反过来操作？有了Vim的选取和拖放寄存器你就能办到。Vim有两个选取寄存器：quotestar ("*) 和 quoteplus ("+)。你可以用它们来访问从外部程序中复制的文本。如果你在运行一个外部程序（比如Chrome浏览器），然后你使用Ctrl-c(或者Cmd-c,取决于你的操作系统)复制了一部分文本，通常你是没有办法在Vim里使用p来粘贴这部分文本的。但是，Vim的两个寄存器"+和"*都是和你系统的粘贴板相连接的，所以你可以使用"+p和"*p来粘贴这些文本。反过来，如果你使用"+yiw或者"*yiw在Vim中复制了一些文本，你可以使用Ctrl-v（或者Cmd-v）。值得注意的是这个方法只在你的Vim开启了+clipboard选项时才有用，可以在命令行中运行vim --version查看这一选项。如果你看见-clipboard的话，则需要安装一下支持Vim粘贴板的配置。我发觉使用=*p或者=+p的话比较麻烦，为了使Vim仅使用p就能粘贴从外部程序复制的文本，你可以在你的vimrc配置文件中加入下面一行：

set clipboard=unnamed

黑洞寄存器 (`"_`)

你每次删除或修改文本的时候，这部分文本都会自动保存在Vim的寄存器中。有些时候你并不希望把什么东西都往寄存器里存，这该怎么办到呢？你可以使用黑洞寄存器（"_）。想要删除一行并且不将其存储在任何寄存器中时，可以使用"_dd命令. 它是和 /dev/null 类似的寄存器。

搜索模式寄存器 (`"/`)

为了粘贴你的上一个搜索询问（/ 或 ?），你可以使用搜索模式寄存器("/)。使用命令 "/p就能粘贴上一个搜索的条目。

查看所有的寄存器

你可以使用:register命令来查看你的所有寄存器。如果你只想查看”a”,”1”和”-“寄存器的内容的话则可以使用命令:register a 1 -。有一个Vim的插件叫做 vim-peekaboo ,可以让你查看到寄存器的内容，在普通模式下输入"或@ 即可，或者在输入模式中输入Ctrl-r。我发现这个插件相当的有用，因为大多数时候我是记不住我的寄存器中的内容的。值得一试！

执行寄存器

命名寄存器不只可以用来存放文本，你还可以借助@来执行宏命令。我会在下一章节中介绍宏命令。注意，因为宏命令时存储在Vim寄存器中的，使用宏时可能会覆盖存储的内容。如果你将文本”Hello Vim”存放在寄存器”a”中，并且之后你在同一个寄存器里记录了一个宏命令 (qa{macro-commands}q),那么这个宏命令将会覆盖之前存储的文本”Hello Vim”（你可以使用@a来执行寄存器中存储的宏命令）。

清除寄存器

从技术上来说，我们没有必要来清除任何寄存器，因为你下一个使用来存储文本的寄存器会自动覆盖该寄存器中之前的内容。然而，你可以通过记录一个空的宏命令来快速地清除任何命名寄存器。比如，如果你运行qaq，Vim就会在寄存器”a”中记录一个空的宏命令。还有一种方法就是运行命令:call setreg('a','hello register a'),其中’a’代表的就是寄存器”a”。而”hello register a”就是你想存储的内容。还有一种清除寄存器的方法就是使用表达式:let @a = ''来将寄存器”a 的值设为空的字符串。

获取寄存器中的内容

你可以使用:put命令来粘贴任何寄存器的内容。比如，如果你运行命令:put a,Vim就会打印出寄存器”a”的内容，这和"ap非常像，唯一的区别在于在普通模式下命令p在当前光标位置之后打印寄存器的内容，而:put新起一行来打印寄存器的内容。因为:put是一个命令行命令，您可以传一个地址给它。:+10put a将会在当前光标下数10行，然后插入新行，内容为寄存器a中的内容。一个很酷的技巧是将黑洞寄存器("_)传给:put命令。因为黑洞寄存器不保存任何值，:put _命令将插入一个新的空白行。您可将这个与全局命令联合起来，插入多个空行。比如，要在所有以文本”end”结尾的行下插入空行，使用:g/end/put _。在后面您将了解关于全局命令的知识。

聪明地学习寄存器

恭喜你成功地坚持到了最后！这一章有非常多的内容需要消化。如果你感觉被新的知识淹没，你要知道你并不孤单，当我最初开始学习Vim寄存器时也有这种感觉。我并不认为你必须现在就记得所有的知识点。为了提高我们的生产效率，你可以从使用以下三类寄存器开始：

匿名寄存器("").
命名寄存器 ("a-z).
编号寄存器 ("0-9).

既然匿名寄存器是默认和p或P，你只需要学习两个寄存器：命名寄存器和编号寄存器。之后如果你需要用到其他的寄存器时你再逐渐地学习其他寄存器的用法，不用急，慢慢来。普通人的短期记忆都是有极限的，大概每次只能记住5-7个信息。这就是为什么在我的日常编辑中，我只用3到7个命名寄存器的原因，我没有办法记住整整26个寄存器的内容。我通常从寄存器”a”开始用，之后用寄存器”b”,以字母表升序的顺序来使用。尝试一下各种方法，看看哪种最适合你。 Vim寄存器非常强大，合理使用的话能够避免你输入数不清的重复文本。但是现在，是时候学习一下宏命令了。

Learn Vim 第七章：点命令

Wed, 29 Apr 2026 00:00:00 +0000

在编辑文本时，我们应该尽可能地避免重复的动作。在这一章节中，你将会学习如何使用点命令来重放上一个修改操作。点命令是最简单的命令，然而又是减少重复操作最为有用的命令。

用法

正如这个命令的名字一样，你可以通过按下.键来使用点命令。比如，如果你想将下面文本中的所有”let”替换为”const”：

let one = "1";
let two = "2";
let three = "3";

首先，使用/let来进行匹配。
接着，使用cwconst<esc>来将”let”替换成”const”。
第三步，使用n来找到下一个匹配的位置。
最后，使用点命令(.)来重复之前的操作。
持续地使用n . n .直到每一个匹配的词都被替换。

在这个例子里面，点命令重复的是cwconst<esc>这一串命令，它能够帮你将需要8次输入的命令简化到只需要敲击一次键盘。

什么才算是修改操作？

如果你查看点命令的定义的话(:h .),文档中说点命令会重复上一个修改操作，那么什么才算是一个修改操作呢？当你使用普通模式下的命令来更新（添加，修改或者删除）当前缓冲区中的内容时，你就是在执行一个修改操作了。其中的例外是使用命令行命令进行的修改（以：开头的命令），这些命令不算作修改操作。在第一个例子中，你看到的cwconst<esc>就是一个修改操作。现在假设你有以下这么一个句子：

pancake, potatoes, fruit-juice,

我们来删除从这行开始的位置到第一个逗号出现的位置。你可以使用df,来完成这个操作,使用.来重复两次直到你将整个句子删除。让我们再来试试另一个例子：

pancake, potatoes, fruit-juice,

这一次你只需要删除所有的逗号，不包括逗号前面的词。我们可以使用f,来找到第一个逗号，再使用x来删除光标下的字符。然后使用用.来重复两次，很简单对不对？等等！这样做行不通(只会重复删除光标下的一个字符，而不是删除逗号)！为什么会这样呢？在Vim里，修改操作是不包括移动（motions）的，因为移动(motions)不会更新缓冲区的内容。当你运行f,x，你实际上是在执行两个独立的操作：f,命令只移动光标，而x更新缓冲区的内容，只有后者算作修改动作。和之前例子中的df,进行一下对比的话，你会发现df,中的f,告诉删除操作d哪里需要删除，是整个删除命令df,的一部分。让我们想想办法完成这个任务。在你运行f,并执行x来删除第一个逗号后，使用;来继续匹配f的下一个目标（下一个逗号）。之后再使用.来重复修改操作，删除光标下的字符。重复; . ; .直到所有的逗号都被删除。完整的命令即为f,x;.;.。再来试试下一个例子：

pancake
potatoes
fruit-juice

我们的目标是给每一行的结尾加上逗号。从第一行开始，我们执行命令A,<esc>j来给结尾加上逗号并移动到下一行。现在我们知道了j是不算作修改操作的，只有A,算作修改操作。你可以使用j . j . 来移动并重复修改操作。完整的命令是A,<esc>j。从你按下输入命令（A）开始到你退出输入模式（）之间的所有输入都算作是一整个修改操作。

重复多行修改操作

假设你有如下的文本：

let one = "1";
let two = "2";
let three = "3";
const foo = "bar";
let four = "4";
let five = "5";
let six = "6";
let seven = "7";
let eight = "8";
let nine = "9";

你的目标是删除除了含有”foo”那一行以外的所有行。首先，使用d2j删除前三行。之后跳过”foo”这一行，在其下一行使用点命令两次来删除剩下的六行。完整的命令是d2jj..。这里的修改操作是d2j，2j不是一个移动(motion)操作，而是整个删除命令的一部分。我们再来看看下一个例子：

zlet zzone = "1";
zlet zztwo = "2";
zlet zzthree = "3";
let four = "4";

我们的目标是删除所有的’z’。从第一行第一个字符开始，首先，在块可视化模式下使用Ctrl-vjj来选中前三行的第一个’z’字母。如果你对块可视化模式不熟悉的话也不用担心，我会在下一章节中进行介绍。在选中前三行的第一个’z’后，使用d来删除它们。接着用w移动到下一个z字母上，使用..重复两次之前选中加删除的动作。完整的命令为Ctrl-vjjdw..。你删除一列上的三个’z’的操作(Ctrl-vjjd)被看做一整个修改操作。可视化模式中的选择操作可以用来选中多行，作为修改动作的一部分。

在修改中包含移动操作

让我们来重新回顾一下本章中的第一个例子。这个例子中我们使用了/letcwconst<esc>紧接着n . n .将下面的文本中的’let’都替换成了’const’。

let one = "1";
let two = "2";
let three = "3";

其实还有更快的方法来完成整个操作。当你使用/let搜索后，执行cgnconst<Esc>，然后. . .。 gn是一个移动并选择的动作，它向前搜索和上一个搜索的模式（本例中为/let）匹配的位置，并且 自动对匹配的文本进行可视化模式下的选取。想要对下一个匹配的位置进行替换的话，你不再需要先移动在重复修改操作（n . n .），而是简单地使用. .就能完成。你不需要再进行移动操作了，因为找到下一个匹配的位置并进行选中成为了修改操作的一部分了。当你在编辑文本时，应该时刻关注像gn命令这种能一下子做好几件事的移动操作。

a
b
foo
c
d
foo
e
f

聪明地学习点命令

点命令的强大之处在于使用仅仅1次键盘敲击代替好几次敲击。对于x这种只需一次敲击键盘就能完成的修改操作来说，点命令或许不会带来什么收益。但是如果你的上一个修改操作是像cgnconst<esc>这种复杂命令的话，使用点命令来替代就有非常可观的收益了。在进行编辑时，思考一下你正将进行的操作是否是可以重复的。举个例子，如果我需要删除接下来的三个单词，是使用d3w更划算，还是dw再使用.两次更划算？之后还会不会再进行删除操作？如果是这样的话，使用dw好几次确实比d3w更加合理，因为dw更加有复用性。在编辑时应该养成”修改操作驱动”的观念。点命令非常简单但又功能强大，帮助你开始自动化处理简单的任务。在后续的章节中，你将会学习到如何使用Vim的宏命令来自动化处理更多复杂的操作。但是首先，还是让我们来学习一下如何使用寄存器来存取文本吧。

Learn Vim 第六章：输入模式

Tue, 28 Apr 2026 00:00:00 +0000

输入模式是大部分文本编辑器的默认模式，在这个模式下，所敲即所得。尽管如此，这并不代表输入模式没什么好学的。Vim的输入模式包含许多有用功能。在这一章节中，你将能够学到如何利用Vim输入模式中的特性来提升你的输入效率。

进入输入模式的方法

我们有很多方式从普通模式进入输入模式，下面列举出了其中的一些方法：

i    从光标之前的位置开始输入文本
I    从当前行第一个非空字符之前的位置之前开始输入文本
a    在光标之后的位置追加文本
A    在当前行的末尾追加文本
o    在光标位置下方新起一行并开始输入文本
O    在光标位置的上方新起一行并开始输入文本
s    删除当前光标位置的字符并开始输入文本
S    删除当前行并开始输入文本
gi   从当前缓冲区上次结束输入模式的地方开始输入文本
gI   在当前行的第一列的位置开始输入文本

值得注意的是这些命令的小写/大写模式，每一个小写命令都有一个与之对应的大写命令。如果你是初学者，不用担心记不住以上整个命令列表，可以从 i 和 a两条命令开始，这两条命令足够在入门阶段使用了，之后再逐渐地掌握更多其他的命令。

退出输入模式的方法

下面列出了一些从输入模式退出到普通模式的方法：

<esc>     退出输入模式进入普通模式
Ctrl-[    退出输入模式进入普通模式
Ctrl-c    与 Ctrl-[ 和 <esc>功能相同, 但是不检查缩写

我发现 esc键在键盘上太远了，很难够到，所以我在我的机器上将 caps lock 映射成了esc键。如果你搜索Bill Joy（Vi的作者）的ADM-3A 键盘，你会发现esc键并不是像现在流行的键盘布局一样在键盘的最左上方，而是在q键的左边，所以我认为将caps lock 映射成esc键是合理的。另一个Vim用户中常见的习惯是用以下的配置方法在输入模式中把esc映射到jj或者jk。

inoremap jj <esc>
inoremap jk <esc>

重复输入模式

你可以在进入输入模式之前传递一个计数参数. 比如：

10i

如果你输入”hello world!”然后退出输入模式， Vim将重复这段文本10次。这个方法对任意一种进入输入模式的方式都有效（如：10I, 11a, 12o）

在输入模式中删除大块文本

当你输入过程中出现一些输入错误时，一直重复地用backspace来删除的话会非常地繁琐。更为合理的做法是切换到普通模式并使用d来删除错误。或者，你能用以下命令在输入模式下就删除一个或者多个字符：

Ctrl-h    删除一个字符
Ctrl-w    删除一个单词
Ctrl-u    删除一整行

此外，这些快捷键也支持在命令行模式和 Ex模式中使用（命令行模式和Ex模式将会在之后的章节中介绍）

用寄存器进行输入

寄存器就像是内存里的暂存器一样，可供存储和取出文本。在输入模式下，可以使用快捷键Ctrl-r加上寄存器的标识来从任何有标识的寄存器输入文本。有很多标识可供使用，但是在这一章节中你只需要知道以（a-z)命名的寄存器是可以使用的就足够了。让我们在一个具体的例子中展示寄存器的用法，首先你需要复制一个单词到寄存器a中，这一步可以用以下这条命令来完成：

"ayiw

"a 告诉Vim你下一个动作的目标地址是寄存器a
yiw 复制一个内词（inner word），可以回顾Vim语法章节查看具体语法。

现在寄存器a存放着你刚复制的单词。在输入模式中，使用以下的快捷键来粘贴存放在寄存器a中文本：

Ctrl-r a

Vim中存在很多种类型的寄存器，我会在后面的章节中介绍更多他们的细节。

页面滚动

你知道在输入模式中也是可以进行页面滚动的吗？在输入模式下，如果你使用快捷键Ctrl-x进入Ctrl-x子模式，你可以进行一些额外操作，页面滚动正是其中之一。

Ctrl-x Ctrl-y    向上滚动页面
Ctrl-x Ctrl-e    向下滚动页面

自动补全

Vim在进入Ctrl-x子模式后（和页面滚动一样），有一个自带的自动补全功能。尽管它不如intellisense或者其他的语言服务器协议（LSP）一样好用，但是也算是一个锦上添花的内置功能了。下面列出了一些适合入门时学习的自动补全命令：

Ctrl-x Ctrl-l	   补全一整行
Ctrl-x Ctrl-n	   从当前文件中补全文本
Ctrl-x Ctrl-i	   从引用（include）的文件中补全文本
Ctrl-x Ctrl-f	   补全一个文件名

当你触发自动补全时，Vim会显示一个选项弹窗，可以使用Ctrl-n和Ctrl-p来分别向上和向下浏览选项。 Vim也提供了两条不需要进入Ctrl-x模式就能使用的命令：

Ctrl-n             使用下一个匹配的单词进行补全
Ctrl-p             使用上一个匹配的单词进行补全

通常Vim会关注所有缓冲区（buffer）中的文本作为自动补全的文本来源。如果你打开了一个缓冲区，其中一行是”Chocolate donuts are the best”：

当你输入”Choco”然后使用快捷键Ctrl-x Ctrl-l， Vim会进行匹配并输出这一整行的文本。
当你输入”Choco”然后使用快捷键Ctrl-p，Vim会进行匹配并输出”Chocolate”这个单词。

Vim的自动补全是一个相当大的话题，以上只是冰山一角，想要进一步学习的话可以使用:h ins-completion命令进行查看。

执行普通模式下的命令

你知道Vim可以在输入模式下执行普通模式的命令吗？在输入模式下，如果你按下Ctrl-o，你就会进入到insert-normal（输入-普通）子模式。如果你关注一下左下角的模式指示器，通常你将看到-- INSERT -- ，但是按下Ctrl-o后就会变为-- (insert) --。在这一模式下，你可以执行一条普通模式的命令，比如你可以做以下这些事： 设置居中以及跳转

Ctrl-o zz       居中窗口
Ctrl-o H/M/L    跳转到窗口的顶部/中部/底部
Ctrl-o 'a       跳转到标志'a处

重复文本

Ctrl-o 100ihello    输入 "hello" 100 次

执行终端命令

Ctrl-o !! curl https://google.com    运行curl命令
Ctrl-o !! pwd                        运行pwd命令

快速删除

Ctrl-o dtz    从当前位置开始删除文本，直到遇到字母"z"
Ctrl-o D      从当前位置开始删除文本，直到行末

聪明地学习输入模式

如果你和我一样是从其他文本编辑器转到Vim的，你或许也会觉得一直待在输入模式下很有诱惑力，但是我强烈反对你在没有输入文本时，却仍然待在输入模式下。应该养成当你的双手没有在输入时，就退出到普通模式的好习惯。当你需要进行输入时，先问问自己将要输入的文本是否已经存在。如果存在的话，试着复制或者移动这段文本而不是手动输入它。再问问自己是不是非得进入输入模式，试试能不能尽可能地使用自动补全来进行输入。尽量避免重复输入同一个单词。

Learn Vim 第五章：在文件中移动

Mon, 27 Apr 2026 00:00:00 +0000

一开始，通过键盘移动会让你感觉特别慢特别不自在，但是不要放弃！一旦你习惯了它，比起鼠标你可以更快的在文件中去到任何地方。这一章，你将学习必要的移动以及如何高效的使用它们。记住，这一章所讲的并不是Vim的全部移动命令(motions)，我们的目标是介绍有用的移动来快速提高效率。如果你需要学习更多的移动命令，查看:h motion.txt。

字符导航

最基本的移动单元是上下左右移动一个字符。

h   左
j   下
k   上
l   右

你也可以通过方向键进行移动，如果你只是初学者，使用任何你觉得最舒服的方法都没有关系。我更喜欢hjkl因为我的右手可以保持在键盘上的默认姿势，这样做可以让我更快的敲到周围的键。为了习惯它，我实际上在刚开始的时候通过~/.vimrc关闭了方向键：

noremap <Up> <NOP>
noremap <Down> <NOP>
noremap <Left> <NOP>
noremap <Right> <NOP>

也有一些插件可以帮助改掉这个坏习惯，其中有一个叫vim-hardtime。让我感到惊讶的是，我只用了几天就习惯了使用hjkl。另外，如果你想知道为什么Vim使用hjkl进行移动，这实际上是因为Bill Joy写VI用的Lear-Siegler ADM-3A终端没有方向键，而是把hjkl当做方向键。如果你想移动到附近的某个地方，比如从一个单词的一个部分移动到另一个部分，我会使用h和l。如果我需要在可见的范围内上下移动几行，我会使用j和k。如果我想去更远的地方，我倾向于使用其他移动命令。

相对行号

我觉得设置number和relativenumber非常有用，你可以在~/.vimrc中设置:

set relativenumber number

这将会展示当前行号和其他行相对当前行的行号。为什么这个功能有用呢？这个功能能够帮助我知道我离我的目标位置差了多少行，有了它我可以很轻松的知道我的目标行在我下方12行，因此我可以使用12j去前往。否则，如果我在69行，我的目标是81行，我需要去计算81-69=12行，这太费劲了，当我需要去一个地方时，我需要思考的部分越少越好。这是一个100%的个人偏好，你可以尝试relativenumber/norelativenumber，number/nonumber 然后选择自己觉得最有用的。

对移动计数

在继续之前，让我们讨论一下”计数”参数。一个移动(motion)可以接受一个数字前缀作为参数，上面我提到的你可以通过12j向下移动12行，其中12j中的12就是计数数字。你使用带计数的移动的语法如下：

[计数] + 移动

你可以把这个应用到所有移动上，如果你想向右移动9个字符，你可以使用9l来代替按9次l。当你学到了更多的动作时，你都可以试试给定计数参数。

单词导航

我们现在移动一个更长的单元：单词(word)。你可以通过w移动到下一个单词的开始，通过e移动到下一个单词的结尾，通过b移动到上一个单词的开始，通过ge移动到前一个单词的结尾。另外，为了和上面说的单词(word)做个区分，还有一种移动的单元：词组(WORD)。你可以通过W移动到下一个词组的开始，通过E移动到下一个词组的结尾，通过B移动到前一个词组的开头，通过gE移动到前一个词组的结尾。为了方便记忆，所以我们选择了词组和单词这两个词，相似但有些区分。

w		移动到下一个单词的开头
W		移动到下一个词组的开头
e		移动到下一个单词的结尾
E		移动到下一个词组的结尾
b		移动到前一个单词的开头
B		移动到前一个词组的开头
ge	移动到前一个单词的结尾
gE	移动到前一个词组的结尾

词组和单词到底有什么相同和不同呢？单词和词组都按照非空字符被分割，一个单词指的是一个只包含a-zA-Z0-9字符串，一个词组指的是一个包含除了空字符(包括空格，tab，EOL)以外的字符的字符串。你可以通过:h word和:h WORD了解更多。例如，假如你有下面这段内容：

const hello = "world";

当你光标位于这行的开头时，你可以通过l走到行尾，但是你需要按21下，使用w，你需要6下，使用W只需要4下。单词和词组都是短距离移动的很好的选择。然而，之后你可以通过当前行导航只按一次从c移动到;。

当前行导航

当你在进行编辑的时候，你经常需要水平地在一行中移动，你可以通过0跳到本行第一个字符，通过$跳到本行最后一个字符。另外，你可以使用^跳到本行第一个非空字符，通过g_跳到本行最后一个非空字符。如果你想去当前行的第n列，你可以使用n|。

0		跳到本行第一个字符
^		跳到本行第一个非空字符
g_      跳到本行最后一个非空字符
$		跳到本行最后一个字符
n|      跳到本行第n列

你也可以在本行通过f和t进行行内搜索，f和t的区别在于f会停在第一个匹配的字母上，t会停在第一个匹配的字母前。因此如果你想要搜索并停留在”h”上，使用fh。如果你想搜索第一个”h”并停留在它的前一个字母上，可以使用th。如果你想去下一个行内匹配的位置，使用;，如果你想去前一个行内匹配的位置，使用,。 F和T是f和t对应的向后搜索版本。如果想向前搜索”h”，可以使用Fh，使用;，保持相同的搜索方向搜索下一个匹配的字母。注意，;不是总是向后搜索，;表示的是上一次搜索的方向，因此如果你使用的F，那么使用;时将会向前搜索使用,时向后搜索。

f   在同一行向后搜索第一个匹配
F   在同一行向前搜索第一个匹配
t   在同一行向后搜索第一个匹配，并停在匹配前
T   在同一行向前搜索第一个匹配，并停在匹配前
;   在同一行重复最近一次搜索
,   在同一行向相反方向重复最近一次搜索

回到上一个例子：

const hello = "world";

当你的光标位于行的开头时，你可以通过按一次键$去往行尾的最后一个字符”;”。如果想去往”world”中的”w”，你可以使用fw。一个建议是，在行内目标附近通过寻找重复出现最少的字母例如”j”，”x”，”z”来前往行中的该位置更快。

句子和段落导航

接下来两个移动的单元是句子和段落。首先我们来聊聊句子。一个句子的定义是以.!?和跟着的一个换行符或空格，tab结尾的。你可以通过)和(跳到下一个和上一个句子。

(   跳到前一个句子
)   跳到下一个句子

让我们来看一些例子，你觉得哪些字段是句子哪些不是? 可以尝试在Vim中用(和)感受一下。

I am a sentence. I am another sentence because I end with a period. I am still a sentence when ending with an exclamation point! What about question mark? I am not quite a sentence because of the hyphen - and neither semicolon ; nor colon :

There is an empty line above me.

另外，如果你的Vim中遇到了无法将一个以.结尾的字段并且后面跟着一个空行的这种情况判断为一个句子的问题，你可能处于compatible的模式。运行:set nocompatible可以修复。在Vi中，一个句子是以两个空格结尾的，你应该总是保持的nocompatible的设置。接下来，我们将讨论什么是段落。一个段落可以从一个空行之后开始，也可以从段落选项(paragraphs)中”字符对”所指定的段落宏的每个集合开始。

{   跳转到上一个段落
}   跳转到下一个段落

如果你不知道什么是段落宏，不用担心，重要的是一个段落总是以一个空行开始和结尾，在大多数时候总是对的。

匹配导航

程序员经常编辑含有代码的文件，这种文件内容会包含大量的小括号，中括号和大括号，并且可能会把你搞迷糊你当前到底在哪对括号里。许多编程语言都用到了小括号，中括号和大括号，你可能会迷失于其中。如果你在它们中的某一对括号中，你可以通过%跳到其中一个括号或另一个上(如果存在)。你也可以通过这种方法弄清你是否各个括号都成对匹配了。

%    Navigate to another match, usually works for (), [], {}

我们来看一段Scheme代码示例因为它用了大量的小括号。你可以在括号中用%移动

(define (fib n)
  (cond ((= n 0) 0)
        ((= n 1) 1)
        (else
          (+ (fib (- n 1)) (fib (- n 2)))
        )))

我个人喜欢使用类似vim-rainbow这样的可视化指示插件来作为%的补充。通过:h %了解更多。

行号导航

你可以通过nG调到行号为n的行，例如如果你想跳到第7行，你可以使用7G，跳到第一行使用gg或1G，跳到最后一行使用G。有时你不知道你想去的位置的具体行号，但是知道它大概在整个文件的70%左右的位置，你可以使用70%跳过去，可以使用50%跳到文件的中间。

gg      跳转到第一行
G       跳转到最后一行
nG      跳转到第n行
n%      跳到文件的n%

另外，如果你想看文件总行数，可以用CTRL-g查看。

窗格导航

为了移动到当前窗格的顶部，中间，底部，你可以使用H，M和L。你也可以给H和L传一个数字前缀。如果你输入10H你会跳转到窗格顶部往下数10行的位置，如果你输入3L，你会跳转到距离当前窗格的底部一行向上数3行的位置。

H   跳转到屏幕的顶部
M   跳转到屏幕的中间
L   跳转到屏幕的底部
nH  跳转到距离顶部n行的位置
nL  跳转到距离底部n行的位置

滚动

在文件中滚动，你有三种速度可以选择：滚动一整页(CTRL-F/CTRL-B)，滚动半页(CTRL-D/CTRL-U)，滚动一行CTRL-E/CTRL-Y)。

Ctrl-e    向下滚动一行
Ctrl-d    向下滚动半屏
Ctrl-f    向下滚动一屏
Ctrl-y    向上滚动一行
Ctrl-u    向上滚动半屏
Ctrl-b    向上滚动一屏

你也可以相对当前行进行滚动

zt    将当前行置于屏幕顶部附近
zz    将当前行置于屏幕中央
zb    将当前行置于屏幕底部

搜索导航

通常，你已经知道这个文件中有一个字段，你可以通过搜索导航非常快速的定位你的目标。你可以通过/向下搜索，也可以通过?向上搜索一个字段。你可以通过n重复最近一次搜索，N向反方向重复最近一次搜索。

/   向后搜索一个匹配
?   向前搜素一个匹配
n   重复上一次搜索(和上一次方向相同)
N   重复上一次搜索(和上一次方向相反)

假设你有一下文本：

let one = 1;
let two = 2;
one = "01";
one = "one";
let onetwo = 12;

你可以通过/let搜索”let”，然后通过n快速的重复搜索下一个”let”，如果需要向相反方向搜索，可以使用N。如果你用?let搜索，会得到一个向前的搜索，这时你使用n，它会继续向前搜索，就和?的方向一致。(N将会向后搜索”let”)。你可以通过:set hlsearch设置搜索高亮。这样，当你搜索/let，它将高亮文件中所有匹配的字段。另外，如果你通过:set incsearch设置了增量搜索，它将在你输入时不断匹配的输入的内容。默认情况下，匹配的字段会一直高亮到你搜索另一个字段，这有时候很烦人，如果你希望取消高亮，可以使用:nohlsearch。因为我经常使用这个功能，所以我会设置一个映射：

nnoremap <esc><esc> :noh<return><esc>

你可以通过*快速的向前搜索光标下的文本，通过#快速向后搜索光标下的文本。如果你的光标位于一个字符串”one”上，按下*相当于/\<one\>。 /\<one\>中的\<和\>表示整词匹配，使得一个更长的包含”one”的单词不会被匹配上，也就是说它会匹配”one”，但不会匹配”onetwo”。如果你的光标在”one”上并且你想向后搜索完全或部分匹配的单词，例如”one”和”onetwo”，你可以用g*替代*。

*   向后查找光标所在的完整单词
#   向前查找光标所在的完整单词
g*  向后搜索光标所在的单词
g#  向前搜索光标所在的单词

位置标记

你可以通过标记保存当前位置并在之后回到这个位置，就像文本编辑中的书签。你可以通过mx设置一个标记，其中x可以是a-zA-Z。有两种办法能回到标记的位置：用`x精确回到(行和列)，或者用'x回到行级位置。

ma    用a标签标记一个位置
`a    精确回到a标签的位置(行和列)
'a    跳转到a标签的行

a-z的标签和A-Z的标签存在一个区别，小写字母是局部标签，大写字母是全局标签(也称文件标记)。我们首先说说局部标记。每个buffer可以有自己的一套局部标记，如果打开了两个文件，我可以在第一个文件中设置标记”a”(ma)，然后在另一个文件中设置另一个标记”a”(ma)。不像你可以在每个buffer中设置一套局部标签，你只能设置一套全局标签。如果你在myFile.txt中设置了标签mA，下一次你在另一个文件中设置mA时，A标签的位置会被覆盖。全局标签有一个好处就是，即使你在不同的项目中，你也可以跳转到任何一个全局标签上，全局标签可以帮助你在文件间切换。使用:marks查看所有标签，你也许会注意到除了a-zA-Z以外还有别的标签，其中有一些例如：

''   在当前buffer中跳转回到上一次跳转前的最后一行
``  在当前buffer中跳转回到上一次跳转前的最后一个位置
`[  跳转到上一次修改或拷贝的文本的开头
`]  跳转到上一次修改或拷贝的文本的结尾
`<  跳转到最近一次可视模式下选择的部分的开头
`>  跳转到最近一次可视模式下选择的部分的结尾
`0  跳转到退出Vim前编辑的最后一个文件

除了上面列举的，还有更多标记，我不会在这一一列举因为我觉得它们很少用到，不过如果你很好奇，你可以通过: marks查看。

跳转

最后，我们聊聊Vim中的跳转你通过任意的移动可以在不同文件中或者同一个的文件的不同部分间跳转。然而并不是所有的移动都被认为是一个跳转。使用j向下移动一行就不被看做一个跳转，即使你使用10j向下移动10行，也不是一个跳转。但是你通过10G去往第10行被算作一个跳转。

'   跳转到标记的行
`   跳转到标记的位置(行和列)
G   跳转到行
/   向后搜索
?   向前搜索
n   重复上一次搜索，相同方向
N   重复上一次搜索，相反方向
%   查找匹配
(   跳转上一个句子
)   跳转下一个句子
{   跳转上一个段落
}   跳转下一个段落
L   跳转到当前屏幕的最后一行
M   跳转到当前屏幕的中间
H   跳转到当前屏幕的第一行
[[  跳转到上一个小节
]]  跳转到下一个小节
:s  替换
:tag  跳转到tag定义

我不建议你把上面这个列表记下来，一个大致的规则是，任何大于一个单词或超过当前行导航的移动都可能是一个跳转。 Vim保留了你移动前位置的记录，你可以通过:jumps查看这个列表，如果想了解更多，可以查看:h jump-motions。为什么跳转有用呢? 因为你可以在跳转列表中通过Ctrl-o和Ctrl-i在记录之间向上或向下跳转到对应位置。你可以在不同文件中进行跳转，这将是我之后会讲的部分。

聪明地学习导航

如果你是Vim的新手，这有很多值得你学，我不期望任何人能够立刻记住每样知识点，做到不用思考就能执行这需要一些时间。我想，最好的开始的办法就是从一些少量的必要的移动开始记。我推荐你从h,j,k,l,w,b,G,/,?,n开始，不断地重复这10个移动直到形成肌肉记忆，这花不了多少时间。为了让你更擅长导航，我有两个建议：

注意重复的动作。如果你发现你自己在重复的使用l，你可以去找一个方法让你前进的更快，然后你会发现你可以用w在单词间移动。如果你发现你自己的重复的使用w，你可以看看是否有一种方法能让你直接到行尾，然后你会想到可以用$。如果你可以口语化的表达你的需求，Vim中大概就会有一种方法去完成它。
当你学习任何一个新的移动时，多需要花一定的时间直到你可以不经过思考直接完成它。

最后，为了提高效率你不需要知道所有的Vim的命令，大多数Vim用户也都不知道，你只需要学习当下能够帮助你完成任务的命令。慢慢来，导航技巧是Vim中很重要的技巧，每天学一点并且把它学好。

Learn Vim 第四章：Vim 语法

Sun, 26 Apr 2026 00:00:00 +0000

刚接触Vim时很容易被Vim许多复杂的命令吓到，如果你看到一个Vim的用户使用gUfV或1GdG，你可能不能立刻想到这些命令是在做什么。这一章中，我将把Vim命令的结构拆分成一个简单的语法规则进行讲解。这一章将是本书中最重要的一章，一旦你理解了Vim命令的语法结构，你将能够和Vim”说话”。注意，在这一章中当我讨论Vim语言时，我讨论并不是Vimscript(Vim自带的插件编写和自定义设置的语言)，这里我讨论的是Vim中normal模式的下的命令的通用规则。

如何学习一门语言

我并不是一个英语为母语的人，当我13岁移民到美国时我学习的英语，我会通过做三件事情建立我的语言能力：

学习语法规则
扩展我的词汇量
练习，练习，练习

同样的，为了说好Vim语言，你需要学习语法规则，增加词汇量，并且不断练习直到你可以把执行命令变成肌肉记忆。

语法规则

你只需要知道一个Vim语言的语法规则：

verb + noun # 动词 + 名词

这就类似与在英语中的祈使句：

“Eat(verb) a donut(noun)”
“Kick(verb) a ball(noun)”
“Learn(verb) the Vim Editor(noun)”

现在你需要的就是用Vim中基本的动词和名字来建立你的词汇表

名词(动作 Motion)

我们这里将 动作 Motion 作为名词， 动作Motion用来在Vim中到处移动。下面列出了一些常见的动作的例子：

h	左
j	下
k	上
l	右
w	向前移动到下一个单词的开头
}	跳转到下一个段落
$	跳转到当前行的末尾

在之后的章节你将学习更多的关于动作的内容，所以如果你不理解上面这些动作也不必担心。

动词(操作符 Operator)

根据:h operator，Vim共有16个操作符，然而根据我的经验，学习这3个操作符在80%的情况下就已经够用了

y	yank(复制)
d	delete(删除)
c	change 删除文本，将删除的文本存到寄存器中，进入插入模式

顺带说一句，当你yank一段文本后，您可以使用p将它粘贴到光标后，或使用P粘贴到光标前。

动词（操作符 Operator）和名词（动作 motions）的结合

现在你已经知道了基本的动词和名词，我们来用一下我们的语法规则，动词和名词的结合！假设你有下面这段文本：

const learn = "Vim";

复制当前位置到行尾的所有内容：y$
删除当前位置到下一个单词的开头：dw
修改当前位置到这个段落的结尾：c}

动作 motions也接受数字作为参数(这个部分我将在下个章节展开)，如果你需要向上移动3行，你可以用3k代替按3次k，数字可应用在Vim语法中。

向左拷贝2个字符：y2h
删除后两个单词：d2w
修改后面两行：c2j

目前，你也许需要想很久才能完成一个简单的命令，不过我刚开始时也是这样，我也经历过类似的挣扎的阶段但是不久我的速度就快了起来，你也一样。唯一途径就是重复、重复再重复。作为补充，行级的 操作符 operations (作用在整行中的操作符)在文本编辑中和其他的 操作符 一样，Vim允许你通过按两次 操作符使它执行行级的操作，例如dd，yy，cc来执行删除，复制或修改整个行。您可以使用其他operations试一下（比如gUgU）。从这可以看出Vim命令的一种执行模式。但是到目前为止还没有结束，Vim有另一种类型的名词：文本对象(text object)

结合性和语法

在学习Vim的语法之后，让我们来讨论一下Vim中的结合性以及为什么在文本编辑器中这是一个强大的功能。结合性意味着你有很多可以组合起来完成更复杂命令的普通命令，就像你在编程中可以通过一些简单的抽象建立更复杂的抽象，在Vim中你可以通过简单的命令的组合执行更复杂的命令。Vim语法正是Vim中命令的可结合性的体现。 Vim的结合性最强大之处体现在它和外部程序结合时，Vim有一个 过滤操作符!可以用外部程序过滤我们的文本。假设你有下面这段混乱的文本并且你想把它用tab格式化的更好看的一些：

Id|Name|Cuteness
Puppy|Very
Kitten|Ok
Bunny|Ok

这件事情通过Vim命令不太容易完成，但是你可以通过终端提供的命令column很快的完成它，当你的光标位于”Id”上时，运行!}column -t -s "|"，你的文本就变得整齐了许多：

Id  Name    Cuteness
Puppy   Very
Kitten  Ok
Bunny   Ok

让我们分解一下上面那条命令，动词是!(过滤操作符)，名词是}(到下一个段落)。过滤操作符!接受终端命令作为另一个参数，因此我把column -t -s "|"传给它。我不想详细描述column是如何工作的，但是总之它格式化了文本。假设你不止想格式化你的文本，还想只展示Ok结尾的行，你知道awk命令可以做这件事情，那么你可以这样做：

!}column -t -s "|" | awk 'NR > 1 && /Ok/{print $0}'

结果如下：

02  Kitten  Ok
03  Bunny   Ok

管道竟然在Vim中也能起作用。这就是Vim的结合性的强大之处。你知道的动词 操作符，名词动作，终端命令越多，你组建复杂操作的能力成倍增长。换句话说，假设你只知道四个动作：w, $, }, G和删除操作符(d)，你可以做8件事：按四种方式移动(w, $, }, G)和删除4种文本对象(dw, d$, d}, dG)。如果有一天你学习了小写变大写的操作符(gU)，你的Vim工具箱中多的不是1种工具，而是4种：gUw, gU$, gU}, gUG。现在你的Vim工具箱中就有12种工具了。如果你知道10个动作和5个操作符，那么你就有60种工具(50个操作+10个移动)。另外，行号动作(nG)给你了n种动作，其中n是你文件中的行数(例如前往第5行，5G)。搜索动作(/)实际上给你带来无限数量的动作因为你可以搜索任何内容。你知道多少终端命令，外部命令操作符(!)就给你了多少种过滤工具。使用Vim这种能够组合的工具，所有你知道的东西都可以被串起来完成更复杂的操作。你知道的越多，你就越强大。这种具有结合性的行为也正符合Unix的哲学：一个命令做好一件事。动作只需要做一件事：前往X。操作符只需要做一件事：完成Y。通过结合一个操作符和一个动作，你就获得了YX：在X上完成Y。甚至，动作和操作符都是可拓展的，你可以自己创造动作和操作符去丰富你的Vim工具箱，Vim-textobj-user插件允许你创建自己的文本对象，同时包含有一系列定义好的文本对象。另外，如果你不知道我刚才使用的column和awk命令也没有关系，重要的是Vim可以和终端命令很好的结合起来。

聪明地学习语法

你刚刚学完Vim唯一的语法规则：

verb + noun

我学Vim中最大的”AHA moment”之一是当我刚学完大写命令(gU)时，想要把一个单词变成大写，我本能的运行了gUiW，它居然成功了，我光标所在的单词都大写了。我正是从那是开始理解Vim的。我希望你也会在不久之后有你自己的”AHA moment”，如果之前没有的话。这一章的目标是向你展现Vim中的verb+noun模式，因此之后你就可以像学习一门新的语言一样渐进的学习Vim而不是死记每个命令的组合。学习这种模式并且理解其中的含义，这是聪明的学习方式。

Learn Vim 第三章：打开和搜索文件

Sat, 25 Apr 2026 00:00:00 +0000

本章的目的是向您介绍如何在Vim中快速搜索，能够快速搜索是提高您的Vim工作效率的重要途径。当我解决了如何快速搜索文件这个问题后，我就决定改为完全使用Vim来工作。本章划分为两个部分：一是如何不依赖插件搜索；二是使用fzf插件搜索。让我们开始吧！

打开和编辑文件

要在Vim中打开一个文件，您可以使用:edit。

:edit file.txt

如果file.txt已经存在，就会打开file.txtbuffer。如果file.txt不存在，会创建一个新buffer名为file.txt。 :edit命令支持使用<Tab>进行自动补全。比如，如果您的文件位于Rails应用控制器的用户控制器目录./app/controllers/users_controllers.rb内，您可以使用<Tab>对文件路径名进行快速扩展。

:edit a<Tab>c<Tab>u<Tab>

:edit可以接收通配符参数。*匹配当前目录下的任意文件。如果您只想查找当前目录下后缀名为.yml的文件：

:edit *.yml<Tab>

Vim将列出当前目录下所有.yml文件供您选择。您可以使用**进行递归的搜索。如果您想查找当前项目文件夹下所有*.md文件，但您不知道在哪个目录，您可以这样做：

:edit **/*.md<Tab>

:edit可以用于运行netrw（Vim的内置文件浏览器）。使用方法是，给:edit一个目录参数而不是文件名就行了：

:edit .
:edit test/unit/

使用find命令搜索文件

您可以使用:find命令搜索文件。比如：

:find package.json
:find app/controllers/users_controller.rb

:find命令同样支持自动补全：

:find p<Tab>                " to find package.json
:find a<Tab>c<Tab>u<Tab>    " to find app/controllers/users_controller.rb

您可能注意到:find和:edit看起来很像。它们的区别是什么呢？

Find 和 Path

两者的区别在于，:find命令根据path选项配置的路径查找文件，而:edit不会。让我们了解一点关于path选项的知识。一旦您学会如何修改您的路径，:find命令能变成一个功能强大的搜索工具。先查看一下您的path是什么：

:set path?

默认情况下，您的path内容很可能是这样的：

path=.,/usr/include,,

. 意思是在当前文件所在目录下搜索。
, 意思是在当前目录下搜索。
/usr/include 表示在C编译器头文件目录下搜索。

前两个配置非常重要，第3个现在可以被忽略。您这里应该记住的是：您可以修改您自己的路径。让我们假设您的项目结构是这样的：

app/
  assets/
  controllers/
    application_controller.rb
    comments_controller.rb
    users_controller.rb
    ...

如果您想从根目录跳到users_controller.rb，您将不得不经过好几层目录（按好几次<Tab>）。一般说来，当您处理一个framework时，90%的时间您都在某个特定的目录下。在这种情况下，您只关心如何用最少的按键跳到controllers/目录。那么path设置可以减少这个途程。您只需要将app/controllers/添加到当前path选项。以下是操作步骤：

:set path+=app/controllers/

现在您的路径已经更新，当您输入:find u<Tab>时，Vim将会在app/controllers/目录内搜索所有以”u”开头的文件。如果您有一个嵌套的目录controllers/，比如app/controllers/account/users_controller.rb，Vim就找不到users_controllers了。您必须改为添加:set path+=app/controllers/**，这样自动补全才会找到users_controller.rb。这太棒了！您现在可以只需要按1次键就可找到users controller。您可能会想将整个项目文件夹添加到path中，这样当您按<Tab>，Vim将在所有文件夹内搜索您要找的文件，就像这样：

:set path+=$PWD/**

$PWD 表示的是当前工作目录。如果您尝试将整个项目路径加到path中，并希望让所有文件名可以用<Tab>补全，虽然对于小项目没问题，但如果您的项目中包含大量文件时，这会显著降低您的搜索速度。我建议仅仅将您最常访问的文件/目录添加到path。您可以将set path+={您需要添加的目录}添加到您的vimrc文件中。更新path仅花费几秒钟，但可以为您的工作节省很多时间。

使用Grep命令在文件中搜索

如果您想在文件内部查找（搜索文件中的词句），您可以使用grep。Vim有两个方法可以完成这个工作：

内置grep （:vim。没错，就是:vim，它是:vimgrep的简写）。
外部grep (:grep)。

让我们首先仔细看看内置grep。:vim有以下语法：

:vim /pattern/ file

/pattern/ 是您要搜索的内容的正则表达式。
file 是文件参数。您可以传入多个参数。Vim将在文件中搜索所有匹配正则表达式的内容。类似于:find，您可以传入*和**通配符。

比如，要在app/controllers/目录下所有ruby文件(.rb)中，查找所有的”breakfast”字符串:

:vim /breakfast/ app/controllers/**/*.rb

输入上面的命令后，您将会被导航到第一个结果。Vim的vim搜索命令使用quickfix进行处理。要查看所有搜索结果，运行:copen会打开一个quickfix窗口。下面有一些有用的quickfix命令，可以让您提高效率：

:copen        打开quickfix窗口
:cclose       关闭quickfix窗口
:cnext        跳到下一个错误
:cprevious    跳到前一个错误
:colder       跳到旧的错误列表
:cnewer       跳到新的错误列表

要了解更多关于quickfix的信息，使用:h quickfix查看帮助信息。您可能注意到运行内置grep(:vim)命令时，如果匹配结果数量较多时系统速度会变慢。这是因为Vim将每一个搜索结果读入内存。Vim加载每一个匹配的文件就像它们被编辑一样。如果Vim查到大量文件，它将消耗很多内存。让我们谈谈外置grep。默认情况下，它使用终端命令grep。要想在app/controllers/目录中搜索字符串”lunch”，您可以这样做：

:grep -R "lunch" app/controllers/

注意这里不是使用/pattern/，它遵循的是终端grep的语法"pattern"，它同样使用’quickfix’来显示所有的匹配结果。 Vim使用grepprg变量来决定运行:grep时，应该使用哪个外部程序。所以您并不是非得使用终端的grep命令。稍后我将为您演示如何改变外部grep程序的默认值。

用Netrw浏览文件

netrw是Vim的内置文件浏览器，当查看项目的目录结构时很有用。要运行netrw，您需要在您的.vimrc中做以下设置：

set nocp
filetype plugin on

由于netrw是一个很宽泛的话题，我将仅仅介绍它的基本用法，这应该已经足够了。您可以在启动Vim时运行netrw，只需要传给Vim一个目录参数（而不是文件参数）就行了。比如：

vim .
vim src/client/
vim app/controllers/

要想从Vim内部运行netrw，您可以使用:edit命令，传给他一个目录而不是文件名：

:edit .
:edit src/client/
:edit app/controllers/

也有其他方法，不需要传递目录参数就运行netrw窗口：

:Explore     从当前文件启动netrw。
:Sexplore    在顶部水平分割的窗口打开netrw。
:Vexplore    在左侧垂直分割的窗口打开netrw。

您可以使用Vim动作(motions，在后面的章节中将详细讲述)在netrw中导航。如果您要创建、删除、重命名文件或文件夹，下面有一些关于netrw的有用命令：

%    创建新文件
d    创建新目录
R    重命名文件/目录
D    删除文件/目录

:h netrw 的信息非常复杂，如果您有时间可以看看。如果您觉得 netrw 过于单调乏味，vim-vinegar是netrw的一个改进插件。如果您想找一个不同的文件浏览器，NERDTree 是一个很好的选择。去看看吧。

Fzf插件

您现在已经学会了如何使用Vim的内置工具去搜索文件，那么让我们学习一下如何用插件实现这些功能吧。现代文本编辑器相比Vim，有一个功能设计得很好，那就是文件搜索和模糊搜索的简化。在本章的下半部分，我将向您演示如何使用fzf.vim插件，在Vim中轻松实现功能强大的搜索功能。

安装

首先，确保您下载了fzf和ripgrep。按照它们在github仓库上的指令一步步做。成功安装后，命令fzf和rg应该就可以用了。 Ripgrep是一个类似grep（从名字上就看得出）的搜索工具。一般说来，它比grep要快，而且还有很多有用的特性。Fzf是一个多用途的命令行模糊搜索工具，您可以讲它与其他命令联合起来使用，包括ripgrep。联合起来后，它们成为一个功能强大的搜索工具。 Fzf默认并不使用ripgrep，所以我们需要设置FZF_DEFAULT_COMMAND变量告诉fzf使用ripgrep命令。在我的.zshrc（如果您用bash，应该是.bashrc）文件内，我有以下设置：

if type rg &> /dev/null; then
  export FZF_DEFAULT_COMMAND='rg --files'
  export FZF_DEFAULT_OPTS='-m'
fi

注意FZF_DEFAULT_OPTS变量中的-m。这个设置允许我们按下<Tab或<Shift-Tab>后进行多重选择。如果仅想让fzf在Vim中能够工作，这个设置不是必须的，但我认为这是一个有用的设置。当您想在多个文件中执行搜索和替换，进行少量修改时，它会很方便。fzf命令可以接收很多标志，但我不会再这里讲。要想了解更多信息，可以查看fzf’s 仓库，或者使用man fzf。要想让fzf使用ripgrep，您至少得有这个设置export FZF_DEFAULT_COMMAND='rg'。安装好了fzf和ripgrep后，让我们再安装fzf的插件。在这个例子中，我使用的是vim-plug插件管理器，当然您可以使用其他插件管理器。将下列配置添加到您的.vimrc中。因为您需要使用fzf.vim插件。（同样是由fzf的作者在维护）

Plug 'junegunn/fzf.vim'
Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }

添加后，您需要打开vim，运行:PlugInstall。这条命令将会安装所有您在vimrc文件中定义了但尚未安装的插件。在我的例子中，将会安装fzf.vim和fzf。要了解更多关于此插件的信息，您可以查看fzf.vim 的仓库。

Fzf的语法

要想高效的使用fzf，您首先得了解一些fzf的基础语法。幸运的是，这个列表比较短：

^ 表示前缀精确匹配。要搜索一个以”welcome”开头的短语：^welcom。
$ 表示后缀精确匹配。要搜索一个以”my friends”结尾的短语：friends$。
' 表示精确匹配。要搜索短语”welcom my friends”：'welcom my friends。
| 表示”或者”匹配。要搜索”friends”或”foes”：friends | foes。
! 表示反向匹配。要搜索一个包含”welcome”但不包含”friends”的短语：welcome !friends。

您可以混合起来使用。比如，^hello | ^welcome friends$将搜索以”welcome”或”hello”开头，并且以”friends”结束的短语。

查找文件

要想在Vim内使用fzf.vim插件搜索文件，您可以使用:Files方法。在Vim中运行:Files，您将看到fzf搜索提示符。因为您将频繁地使用这个命令，最好建立一个键盘映射，我把它映射到Ctrl-f。在我的vimrc配置中，有这个设置：

nnoremap <silent> <C-f> :Files<CR>

在文件中查找

要想在文件内部搜索，您可以使用:Rg命令。同样，因为您可能将频繁的使用这个命令，让我们给它一个键盘映射。我的映射在<Leader>f。

nnoremap <silent> <Leader>f :Rg<CR>

其他搜索

Fzf.vim提供了许多其他命令。这里我不会一个个仔细讲，您可以去这里查看更多信息。这是我的fzf键盘映射：

nnoremap <silent> <Leader>b :Buffers<CR>
nnoremap <silent> <C-f> :Files<CR>
nnoremap <silent> <Leader>f :Rg<CR>
nnoremap <silent> <Leader>/ :BLines<CR>
nnoremap <silent> <Leader>' :Marks<CR>
nnoremap <silent> <Leader>g :Commits<CR>
nnoremap <silent> <Leader>H :Helptags<CR>
nnoremap <silent> <Leader>hh :History<CR>
nnoremap <silent> <Leader>h: :History:<CR>
nnoremap <silent> <Leader>h/ :History/<CR>

将Grep替换为Rg

正如前面提到的，Vim有两种方法在文件内搜索：:vim和:grep。您可以使用grepprg这个关键字重新指定:grep使用的外部搜索工具。我将向您演示如何设置Vim，使得当运行:grep命令时，使用ripgrep代替终端的grep。现在，让我们设置grepprg来使:grep使用ripgrep。将下列设置添加到您的vimrc：

set grepprg=rg\ --vimgrep\ --smart-case\ --follow

上面的一些选项可以随意修改！要想了解更多关于这些选项的含义，请使用man rg了解详情。当您更新grepprg选项后，现在当您运行:grep，它将实际运行rg --vimgrep --smart-case --follow而不是grep。如果您想使用ripgrep搜索”donut”，您可以运行一条更简洁的命令:grep "donut"，而不是:grep "donut" . -R 就像老的:grep一样，新的:grep同样使用quickfix窗口来显示结果。

在多文件中搜索和替换

现代文本编辑器，比如VSCode中，在多个文件中搜索和替换一个字符串是很简单的事情。在这一节，我将向您演示如何在Vim中轻松实现这个。第一个方法是在您的项目中替换所有的匹配短句。您得使用:grep命令。如果您想将所有”pizza”替换为”donut”，下面是操作方法：

:grep "pizza"
:cfdo %s/pizza/donut/g | update

让我们来分析一下这条命令：

:grep pizza使用ripgrep去搜索所有”pizza”。
:cfdo会在您的quickfix列表中所有文件里，执行您传递给它的命令。在这个例子中，您的命令是一条替换命令%s/pizza/donut/g。管道符号(|)是一个链接操作符。命令update在每个文件被替换后，立刻保存。

第二个方法是在您选择文件中执行搜索和替换。用这个方法，您可以手动选择您想执行搜索和替换的文件。下面是操作方法：

首先清空您的buffer。让您的buffer列表仅包含您所需要的文件，这一点很有必要。您可以重启Vim，也可以运行:%bd | e#命令。
运行:Files。
选择好您想搜索-替换的文件。要选择多个文件，使用<Tab>或<Shift-Tab>。
运行:bufdo %s/pizza/donut/g | update。区别在于，(:cfdo)替换所有quickfix中的实体，而(:bufdo)替换所有buffer中的实体。

用聪明的方法学习搜索

在文本编辑时，搜索是一个很实用的技巧。学会在Vim中如何搜索，将显著提高您的文本编辑工作流程效率。 Fzf.vim插件就像一个游戏规则改变者。我无法想象使用Vim没有它的情景。当最开始使用Vim时，如果有一个好的搜索工具，我想是非常重要的。我看见很多人过渡到Vim时的艰难历程，就是因为Vim缺少了现代编辑器所拥有的一些关键功能特性，比如简单快捷且功能强大的搜索功能。我希望本章将帮助您更轻松地向Vim过渡。

Learn Vim 第二章：缓冲区、窗口和标签页

Fri, 24 Apr 2026 00:00:00 +0000

（译者注：在Vim中，Buffers缓冲区，Windows窗口，Tabs选项卡是专有名词。为适应不同读者的翻译习惯，确保没有歧义，本文将不对Buffers、Windows、Tabs这三个词进行翻译）。如果您使用过现代文本编辑器，您很可能对Windows和tabs这两个概念是非常熟悉的。但Vim使用了三个关于显示方面的抽象概念：buffers, windows, 还有tabs。在本章，我将向您解释什么是buffers, windows和tabs，以及它们在Vim中如何工作。在开始之前，确保您的vimrc文件中开启了set hidden选项。若没有配置该选项，当您想切换buffer且当前buffer没有保存时，Vim将提示您保存文件（如果您想快速切换，您不会想要这个提示）。我目前还没有讲vimrc，如果您没有vimrc配置文件，那就创建一个。它通常位于根目录下，名字叫.vimrc。我的vimrc位于~/.vimrc。要查看您自己的vimrc文件应该放置在哪，可以在Vim命令模式中输入:h vimrc。在vimrc文件中，添加：

set hidden

保存好vimrc文件，然后激活它(在vimrc文件中运行:source %)。

Buffers

buffer到底是什么？ buffer就是内存中的一块空间，您可以在这里写入或编辑文本。当您在Vim中打开一个文件时，文件的数据就与一个buffer绑定。当您在Vim中打开3个文件，您就有3个buffers。创建两个可使用的空文件，分别名为file1.js和file2.js（如果可能，尽量使用Vim来创建）。在终端中运行下面的命令：

vim file1.js

这时您看到的是file1.js的 buffer 。每当您打开一个新文件，Vim总是会创建一个新的buffer。退出Vim。这一次，打开两个新文件：

vim file1.js file2.js

Vim当前显示的是file1.js的buffer，但它实际上创建了两个buffers：file1.jsbuffer和file2.jsbuffer。运行:buffers命令可以查看所有的buffers（另外，您也可以使用:ls和:files命令）。您应该会同时看到列出来的file1.js和file2.js。运行vim file1 file2 file3 ... filen创建n个buffers。每一次您打开一个新文件，Vim就为这个文件创建一个新的buffer。要遍历所有buffers，有以下几种方法：

:bnext 切换至下一个buffer（:bprevious切换至前一个buffer）。
:buffer + 文件名。（按下<Tab>键Vim会自动补全文件名）。
:buffer + n, n是buffer的编号。比如，输入:buffer 2将使您切换到buffer #2。
按下Ctrl-O将跳转至跳转列表中旧的位置，对应的，按下Ctrl-I将跳转至跳转列表中新的位置。这并不是属于buffer的特有方法，但它可以用来在不同的buffers中跳转。我将在第5章详细讲述关于跳转的知识。
按下Ctrl-^跳转至先前编辑过的buffer。

一旦Vim创建了一个buffer，它将保留在您的buffers列表中。若想删除它，您可以输入:bdelete。这条命令也可以接收一个buffer编号（:bdelete 3将删除buffer #3）或一个文件名（:bdelete然后按<Tab>自动补全文件名）。我学习buffer时最困难的事情就是理解buffer如何工作，因为我当时的思维已经习惯了使用主流文本编辑器时关于窗口的概念。要理解buffer，可以打个很好的比方，就是打牌的桌面。如果您有2个buffers，就像您有一叠牌（2张）。您只能看见顶部的牌，虽然您知道在它下面还有其他的牌。如果您看见file1.jsbuffer，那么file1.js就是顶部的牌。虽然您看不到其他的牌file2.js，但它实际上就在那。如果您切换buffers到file2.js，那么file2.js这张牌就换到了顶部，而file1.js就换到了底部。如果您以前没有用过Vim，这是一个新的概念。花上几分钟理解一下。

退出Vim

顺带说一句，如果您已经打开了多个buffers，您可以使用quit -all来关闭所有的buffers：

:qall

如果您想关闭所有buffers但不保存，仅需要在后面加!（叹号）就行了：

:qall!

若要保存所有buffers然后退出，请运行：

:wqall

Windows

一个window就是在buffer上的一个视口。如果您使用过主流的编辑器，Windows这个概念应该很熟悉。大部分文本编辑器具有显示多个窗口的能力。在Vim中，您同样可以拥有多个窗口。让我们从终端再次打开file1.js：

vim file1.js

先前我说过，您看到的是file1.js的buffer。但这个说法并不完整，现在这句话得更正一下，您看到的是file1.js 的buffer通过 一个窗口 显示出来。窗口就是您查看的buffer所使用的视口。先不忙急着退出Vim，在Vim中运行：

:split file2.js

现在您看到的是两个buffers通过 两个窗口 显示出来。上面的窗口显示的是file2.js的buffer。而下面的窗口显示的是file1.js的buffer。如果您想在窗口之间导航，使用这些快捷键：

Ctrl-W H    移动光标到左边的窗口
Ctrl-W J    移动光标到下面的窗口
Ctrl-W K    移动光标到上面的窗口
Ctrl-W L    移动光标到右边的窗口

现在，在Vim中运行：

:vsplit file3.js

您现在看到的是三个窗口显示三个buffers。一个窗口显示file3.js的buffer，一个窗口显示file2.js的buffer，还有一个窗口显示file1.js的buffer。您可以使多个窗口显示同一个buffer。当光标位于左上方窗口时，输入：

:buffer file2.js

现在两个窗口显示的都是file2.js的buffer。如果您现在在这两个窗口中的某一个输入内容，您会看到所有显示file2.jsbuffer的窗口都在实时更新。要关闭当前的窗口，您可以按Ctrl-W C或输入:quit。当您关闭一个窗口后，buffers仍然会在列表中。（可以运行:buffers来确认这一点）。这里有一些普通模式下关于窗口的命令：

Ctrl-W V    打开一个新的垂直分割的窗口
Ctrl-W S    打开一个新的水平分割的窗口
Ctrl-W C    关闭一个窗口
Ctrl-W O    除了当前窗口，关闭所有其他的窗口

另外，下面的列表列出了一些有用的关于windows的命令行命令

:vsplit filename    垂直分割当前窗口，并在新窗口中打开名为filename的文件。
:split filename     水平分割当前窗口，并在新窗口中打开名为filename的文件。
:new filename       创建一个新窗口并打开名为filename的文件。

花一点时间理解上面的知识。要了解更多信息，可以查看帮助:h window。

Tabs

Tabs就是windows的集合。它就像窗口的布局。在大部分的现代文本编辑器（还有现代互联网浏览器）中，一个tab意味着打开一个文件/页面，当您关闭标签，相应的文件/页面就消失了。但在Vim中，tab并不表示打开了一个文件。当您在Vim中关闭一个tab，您并不是关闭一个文件。您仅仅关闭了窗口布局。文件的数据依然存储在内存中的buffers中。让我们运行几个命令看看Vim中tabs的功能。打开file1.js：

vim file1.js

若要在新tab中打开file2.js：

:tabnew file2.js

当然您可以按<Tab>让Vim自动补全 新tab 中将要打开的文件名（啰嗦几句，请理解作者的幽默）。下面的列表列出了一些有用的关于tab导航的命令：

:tabnew file.txt    在tab中打开一个文件
:tabclose           关闭当前tab
:tabnext            切换至下一个tab
:tabprevious        切换至前一个tab
:tablast            切换至最后一个tab
:tabfirst           切换至第一个tab

您可以输入gt切换到下一个标签页（对应的，可以用gT切换到前一个标签页）。您也可以传递一个数字作为参数给gt，这个数字是tab的编号。若想切换到第3个tab，输入3gt。拥有多个tabs的好处是，您可以在不同的tab中使用不同的窗口布局。也许，您想让您的第1个tab包含3个垂直分割的窗口，然后让第2个tab为水平分割和垂直分割混合的窗口布局。tab是完成这件工作的完美工具! 若想让Vim启动时就包含多个tabs，您可以在终端中运行如下命令：

vim -p file1.js file2.js file3.js

三维移动

在windows之间移动就像在笛卡尔坐标系的二维平面上沿着X-Y轴移动。您可以使用Ctrl-W H/J/K/L移动到上面、右侧、下面、以及左侧的窗口。在buffer之间移动就像在笛卡尔坐标系的Z轴上穿梭。想象您的buffer文件在Z轴上呈线性排列，您可以使用:bnext和bprevious在Z轴上一次一个buffer地遍历。您也可以使用:buffer 文件名/buffer编号在Z轴上跳转到任意坐标。结合window和buffer的移动，您可以在 三维空间 中移动。您可以使用window导航命令移动到上面、右侧、下面、或左侧的窗口（X-Y平面导航）。因为每个window都可能包含了多个buffers，您可以使用buffer移动命令向前、向后移动（Z轴导航）。

用聪明的方法使用Buffers、Windows、以及Tabs

您已经学习了什么是buffers、windows、以及tabs，也学习了它们如何在Vim中工作。现在您对它们有了更好地理解，您可以把它们用在您自己的工作流程中。每个人都有不同的工作流程，以下示例是我的工作流程：

首先，对于某个特定任务，我先使用buffers存储所有需要的文件。Vim就算打开很多buffer，速度一般也不会减慢。另外打开多个buffers并不会使我的屏幕变得拥挤。我始终只会看到1个buffer（假设我只有1个window），这可以让我注意力集中在1个屏幕上。当我需要使用其他文件时，可以快速切换至对应文件的buffer。
当比对文件、读文档、或追踪代码流时，我使用多窗口来一次查看多个buffers。我尽量保持屏幕上的窗口数不超过3个，因为超过3个屏幕将变得拥挤（我使用的是小型笔记本）。当相应工作完成后，我就关掉多余的窗口。窗口越少可以使注意力更集中。
我使用tmuxwindows来代替tabs。通常一次使用多个tmux窗口。比如，一个tmux窗口用来写客户端代码，一个用来写后台代码。

由于编辑风格不同，我的工作流程可能和您的工作流程不同，这没关系。您可以在实践中去探索适合您自己工作流程的编码风格。

Learn Vim 第一章：起步

Thu, 23 Apr 2026 00:00:00 +0000

在本章，您将了解从终端启动Vim的几种不同方法。我写这本教程时使用的Vim版本是8.2。如果您使用Neovim或老版本的Vim，大部分情况下方法是通用的，但注意个别命令可能无效。

安装

我不会给出在某台特定机器上安装Vim的详细指令。好消息是，大部分Unix-based电脑应该预装了Vim。如果没有，大部分发行版也应该有关于如何安装Vim的指令。从Vim的官方网站或官方仓库可以获得下载链接：

Vim命令

当您安装好Vim后，在终端运行以下命令：

vim

您应该会看到一个介绍界面。这就是您用来处理文本的工作区。不像其它大部分文本编辑器和IDE，Vim是一个模式编辑器。如果您想输入”hello”，您需要使用’i’命令切换到插入模式。按下’ihello'可以在工作区插入文本"hello"。

退出Vim

有好几种不同的方法都可以退出Vim。（译者注：在stackflow论坛上，有个著名的问题”如何退出Vim”，五年来，有超过100万开发者遇到相同的问题。^_^，这件事已经成为了开发者中的一个梗）。最常用的退出方法是在Vim中输入：

:quit

您可以使用简写:q。这是一个命令行模式的命令(command-line mode：Vim的另一种模式)。如果您在普通模式输入:，光标将移动到屏幕底部，在这里您可以输入命令。在后面的第15章，您会学到关于命令行模式更多信息。如果您处于插入模式，按下:将会在屏幕上直接显示”:”(冒号)。因此，您需要按下<Esc>键切换回普通模式。顺带说一下，在命令行模式也可以通过按<Esc>键切换回普通模式。您将会注意到，在Vim的好几种模式下都可以通过按<Esc>键切回普通模式。

保存文件

若要保存您的修改，在Vim中输入：

:write

您也可以输入简写’:w’。如果这是一个新建的文件，您必须给出文件名才能保存。下面的命令使文件保存为名为’file.txt’的文件，在Vim命令行运行：

:w file.txt

如果想保存并退出，可以将’:w’和’:q’命令联起来，在Vim命令行中输入：

:wq

如果想不保存修改而强制退出，可以在’:q’命令后加’!’（叹号）,在Vim命令行中：

:q!

帮助

在本指南全文中，我将向您提及好几种Vim的帮助页面。您可以通过输入:help {命令}(:h是简写)进入相关命令的帮助文档。可以向:h命令传递主题、命令名作为参数。比如，如果想查询退出Vim的方法，在vim中输入：

:h write-quit

我是怎么知道应该搜索”write-quit”这个关键词的呢？实际上我也不知道，我仅仅只是输入’:h quit’，然后按<Tab>。Vim会自动显示相关联的关键词供用户选择。如果您需要查询一些信息，只需要输入:h后接关键词，然后按<Tab>。

打开文件

如果想在终端中使用Vim打开名为(‘hello1.txt’)，在终端中运行：

vim hello1.txt

可以一次打开多个文件，在终端中：

vim hello1.txt hello2.txt hello3.txt

Vim会在不同的buffers中打开’hello1.txt’，’hello2.txt’，’hello3.txt’。在下一章您将学到关于buffers的知识。

参数

您可以在终端中向vim命令传递参数。如果想查看Vim的当前版本，在终端中运行：

vim --version

终端中将显示您当前Vim的版本和所有支持的特性，’+’表示支持的特性，’-‘表示不支持的特性。本教程中的一些操作需要您的Vim支持特定的特性。比如，在后面的章节中提到可以使用:history查看Vim的命令行历史记录。您的Vim必须包含+cmdline_history这一特性，这条命令才能正常使用。一般情况下，如果您通过主流的安装源下载Vim的话，您安装的Vim是支持所有特性的，您在终端里做的很多事情都可以在Vim内部实现。比如，在Vim程序中也可以查看当前Vim版本，您可以运行下面的命令，在Vim中输入：

:version

如果您想打开hello.txt文件后迅速执行一条命令，您可以向vim传递一个+{cmd}选项。在Vim中，您可以使用:s命令（substitue的缩写）替换文本。如果您想打开hello.txt后立即将所有的”pancake”替换成”bagel”，在终端中：

vim +%s/pancake/bagel/g hello.txt

该命令可以被叠加，在终端中：

vim +%s/pancake/bagel/g +%s/bagel/egg/g +%s/egg/donut/g hello.txt

Vim会将所有”pancake” 实例替换为”bagel”，然后将所有”bagel”替换为”egg”，然后将所有”egg”替换为”donut”（在后面的章节中您将学到如何替换）。您同样可以使用c标志来代替+语法，在终端中：

vim -c %s/pancake/bagel/g hello.txt
vim -c %s/pancake/bagel/g -c %s/bagel/egg/g -c %s/egg/donut/g hello.txt

打开多个窗口

您可以使用o和O选项使Vim打开后分别显示为水平或垂直分割的窗口。若想将Vim打开为2个水平分割的窗口，在终端中运行：

vim -o2

若想将Vim打开为5个水平分割的窗口，在终端中运行：

vim -o5

若想将Vim打开为5个水平分割的窗口，并使前两个窗口显示hello1.txt和hello2.txt的内容，在终端中运行：

vim -o5 hello1.txt hello2.txt

若想将Vim打开为2个垂直分割的窗口、5个垂直分割的窗口、5个垂直分割窗口并显示2个文件，在终端中分别运行以下命令：

vim -O2
vim -O5
vim -O5 hello1.txt hello2.txt

挂起

如果您编辑时想将Vim挂起，您可以按下Ctrl-z。同样，您也可以使用:stop或:suspend命令达到相同的效果。若想从挂起状态返回，在终端中运行fg命令。

聪明的启动Vim

您可以向vim命令传递不同的选项(option)和标志(flag)，就像其他终端命令一样。其中一个选项是命令行命令（+{cmd}或-c cmd）。当您读完本教程学到更多命令后，看看您是否能将相应命令应用到Vim的启动中。同样，作为一个终端命令，您可以将vim命令和其他终端命令联合起来。比如，您可以将ls命令的输出重定向到Vim中编辑，命令是ls -l | vim -。若要了解更多Vim终端命令，查看man vim。若要了解更多关于Vim编辑器的知识，继续阅读本教程，多使用:help命令。

Learn Vim 前言：为什么学 Vim

Wed, 22 Apr 2026 00:00:00 +0000

为什么写这本教程

有很多途径可以学习Vim:vimtutor就是一个很好的途径，另外还有Vim自带的帮助手册（:help查看）包含了所有需要的参考信息。但是在日常使用中，对于绝大部分用户的需求而言，vimtutor讲得太浅不能满足需要，而:help所提供的信息又有很多是用不上的。本指南尝试在两者之间搭一座桥，仅重点介绍关键功能，使您尽可能在最短的时间内掌握Vim中最有用的知识。绝大部分情况下，您并不会使用到Vim100%的功能。您可能仅仅需要掌握其中20%就可以成为一名娴熟的Vim用户。本指南将为您展示Vim中最有用的功能。本指南带有作者强烈的个人观点。它涵盖了作者在使用Vim的过程中经常用到的技巧。章节按照作者认为的，最适合初学者最符合逻辑的顺序排列。本指南包含大量示例。当学习一个新技能时，示例是不可缺少的，大量的示例可以更有效的巩固所学概念。部分读者可能好奇为什么要学习Vimscript？我刚使用Vim时，仅仅满足于知道如何使用Vim。随着时间推移，我越来越需要使用Vimscript去写一些自定义命令，以满足特殊的编辑需要。在您使用Vim的过程中，您早晚会接触Vimscript。所以为什么不早点学呢？Vimscript是一门小巧的脚本语言，仅需要本指南的四个章节，您就可以学到它的基础知识。您当然可以继续使用Vim而不了解任何Vimscript知识，但了解它可以使您更加擅长Vim。本指南同时为初学者和高级Vim用户撰写。它从宽泛而简单的概念开始讲，最后落在特殊的、进阶的技巧上。如果您已经是一名进阶用户，我还是鼓励您从头到尾阅读本指南，因为您将了解到一些新的东西。

如何从其他编辑器过渡到Vim

学习Vim的过程虽然很困难,但很具有成就感。有两种方法去学习Vim：

强制转换地使用Vim
循序渐进地使用Vim

强制转换为Vim意味着从现在开始只使用Vim，停止使用您以前使用的任何编辑器/IDE。本方法的缺点是在前一周或两周，您将面临编辑效率的严重下降。如果您是一名专职程序员，本方法可能不太行得通。这也是为什么对于大部分读者而言，我认为过渡到Vim最好是循序渐进地使用Vim。想要循序渐进地使用Vim，应该在最开始的两个星期，每天花1个小时使用Vim作为您的编辑器，而剩下的时间您可以继续使用其他编辑器。许多现代编辑器都带有Vim插件。我刚开始时，每天花1个小时使用VSCode的Vim插件。逐渐地，我增加使用Vim插件的时间，直到最终完全使用Vim插件。记住，这些插件仅仅模拟了Vim中的一小部分功能。要想体验Vim中比如Vimscript、命令行命令（Ex模式）、以及外部集成命令的强大功能，您必须使用Vim自身。有两个关键节点驱使我开始100%地使用Vim：一是当我理解到Vim命令的语法结构（看第4章）时。二是学会fzf.vim插件时（看第3章）。第一个，当我了解了Vim命令的语法结构时。这是一个决定性时间节点，我终于理解了Vim用户以前讨论的是什么。我并不需要去学习上百个命令，而仅需要学习一小部分命令，然后就可以凭直觉将它们串起来去做很多事情。第二个，fzf插件我经常使用，该插件具有类似IDE的模糊文件查找功能。当我学会在Vim中如何使用该功能时，我的编辑效率极大提升，从此再也回不去了。尽管每一个程序都是不同的。但仔细一想，您会发现您所偏爱的编辑器/IDE总有1个或2个功能是您频繁使用的。也许是模糊查找，也许是跳转至定义，或是快速编译，但不管是什么，快速确认这些功能，然后学会如何在Vim中实现它们（一般情况下Vim都能办到）。您的编辑速度将会获得一个巨大的提高。当您使用Vim可以达到您原来50%的效率时，就是时候完全使用Vim了。

如何阅读本指南

本指南注重实效性。为了更好地在Vim中工作，您需要锻炼您的肌肉记忆，而不是大脑理解。想学会骑自行车，您并不需要首先阅读一本骑车教程。您需要做的是骑上一辆真正的自行车，然后在实践中探索。您需要输入每一条本指南中提到的命令。不仅如此，您还需要不断地重复，然后尝试命令的不同联合方式。想了解您刚学到命令具有什么功能，:help命令和搜索引擎是您最好的帮手。但您的目标并不是去掌握关于一条命令的全部信息，而是能够本能地、自然地使用该命令。我本想尽可能地使本指南的知识点呈线性化展示，但有些概念还是不得不违反顺序。比如在第1章，我就提到了替换命令（:s），这个知识点要到第12章才讲。作为补救，不管是什么概念，如果被提前讲到了，我将为它提供一个简短的说明，原谅我吧。

语法

大部分命令或涉及的代码片段都使用代码样式（like this）。字符串使用双引号包括（”like this”）。 Vim命令可以使用简写。比如，:join可以简写为:j。本指南全文中，我将混合使用简写和全称。对于本指南不经常使用的命令，我将使用全称。而对于经常使用的命令，我将使用简写。我为这不一致性道歉。总之，不管什么时候当您看到一个新命令，记得使用:help查看它的简写。

Vimrc

在本指南的很多地方，我将提到vimrc选项。如果您是初学者，可以把vimrc看做一个配置文件。 Vimrc直到第21章才讲。为了保持清晰，我将在这里简要的介绍如何配置Vimrc。假设您需要设置number选项，即显示行号(set number)。如果您还没有vimrc文件，就创建一个。它通常位于根目录，名字为.vimrc。根据您的操作系统，该位置可能不同。在macOS，我将它放在~/.vimrc。要查看您的vimrc文件应该放在哪里，查看:h vimrc。在vimrc文件内，添加一行set number。保存(:w)，然后激活这一配置(:source %)。您将会在每一行的的左侧看到行号。另外，如果您不想永久配置一个选项，您可以在Vim命令行使用set命令，输入:set number。这种方法的缺点是设置是临时的。当您关闭Vim，该配置选项将消失。因为我们学的是Vim而不是Vi，有一个设置您必须启用，这就是nocompatible选项。在您的vimrc文件中添加set nocompatible。如果启用compatible选项，许多Vim特有的功能将会被禁止。一般而言，不管什么时候只要有一段内容涉及vimrc选项，只需要将该选项添加到vimrc中就好了，然后保存并激活相关选项。

未来计划，错误，问题

期待未来有更多的更新。如果您发现任何错误或有什么疑问，请随意提交。我计划近期再发布一些更新章节，敬请关注。

感谢

感谢Bram Moleenar编写了Vim，没有Vim就不会有本指南。感谢我的妻子当我编写本指南时表现的耐心和支持。感谢所有的贡献者contributors，感谢Vim社区，还有很多其他没有提及的人们。谢谢，您们使得这件工作更加有趣。:)

Nova - chat.nvim 的 Android 客户端

Wed, 22 Apr 2026 00:00:00 +0000

Nova 是 chat.nvim 的 Android 客户端，让你在手机上继续 Neovim 中的 AI 对话。

curl 请求体长度限制问题及解决方案

Mon, 20 Apr 2026 00:00:00 +0000

排查 curl 通过 stdin 传递请求体时的长度限制问题，并给出解决方案。

阿里云 Coding Plan Bug：流式输出内容截断

Mon, 20 Apr 2026 00:00:00 +0000

记录阿里云百炼平台 Coding Plan 流式输出内容截断的 Bug 分析过程。

Neovim 配置管理最佳实践

Sat, 21 Mar 2026 00:00:00 +0000

Neovim 配置管理的最佳实践，从目录结构到多机器同步的完整方案。

阿里云 Coding Plan GLM-5 流式 Tool Call 异常输出

Sat, 21 Mar 2026 00:00:00 +0000

分析阿里云 Coding Plan GLM-5 模型流式 Tool Call 输出的协议异常问题。

job.nvim raw 参数导致 JSON 解析失败

Tue, 10 Mar 2026 00:00:00 +0000

排查 job.nvim 中 raw 参数导致 JSON 解析失败的问题。

为什么仍然在使用 job.nvim

Wed, 25 Feb 2026 00:00:00 +0000

对比 job.nvim 与 vim.system，解释为什么仍然选择使用 job.nvim。

从零开始理解如何制作自己的 AI 助手

Wed, 25 Feb 2026 00:00:00 +0000

从零开始理解 AI 助手的核心原理，拨开概念迷雾，看清技术本质。

Neovim 智能对话伙伴 chat.nvim

Tue, 03 Feb 2026 00:00:00 +0000

chat.nvim 插件介绍：在 Neovim 中集成 AI 对话，提升编码效率。

Neovim buffer 删除插件 bufdel.nvim

Wed, 28 Jan 2026 00:00:00 +0000

bufdel.nvim 插件介绍：删除 buffer 时保持窗口布局不变。

Neovim 日历插件 calendar.nvim

Sun, 04 Jan 2026 00:00:00 +0000

calendar.nvim 插件介绍：在 Neovim 中查看日历，方便笔记日期管理。

文件路径大小写敏感导致 Lua 模块重载

Sun, 28 Dec 2025 00:00:00 +0000

文件路径大小写敏感问题导致 Lua 模块重载失败的排查过程。

Neovim 悬浮滚动条 scrollbar.nvim

Thu, 25 Dec 2025 00:00:00 +0000

scrollbar.nvim 插件介绍：为 Neovim 提供悬浮滚动条功能。

如何正确地使用 ftplugin 目录

Tue, 23 Dec 2025 00:00:00 +0000

正确使用 Neovim ftplugin 目录的方法，避免常见配置陷阱。

本地化管理 Github secrets

Thu, 04 Dec 2025 00:00:00 +0000

使用脚本本地化管理多个 GitHub 仓库的 secrets，提升效率。

发现 Git 仓库中幽灵文件

Sat, 29 Nov 2025 00:00:00 +0000

在 Git 历史中搜索已删除文件的技巧，快速定位删除 commit。

Neovim 中使用 luarocks

Thu, 27 Nov 2025 00:00:00 +0000

在 Neovim 中使用 luarocks 包管理器管理 Lua 依赖。

Neovim 窗口 API 参数 noautocmd 测试

Wed, 12 Nov 2025 00:00:00 +0000

测试 Neovim 窗口 API 的 noautocmd 参数行为。

Neovim 模糊搜索插件 picker.nvim

Fri, 31 Oct 2025 00:00:00 +0000

picker.nvim 插件介绍：纯 Lua 实现的 Neovim 模糊搜索插件。

Github 仓库自动 release

Mon, 22 Sep 2025 00:00:00 +0000

使用 Google release-please-action 自动化 GitHub 仓库版本发布。

为什么有那么多人讨厌清朝？

Wed, 03 Sep 2025 00:00:00 +0000

从历史屠杀事件探讨为什么很多人对清朝评价负面。

Lua 可变参数

Sun, 24 Aug 2025 00:00:00 +0000

Lua 可变参数的使用方法与技巧。

高效处理 Markdown 中的代码块

Sun, 24 Aug 2025 00:00:00 +0000

使用插件高效编辑和执行 Markdown 中的代码块。

为什么停止维护 SpaceVim

Sat, 03 May 2025 00:00:00 +0000

停止维护 SpaceVim 项目的原因说明。

解决 Windows 系统下输入法问题

Wed, 23 Apr 2025 00:00:00 +0000

解决 Windows 系统下 Neovim 输入法切换问题。

Neovim 历史使用文件插件 mru.nvim

Sun, 13 Apr 2025 00:00:00 +0000

mru.nvim 插件介绍：Neovim 最近使用文件管理插件。

Neovim 录制按键及屏幕

Sat, 12 Apr 2025 00:00:00 +0000

在 Neovim 中录制按键和屏幕动图的方法。

Neovim 自动切换至项目根目录

Sat, 22 Mar 2025 00:00:00 +0000

Neovim 自动切换至项目根目录的插件介绍。

Neovim 日志插件 logger.nvim

Sun, 16 Mar 2025 00:00:00 +0000

logger.nvim 插件介绍：为 Neovim 插件提供统一的日志框架。

Neovim 任务管理插件 tasks.nvim

Sat, 01 Mar 2025 00:00:00 +0000

tasks.nvim 插件介绍：Neovim 任务管理插件，支持 TOML 任务定义、变量展开、Problem Matcher、自动检测和 Task Provider API。

Neovim 代码执行插件 code-runner.nvim

Fri, 28 Feb 2025 00:00:00 +0000

code-runner.nvim 插件介绍：在 Neovim 中快速执行代码。

Neovim 插件管理器 nvim-plug

Sun, 09 Feb 2025 00:00:00 +0000

nvim-plug 插件介绍：轻量级 Neovim 插件管理器。

从 VimScipt 切换至 Lua

Sat, 01 Feb 2025 00:00:00 +0000

从 VimScript 切换到 Lua 开发 Neovim 配置和插件的经验分享。

启用 Git Commit 签名

Fri, 24 Jan 2025 00:00:00 +0000

启用 Git Commit 签名验证，提升代码安全性。

从零开始制作实时搜索插件

Thu, 23 Jan 2025 00:00:00 +0000

从零开始制作 Neovim 实时搜索插件的完整过程。

Neovim extmarks 功能介绍

Sun, 19 Jan 2025 00:00:00 +0000

Neovim extmarks 功能介绍：精确的缓冲区文本标记。

Neovim winbar 设置

Tue, 14 Jan 2025 00:00:00 +0000

Neovim winbar 的设置方法与使用技巧。

自定义 quickfix 窗口格式

Fri, 10 Jan 2025 00:00:00 +0000

自定义 Neovim quickfix 窗口的显示格式。

《误杀3》观后感

Wed, 08 Jan 2025 00:00:00 +0000

电影《误杀3》观后感。

Neovim quickfix 窗口内的一些快捷键

Mon, 30 Dec 2024 00:00:00 +0000

Neovim quickfix 窗口内的常用快捷键配置。

Vim/Neovim 中使用正则表达式

Sun, 29 Dec 2024 00:00:00 +0000

Vim/Neovim 正则表达式的使用方法与注意事项。

Neovim 状态栏及标签栏点击事件

Sat, 28 Dec 2024 00:00:00 +0000

Neovim 状态栏和标签栏的点击事件处理。

代码格式化插件 format.nvim

Wed, 25 Dec 2024 00:00:00 +0000

format.nvim 插件介绍：Neovim 代码格式化插件。

在 SpaceVim 中使用卢曼卡片盒笔记法做笔记

Wed, 11 Dec 2024 00:00:00 +0000

在 SpaceVim 中使用卢曼卡片盒笔记法管理笔记。

《好东西》观后感

Mon, 25 Nov 2024 00:00:00 +0000

电影《好东西》观后感，在压抑生活中寻找温暖。

《重生》：揭穿人性假面

Sun, 08 Sep 2024 00:00:00 +0000

电影《重生》观后感：揭穿人性假面。

删除 Telegram 账号

Sat, 24 Aug 2024 00:00:00 +0000

删除 Telegram 账号的原因与过程。

Vim Script 的新语法

Wed, 21 Aug 2024 00:00:00 +0000

Vim Script 新语法介绍，从旧版本到新特性的演变。

龙迹之城散人玩家攻略

Wed, 21 Aug 2024 00:00:00 +0000

龙迹之城传奇类游戏散人玩家攻略分享。

使用 GitHub 进行身份验证时要小心

Mon, 12 Aug 2024 00:00:00 +0000

使用 GitHub 身份验证时的安全注意事项。

请停止复制我的个人网站

Sun, 11 Aug 2024 00:00:00 +0000

发现个人博客被全站复制，呼吁尊重原创内容。

从 GitHub Page 切换至 Cloudflare Page

Sun, 11 Aug 2024 00:00:00 +0000

从 GitHub Page 迁移到 Cloudflare Page 的过程与原因。

Vim9Script 与 Lua 的速度比较

Sat, 10 Aug 2024 00:00:00 +0000

Vim9Script 与 Lua 执行速度的比较测试。

Neovim 和 Vim 插件管理器的实现逻辑

Thu, 08 Aug 2024 00:00:00 +0000

Neovim/Vim 插件管理器的实现逻辑分析。

实时调整 Neovim 的颜色主题

Sat, 03 Aug 2024 00:00:00 +0000

实时调整 Neovim 颜色主题的插件介绍。

悬浮滚动条插件 scrollbar.vim

Tue, 30 Jul 2024 00:00:00 +0000

scrollbar.vim 插件介绍：Vim/Neovim 悬浮滚动条。

关于 Neovim 插件开发的指南

Mon, 29 Jul 2024 00:00:00 +0000

对 Neovim 插件开发指南的看法与讨论。

Neovim 调色板插件 cpicker.nvim

Sun, 14 Jul 2024 00:00:00 +0000

cpicker.nvim 插件介绍：Neovim 内置调色板工具。

Neovim 缓冲区（buffer）相关事件

Sun, 07 Jul 2024 00:00:00 +0000

Neovim 缓冲区相关事件的详解与分析。

(Neo)Vim 括号补全插件比较

Thu, 27 Jun 2024 00:00:00 +0000

(Neo)Vim 括号自动补全插件的横向比较。

Lua 与 Vim Script 之间函数相互调用

Tue, 11 Jun 2024 00:00:00 +0000

Lua 与 Vim Script 之间函数相互调用的方法。

更新 Neovim 遇到的问题

Mon, 11 Mar 2024 00:00:00 +0000

升级 Neovim nightly 版本时遇到的兼容性问题。

修复 git clone 问题: gnutls_handshake() failed

Fri, 23 Feb 2024 00:00:00 +0000

修复 WSL 中 git clone 出现的 gnutls_handshake 错误。

《热辣滚烫》观后感

Thu, 15 Feb 2024 00:00:00 +0000

电影《热辣滚烫》观后感：为梦想坚持与改变。

从 Github 迁移到 Gitlab

Wed, 27 Sep 2023 00:00:00 +0000

从 GitHub 迁移到 GitLab 的原因与过程。

非常棒的安卓输入法 fcitx-android

Wed, 07 Jun 2023 00:00:00 +0000

fcitx5-android 输入法推荐：安卓平台的开源隐私选择。

Neo-tree.nvim 糟糕的体验

Wed, 31 May 2023 00:00:00 +0000

Neo-tree.nvim 文件树插件的使用体验与问题。

我的 Neovim 之旅

Wed, 24 May 2023 00:00:00 +0000

从 Vim 到 Neovim 的使用历程与技术演进。

写给自己·关于健康

Mon, 22 May 2023 00:00:00 +0000

关于健康重要性的思考，珍惜生命与奋斗的平衡。

停用 v2ex 账号

Mon, 15 May 2023 00:00:00 +0000

停用 v2ex 账号的原因与经过。

母亲节·常回家看看

Sun, 14 May 2023 00:00:00 +0000

母亲节回家看望家人的温馨记录。

介绍我的新插件 gfr.vim

Sun, 07 May 2023 00:00:00 +0000

gfr.vim 插件介绍：集搜索、筛选、替换于一体的 Vim 插件。

将微信朋友圈移至静态网站

Thu, 04 May 2023 00:00:00 +0000

将微信朋友圈内容迁移至博客相册的过程分享。

五一假期·苏州一日游

Mon, 01 May 2023 00:00:00 +0000

毕业十三年后重返苏州大学的五一一日游记录。

《长空之王》观后感

Sun, 30 Apr 2023 00:00:00 +0000

电影《长空之王》观后感。

Neovim lua bindeval 解决方案

Mon, 03 Apr 2023 00:00:00 +0000

Neovim Lua bindeval 问题的解决方案。

《忠犬八公》观后感

Fri, 31 Mar 2023 00:00:00 +0000

电影《忠犬八公》观后感：忠诚与陪伴的故事。

《保你平安》观后感

Fri, 24 Mar 2023 00:00:00 +0000

电影《保你平安》观后感：网络谣言与人性的思考。

使用 Lua 重写 SpaceVim 内置插件

Sat, 22 Oct 2022 00:00:00 +0000

使用 Lua 重写 SpaceVim 内置插件的过程与速度对比。

使用 Vim 作为 SSH 客户端

Mon, 10 Oct 2022 00:00:00 +0000

使用 Vim/Neovim 作为 SSH 客户端连接远程服务器。

安装并设置 Shadowsocks

Fri, 03 Jun 2022 00:00:00 +0000

下载安装并配置 Shadowsocks 代理服务。

重新启用知乎账号

Fri, 20 May 2022 00:00:00 +0000

注销又重新启用知乎账号的经历。

想对微博说 FUCK

Tue, 17 May 2022 00:00:00 +0000

对微博随意封号行为的抗议与反思。

nvim-tree.lua 使用初体验

Mon, 09 May 2022 00:00:00 +0000

nvim-tree.lua 文件树插件的初次使用体验。

如何使用 SpaceVim 的 Job API

Tue, 03 May 2022 00:00:00 +0000

SpaceVim Job API 的使用方法，统一 Vim8 和 Neovim 的异步接口。

使用 Vim 作为聊天客户端

Mon, 02 May 2022 00:00:00 +0000

使用 Vim 作为聊天客户端，在终端中直接沟通。

下载安装winrar，并激活去广告

Sat, 19 Feb 2022 00:00:00 +0000

下载安装 WinRAR 并去除广告的方法。

在 SpaceVim 中启自动保存

Sun, 06 Feb 2022 00:00:00 +0000

在 SpaceVim 中启用自动保存功能的方法。

Window 7 下安装 nodejs

Sat, 02 Oct 2021 00:00:00 +0000

Windows 7 下安装指定版本 Node.js 的方法。

配置 zig 的 Vim 开发环境

Sun, 03 Jan 2021 00:00:00 +0000

配置 Vim/Neovim 的 Zig 语言开发环境。

字符串编辑距离算法

Tue, 24 Mar 2020 00:00:00 +0000

Rust 实现字符串编辑距离算法。

Rust 模块与项目文件组织

Sun, 22 Mar 2020 00:00:00 +0000

Rust 模块系统与项目文件组织方式详解。

Rust 读取标准输入

Tue, 17 Mar 2020 00:00:00 +0000

Rust 读取标准输入的方法与实践。

Rust 字符串算法

Sun, 15 Mar 2020 00:00:00 +0000

使用 Rust 解决字符串相关的算法问题。

Vim 字典补全插件

Sat, 14 Mar 2020 00:00:00 +0000

使用 Rust 编写 Vim 异步字典补全插件。

rust 格式化整理

Sat, 07 Mar 2020 00:00:00 +0000

Rust 格式化宏的使用方法整理。

开始学习 Rust

Sun, 01 Mar 2020 00:00:00 +0000

从零开始学习 Rust 编程语言的入门笔记。

从 Vim 切换至 SpaceVim 的细节

Thu, 20 Feb 2020 00:00:00 +0000

从原生 Vim 切换至 SpaceVim 的实用指南。

SpaceVim 下的异步任务系统

Fri, 14 Feb 2020 00:00:00 +0000

SpaceVim 异步任务系统的配置与使用。

心型脂肪酸结合蛋白（H-FABP）检测的临床意义

Thu, 22 Aug 2019 00:00:00 +0000

心型脂肪酸结合蛋白（H-FABP）在急性心肌梗死早期诊断中的临床意义。

右键使用 SpaceVim 打开文件

Wed, 07 Aug 2019 00:00:00 +0000

在 Windows 右键菜单中添加用 SpaceVim 打开文件。

使用 Vim 管理待办事项

Tue, 06 Aug 2019 00:00:00 +0000

使用 Vim 管理源码中的待办事项（TODO）。

如何学习并使用 SpaceVim

Mon, 05 Aug 2019 00:00:00 +0000

如何高效学习并使用 SpaceVim 的建议。

《波西米亚狂想曲》观后感

Wed, 27 Mar 2019 00:00:00 +0000

电影《波西米亚狂想曲》观后感：保持初心。

降钙素原检测的临床意义

Tue, 01 Jan 2019 00:00:00 +0000

降钙素原（PCT）检测在细菌感染诊断中的临床意义。

再见了，网易博客

Wed, 12 Dec 2018 00:00:00 +0000

告别网易博客，迁移至独立博客平台。

Ruby 模块和包

Wed, 10 Oct 2018 00:00:00 +0000

Ruby 模块和包详解：命名空间、Mixin 机制与 require 用法。

Ruby 代码块

Thu, 04 Oct 2018 00:00:00 +0000

Ruby 代码块详解：块声明、yield 语句与 BEGIN/END 块。

Ruby 函数

Sun, 30 Sep 2018 00:00:00 +0000

Ruby 函数详解：方法定义、参数传递与返回值。

Ruby 循环

Mon, 24 Sep 2018 00:00:00 +0000

Ruby 循环详解：while、until、for 及循环控制语句。

ruby 流程控制

Thu, 20 Sep 2018 00:00:00 +0000

Ruby 流程控制详解：if/else、case、unless 条件语句。

Ruby 运算符

Wed, 12 Sep 2018 00:00:00 +0000

Ruby 运算符详解：算术、比较、赋值、位运算等。

如何在 Vim 内进行高效的排序

Fri, 07 Sep 2018 00:00:00 +0000

Vim 内高效排序的方法：sort 函数与 sort 命令。

(Neo)Vim 插件开发指南

Fri, 31 Aug 2018 00:00:00 +0000

(Neo)Vim 插件开发完整指南。

如何配置 SpaceVim

Tue, 28 Aug 2018 00:00:00 +0000

SpaceVim 配置详解：选项设置、模块管理与自定义插件。

Ruby 数据类型

Wed, 15 Aug 2018 00:00:00 +0000

Ruby 数据类型详解：数值、字符串、范围、符号、数组与哈希。

Ruby 基本语法

Sun, 12 Aug 2018 00:00:00 +0000

Ruby 基本语法入门：空白、标识符、注释与 Here Document。

初识 Ruby 编程语言

Thu, 09 Aug 2018 00:00:00 +0000

初识 Ruby 编程语言：灵活的语法与代码块特性。

Vim 中文文档规范检查插件

Wed, 01 Aug 2018 00:00:00 +0000

chinese_linter.vim 插件：中文文档排版规范检查工具。

为什么要学习 Vim？

Sun, 25 Mar 2018 00:00:00 +0000

为什么要学习 Vim：从编辑器选择到效率提升的思考。

Vim 下多光标编辑 iedit 模式

Tue, 23 Jan 2018 00:00:00 +0000

Vim/Neovim 多光标编辑 iedit 模式介绍。

Vim 从入门到精通

Mon, 27 Mar 2017 00:00:00 +0000

Vim 从入门到精通的中文综合指南。

SpaceVim 第一个版本

Wed, 18 Jan 2017 00:00:00 +0000

SpaceVim 首个版本发布：社区驱动的 Vim 发行版。

在 Vim 中使用聊天工具

Fri, 30 Dec 2016 00:00:00 +0000

在 Vim 中集成聊天工具，在 I3-WM 桌面下实现即时通讯。

为什么要写博客

Wed, 24 Jun 2015 00:00:00 +0000

关于写博客的意义与坚持。

可爱的小天使

Mon, 25 May 2015 00:00:00 +0000

记录女儿出生的喜悦时刻。

不忘初心、方得始终

Sat, 12 Jul 2014 00:00:00 +0000

不忘初心方得始终：关于梦想与坚持的感悟。

强大的vim命令 :g 和 :s

Mon, 01 Jul 2013 00:00:00 +0000

Vim 全局替换命令 :g 和 :s 的强大用法。

欢迎来到 Racket

Tue, 19 Mar 2013 00:00:00 +0000

Racket 编程语言入门：Lisp 方言与 Scheme 派生。

使用 Windows Live Writer 发布博客

Fri, 20 May 2011 00:00:00 +0000

使用 Windows Live Writer 发布博客的体验。

大学毕业了

Wed, 30 Jun 2010 00:00:00 +0000

大学毕业回忆：从苏州大学走出的青春岁月。

模块化 vimrc 初体验

Wed, 01 Apr 2009 00:00:00 +0000

模块化管理 Vim 配置文件的思路与实践。

Lua 数据库访问

Fri, 20 Jun 2008 00:00:00 +0000

Lua 数据库访问库 LuaSQL 的使用方法。

Lua 面向对象

Sat, 14 Jun 2008 00:00:00 +0000

Lua 面向对象编程的实现方式。

Lua 垃圾回收

Thu, 12 Jun 2008 00:00:00 +0000

Lua 自动内存管理与垃圾回收机制详解。

Lua 调试(Debug)

Tue, 10 Jun 2008 00:00:00 +0000

Lua debug 库的使用方法与调试技巧。

Lua 异常处理

Fri, 30 May 2008 00:00:00 +0000

Lua 异常处理机制与错误类型详解。

Lua 文件 IO

Sat, 24 May 2008 00:00:00 +0000

Lua 文件 IO 操作：简单模式与完全模式。

Lua 协同程序(coroutine)

Tue, 20 May 2008 00:00:00 +0000

Lua 协同程序（coroutine）的概念与使用。

Lua 元表(Metatable)

Tue, 13 May 2008 00:00:00 +0000

Lua 元表（Metatable）的使用方法与元方法。

Lua 模块和包

Sat, 10 May 2008 00:00:00 +0000

Lua 模块和包的管理机制与使用方法。

Lua tables（表）

Mon, 28 Apr 2008 00:00:00 +0000

Lua table 数据结构详解：关联数组与多种数据类型。

Lua 迭代器

Sun, 20 Apr 2008 00:00:00 +0000

Lua 迭代器的概念与遍历集合的使用方法。

Lua 数组

Mon, 14 Apr 2008 00:00:00 +0000

Lua 数组的使用：一维与多维数组。

Lua 字符串

Tue, 08 Apr 2008 00:00:00 +0000

Lua 字符串的三种表示方式与常用操作。

Lua 运算符

Fri, 28 Mar 2008 00:00:00 +0000

Lua 运算符详解：算术、关系、逻辑及其他运算符。

Lua 函数

Thu, 20 Mar 2008 00:00:00 +0000

Lua 函数的定义、参数传递与多返回值。

Lua 流程控制

Thu, 13 Mar 2008 00:00:00 +0000

Lua 流程控制：条件语句与布尔值判断。

Lua 循环

Sun, 09 Mar 2008 00:00:00 +0000

Lua 循环语句：while、for、repeat-until 的使用。

Lua 数据类型

Wed, 13 Feb 2008 00:00:00 +0000

Lua 数据类型详解：8 种基本类型与动态类型特性。

Lua 基本语法

Sat, 09 Feb 2008 00:00:00 +0000

Lua 基本语法：交互式编程与脚本式编程入门。

学习 Lua 脚本语言

Sun, 03 Feb 2008 00:00:00 +0000

因魔兽世界插件开始学习 Lua 脚本语言的经历。

大学选修课《Java 编程》

Wed, 11 Oct 2006 00:00:00 +0000

大学选修 Java 编程课：从生物专业到编程的转折。

进入苏州大学的第一天

Mon, 21 Aug 2006 00:00:00 +0000

进入苏州大学第一天的入学回忆。

高中毕业了

Fri, 30 Jun 2006 00:00:00 +0000

高中毕业回忆：游戏与成长的青春岁月。

不要轻言放弃

Thu, 01 Sep 2005 00:00:00 +0000

不要轻言放弃：从荒废学业到重新振作的心路历程。

分班选生物还是化学

Wed, 01 Sep 2004 00:00:00 +0000

高中分班时在生物和化学之间的选择与思考。

Vim 环视和固化分组

Sun, 01 Aug 2004 00:00:00 +0000

Vim 正则表达式中的环视和固化分组用法。

最后一封信

Wed, 30 Jun 2004 00:00:00 +0000

高中分班前夕收到同学来信的意外与失落。

Lisp 编程语言相关知识

Tue, 01 Jul 2003 00:00:00 +0000

暑假学习 Lisp 编程语言的入门笔记。

过往的记忆

Mon, 30 Jun 2003 00:00:00 +0000

零碎旧时光记忆的合集，给过去画一个句号。