内存泄露相关

• valgrind

汇编反汇编相关

• objdump

debug相关

• gdb
• address2line

镜像、容器与仓库

通俗解释：镜像就类似操作系统光盘介质，容器相当于通过光盘安装后的系统。

• 通过光盘(镜像)，我们能在不同机器上部署系统(容器)，系统内的操作只会保留在当前的系统(容器)中，

• 如果要升级系统，需要使用到光盘(镜像)，但是可能会导致操作系统(容器)的数据丢失。

Shell调试的方法

Makefile学习记录

Secure Shell (SSH) 是一个网络协议，它主要被用来加密客户端和服务端之间的连接。 在客户端和服务端的每一次交互都被加密。

这个教程解释了如何在 Ubuntu 机器上启用 SSH。

启用 SSH 将会允许你远程连接到你的系统，并且执行管理员任务。你将能够通过 scp和sftp安全传输文件。

在 Ubuntu 上启用 SSH

默认情况下，当 Ubuntu 最初被安装的时候，通过 SSH 进行远程访问是不被允许的。在 Ubuntu 上启用 SSH 非常的简单直接。

以 root 或者其他 sudo 用户身份执行下面的步骤，在你的 Ubuntu 系统上安装并且启用 SSH。

01.使用Ctrl+Alt+T打开终端，并且安装openssh-server软件包：

1
2

sudo apt update
sudo apt install openssh-server

当被提示时，输入你的密码并且按 Enter，继续安装。

02.一旦安装完成，SSH 服务将会被自动启动。你可以验证 SSH 是否正在运行，输入：

1

sudo systemctl status ssh

输出将会告诉你服务正在运行，并且启用开机启动：

1
2
3
4

● ssh.service - OpenBSD Secure Shell server
    Loaded: loaded (/lib/systemd/system/ssh.service; enabled; vendor preset: enabled)
    Active: active (running) since Mon 2020-06-01 12:34:00 CEST; 9h ago
...

按q返回命令行。

03.Ubuntu 自带一个配置防火墙配置工具，称为 UFW。如果防火墙在你的系统上被启用，请确保打开了 SSH 端口：

1

sudo ufw allow ssh

就这些。现在你可以从任何远程机器上通过 SSH 连接到你的 Ubuntu 系统。Linux 和 macOS 系统默认都安装了 SSH 客户端。想要从一个 Window 机器上连接，使用一个 SSH 客户端，例如:PUTTY。

连接到 SSH 服务器

想要在局域网内连接到你的 Ubuntu 机器，以下面的格式输入 ssh 命令，加上用户名和 IP 地址。

1

ssh username@ip_address

1

确保你将`username`修改成你自己的用户名，`ip_address`修改成你安装了 SSH 的 Ubuntu 机器的 IP 地址。

如果你不知道你的 IP 地址，你可以使用ip命令轻易地找到它：

1

ip a

你可以从输出中看到，系统 IP 地址是10.0.2.15。

一旦你找到 IP 地址，通过运行下面的ssh 命令登录远程机器：

1

ssh linuxize@10.0.2.15

当你第一次连接时，你将看到下面的信息：

1
2
3

The authenticity of host '10.0.2.15 (10.0.2.15)' can't be established.
ECDSA key fingerprint is SHA256:Vybt22mVXuNuB5unE++yowF7lgA/9/2bLSiO3qmYWBY.
Are you sure you want to continue connecting (yes/no)?

输入yes并且你将会被提示输入你的密码：

1
2

Warning: Permanently added '10.0.2.15' (ECDSA) to the list of known hosts.
linuxize@10.0.2.15's password:

一旦你输入密码，你将会看到默认的 Ubuntu 消息：

1
2
3
4
5
6

Welcome to Ubuntu 20.04 LTS (GNU/Linux 5.4.0-26-generic x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage
...

现在你可以登录到你的 Ubuntu 机器上。

连接到 NAT 后面的 SSH

想要通过互联网连接到你的 Ubuntu 机器，你需要知道你的公网 IP 地址，并且配置你的路由器接收端口22的数据，并且发送它到正在运行 SSH 的 Ubuntu 机器。

想要获取你尝试通过 SSH 连接的机器的公网 IP，在这个机器上访问 URL 地址：https://api.ipify.org。

当设置端口转发时，每一个路由器都有不同的方式来设置端口转发。你应该参考你的路由器文档，关于如何设置端口转发的信息。简单来讲，你应该输入之前设置的 SSH 端口号 22，以及之前服务器的私有 IP 地址。

一旦你找到 IP 地址，配置你的路由器，输入：

1

ssh username@public_ip_address

如果你将你的机器暴露在互联网中，你最好采取一些安全措施。最基础的一个措施就是配置你的路由器接受一个非标准端口的 SSH 流量，并且转发到你运行 SSH 服务的机器的端口22。

你也可以设置 SSH 密钥公钥验证方式，之后你就可以不使用密码就可以连接到你的 Ubuntu 机器上了。

在 Ubuntu 上禁用 SSH

想要在你的 Ubuntu 系统上禁用 SSH 服务器，简单停止 SSH 即可，输入：

1

sudo systemctl disable --now ssh

稍后，你可以重新启用，输入：

1

sudo systemctl enable --now ssh

SSH登录

SSH 无密登录

step1 客户端生成公私钥

本地客户端生成公私钥：（一路回车默认即可）

1

ssh-keygen

生成之后会在用户的根目录生成一个 “.ssh”的文件夹，进入“.ssh”会生成如下几个文件：

1

cd ~/.ssh

下创建两个密钥：

1. authorized_keys: 存放远程免密登录的公钥,主要通过这个文件记录多台机器的公钥
2. id_rsa : 生成的私钥文件
3. id_rsa.pub ： 生成的公钥文件
4. know_hosts : 已知的主机公钥清单

ps

ssh公钥生效需满足至少下面两个条件：

• .ssh 目录的权限必须是700
• .ssh/authorized_keys 文件权限必须是600

step2 上传公钥到服务器

这里测试用的服务器地址为：192.168.32.32

用户为：root

方法1

1

ssh-copy-id -i ~/.ssh/id_rsa.pub <remote_ip>

上面这条命令是写到服务器上的ssh目录下去了

1
2

cd ~/.ssh
vim authorized_keys

可以看到客户端写入到服务器的 id_rsa.pub （公钥）内容。

方法2

使用命令ssh-copy-id <remote_ip>

1

ssh-copy-id root@192.168.32.32

方法3

通过scp将内容写到对方的authorized_keys文件中

1

scp -p ~/.ssh/id_rsa.pub root@<remote_ip>:/root/.ssh/authorized_keys

step3 测试免密登录

客户端通过ssh连接远程服务器，就可以免密登录了。

1

ssh root@192.168.32.32

设置指定用户

step1 配置SSH服务器

编辑SSH服务器配置文件（通常位于/etc/ssh/sshd_config）。

1

$ sudo vim /etc/ssh/sshd_config

确保以下行未注释（没有#）：

1
2

PubkeyAuthentication yes
PasswordAuthentication yes

这允许使用SSH密钥和密码进行身份验证。

step2 设置Match块

在配置文件的末尾添加Match块，限制只允许用户user1, user2, user3使用密钥登录。您可以这样做：

1
2

Match User user1,user2,user3
    PasswordAuthentication no

或

1
2
3
4
5
6
7
8

Match User user1
    PasswordAuthentication no

Match User user2
    PasswordAuthentication no

Match User user3
    PasswordAuthentication no

这将禁用user1,user2,user3用户的密码登录。其他用户将按照默认设置进行身份验证，允许密码登录。

多个用户也可以单独

step3 重启SSH服务

保存配置文件并重启SSH服务，以使更改生效：

1

$ sudo systemctl restart ssh

现在，user1,user2,user3用户只能使用其SSH密钥进行身份验证，而其他用户仍然可以使用密码进行身份验证。

请确保在执行此操作之前，您已经测试过SSH密钥对的工作方式，并且确保您至少有一种方法可以访问服务器，以防止自身被锁定。

SSH设置环境变量

方法1

在 ~/.ssh/config 中设置如下内容:

1
2

Host *
   SetEnv TERM=xterm-256color

它的作用是为所有主机（Host * 表示匹配所有主机）设置一个环境变量 TERM, 其值为 xterm-256color, 具体含义如下：

• Host *: 这是一个通配符规则，表示该配置适用于所有远程主机。 如果你只想针对特定主机应用配置，可以将 * 替换为主机名或 IP 地址。
• SetEnv TERM=xterm-256color : SetEnv 是 SSH 配置指令, 用于在连接到远程主机时传递环境变量. TERM=xterm-256color 设置了终端类型为 xterm-256color, 这是一种支持 256 色的终端模拟器类型。这对于需要彩色输出的程序（如 vim、tmux 等）非常重要。

TERM=xterm-256color 的是为了解决远程连接用户时, 键入字符错乱的问题

方法2

ssh 连接时, 使用命令行 -o 选项设置环境变量: ssh -o SetEnv="TERM=xterm-256color" user@hostname

SSH 上传下载

上传

上传本地文件到服务器

格式：scp 要上传的文件路径 用户名@服务器地址:服务器保存路径

例如：把本机 /home/test.txt 文件上传到 192.168.0.101 这台服务器上的 /data/ 目录中

1

scp /home/test.txt root@192.168.0.101:/data/

上传目录到服务器

格式：scp -r 要上传的目录 用户名@服务器地址:服务器的保存目录

例如：把 /home 目录上传到服务器的 /data/ 目录

1

scp -r /home root@192.168.0.101:/data/

下载

从服务器上下载文件

格式：scp 用户名@服务器地址:要下载的文件路径 保存文件的文件夹路径

例如：把 192.168.0.101 上的 /data/test.txt 的文件下载到 /home（本地目录）

1

scp root@192.168.0.101:/data/test.txt /home

从服务器下载整个目录

格式：scp -r 用户名@服务器地址:要下载的服务器目录 保存下载的目录

例如：把 192.168.0.101 上的 /data 目录下载到 /home（本地目录）

1

scp -r root@192.168.0.101:/data  /home/

注：目标服务器要开启写入权限。

访问服务器的 127.0.0.1:port

假设目标服务器的 ip 地址为: 192.168.32.32, port 为 8080

则在本地的浏览器地址栏输入: <ip>:<port>, 这里输入: 192.168.32.32:8080

设置特定用户的sshd_config

1
2

Match User <用户名>
	PasswordAuthentication yes

FAQ

ssh 连接 remote host identification has changed

找到.ssh目录，下面有一个known_hosts文件，删除 ~/.ssh/known_hosts 文件，或者如果你可以判断出known_hosts中原ssh服务器的公钥，删去那部分，

Double and random letters when typing on a SSH MacOS -> Ubuntu connection

见这里, 设置远程机器的 TERM 变量为 xterm-256color.

Win10 使用注册表一键添加小鹤双拼方案

方法1

新建.txt 文件

1
2
3

Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Microsoft\InputMethod\Settings\CHS]
"UserDefinedDoublePinyinScheme0"="小鹤双拼*2*^*iuvdjhcwfg^xmlnpbksqszxkrltvyovt"

方法2

1. win+r 输入 regedit, 打开注册表

2. 找到 计算机\HKEY_CURRENT_USER\Software\Microsoft\InputMethod\Settings\CHS 项

3. 新建字符串值

   名为 UserDefinedDoublePinyinScheme0

   值为 小鹤双拼*2*^*iuvdjhcwfg^xmlnpbksqszxkrltvyovt

按键映射

互换按键reg文件

交换 esc 和 caps lock 按键

1
2
3
4

Windows Registry Editor Version 5.00
 
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]
"Scancode Map"=hex:00,00,00,00,00,00,00,00,03,00,00,00,3a,00,01,00,01,00,3a,00,00,00,00,00

交换 ctrl 和 caps lock 按键

1
2
3
4

Windows Registry Editor Version 5.00
 
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]
"Scancode Map"=hex:00,00,00,00,00,00,00,00,03,00,00,00,3a,00,1d,00,1d,00,3a,00,00,00,00,00

取消互换按键

1
2
3
4

Windows Registry Editor Version 5.00
 
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]
"Scancode Map"=-

原理

在 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout\ 下新建一个二进制值项： “Scancode Map”

Scancode Map格式说明

1
2
3
4
5
6

00 00 00 00 00 00 00 00 (固定格式)
XX 00 00 00 (XX为修改的总键数+1的16进制数)
XX XX XX XX (修改后的按键扫描码 (在前) + 原按键的扫描码 (在后))
XX XX XX XX (另一个要替换的按键，同上)
......
00 00 00 00 (固定格式)

示例

1
2
3
4

0000 00 00 00 00 00 00 00 00 	
0008 04 00 00 00 1D 00 5B E0 
0010 1D E0 5C E0 5B E0 1D 00
0018 00 00 00 00 

1. 00 00 00 00 00 00 00 00: 固定，照写就好

2. 04 00 00 00: 04代表要修改三个按键的映射，两个是02，一个是01

3. 1D 00 5B E0

   • 1D 00 : 是修改后的按键扫描码；
   • 5B E0 : 是原按键的扫描码；

   左Ctrl键的扫描码是1D 00，左win键的扫描码5B E0；
   这四个字节代表的意思是将 左win键 替换成 左Ctrl键。

4. 1D E0 5C E0: 这四个字节代表的意思是将 右win键 替换成 右Ctrl键。

5. 5B E0 1D 00: 这四个字节代表的意思是将 左Ctrl键 替换成 左win键。

6. 00 00 00 00: 固定，照写就好

键位16进制对应表

office 365

Office 365 Professional Plus

• 简体中文版
• 繁体中文版
• English

Office 365 Home Premium

• 简体中文版
• 繁体中文版
• English

Office 365 Business

• 简体中文版
• 繁体中文版
• English

office 2021

Office ProPlus 2021

下载地址

Visio Pro 2021

下载地址

Project Pro 2021

下载地址

vagrant 安装

下载地址

• vagrant 官网地址

• vagrantbox

  • 官方文档

  • 下载地址

安装

1. 添加 box 到vagrant

   1	vagrant box add <box_name> <box_path>

   • <box_name>: 为 box 取的名字，供后续创建虚拟机
   • <box_path>: vagrantbox 所在地址

2. 查看是否添加成功

   1	vagrant box list

3. 创建虚拟机

   创建一个目录, 然后在该目录下执行以下命令

   1	vagrant init <box_name>

   会生成一个 Vagrantfile 文件

4. 修改 Vagrantfile 文件配置

5. 启动虚拟机

   1	vagrant up

6. 进入虚拟机

   1	vagrant ssh

   • 默认用户: vagrant
   • 用户密码: vagrant

7. 关闭虚拟机

   1	vagrant halt

PS:

• 每次启动虚拟机需要使用命令行（cmd）进入 Vagrantfile 文件所在的目录，然后再使用 vagrant up 命令启动虚拟机。
• 关机同理，使用命令行（cmd）进入 Vagrantfile 文件所在的目录，然后再使用 vagrant halt 命令关闭虚拟机。

virtualbox 安装

下载地址

• 官网下载地址

• c++依赖下载地址

  按需下载即可

安装教程

双击打开, 默认安装就可以

Ubuntu镜像地址

清华镜像站

fate 官方测试使用的版本为 18.04

vagrant 系统外部可访问

win10系统下的设置

step1. 设置防火墙入站规则

1. 进入windows 防火墙

2. 控制面板 -> 系统和安全 -> Windows Defender 防火墙 -> 高级设置 -> 入站规则 -> 文件和打印机共享(回显请求 - ICMPv4-In)

3. 右键属性 -> 作用域 -> 远程IP地址 -> 下列 IP 地址 -> 添加

4. 我使用的是 此IP地址或子网

   目的: 仅允许部分用户使用

   如添加: 10.132.0.0/16

测试是否成功配置

即查看是否可以 ping 通

step2. 设置 vagrantfile 为桥接网络

1. 查看名称或接口索引

   • 方法1

     1	netsh interface ipv4 show interfaces

     我的这里是 WLAN

   • 方法2 (未测试)

     1. 打开”控制面板”。您可以在开始菜单中搜索”控制面板”，然后选择相应的结果打开它。
     2. 在控制面板窗口中，将视图设置为”小图标”或”大图标”，以便更轻松找到所需的项目。
     3. 找到并点击”网络和共享中心”。
     4. 在左侧导航栏中，点击”更改适配器设置”，以打开网络连接设置。
     5. 在网络连接设置中，您将看到可用的网络适配器列表。查找您希望用作桥接网络的适配器，例如您的有线网卡或无线网卡。
     6. 右键单击所选适配器，并选择”属性”。
     7. 在适配器属性对话框中，找到并选中”Internet 协议版本 4 (TCP/IPv4)”，然后点击”属性”按钮。
     8. 在”Internet 协议版本 4 (TCP/IPv4) 属性”对话框中，您可以看到适配器的IP地址配置。请注意当前配置的详细信息，以便在后续步骤中进行参考。
     9. 在同一对话框中，点击”高级”按钮。
     10. 在”高级 TCP/IP 设置”对话框中，切换到”IP 设置”选项卡。
     11. 在”IP 设置”选项卡中，您将看到网卡的名称和接口索引。记下名称或接口索引，这将用于Vagrantfile中的网络配置。

2. 设置 config.vm.network "public_network", bright: "WLAN"

   bright: 就是上面的“查看名称或接口索引 ”

3. 启动/重启虚拟机: vagrant up/vagrant reload

4. 查看ip地址: ifconfig, 我这里的是 10.132.22.5

5. 设置Vigrant: config.vm.network "public_network", bright: "WLAN", ip: "10.132.22.5"

   也可以加入子网掩码, 如 config.vm.network "public_network", bridge: "WLAN", netmask: "255.255.0.0", ip: "10.132.22.5"

step3. 更改 vagrant 密码

passwd

或

1
2

sudo su
passwd vagrant

PS: 更多信息查看 Ubuntu 处理方法

FAQ

• 华硕主板打不开virtualbox虚拟机的ubuntu安装系统 (虚拟机VirtualBox异常退出解决办法)
• vagrant ssh 连接 remote host identification has changed
• 解决vagrant ssh登录时permission deny的问题

华硕主板打不开virtualbox虚拟机的ubuntu安装系统 (虚拟机VirtualBox异常退出解决办法)

vagrant 启动失败 There was an error while executing VBoxManage, a CLI used by Vagrant for controlli……

进入 BIOS 下, 开启 Intel (VMX) 虚拟化技术

vagrant ssh 连接 remote host identification has changed

找到.ssh目录，下面有一个known_hosts文件，删除 ~/.ssh/known_hosts 文件，或者如果你可以判断出known_hosts中原ssh服务器的公钥，删去那部分，

解决vagrant ssh登录时permission deny的问题

1. 进入虚拟机

   • 方法1: vagrant ssh

     在 Vagrantfile 文件夹下打开 cmd, 运行命令 vagrant ssh

   • 方法2: virtualbox

     打开 Vagrantfile 中的 virtualbox 显示

     1 2 3

     config.vm.provider "virtualbox" do |vb| vb.gui = true # 启动机器时显示 VirtualBox GUI end

     然后运行 vagrant up (虚拟机处于关机状态) 或 vagrant reload (虚拟机处于开机状态)

2. 更改 /etc/ssh/sshd_config 文件下的 PasswordAuthentication no 改为 PasswordAuthentication yes

3. 重启虚拟机 vagrant reload

不在一个小局域网，而在同一个大局域网

那就把局域网扩大一些, 可以通过设置子网掩码来设置

• 临时设置子网掩码

  1. 查看网络: ifconfig

     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

     enp0s3: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500 inet 10.0.2.15 netmask 255.255.255.0 broadcast 10.0.2.255 inet6 fe80::3b:7bff:feb7:3b2d prefixlen 64 scopeid 0x20<link> ether 02:3b:7b:b7:3b:2d txqueuelen 1000 (Ethernet) RX packets 523 bytes 61926 (61.9 KB) RX errors 0 dropped 0 overruns 0 frame 0 TX packets 387 bytes 70310 (70.3 KB) TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0 enp0s8: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500 inet 10.10.32.32 netmask 255.255.255.0 broadcast 10.10.32.255 inet6 240c:c983:5:2b48::813 prefixlen 128 scopeid 0x0<global> inet6 240c:c983:5:2b48:a00:27ff:feab:56e5 prefixlen 64 scopeid 0x0<global> inet6 fe80::a00:27ff:feab:56e5 prefixlen 64 scopeid 0x20<link> ether 08:00:27:ab:56:e5 txqueuelen 1000 (Ethernet) RX packets 1089 bytes 184808 (184.8 KB) RX errors 0 dropped 0 overruns 0 frame 0 TX packets 85 bytes 12017 (12.0 KB) TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0 lo: flags=73<UP,LOOPBACK,RUNNING> mtu 65536 inet 127.0.0.1 netmask 255.0.0.0 inet6 ::1 prefixlen 128 scopeid 0x10<host> loop txqueuelen 1000 (Local Loopback) RX packets 0 bytes 0 (0.0 B) RX errors 0 dropped 0 overruns 0 frame 0 TX packets 0 bytes 0 (0.0 B) TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

  2. 设置子网

     1	sudo ifconfig enp0s8 10.10.32.32 netmask 255.255.0.0

第22章 Vimrc

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

Vim如何找到Vimrc

对于Vimrc，常见的理解是在根目录下添加一个 .vimrc 点文件（根据您使用的操作系统，文件路径名可能不同）。

实际上，Vim在多个地方查找vimrc文件。下面是Vim检查的路径：

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

当您启动Vim时，它将在上面列出的6个位置按顺序检查vimrc文件，第一个被找到的vimrc文件将被加载，而其余的将被忽略。

首先，Vim将查找环境变量 $VIMINIT。如果没有找到，Vim将检查 $HOME/.vimrc。如果还没找到，VIm就检查 $HOME/.vim/vimrc。如果Vim找到了vimrc文件，它就停止查找，并使用 $HOME/.vim/vimrc。

关于第一个位置，$VIMINIT 是一个环境变量。默认情况下它是未定义的。如果您想将 ~/dotfiles/testvimrc 作为 $VIMINTI 的值，您可以创建一个包含那个vimrc路径的环境变量。当您运行 export VIMINIT='let $MYVIMRC="$HOME/dotfiles/testvimrc" | source $MYVIMRC'后，VIm将使用 ~/dotfiles/testvimrc 作为您的vimrc文件。

第二个位置，$HOME/.vimrc 是很多Vim用户习惯使用的路径。$HOME 大部分情况下是您的根目录（~）。如果您有一个 ~/.vimrc 文件，Vim将使用它作为您的vimrc文件。

第三个，$HOME/.vim/vimrc，位于 ~/.vim 目录中。您可能已经有了一个 ~/.vim 目录用于存放插件、自定义脚本、或视图文件。注意这里的vimrc文件名没有“点”（$HOME/.vim/.vimrc 不会被识别，但 $HOME/.vim/vimrc能被识别）。

第四个，$EXINIT 工作方式与 $VIMINIT 类似。

第五个，$HOME/.exrc 工作方式与 $HOME/.vimrc 类似。

第六个，$VIMRUNTIME/defaults.vim 是Vim编译时自带的默认vimrc文件。在我的电脑中，我是使用Homebrew安装的Vim8.2，所以我的路径是（/usr/local/share/vim/vim82）。如果Vim在前5个位置都没有找到vimrc文件，它将使用这个Vim自带的vimrc文件。

在本章剩余部分，我将假设vimrc使用的路径是 ~/.vimrc。

应该把什么放在Vimrc中？

我刚开始配置Vimrc时，曾问过一个问题，“我究竟该把什么放在Vimrc文件中？”。

答案是，“任何您想放的东西”。 直接复制粘贴别人的vimrc文件的确是一个诱惑，但您应当抵制这个诱惑。如果您仍然坚持使用别人的vimrc文件，确保您知道这个vimrc干了什么，为什么他/她要用这些设置？以及他/她如何使用这些设置？还有最重要的是，这个vimrc文件是否符合你的实际需要？别人使用并不代表您也要使用。

Vimrc基础内容

简单地说，一个vimrc是以下内容的集合：

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

当然还有一些上面没有提到的内容，但总体说，已经涵盖了绝大部分使用场景。

插件

在前面的章节中，我曾提到很多不同的插件，比如fzf.vim, vim-mundo, 还有 vim-fugitive.

十年前，管理插件插件是一个噩梦。但随着很多现代插件管理器的开发，现在安装插件可以在几秒内完成。我现在正在使用vim-plug作为我的插件管理器，所以我在本节中将使用它。相关概念和其他流行的插件管理器应该是类似的。我强烈建议您多试试几个插件管理器，比如：

• vundle.vim
• vim-pathogen
• dein.vim

除了上面列出的，还有很多插件管理器，可以随便看看。要想安装 vim-plug，如果您使用的是Unix，运行：

1

curl -fLo ~/.vim/autoload/plug.vim --create-dirs https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

要添加新的插件，将您的插件名(比如，Plug 'github-username/repository-name') 放置在 call plug#begin() 和 call plug#end() 之间的行中. 所以，如果您想安装 emmet-vim 和 nerdtree，将下面的片段放到您的vimrc中：

1
2
3
4

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

然后保存修改，加载当前vimrc (:source %), 然后运行 :PlugInstall 安装插件。

如果以后您想删除不使用的插件，您只需将插件名从 call 代码块之间移除，保存并加载，然后运行 :PlugClean 命令将它从机器上删除。

Vim 8 有自己的内置包管理器。您可以查阅 :h packages 了解更多信息。在后面一章中，我将向您展示如何使用它。

设置

在任意一个vimrc文件中都可以看到大量的 set 选项。 如果您在命令行模式中运行 set 命令，它只是暂时的。当您关闭Vim，设置就会丢失。比如，为了避免您每次运行Vim时都必须在命令行模式运行 :set relativenumber number 命令，您可以将这个命令添加在vimrc中：

1

set relativenumber number

有一些设置需要您赋予一个值，比如 set tabstop=2。想了解一个设置可以接收什么类型的值，可以查看帮助页。

您也可以使用 let 来代替 set（==确保在选项前添加一个 &号==）。使用 let ，您可以使用表达式进行赋值。比如，要想仅当某个路径存在时，才将该路径赋予 'dictionary' 选项：

1
2
3
4
5

let s:english_dict = "/usr/share/dict/words"

if filereadable(s:english_dict)
  let &dictionary=s:english_dict
endif

在后面的章节中您将了解关于Vimscript赋值和条件的知识。

要查看Vim中所有可用的选项，查阅 :h E355。

自定义函数

Vimrc是一个很好的用来放置自定义函数的地方。在后面的章节中您将学习如何写您自己的Vimscript函数。

自定义命令

您可以使用 command 创建一个自定义命令行命令。

比如，创建一个用于显示今天日期的基本命令 GimmeDate：

1

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

当您运行 :GimmeDate 时，Vim将显示一个类似 “2021-01-1”的日期。

要创建一个可以接收输入的基本命令，您可以使用 <args> 。如果您想向 GimmeDate 传递一个时间/日期格式参数：

1
2
3
4
5
6
7

:command! GimmeDate echo call("strftime", [<args>])

:GimmeDate "%F"
" 2020-01-01

:GimmeDate "%H:%M"
" 11:30

如果您想限定参数的数目，您可以使用 -nargs 标志。-nargs=0 表示没有参数，-nargs=1 表示传递1个参数，-nargs=+ 表示至少1个参数，-nargs=* 表示传递任意数量的参数，-nargs=? 表示传递0个或1个参数。如果您想传递n个参数，使用 -nargs=n（这里 n 是一个任意整数）。

<args> 有两个变体：<f-args> 和 <q-args> 。前者用来向Vimscript函数传递参数，后者用来将用户输入自动转换为字符串。

使用 args:

1
2
3
4
5
6

:command! -nargs=1 Hello echo "Hello " . <args>
:Hello "Iggy"
" returns 'Hello Iggy'

:Hello Iggy
" Undefined variable error

使用 q-args:

1
2
3

:command! -nargs=1 Hello echo "Hello " . <q-args>
:Hello Iggy
" returns 'Hello Iggy'

使用 f-args:

1
2
3
4
5
6
7
8

:function! PrintHello(person1, person2)
:  echo "Hello " . a:person1 . " and " . a:person2
:endfunction

:command! -nargs=* Hello call PrintHello(<f-args>)

:Hello Iggy1 Iggy2
" returns "Hello Iggy1 and Iggy2"

当您学了关于Vimscript函数的章节后，上面的函数将更有意义。

查阅 :h command 和 :args 了解更多关于command和args的信息。

键盘映射

如果您发现您重复地执行一些相同的复杂操作，那么为这些复杂操作建立一个键盘映射将会很有用：

比如，在我的vimrc文件中有2个键盘映射：

1
2
3

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

nnoremap <Leader>tn :call ToggleNumber()<CR>

在第一个中，我将 Ctrl-F 映射到 fzf.vim 插件的 :Gfiles 命令(快速搜索Git文件)上。在第二个中，我将 <leader>tn 映射到调用一个自定义函数 ToggleNumber （切换 norelativenumber 和 relativenumber 选项）。Ctrl-f 映射覆盖了Vim的原生的页面滚动。如果发生冲突，您的映射将会覆盖Vim的设置。因为从几乎从来不用Vim原生的页面滚动功能，所以我认为可以安全地覆盖它。

另外，在 <Leader>tn 中的 “leader” 键到底是什么?

Vim有一个leader键用来辅助键盘映射。比如，我将 <leader>tn 映射为运行 ToggleNumber() 函数。如果没有leader键，我可能会用 tn，但Vim中的 t 已经用做其他功能（”till”搜索导航命令）了。有了leader键，我现在先按定义好的leader键作为开头，然后按 tn，而不用干扰已经存在的命令。您可以设置leader键作为您映射的连续按键的第一个按键。默认Vim使用反斜杠作为leader键（所以 <Leader>tn 会变成 “反斜杠-t-n”）。

我个人喜欢使用空格 <Space> 作为leader键，代替默认的反斜杠。要想改变您的leader键，将下面的文本添加到您的vimrc中：

1

let mapleader = "\<space>"

上面的 nnoremap 命令可以分解为三个部分：

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

如果不想使用 nnoremap，您至少也得使用 nmap (nmap <silent> <C-f> :Gfiles<CR>)。但是，最好还是使用禁止递归的版本，这样是为了避免键盘映射时潜在的无限循环风险。

如果您进行键盘映射时不使用禁止递归，下面例子演示了会发生什么。假设您想给 B 添加一个键盘映射，用来在一行的末尾添加一个分号，然后跳回前一个词组（回想一下，B 是Vim普通模式的一个导航命令，用来跳回前一个词组)。

1

nmap B A;<esc>B

当您按下 B …哦豁，Vim开始失控了，开始无止尽的添加;（用 Ctrl-c终止）。为什么会发生这样的情况？因为在键盘映射 A;<esc>B中，这个 B不再是Vim原生的导航命令，它已经被映射到您刚才创建的键盘映射中了。这是您实际上执行的操作序列：

1

A;<esc>A;<esc>A;<esc>A;esc>...

要解决这个问题，您需要指定键盘映射禁止递归：

1

nnoremap B A;<esc>B

现在再按一下 B 试试。这一次它成功地在行尾添加了一个 ;，然后跳回到前一个词组。这个映射中的 B 就表示Vim原生的 B了。

Vim针对不同的模式有不同的键盘映射命令。如果您想创建一个插入模式下的键盘映射 jk，用来退出插入模式：

1

inoremap jk <esc>

其他模式的键盘映射命令有：map（普通、可视、选择、以及操作符等待模式）， vmap（可视、选择）， smap（选择）， xmap（可视）， omap（操作符等待模式）， map!（插入、命令行）， lmap（插入，命令行，Lang-arg模式）， cmap（命令行）， 还有tmap（终端任务）。在这里我不会详细的讲解它们，要了解更多信息，查阅 :h map.txt。

创建最直观、最一致、最易于记忆的键盘映射。

组织管理Vimrc

一段时候键，您的vimrc文件就会变大且复杂得难以阅读。有两种方法让您的vimrc文件保持整洁：

• 将您的vimrc文件划分为几个文件
• 折叠您的vimrc文件

划分您的vimrc

您可以使用Vim的 :source 命令将您的vimrc文件划分为多个文件。这个命令可以根据给定的文件参数，读取文件中的命令行命令。

让我们在 ~/.vim 下创建一个子文件夹，取名为 /settings（~/.vim/settings）。名字可以取为任意您喜欢的名字。

然后你在这个文件夹下创建4个文件：

• 第三方插件 (~/.vim/settings/plugins.vim).
• 通用设置 (~/.vim/settings/configs.vim).
• 自定义函数 (~/.vim/settings/functions.vim).
• 键盘映射 (~/.vim/settings/mappings.vim) .

在 ~/.vimrc 里面添加:

1
2
3
4

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

在 ~/.vim/settings/plugins.vim 里面:

1
2
3
4

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

在 ~/.vim/settings/configs.vim 里面:

1
2
3

set nocompatible
set relativenumber
set number

在 ~/.vim/settings/functions.vim 里面:

1
2
3
4
5
6
7

function! ToggleNumber()
  if(&relativenumber == 1)
    set norelativenumber
  else
    set relativenumber
  endif
endfunc

在 ~/.vim/settings/mappings.vim 里面:

1
2
3

inoremap jk <esc>
nnoremap <silent> <C-f> :GFiles<CR>
nnoremap <Leader>tn :call ToggleNumber()<CR>

这样您的vimrc文件依然能够正常工作，但现在它只有4行了。

使用这样的设置，您可以轻易知道到哪去修改配置。如果您要添加一些键盘映射，就将它们添加在 /mappings.vim 文件中。以后，当您的vimrc变大时，您总是可以新建几个子文件来缩小它的大小。比如，如果您想为主题配色创建相关设置，您可以添加 ~/.vim/settings/themes.vim。

保持单独的一个Vimrc文件

如果您倾向于保持一个单独的vimrc文件，以使它更加便于携带，您可以使用标志折叠让它保持有序。在vimrc文件的顶部添加一下内容：

1
2
3
4
5
6

" setup folds {{{
augroup filetype_vim
  autocmd!
  autocmd FileType vim setlocal foldmethod=marker
augroup END
" }}}

Vim能够检测当前buffer所属的文件类型 (:set filetype?). 如果发现属于 vim 类型，您可以使用标志折叠。回想一个标志折叠的用法，它使用 {{{` 和 `}}} 来指明折叠的开始和结束。

添加 {{{` 和 `}}} 标志将您的vimrc文件其他部分折叠起来。(别忘了使用 " 对标志进行注释):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

" setup folds {{{
augroup filetype_vim
  autocmd!
  autocmd FileType vim setlocal foldmethod=marker
augroup END
" }}}

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

" configs {{{
set nocompatible
set relativenumber
set number
" }}}

" functions {{{
function! ToggleNumber()
  if(&relativenumber == 1)
    set norelativenumber
  else
    set relativenumber
  endif
endfunc
" }}}

" mappings {{{
inoremap jk <esc>
nnoremap <silent> <C-f> :GFiles<CR>
nnoremap <Leader>tn :call ToggleNumber()<CR>
" }}}

您的vimrc文件将会看起来类似下面：

1
2
3
4
5
6
7
8
9

+-- 6 lines: setup folds -----

+-- 6 lines: plugins ---------

+-- 5 lines: configs ---------

+-- 9 lines: functions -------

+-- 5 lines: mappings --------

启动Vim时加载/不加载Vimrc和插件

如果您要启动Vim时，既不加载Vimrc，也不加载插件，运行：

1

vim -u NONE

如果您要启动Vim时，不加载Vimrc，但加载插件，运行：

1

vim -u NORC

如果您要启动Vim时，加载Vimrc，但不加载插件，运行

1

vim --noplugin

如果您要Vim启动加载一个 其他的 vimrc, 比如 ~/.vimrc-backup, 运行:

1

vim -u ~/.vimrc-backup

聪明地配置Vimrc

Vimrc是定制Vim时的一个重要组件，学习构建您的Vimrc最好是首先阅读他人的vimrc文件，然后逐渐地建立自己的。最好的vimrc并不是谁谁谁使用的，而是最适合您的工作需要和编辑风格的。

第23章 Vim软件包

在前面的章节中，我提到使用第三方插件管理器来安装插件。从Vim 8开始，Vim自带了一个内置的插件管理器，名叫 软件包（packages）。在本章，您将学习如何使用Vim软件包来安装插件。

要看您的Vim编译版本是否能够使用软件包，运行 :version。然后查看是否有 +packages属性。另外，您也可以运行 :echo has('packages')（如果返回1，表示可以使用软件包）。

包目录

在根目录下查看您是否有一个 ~/.vim 文件夹。如果没有就新建一个。在文件夹里面，创建一个子文件夹取名 pack(~/.vim/pack/)。Vim会在这个子文件夹内自动搜索插件。

两种加载方式

Vim软件包有两种加载机制：自动加载和手动加载。

自动加载

要想让Vim启动时自动加载插件，你需要将它们放置在 start/子目录中。路径看起来像这样：

1

~/.vim/pack/*/start/

现在您可能会问，为什么在pack/ 和 start/ 之间有一个 * ？这个星号可以是任意名字。让我们将它取为packdemo/：

1

~/.vim/pack/packdemo/start/

记住，如果您忽略这一点，用下面的路径代替的话：

1

~/.vim/pack/start/

软件包系统是不会正常工作的。 必须在pack/ 和 start/之间添加一个名字才能正常运行。

在这个示例中，让我们尝试安装 [NERDTree](https://github.com/preservim/nThe package system won’t work. It is imperative to put a name between pack/ and start/.erdtree) 插件。用任意方法进入 start/ 目录（cd ~/.vim/pack/packdemo/start/），然后将NERDTree的仓库克隆下来：

1

git clone https://github.com/preservim/nerdtree.git

完成了！您已经完成了安装。下一次您启动Vim，您可以立即执行 NERDTree 命令 :NERDTreeToggle。

在 ~/.vim/pack/*/start/ 目录中，您想克隆多少插件仓库就克隆多少。Vim将会自动加载每一个插件。如果您删除了克隆的仓库（rm -rf nerdtree），那么插件就失效了。

手动加载

要想在Vim启动时手动加载插件，您得将相关插件放置在 opt/ 目录中，类似于自动加载，这个路径看起来像这样：

1

~/.vim/pack/*/opt/

让我们继续使用前面的 packdemo/ 这个名字：

1

~/.vim/pack/packdemo/opt/

这一次，让我们安装killersheep 游戏（需要Vim8.2以上版本）。进入opt/ 目录(cd ~/.vim/pack/packdemo/opt/) 然后克隆仓库：

1

git clone https://github.com/vim/killersheep.git

启动Vim。执行游戏的命令是 :KillKillKill。试着运行一下。Vim将会提示这不是一个有效的编辑命令。您需要首先 手动 加载插件，运行：

1

:packadd killersheep

现在再运行一下 :KillKillKill 。命令已经可以使用了。

您可能好奇，“为什么我需要手动加载插件？启动时自动加载岂不是更好？”

很好的问题。有时候有些插件我们并不是所有的时候都在用，比如 KillerSheep 游戏。您可能不会想要加载10个不同的游戏导致Vim启动变慢。但是偶尔当您觉得乏味的时候，您可能想要玩几个游戏，使用手动加载一些非必须的插件。

您也可以使用这个方法有条件的加载插件。可能您同时使用了Neovim和Vim，有一些插件是为NeoVim优化过的。您可以添加类似下列的内容到您的vimrc中：

1
2
3
4
5

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

组织管理软件包

回想一下，要使用Vim的软件包系统必须有以下需求：

1

~/.vim/pack/*/start/

或者:

1

~/.vim/pack/*/opt/

实际上，*星号可以使 任意 名字，这个名字就可以用来管理您的插件。假设您想将您的插件根据类型（颜色、语法、游戏）分组：

1
2
3

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

您仍然可以使用各个目录下的 start/ 和 opt/ 。

1
2
3
4
5
6
7
8

~/.vim/pack/colors/start/
~/.vim/pack/colors/opt/

~/.vim/pack/syntax/start/
~/.vim/pack/syntax/opt/

~/.vim/pack/games/start/
~/.vim/pack/games/opt/

聪明地添加插件

您可能好奇，Vim软件包是否让一些流行的插件管理器，比如 vim-pathogen, vundle.vim, dein.vim, a还有vim-plug面临淘汰？

答案永远是：“看情况而定。”

我仍然使用vim-plug，因为使用它添加、删除、更新插件很容易。如果您使用了很多插件，插件管理器的好处更加明显，因为使用它可以对很多插件进行同时更新。有些插件管理器同时也提供了一些异步功能。

如果您是极简主义者，可以尝试一下Vim软件包。如果您是一名插件重度使用者，您可能需要一个插件管理器。

第24章 Vim Runtime

在前面的章节中，我提到Vim会自动查找一些特殊的路径，比如在~/.vim/ 中的 pack/(第23章) compiler/（第19章）。这些都是Vim runtime路径的例子。

除了上面提到的两个，Vim还有更多runtime路径。在本章，您将学习关于Vim runtime路径的高层次概述。本章的目标是向您展示它们什么时候被调用。知道这些知识能够帮您更进一步理解和定制Vim。

Runtime路径

在一台Unix机器中，其中一个vim runtime路径就是 $HOME/.vim/ （如果您用的是其他操作系统，比如Windows，您的路径可能有所不同）。要查看不同的操作系统有什么样的runtime路径，查阅 :h runtimepath。在本章，我将使用 ~/.vim/ 作为默认的runtime路径。

Plugin脚本

Vim有一个runtime路径 plugin，每次Vim启动时都会执行这个路径中的所有脚本。不要把这个名字 “plugin” 和Vim的外部插件（external plugins，比如NERDTree, fzf.vim, 等)搞混了。

进入 ~/.vim/ 目录，然后创建 plugin/ 子目录。 创建两个文件： donut.vim 和 chocolate.vim。

在 ~/.vim/plugin/donut.vim里面:

1

echo "donut!"

在 ~/.vim/plugin/chocolate.vim里面:

1

echo "chocolate!"

现在关闭Vim。下次您启动Vim，您将会看到 "donut!" 和 :chocolate! 的显示。此 plugin runtime路径可以用来执行一些初始化脚本。

文件类型检测

在开始之前，为保证检测能正常运行，确保在您的vimrc中至少包含了下列的行：

1

filetype plugin indent on

查阅 :h filetype-overview 了解更多信息。本质上，这条代码开启Vim的文件类型检测。

当您打开一个新的文件，Vim通常知道这个文件是什么类型。如果您有一个文件 hello.rb，运行 :set filetype? 会返回正确的相应 filetype=ruby。

Vim知道如何检测 “常见” 的文件类型（Ruby, Python, Javascript, 等）。但如果是一个自定义文件会怎样呢？您需要告诉Vim去检测它，并给它指派一个正确的文件类型。

有两种检测方法：使用文件名和使用文件内容

文件名检测

文件名检测使用一个文件的文件名来检测文件类型。当您打开 hello.rb文件时，Vim依靠扩展名 .rb 知道它是一个Ruby文件。

有两种方法实现文件名检测：一是使用 ftdetect runtime目录，二是使用 filetype.vim runtime文件。我们两个都看一看。

ftdetect/

让我们创建一个古怪（但优雅）的名字，hello.chocodonut。当您打开它后运行 :set filetype? ，因为它的后缀名不是常见的文件名，Vim不知道它是什么类型，会返回 filetype=。

您需要指示Vim将所有以 .chocodonut结尾的文件设置为 “chocodonut”类型的文件。在runtime路径根目录(~/.vim/)创建一个子目录，名为 ftdetect/ 。在子目录里面，再创建一个名叫 chocodonut.vim 的文件（~/.vim/ftdetect/chocodonut.vim），在文件里面，添加：

1

autocmd BufNewFile,BufRead *.chocodonut set filetype=chocodonut

当您创建新buffer或打开新buffer时，事件BufNewFile 和 BufRead 就会被触发。 *.chocodonut 意思是只有当新打开的buffer文件名后缀是 .chocodonut 时事件才会被触发。最后，set filetype=chocodonut 命令将文件类型设置为chocodonut类型。

重启Vim。新建一个 hello.chocodonut 文件然后运行 :set filetype?。它将返回 filetype=chocodonut.

好极了！只要您想，您可以将任意多的文件放置在 ftdetect/ 中。以后，如果您想扩展您的 donut 文件类型，你可以添加 ftdetect/strawberrydonut.vim, ftdetect/plaindonut.vim 等等。

在Vim中，实际上有两种方法设置文件类型。其中给一个是您刚刚使用的 set filetype=chocodonut。另一种方法是运行 setfiletype chocodonut。前一个命令 set filetype=chocodonut 将 总是 设置文件类型为chocodonut。 而后者setfiletype chocodonut只有当文件类型尚未设置时，才会将文件类型设置为chocodonut。

文件类型文件

第二种文件类型检测需要你创建一个名为 filetype.vim的文件，并将它放置在根目录(~/.vim/filetype.vim)。在文件内添加一下内容：

1

autocmd BufNewFile,BufRead *.plaindonut set filetype=plaindonut

创建一个名为 hello.plaindonut 的文件。当你打开它后运行 :set filetype? Vim会显示正确的自定义文件类型 filetype=plaindonut。

太好了，修改生效了。另外，如果您仔细看看 filetype.vim ，您会发现当您打开hello.plaindonut时，这个文件文件运行了多次。为防止这一点，您可以添加一个守卫，让主脚本只运行一次。更新 filetype.vim:

1
2
3
4
5
6
7

if exists("did_load_filetypes")
  finish
endif

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

finish 是一个Vim命令，用来停止执行剩余的脚本。表达式"did_load_filetypes" 并 不是 一个Vim内置函数。它实际上是$VIMRUNTIME/filetype.vim 中的一个全局变量。如果您好奇，运行:e $VIMRUNTIME/filetype.vim。您将会发现以下内容：

1
2
3
4
5

if exists("did_load_filetypes")
  finish
endif

let did_load_filetypes = 1

当Vim调用这个文件时，它会定义 did_load_filetypes 变量，并将它设置为 1 。在Vim中，1 表示真。你可以试着读完 filetype.vim 剩余的内容，看看您是否能够理解当Vim调用它时干了什么。

文件类型脚本

让我们学习如何基于文件内容检测文件类型。

假设您有一个无扩展名的文件的集合。这些文件唯一相同的地方是，第一行都是以 “donutify” 开头。您现在想给这些文件指派一个 donut 的文件类型。创建新文件，起名为 sugardonut, glazeddonut, 还有 frieddonut（没有扩展名）。在每个文件中，添加下列内容：

1

donutify

当您在sugardonut中运行 :set filetype?，Vim无法知道应该给这个文件指派什么文件类型，会返回 filetype=。

在runtime根目录，添加一个 scripts.vim 文件(~/.vim/scripts.vim)，在文件中，添加一下内容：

1
2
3
4
5
6
7

if did_filetype()
  finish
endif

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

函数 getline(1) 返回文件第一行的内容。它检查第一行是否以 “donutify” 开头。函数 did_filetype() 是Vim的内置函数，当一个与文件类型相关的事件发生至少一次时，它返回真。它用来做守卫，防止文件类型事件反复运行。

打开文件 sugardonut 然后运行 :set filetype?，Vim现在返回 filetype=donut。如果您打开另外一个donut文件 (glazeddonut 和 frieddonut)，Vim同样会将它们的文件类型定义为 donut 类型。

注意，scripts.vim 仅当Vim打开一个未知文件类型的文件时才会运行。如果Vim打开一个已知文件类型的文件，scripts.vim 将不会运行。

文件类型插件

如果您想让Vim仅当您打开一个 chocodonut 文件时才运行 chocodonut 相关的特殊脚本，而当您打开的是 plaindonut 文件时，Vim就不运行这些脚本。能否做到呢？

您可以使用文件类型插件runtime路径(~/.vim/ftplugin/)来完成这个功能。Vim会在这个目录中查找一个文件，这个文件的文件名与您打开的文件类型一样。创建一个文件，起名为chocodonut.vim (~/.vim/ftplugin/chocodonut.vim):

1

echo "Calling from chocodonut ftplugin"

创建另一个 ftplugin 文件，起名为plaindonut.vim (~/.vim/ftplugin/plaindonut.vim):

1

echo "Calling from plaindonut ftplugin"

现在，每次您打开一个 chocodonut 类型的文件时，Vim会运行 ~/.vim/ftplugin/chocodonut.vim中的脚本。每次您打开 plaindonut 类型的文件时，Vim会运行 ~/.vim/ftplugin/plaindonut.vim 中的脚本。

一个警告：每当一个buffer的文件类型被设置时(比如，set filetype=chocodonut)，上述脚本就会运行一次。如果您打开3个不同的 chocodonut 文件，该脚本将运行 总共 3次。

缩进文件

Vim有一个 缩进runtime路径，其工作方式与ftplugin类似，Vim也会在这个目录中查找一个与打开的文件类型名字一样的文件。缩进runtime路径的目的是存储缩进相关的代码。如果您有文件 ~/.vim/indent/chocodonut.vim，它仅当您打开一个 chocodonut 类型的文件时执行。您可以将 chocodonut 文件中缩进相关的代码存储在这里。

颜色

Vim 有一个颜色runtime路径 (~/.vim/colors/) ，用来存储颜色主题。这个目录中的任何文件都会在命令行命令 :color 中显示出来。

如果您有一个文件 ~/.vim/colors/beautifulprettycolors.vim，当您运行 :color 然后按 Tab，您将会看到 beautifulprettycolors 出现在颜色选项中。 如果您想添加自己的颜色主题，就放在这个地方。

如果您想看其他人做的颜色主题，有一个好地方值得推荐：vimcolors。

语法高亮

Vim有一个语法runtime路径 (~/.vim/syntax/)，用来定义语法高亮。

假设您有一个文件 hello.chocodonut，在文件里面有以下内容：

1
2

(donut "tasty")
(donut "savory")

虽然Vim现在知道了正确的文件类型，但所有的文本都是相同的颜色。让我们添加语法高亮规则，使 “donut” 关键词高亮显示。创建一个新的 chocodonut 语法文件 ~/.vim/syntax/chocodonut.vim，在文件中添加：

1
2
3

syntax keyword donutKeyword donut

highlight link donutKeyword Keyword

现在重新打开 hello.chocodonut 文件，关键词 donut 已经高亮显示了。

本章不会详细介绍语法高亮。它是一个庞大的主题。如果您感兴趣，可以查阅 :h syntax.txt。

vim-polyglot 插件非常的棒，它提供了很多流行的编程语言的语法高亮。

文档

如果您写了一个插件，您还得创建一个您自己的文档。您可以使用文档runtime路径完成这个。

让我们为 chocodonut 和 plaindonut 关键字创建一个基本文档。创建文件 donut.txt (~/.vim/doc/donut.txt)。在文件中，添加一下内容：

1
2
3

*chocodonut* Delicious chocolate donut

*plaindonut* No choco goodness but still delicious nonetheless

如果您试着搜索 chocodonut 或 plaindonut (:h chocodonut 或 :h plaindonut)，您找不到任何东西。

首先，你需要运行 :helptags来创建新的帮助入口。运行 :helptags ~/.vim/doc/

现在，如果您运行 :h chocodonut 或 :h plaindonut，您将找到上面那些新的帮助入口。注意，现在文件是只读的，而且类型是 “help”。

延时加载脚本

到现在，本章您学到的所有runtime路径都是自动运行的。如果您想手动加载一个脚本，可使用 autoload runtime路径。

创建一个目录名为 autoload(~/.vim/autoload/)。在目录中，创建一个新文件，起名为 tasty.vim (~/.vim/autoload/tasty.vim)。在文件中：

1
2
3
4
5

echo "tasty.vim global"

function tasty#donut()
  echo "tasty#donut"
endfunction

注意，函数名是 tasty#donut 而不是 donut()。要想使用autoload功能，井号(#)是必须的。在使用autoload功能时，函数的命名惯例是：

1
2
3

function fileName#functionName()
  ...
endfunction

在本例中，文件名是 tasty.vim，而函数名是donut。

要调用一个函数，可以使用 call 命令。让我们call这个函数 :call tasty#donut()。

您第一次调用这个函数时，您应当会 同时 看到两条信息 (“tasty.vim global” 和 “tasty#donut”) 。后面再调用 tasty#donut 函数，将只会显示 “testy#donut”。

当您在Vim中打开一个文件，不像前面说的runtime路径，autoload脚本不会被自动加载。仅当您显式地调用 tasty#donut()，Vim才会查找文件tasty.vim，然后加载文件中的内容，包括函数 tasty#donut()。有些函数会占用大量资源，但我们又不常用，这时候 Autoload runtime路径就是最佳的解决方案。

您可以在autoload目录任意添加嵌套的目录。如果您有一个runtime路径 ~/.vim/autoload/one/two/three/tasty.vim，您可以使用:call one#two#three#tasty#donut()来调用函数。

After脚本

Vim有一个 after runtime路径 (~/.vim/after/) ，它的结构是 ~/.vim/的镜像。在此目录中的任何脚本都会最后执行，所以开发者通常使用这个路径来重载脚本。

比如，如果您想重载 plugin/chocolate.vim 中的脚本，您可以创建~/.vim/after/plugin/chocolate.vim来放置重载脚本。Vim将会先运行 ~/.vim/plugin/chocolate.vim， 然后运行 ~/.vim/after/plugin/chocolate.vim

$VIMRUNTIME

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

它的结构应该看起来很熟悉。它包含的很多runtime路径都是我们本章前面学过的。

回想第22章，当您打开Vim时，它会在6个不同的位置查找vimrc文件。当时我说最后一个位置就是 $VIMRUNTIME/default.vim，如果Vim在前5个位置查找用户vimrc文件失败，就会使用default.vim 作为vimrc。

不知您是否尝试过，运行Vim是不加载比如vim-polyglot之类的语法插件，但您的文件依然有语法高亮?这是因为当Vim在runtime路径查找语法文件失败时，会从$VIMRUNTIME 的语法目录中查找语法文件。

查阅 :h $VIMRUNTIME了解更多信息。

Runtimepath选项

运行 :set runtimepath?，可以查看您的runtime路径。

如果您使用 Vim-Plug 或其他流行的第三方插件管理器，它应该会显示一个目录列表。比如，我的显示如下：

1

runtimepath=~/.vim,~/.vim/plugged/vim-signify,~/.vim/plugged/base16-vim,~/.vim/plugged/fzf.vim,~/.vim/plugged/fzf,~/.vim/plugged/vim-gutentags,~/.vim/plugged/tcomment_vim,~/.vim/plugged/emmet-vim,~/.vim/plugged/vim-fugitive,~/.vim/plugged/vim-sensible,~/.vim/plugged/lightline.vim, ...

插件管理器做了一件事，就是将每个插件添加到runtime路径中。每个runtime路径都有一个类似 ~/.vim/的目录结构。

如果您有一个目录 ~/box/of/donuts/，然后您想将这个目录添加到您的runtime路径中，您可以在vimrc中添加以下内容：

1

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

如果在 ~/box/of/donuts/ 里面，您有一个plugin目录 (~/box/of/donuts/plugin/hello.vim) 以及ftplugin目录 (~/box/of/donuts/ftplugin/chocodonut.vim)，当您打开Vim时，Vim将会运行 plugin/hello.vim 中所有脚本。同样，当您打开一个 chocodonut 文件时，Vim 将会运行 ftplugin/chocodonut.vim。

自己试着做一下：创建一个任意目录，然后将它添加到您的 runtimepath中。添加一些我们本章学到的runtime路径。确保它们按预期工作。

聪明地学习Runtime

花点时间阅读本章，还有认真研究一下这些runtime路径。看一下真实环境下runtime路径是如何使用的。浏览一下您最喜欢的Vim插件仓库，仔细研究一下它的目录结构，您应该能够理解它们中的绝大部分。试着领会重点并跟着做。现在您已经理解了Vim的目录结构，您可以准备学习Vimscript了。

第25章 Vimscript 基础和数据类型

Ex 模式

技术上来说，Vim 没有内置的交互式解释器 (REPL)，但是有一个 Ex 模式，可以使 vim 像使用 REPL 一样、Ex 模式更现实命令行模式的拓展，即非停止的命令行模式

进入EX模式的方法：

• Q
• gQ

退出Ex模式

• 输入: :visual

echo

类似于 python 的 print()

echom: 和 echo 相同， 不同支出在于 echom 会将结果保存到 message 历史记录中

• 查看 message 历史记录

  :messages

• 清空 mwssage 历史记录

  :message clear

数字

模式指的是==十进制==数字

十进制 Decimal

1, -1, -10

十六进制 Hexadecimal

以 0x 或 oX 开头

二进制 Binary

以 0b 或 0B 开头

八进制 Octal

以 0, 0o 或 0O 开头

真假值

• 真：非0
• 假：0

数值运算

同 C++ 的数值运算

字符串

使用 双引号("") 或 单引号('') 包裹起来

字符串连接

使用 . 连接字符串

1

:echo "Hello" . "world"

字符串算数

当使用数字和字符串使用运算符 + - * / 进行算数运算时，vim会将字符串转化为数字

1

:echo "12 donuts" + 3

也可以是字符串与字符串进行数值计算

1

:echo "12 donuts" * "6 pastries"

要求：

• 数字字符必须是字符串的第一个字符

注意

• 当使用浮点型进行运算时，将被转化成整数

数字与字符串连接

使用 . 运算符

注意

• 不适用于浮点数

字符串作为条件时

• 真：第一个字符为数字
• 假：第一个字符不为数字

单引号与双引号

• 单引号只会输出字面值
• 双引号可以接受特殊字符，如: \n, \"

内置字符串程序

getline(): 获取传入行号的文本

列表

类似于 Python 的列表，类型可以混合在一起

子列表

获取单个值

同 Python 的索引，类似于list[n]

切片

• list[n:m] 获取 list 列表中的索引号 n 到 m 的元素 （包括m）
• list[n:]: n到末尾
• list[:m]: 从头到m

注: 若 m > list 的长度，那么就是获取 m 到末尾的元素

切片字符串

同list

数值运算

使用 +: 连接两个劫镖

函数

1
2
3
4
5
6
7
8
9

:let sweeterList = ["glazed", "chocolate", "strawberry"]
:call filter(sweeterList, 'v:val !~ "choco"')
:echo sweeterList
" returns ["glazed", "strawberry"]

:let sweetestList = ["chocolate", "glazed", "sugar"]
:call map(sweetestList, 'v:val . " donut"')
:echo sweetestList
" returns ['chocolate donut', 'glazed donut', 'sugar donut']

解包

像python

1
2
3
4
5
6
7
8

:let favoriteFlavor = ["chocolate", "glazed", "plain"]
:let [flavor1, flavor2, flavor3] = favoriteFlavor

:echo flavor1
" returns "chocolate"

:echo flavor2
" returns "glazed"

使用 ; 分配剩余的元素

1
2
3
4
5
6
7
8

:let favoriteFruits = ["apple", "banana", "lemon", "blueberry", "raspberry"]
:let [fruit1, fruit2; restFruits] = favoriteFruits

:echo fruit1
" returns "apple"

:echo restFruits
" returns ['lemon', 'blueberry', 'raspberry']

修改列表

修改一项

1
2
3
4

:let favoriteFlavor = ["chocolate", "glazed", "plain"]
:let favoriteFlavor[0] = "sugar"
:echo favoriteFlavor
" returns ['sugar', 'glazed', 'plain']

修改多项

1
2
3
4

:let favoriteFlavor = ["chocolate", "glazed", "plain"]
:let favoriteFlavor[2:] = ["strawberry", "chocolate"]
:echo favoriteFlavor
" returns ['chocolate', 'glazed', 'strawberry', 'chocolate']

字典

类似于 python

==区别==在于 vim 只使用字符串为“键”，即使使用数字，也会将数字转化为字符串

偷懒方法

使用 #{} 来表示

1
2
3
4

:let mealPlans = #{breakfast: "waffles", lunch: "pancakes", dinner: "donuts"}

:echo mealPlans
" returns {'lunch': 'pancakes', 'breakfast': 'waffles', 'dinner': 'donuts'}

要求

“键”的字符必须满足一下条件：

• ASCII character.
• Digit.
• An underscore (_).
• A hyphen (-).

访问字典

• []

  1	meal['breakfast']

• .

  1	meal.lunch

修改字典

• []`

  1	meal['breakfast'] = "..."

• .

  1	meal.lunch = "..."

内置函数

特殊基元

• v:false
• v:true
• v:none
• v:null

注：

• v: 是 vim 内置的变量
• 这些不常用
• 常用如下
  • 布尔值：0(假)；non-0 (真)
  • 空字符串：""

True

1
2

:echo json_encode({"test": v:true})
" returns {"test": true}

False

1
2

:echo json_encode({"test": v:false})
" returns {"test": false}

None

1
2

:echo json_encode({"test": v:none})
" returns {"test": null}

被解释成 null

Null

1
2

:echo json_encode({"test": v:null})
" returns {"test": null}

类似于 v:none

第26章 条件和循环

关系表达式

• ==
• !=
• >
• >=
• <
• <=

注意：这里的字符串仍被转换为数字

字符串逻辑运算

用关系运算符来比较字符串

• =~：对字符串进行正则表达式匹配：可以模式匹配上
• !~: 对字符串进行正则表达式匹配：不可以匹配上
• ==: 完全匹配：相等
• !=：完全匹配：不相等

注意：如果在设置了 set ignorecase，那么比较时也会忽略大小写

设置总是忽略大小写

• 在末尾加一个 #，如：=~# （推荐：安全）

  1	echo str =~# "hearty"

• 在末尾加一个 ?，如：=~?

  1	echo str =~? "hearty"

if

最小的 if 语句

1
2
3

if {clasuse}
	{some expression}
endif

if 全貌

1
2
3
4
5
6
7
8
9

if {predicate1}
	{expression1}
elseif {predicate2}
	{expression2}
elseif {predicate3}
	{expression3}
else
	{expression4}
endif

三元表达式

1

{predicate} ? expressiontrue : expressionfalse

补充

• background: 背景
• strftime()： 目前时间

or

||

注意：短路运算

and

&&

注意：短路运算

for

方法1

1
2
3
4
5

let breakfasts = ["pancakes", "waffles", "eggs"]

for breakfast in breakfasts
  echo breakfast
endfor

方法2

1
2
3
4
5

let meals = [["breakfast", "pancakes"], ["lunch", "fish"], ["dinner", "pasta"]]

for [meal_type, food] in meals
  echo "I am having " . food . " for " . meal_type
endfor

方法3

1
2
3
4

let beverages = #{breakfast: "milk", lunch: "orange juice", dinner: "water"}
for beverage_type in keys(beverages)
  echo "I am drinking " . beverages[beverage_type] . " for " . beverage_type
endfor

while

常见

1
2
3
4
5

let counter = 1
while counter < 5
  echo "Counter is: " . counter
  let counter += 1
endwhile

获得每行内容

1
2
3
4
5
6
7

let current_line = line(".")
let last_line = line("$")

while current_line <= last_line
  echo getline(current_line)
  let current_line += 1
endwhile

Error Handling

break

和 python 一样：中断循环

Continue

和 python 一样：跳过当前轮

try, finally, and catch

和 python 一样

• finally: 总是被执行，且是最后被执行
• catch: 捕获错误

注

• throw：抛出一个错误

catch 捕捉的错误

:h :catch

1
2
3
4
5
6
7
8

catch /^Vim:Interrupt$/.             " catch interrupts (CTRL-C)
catch /^Vim\\%((\\a\\+)\\)\\=:E/.    " catch all Vim errors
catch /^Vim\\%((\\a\\+)\\)\\=:/.     " catch errors and interrupts
catch /^Vim(write):/.                " catch all errors in :write
catch /^Vim\\%((\\a\\+)\\)\\=:E123:/ " catch error E123
catch /my-exception/.                " catch user exception
catch /.*/                           " catch everything
catch.                               " same as /.*/

第27章 变量范围

变量与常量

变量

定义变量

1

let val = "value"

let 定义的是==变量==

修改变量

当需要改变变量的值时，需要使用 let

1
2

let val = "value"
let val = "value1"

使用变量

1

echo val

常量

定义

使用 const

1

const val = "value"

变量源

• 环境变量
• 选项变量
• 寄存器变量

环境变量

vim 可以访问==终端的环境变量==

语法

1

${Enviroment_variable}

示例

1

echo $SHELL

注意：不要使用 {}，错误的用法: echo ${SHELL}

选项变量

这些变量也就是 .vimrc 中使用 set 设置的那些变量

访问

• 方法1: 使用 &`

  1	echo &background

• 方法2: set background?

寄存器变量

访问

使用 @

更新寄存器的值

使用 let

示例

• 访问寄存器 a

  1

  echo @a

• 更新寄存器 a 的值

  1	let @a .= " donut"

变量范围

全局变量

范围

可以在任何地方使用

定义

• let val = "value"
• let g:val = "value"

使用

• echo val
• echo g:val

缓冲区变量

定义

添加前缀 b:

1

const b:donut = "chocoldate donut"

说明

定义的每个缓冲区变量仅在定义时所在的缓冲区有效，也就是说缓冲区变量的作用域是定义所在缓冲区

特殊缓冲区值

b:changedtick: 跟踪了在当前缓冲区所有的改变

窗口变量

定义

添加前缀 w:

1

let w:donut = "donut"

说明

类似于缓冲区变量，变量的作用域为定义的窗口

标签变量

定义

添加前缀 t:

1

let t:done

说明

类似于窗口变量和缓冲区变量

脚本变量

定义

使用前缀 s:

说明

仅在定义变量的脚本内部才可以访问到

Function Local and Function Formal Parameter Variable

定义

• 函数局部变量：l:
• 函数形参变量: a:

内置变量

说明

前缀为 v:

注意

无法定义这些变量

常见

注意：查看其他的内置变量 :h vim-variable or :h v:.

第28章 函数

函数语法

1
2
3

function {FunctionNmae}()
	{do-something}
endfunction

注意：

• ==函数名必须以大写字母开头==
• 函数名不能以数字开头

函数名小写字母开始

使用脚本变量前缀 s:，如：function s:tasty()

同名函数

不允许有重名函数

覆写函数

在 function 后面使用 !

1
2
3

function！ Tasty()
	echo "Tasty"
endfunction

覆写之后上面的函数就会没有。==覆写不是重载==哦

查看所有可用函数

使用 :function

查看某一个函数内容

:function Tasty

模式搜索函数

:function /pattern

查看函数位置

使用 :verbose 和 :function 命令

• 某一函数

  1	:verbose function <FunctionName>

• 模式匹配函数

  1	:verbose function /<pattern>

删除函数

删除一个已有函数: :delfunction {FunctionName}

例如: :delfunction Tasty

函数返回值

• 默认返回 0
• return: 等价于返回0

函数参数

用法

使用 a:

示例

如函数 Tasty() 使用参数 food

1
2
3

function! Tasty(food)
	return "Tasty" . a:food
endfunction

局部变量

用法

使用 l:

常见问题

问题 1

若在函数内部定义一个变量，那么这个变量默认为局部变量

1
2
3
4

function! Tasty()
	let location = "tasty"
	return location . " in Tasty"
endfunction

与下面代码等价，但是==没有下面的代码好==

1
2
3
4

function! Tasty()
	let l:location = "tasty"
	return l:location . " in Tasty"
endfunction

问题 2

1
2
3
4
5
6
7

function! Calories()
  let count = "count"
  return "I do not " . count . " my calories"
endfunction

echo Calories()
" throws an error

变量会与特殊变量同名，导致错误

错误根源：let count = "count"

调用函数

使用

纯粹调用函数

使用 call 调用函数

• 命令行

  1	:call Tasty()

• 脚本

  1	call Tasty()

You cannot call a command-line command with another command-line command.

你不能使用命令行命令调用命令行命令

使用函数返回值
使用 call("<FunctionName>", [<参数列表>])

[] 不可以省略

区别

• :call 是命令行命令
• call()： 函数
  • 第一个参数接收函数名
  • 第二个参数接收形参列表

默认参数

使用 =

示例

1
2
3
4
5
6
7
8
9

function! Breakfast(meal, beverage = "Milk")
  return "I had " . a:meal . " and " . a:beverage . " for breakfast"
endfunction

echo Breakfast("Hash Browns")
" returns I had hash browns and milk for breakfast

echo Breakfast("Cereal", "Orange Juice")
" returns I had Cereal and Orange Juice for breakfast

可变参数

使用 ...

示例

1
2
3

function! Buffet(...)
  return a:1
endfunction

• a:0: 共有多少个参数
• a:1 是第一个参数
• a:2 是第二个参数
• …
• a:20 是第20个参数
• a:000 是所有参数值组成的列表

a:0 示例

1
2
3
4
5
6
7
8
9

function! Buffet(...)
  let l:food_counter = 1
  let l:foods = ""
  while l:food_counter <= a:0
    let l:foods .= a:{l:food_counter} . " "
    let l:food_counter += 1
  endwhile
  return l:foods
endfunction

a:000 + for

1
2
3
4
5
6
7
8
9
10

function! Buffet(...)
  let l:foods = ""
  for food_item in a:000
    let l:foods .= food_item . " "
  endfor
  return l:foods
endfunction

echo Buffet("Noodles", "Sushi", "Ice cream", "Tofu", "Mochi")
" returns Noodles Sushi Ice cream Tofu Mochi

Range

在定义函数的第一行最后加入 range

效果

会给该函数添加两个特定变量：

• a:firstline: 所选范围的第一行的行号
• b:lastline: 所选范围的最后一行的行号

与 line(“.”) 区别

• line(".")： 会在所选范围的所有行上，每行会执行一次函数
• range： 只会在第一行执行一次

示例

1
2
3

function! Breakfast() range
    echo line(".")
endfunction

1

:11,20 call Breakfast

字典

没什么用处

也没怎么看懂

函数引用

类似于函数指针，将变量指向一个函数

使用

使用 function()

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14

function! Breakfast(item)
  return "I am having " . a:item . " for breakfast"
endfunction

let Breakfastify = Breakfast
" returns error

let Breakfastify = function("Breakfast")

echo Breakfastify("oatmeal")
" returns "I am having oatmeal for breakfast"

echo Breakfastify("pancake")
" returns "I am having pancake for breakfast"

Lambda

未命名函数

示例

1
2
3
4
5
6
7

let Plus = {x,y -> x + y}
echo Plus(1,2)
" returns 3

let Tasty = { -> 'tasty'}
echo Tasty()
" returns "tasty"

You can call a function from insisde a lambda expression（没看懂）

方法链

用法

使用 ->

->跟在函数名后面，且中间不能添加空格

1

Source->Method1()->Method2()->...->MethodN()

说明

像 shell 的 ==管道==

Closure

1
2
3
4
5
6
7
8
9

function! Lunch()
  let appetizer = "shrimp"

  function! SecondLunch()
    return appetizer
  endfunction

  return funcref("SecondLunch")
endfunction

appetizer在Lunch函数中定义，该函数返回SecondLunch函数。注意，SecondLunch使用了appetizer，但在Vimscript中，它没有访问该变量的权限。如果你尝试运行echo Lunch()()， Vim将抛出一个未定义变量错误。

解决

1
2
3
4
5
6
7
8
9

function! Lunch()
  let appetizer = "shrimp"

  function! SecondLunch() closure
    return appetizer
  endfunction

  return funcref("SecondLunch")
endfunction

写插件

略

第13章 全局命令

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

在本章中，您将学习如何在全局命令中重复命令行命令。

全局命令概述

Vim的全局命令用于同时在多行上运行命令行命令。

顺便说一句，您之前可能已经听说过 “Ex命令” 一词。在本书中，我将它们称为==命令行命令==，但Ex命令和命令行命令是相同的。它们是以冒号（:）开头的命令。在上一章中，您了解了替代命令。这是一个Ex命令的示例。它们之所以称为Ex，是因为它们最初来自Ex文本编辑器。在本书中，我将继续将它们称为命令行命令。有关Ex命令的完整列表，请查看:h ex-cmd-index。

全局命令具有以下语法：

1

:g/pattern/command

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

如果您具有以下表达式：

1
2
3
4
5
6
7
8

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

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

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

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

1

:g/console/d

结果：

1
2
3
4
5

const one = 1;

const two = 2;

const three = 3;

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

运行g命令时，Vim对文件进行两次扫描。在第一次运行时，它将扫描每行并标记与/console/模式传教匹配的行。一旦所有匹配的行都被标记，它将进行第二次运行，并在标记的行上执行d命令。

如果要删除所有包含”const”的行，请运行：

1

:g/const/d

结果：

1
2
3
4
5

console.log("one: ", one);

console.log("two: ", two);

console.log("three: ", three);

逆向匹配

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

1

:g!/{pattern}/{command}

或者

1

:v/{pattern}/{command}

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

模式串

全局命令使用与替代命令相同的模式串系统，因此本节将作为更新。随意跳到下一部分或继续阅读！

如果您具有以下表达式：

1
2
3
4
5
6
7
8

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

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

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

要删除包含”one”或”two”的行，请运行：

1

:g/one\|two/d

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

1

:g/[0-9]/d

或者

1

:g/\d/d

如果您有表达式：

1
2
3

const oneMillion = 1000000;
const oneThousand = 1000;
const one = 1;

要匹配包含三到六个零的行，请运行：

1

:g/0\{3,6\}/d

传递范围参数

您可以在g命令之前传递一个范围。您可以通过以下几种方法来做到这一点：

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

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

• . 表示当前行。范围.,3表示当前行和第3行之间。
• $ 表示文件的最后一行。 3,$范围表示在第3行和最后一行之间。
• +n 表示当前行之后的n行。您可以将其与.结合使用，也可以不结合使用。 3,+1或3,.+1表示在第3行和当前行之后的行之间。

如果您不给它任何范围，默认情况下它将影响整个文件。这实际上不是常态。如果您不传递任何范围，Vim的大多数命令行命令仅在当前行上运行(两个值得注意的例外是：这里介绍的全局命令(:g)和save(:w)命令)。

普通模式命令

您可以将全局命令和:normal命令行命令一起运行。

如果您有以下文字：

1
2
3
4
5
6
7
8
9

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

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

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

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

1

:g/./normal A;

让我们分解一下：

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

执行宏

您也可以使用全局命令执行宏。宏只是普通模式下的操作，因此可以使用:normal来执行宏。如果您有以下表达式：

1
2
3
4
5
6
7
8

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

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

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

请注意，带有”const”的行没有分号。让我们创建一个宏，以在寄存器”a”的这些行的末尾添加逗号：

1

qa0A;<esc>q

如果您需要复习，请查看有关宏的章节。现在运行：

1

:g/const/normal @a

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

1
2
3
4
5
6
7
8

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

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

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

如果您一步一步按照示例做，您将会在第一行末尾看到两个分号。为避免这种情况，使用全局命令时，给一个范围参数，从第2行到最后一行, :2,$g/const/normal @a。

递归全局命令

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

给定表达式：

1
2
3
4
5
6
7
8

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

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

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

如果您运行：

1

:g/console/g/two/d

首先，g将查找包含模式”console”的行，并找到3个匹配项。然后，第二个”g”将从那三个匹配项中查找包含模式”two”的行。最后，它将删除该匹配项。

您也可以将g与v结合使用以找到正负模式。例如：

1

:g/console/v/two/d

与前面的命令不同，它将查找 不 包含”two”的行。

更改定界符

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

要删除包含”console”的行：

1

:g@console@d

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

1

g@one@s+const+let+g

此处，全局命令将查找包含”one”的所有行。 替换命令将从这些匹配项中将字符串”const”替换为”let”。

默认命令

如果在全局命令中未指定任何命令行命令，会发生什么？

全局命令将使用打印(:p)命令来打印当前行的文本。如果您运行：

1

:g/console

它将在屏幕底部打印所有包含”console”的行。

顺便说一下，这是一个有趣的事实。因为全局命令使用的默认命令是p，所以这使g语法为：

1

:g/re/p

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

这三个元素连起来拼写为 **”grep”**，与命令行中的grep 相同。但这 不 是巧合。 g/re/p命令最初来自Ed编辑器（一个行文本编辑器）。 grep命令的名称来自Ed。

您的计算机可能仍具有Ed编辑器。从终端运行ed（提示：要退出，请键入q）。

反转整个缓冲区

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

1

:g/^/m 0 

^表示行的开始。使用^匹配所有行，包括空行。

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

1

:5,10g/^/m 0

要了解有关move命令的更多信息，请查看:h :move。

汇总所有待办事项

当我编码时，有时我会想到一个随机的绝妙主意。不想失去专注，我通常将它们写在我正在编辑的文件中，例如：

1
2
3
4
5
6
7
8
9
10
11

const one = 1;
console.log("one: ", one);
// TODO: 喂小狗

const two = 2;
// TODO：自动喂小狗
console.log("two: ", two);

const three = 3;
console.log("three: ", three);
// TODO：创建一家销售自动小狗喂食器的初创公司

跟踪所有已创建的TODO可能很困难。 Vim有一个:t（copy）方法来将所有匹配项复制到一个地址。要了解有关复制方法的更多信息，请查看:h :copy。

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

1

:g/TODO/t $

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

const one = 1;
console.log("one: ", one);
// TODO：喂小狗

const two = 2;
// TODO：自动喂小狗
console.log("two: ", two);

const three = 3;
console.log("three: ", three);
// TODO：创建一家销售自动小狗喂食器的初创公司

// TODO：喂小狗
// TODO：自动喂小狗
// TODO：创建一家销售自动小狗喂食器的初创公司

现在，我可以查看我创建的所有TODO，另外找个时间来完成它们，或将它们委托给其他人，然后继续执行下一个任务。

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

1

:g/TODO/m $

结果：

1
2
3
4
5
6
7
8
9
10
11
12

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

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

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

// TODO：喂小狗
// TODO：自动喂小狗
// TODO：创建一家销售自动小狗喂食器的初创公司

黑洞删除

回想一下寄存器那一章，已删除的文本存储在编号寄存器中（允许它们足够大）。每当运行:g/console/d时，Vim都会将删除的行存储在编号寄存器中。如果删除多行，所有编号的寄存器将很快被填满。为了避免这种情况，您可以使用黑洞寄存器（"_） 不 将删除的行存储到寄存器中。

1

:g/console/d _

通过在d之后传递_，Vim不会将删除的行保存到任何寄存器中。

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

如果您的文件带有多个空行，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13

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


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





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

您可以快速将多个空行减少为一条空行。运行：

1

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

结果：

1
2
3
4
5
6
7
8

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

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

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

一般情况下全局命令遵循下列格式：:g/pattern/command。但是，您也可以使用下面的格式：:g/pattern1/,/pattern2/command。用这种格式，Vim将会使command作用在pattern1和pattern2上。

记住上面说的格式，让我们根据:g/pattern1/,/pattern2/command这个格式分解一下命令:g/^$/,/./-1j：

• /pattern1/ 就是 /^$/ 。它表示一个空行（一个没有任何字符的行）。
• /pattern2/ 就是 /./（用-1作为行修正）。/./表示一个非空行（一个含有至少1个字符的行）。这里的 -1 意思是向上偏移1行。
• command 就是 j，一个联接命令(:j)。在这个示例中，该全局命令联接所有给定的行。

顺便说一句，如果您想要将多个空行全部删去，运行下面的命令：

1

:g/^$/,/./j

或者：

1

:g/^$/-j

您的文本将会减少为：

1
2
3
4
5
6

const one = 1;
console.log("one: ", one);
const two = 2;
console.log("two: ", two);
const three = 3;
console.log("three: ", three);

（译者补充：j连接命令的格式是：:[range]j。比如：:1,5j将连接第1至5行。在前面的命令中:g/pattern1/,/pattern2/-1j，/pattern1/和/pattern2都是j命令的范围参数，表示连接空行至非空行上方一行，这样就会保留1个空行。在早前的英文版本中有关于j命令的介绍，不知为何在后面的更新中，原作者删除了关于j命令的介绍）

高级排序

Vim有一个:sort命令来对一个范围内的行进行排序。例如：

1
2
3
4
5

d
b
a
e
c

您可以通过运行:sort对它们进行排序。如果给它一个范围，它将只对该范围内的行进行排序。例如，:3,5sort仅在第三和第五行之间排序。

如果您具有以下表达式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

const arrayB = [
  "i",
  "g",
  "h",
  "b",
  "f",
  "d",
  "e",
  "c",
  "a",
]

const arrayA = [
  "h",
  "b",
  "f",
  "d",
  "e",
  "a",
  "c",
]

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

1

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

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

const arrayB = [
  "a",
  "b",
  "c",
  "d",
  "e",
  "f",
  "g",
  "h",
  "i",
]

const arrayA = [
  "a"
  "b",
  "c",
  "d",
  "e",
  "f",
  "h",
]

这很棒！但是命令看起来很复杂。让我们分解一下。该命令依然遵循 :g/pattern1/,/pattern2/command这个格式。

• :g 是全局命令
• /\[/+1 是第一个模式串，它匹配左方括号”[“。+1表示匹配行的下面1行。
• /\]/-1 是第二个模式串，它匹配右方括号”]”。-1表示匹配行的上面1行。
• /\[/+1,/\]/-1 表示在”[“和”]”之间的行。
• sort 是命令行命令：排序。

聪明地学习全局命令

全局命令针对所有匹配的行执行命令行命令。有了它，您只需要运行一次命令，Vim就会为您完成其余的工作。要精通全局命令，需要做两件事：良好的命令行命令词汇表和正则表达式知识。随着您花费更多的时间使用Vim，您自然会学到更多的命令行命令。正则表达式知识需要更多的实际操作。但是一旦您适应了使用正则表达式，您将领先于很多其他人。

这里的一些例子很复杂。不要被吓到。真正花时间了解它们。认真阅读每个模式串，不要放弃。

每当需要在多个位置应用命令时，请暂停并查看是否可以使用g命令。寻找最适合工作的命令，并编写一个模式串以同时定位多个目标。

既然您已经知道全局命令的功能强大，那么让我们学习如何使用外部命令来增加工具库。

第14章 外部命令

在Unix系统内部，您会发现许多小型的，超专业化命令，每个命令只做一件事（而且能很好地完成）。您可以将这些命令链接在一起以共同解决一个复杂的问题。如果可以从Vim内部使用这些命令，那不是很好吗？

答案是肯定的!在本章中，您将学习如何扩展Vim以使其与外部命令无缝协作。

Bang 命令

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

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

让我们一个个认真看一下。

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

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

1

:r !{cmd}

:r是Vim的读命令。如果不带!使用它，则可以使用它来获取文件的内容。如果当前目录中有文件file1.txt，运行：

1

:r file1.txt

Vim会将file1.txt的内容放入当前缓冲区。

如果您运行的:r命令后面跟一个!和外部命令，则该命令的输出将插入到当前缓冲区中。要获取ls命令的结果，请运行：

1

:r !ls

它返回类似下列的文本：

1
2
3

file1.txt
file2.txt
file3.txt

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

1

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

r命令也接受一个地址：

1

:10r !cat file1.txt

现在，将在第10行之后插入来自运行cat file.txt的STDOUT。

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

:w命令除了保存文件，还可以用来将当前缓冲区中的文本作为作为STDIN传递给外部命令。语法为：

1

:w !cmd

如果您具有以下表达式：

1
2

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

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

1

:w !node

Vim将使用node执行Javascript表达式来打印”Hello Vim”和”Vim is awesome”。

当使用：w命令时，Vim使用当前缓冲区中的所有文本，与global命令类似（大多数命令行命令，如果不给它传递范围，则仅对当前行执行该命令）。如果您通过：w来指定地址：

1

:2w !node

“Vim”只使用第二行中的文本到node解释器中。

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

执行外部命令

您可以使用bang命令从Vim内部执行外部命令。语法为：

1

:!cmd

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

1

:!ls -ls

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

1

:!kill -9 3456

您可以在不离开Vim的情况下运行任何外部命令，因此您可以专注于自己的任务。

过滤文本

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

1
2

hello vim
hello vim

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

1

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

结果：

1
2

HELLO VIM
hello vim

命令分解：

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

==必须传递范围以运行外部命令作为过滤器。==如果您尝试在没有.的情况下运行上述命令(:!tr '[:lower:]' '[:upper:]')，则会看到错误。

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

1

:%!awk "{print $1}"

结果：

1
2

hello
hello

命令分解：

• :%! 在所有行(%)上执行filter命令。
• awk "{print $1}" 仅打印匹配项的第一列。

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

1
2
3
4

name price
chocolate pancake 10
buttermilk pancake 9
blueberry pancake 12

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

1

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

结果：

1
2
3

buttermilk pancake 9
chocolate pancake 10
blueberry pancake 12

命令分解：

• :%! 将过滤器应用于所有行(%)。
• awk 'NR > 1' 仅从第二行开始显示文本。
• |链接下一个命令。
• sort -nk 3使用列3（k 3）中的值对数字进行排序（n）。
• column -t以均匀的间距组织文本。

普通模式命令

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

1
2
3
4

hello vim
hola vim
bonjour vim
salve vim

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

1

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

命令分解：

• !j 运行常规命令过滤器运算符（!），目标是当前行及其下方的行。回想一下，因为它是普通模式运算符，所以适用语法规则”动词+名词”。
• tr '[a-z]' '[A-Z]'将小写字母替换为大写字母。

filter normal命令仅适用于至少一行以上的motion或至少一行以上的文本对象。如果您尝试运行!iwtr'[az]''[AZ]'（在内部单词上执行tr），您会发现它在整个行上都应用了tr命令，而不是光标所在的单词。

聪明地学习外部命令

Vim不是IDE。它是一种轻量级的模式编辑器，通过设计可以高度扩展。由于这种可扩展性，您可以轻松访问系统中的任何外部命令。这样，Vim离成为IDE仅一步之遥。有人说Unix系统是有史以来的第一个IDE。

Bang 命令的有用程度与您知道多少个外部命令相关。如果您的外部命令知识有限，请不要担心。我还有很多东西要学。以此作为持续学习的动力。每当您需要过滤文本时，请查看是否存在可以解决问题的外部命令。不必担心掌握所有的命令。只需学习完成当前任务所需的内容即可。

第15章 命令行模式

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

在本章中，您将学习命令行模式的更多技巧。

进入和退出命令行模式

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

有 4 种进入命令行模式的方式：

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

您可以从正常模式或可视模式进入命令行模式。

若要离开命令行模式，您可以使用 <esc>、Ctrl-c、Ctrl-[。

有时其他资料可能会将”命令行指令”称为”Ex 命令”，将”外部命令”称为”过滤命令”或者”叹号运算符”。

重复上一个命令

您可以用 @: 来重复上一个命令行指令或外部命令。

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

命令行模式快捷键

在命令行模式中，您可以使用 Left 或 Right 方向键，来左右移动一个字符。

如果需要移动一个单词，使用 Shift-Left 或 Shift-Right (在某些操作系统中，您需要使用 Ctrl 而不是 Shift)。

使用 Ctrl-b移动到该行的开始，使用 Ctrl-e移动到该行的结束。

和输入模式类似，在命令行模式中，有三种方法可以删除字符：

1
2
3

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 Ctlr-l 获取当前光标所在行。按 Ctrl-r Ctrl-f 获取光标下的文件名。

您也可以对已存在的命令使用自动补全。要自动补全 echo 命令，当处于命令行模式时，首先输入 “ec”，接着按下 <Tab>，此时您应该能在左下角看到一些 “ec” 开头的 Vim 命令（例如：echo echoerr echohl echomsg econ）。按下 <Tab> 或 Ctrl-n 可以跳到下一个选项。按下 <Shift-Tab> 或 Ctrl-p 可以回到上一个选项。

一些命令行指令接受文件名作为参数。edit 就是一个例子，这时候您也可以使用自动补全。当输入 :e 后（不要忘记空格了），按下 <Tab>，Vim 将列出所有相关的文件名，这样您就可以进行选择而不必完整的输入它们。

历史记录窗口

您可以查看命令行指令和搜索项的历史记录（要确保在运行 vim --version 时，Vim 的编译选项中含有+cmdline_hist）。

运行 :his : 来查看命令行指令的历史记录：

1
2
3
4

##  cmd History
2  e file1.txt
3  g/foo/d
4  s/foo/bar/g

Vim 列出了您运行的所有 : 命令。默认情况下，Vim 存储最后 50 个命令。运行 :set history=100 可以将 Vim 记住的条目总数更改为 100。

一个更有用的做法是使用命令行历史记录窗口，按q:将会打开一个可搜索、可编辑的历史记录窗口。假设按下q:后您有如下的表达式：

1
2
3

51  s/verylongsubstitutionpattern/pancake/g
52  his :
53  wq

如果您当前任务是执行 s/verylongsubstitutionpattern/donut/g（”pancake”换成了”donut”），为什么不复用 s/verylongsubstitutionpattern/pancake/g 呢？毕竟，两条命令唯一不同的是替换的单词，”donut” vs “pancake” ，所有其他的内容都是相同的。

当您运行 q:后，在历史记录中找到 s/verylongsubstitutionpattern/pancake/g（在这个环境中，您可以使用Vim导航），然后直接编辑它！ 在历史记录窗口中将 “pancake” 改为 “donut” ，然后按 <Enter。Vim立刻执行 s/verylongsubstitutionpattern/donut/g 命令，超级方便！

类似地，运行 :his / 或 :his ? 可以查看搜索记录。要想打开您可以直接搜索和编辑的搜索历史记录窗口，您可以运行 q/ 和 q?。

要退出这个窗口，按 Ctrl-c, Ctrl-w c, 或输入 :quit。

更多命令行指令

Vim有几百个内置指令，要查看Vim的所有指令，执行 :h ex-cmd-index 或 :h :index。

聪明地学习命令行模式

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

是时候离开 Vim 模式，来了解如何使用 Vim 标记进行更快的导航了。

第16章 标签

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

标签概述

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

1
2

one = One.new
one.donut

One？donut？呃，对于当时编写代码的开发者而言，这些代码的含义可能显而易见。问题是当时的开发者已经不在了，现在要由您来理解这些费解的代码。而跟随有One 和 donut定义的源代码，是帮助您理解的一个有效方法。

您可以使用fzf 或 grep来搜索它们，但这种情况下，但使用标签将更快。

把标签想象成地址簿：

1
2
3

Name    Address
Iggy1   1234 Cool St, 11111
Iggy2   9876 Awesome Ave, 2222

当然，标签可不是存储着“姓名-地址”对，而是“定义-地址”对。

假设您在一个目录中有两个 Ruby 文件：

1
2
3
4
5
6
7
8
9
10

## one.rb
class One
  def initialize
    puts "Initialized"
  end

  def donut
    puts "Bar"
  end
end

以及