Eric's Blog

GLM-5 流式 Tool Call 异常分析（基于 curl 原始输出）

Sat, 21 Mar 2026 00:00:00 +0000

问题背景
调用架构与实现
- 客户端请求实现
- 关键请求参数
异常现象详述
根因分析
对客户端的影响
调试与验证方法
结论与建议
参考资料

问题背景

本文记录在使用 阿里云百炼平台 Coding Plan（GLM-5 模型） 时遇到的一个流式输出协议异常问题。请求客户端为 Neovim 插件 chat.nvim，通过 curl 命令异步调用阿里云的流式聊天补全接口。在正常开发过程中，chat.nvim 需要调用大模型完成代码生成、问题解答等任务，并支持 Tool Call 功能以扩展模型能力。然而在实际使用中，发现当模型返回 Tool Call 响应时，SSE（Server-Sent Events）流中会夹杂未经封装的原始文本数据，导致客户端解析失败。

调用架构与实现

客户端请求实现

chat.nvim 底层使用 Neovim 的 job 系统异步执行 curl 命令，通过标准输入输出与服务端通信。核心请求函数如下：

function M.request(opt)
  local cmd = {
    'curl',
    '-s',
    'https://coding.dashscope.aliyuncs.com/v1/chat/completions',
    '-H',
    'Content-Type: application/json',
    '-H',
    'Authorization: Bearer ' .. config.config.api_key.aliyuncs_pc,
    '-X',
    'POST',
    '-d',
    '@-',
  }

  local body = vim.json.encode({
    model = sessions.get_session_model(opt.session),
    messages = opt.messages,
    enable_thinking = true,
    stream = true,
    stream_options = { include_usage = true },
    tools = require('chat.tools').available_tools(),
  })

  local jobid = job.start(cmd, {
    on_stdout = opt.on_stdout,
    on_stderr = opt.on_stderr,
    on_exit = opt.on_exit,
  })
  job.send(jobid, body)
  job.send(jobid, nil)
  sessions.set_session_jobid(opt.session, jobid)

  return jobid
end

关键请求参数

参数	配置值	说明
服务端点	`https://coding.dashscope.aliyuncs.com/v1/chat/completions`	阿里云百炼平台 API
模型	`glm-5`	GLM-5 模型（Coding Plan）
流式输出	`stream = true`	启用 SSE 流式响应
Tool Call	`tools = available_tools()`	注册可用工具函数
思考模式	`enable_thinking = true`	启用模型思考过程
使用量统计	`stream_options.include_usage = true`	返回 token 使用统计

请求体通过 curl -d @- 从标准输入读取，job 系统通过 job.send() 将 JSON 编码的请求体发送给 curl 进程。响应数据通过 on_stdout 回调逐行接收，客户端需要实时解析 SSE 格式的数据流。

异常现象详述

正常的 SSE 流格式

符合 OpenAI 规范的 SSE 流式响应应当严格遵循以下格式，每一行都以 data: 前缀开头，后面跟随完整的 JSON 对象或 [DONE] 标记：

data: {"id":"chat-123","choices":[{"delta":{"content":"Hello"},"index":0}]}
data: {"id":"chat-123","choices":[{"delta":{"content":" world"},"index":0}]}
data: {"id":"chat-123","choices":[{"delta":{"content":"!"},"index":0}]}
data: {"id":"chat-123","choices":[{"finish_reason":"stop","index":0}]}
data: [DONE]

客户端解析器通过检测 data: 前缀识别有效数据行，使用 vim.json.decode() 解析 JSON 内容，遇到 [DONE] 标记时结束流式处理。

实际收到的异常数据

在实际调用 GLM-5 模型时，收到的响应流中出现了不符合 SSE 规范的裸文本数据：

data: {"id":"chat-456","choices":[{"delta":{"content":"请查看"},"index":0}]}
data: {"id":"chat-456","choices":[{"delta":{"tool_calls":[{"id":"call_1","function":{"name":"read_file","arguments":""},"index":0}]}]}
ts from you under
this License for any purpose whatsoever, with or without
data: {"id":"chat-456","choices":[{"delta":{"tool_calls":[{"function":{"arguments":"\"--filepath\""},"index":0}]}]}
data: {"id":"chat-456","choices":[{"finish_reason":"tool_calls","index":0}]}
data: [DONE]

可以看到在第 2 行和第 3 行之间，插入了两行没有 data: 前缀的纯文本内容。这些文本实际上是 Tool Call 的 arguments 参数值的一部分，应该是 GPL 许可证文本的片段。

异常数据特征分析

通过对多次请求的原始响应进行比对，总结出以下异常特征：

特征	表现	出现频率
裸文本行	无 `data:` 前缀的纯文本	每次 Tool Call 必现
内容来源	Tool Call arguments 字符串片段	100%
出现位置	tool_calls delta 输出过程中	100%
content 输出	正常 SSE 格式	不受影响
finish_reason	正确返回 tool_calls	不受影响
JSON 完整性	tool_call JSON 被截断	100%

这些特征表明问题具有高度一致性，并非网络传输错误或偶发异常，而是服务端实现层面的系统性问题。

根因分析

问题本质：协议层混流

该问题的本质是服务端在流式输出过程中，存在两条独立的输出通道被错误地混合写入同一个 HTTP 响应流：

输出类型	预期通道	实际通道	状态
普通内容 (content)	SSE JSON 封装	SSE JSON 封装	✅ 正常
Tool Call 参数 (arguments)	SSE JSON 封装	原始 stdout 直写	❌ 异常

正常情况下，所有输出内容都应当经过 SSE 协议封装层，统一格式化为 data: {...} 后写入 HTTP 响应体。但实际实现中，Tool Call 的 arguments 生成逻辑绕过了封装层，直接将 token 写入输出流。

推测的错误实现

根据输出特征，推测服务端可能存在类似以下的错误实现：

// ❌ 错误实现示意
func streamToolCallArguments(tokens []string, writer http.ResponseWriter) {
    for _, token := range tokens {
        // 错误：直接写入原始 token，未经过 SSE 封装
        writer.Write([]byte(token))
        writer.(http.Flusher).Flush()
    }
}

// ✅ 正确实现应当是
func streamToolCallArguments(tokens []string, writer http.ResponseWriter) {
    for _, token := range tokens {
        // 正确：构造完整的 SSE 消息
        message := SSEMessage{
            Choices: []Choice{
                {
                    Delta: Delta{
                        ToolCalls: []ToolCall{
                            {
                                Function: Function{
                                    Arguments: token,
                                },
                            },
                        },
                    },
                },
            },
        }
        fmt.Fprintf(writer, "data: %s\n\n", json.Marshal(message))
        writer.(http.Flusher).Flush()
    }
}

为什么会出现”半截字符串”

观察到的裸文本如 ts from you under 实际上是 arguments 字符串的中间片段。这是因为：

Token 级流式输出：模型生成 arguments 时按 token 逐个输出，而非等待完整字符串生成后一次性输出
写入时机错误：每个 token 生成后立即被写入输出流，但未经过 JSON 转义和 SSE 封装
边界不匹配：token 切分点与 JSON 字符串边界不一致，导致输出的是字符串中间片段

例如，当 arguments 应该是 "GPL License text from you under this License" 时，实际输出可能是：

data: {"arguments":"GPL Licen"}   // 正常 SSE
se text from you under            // 裸文本（错误）
this License"                     // 裸文本（错误）
data: {"arguments":""}            // 正常 SSE

通道混用的可能原因

从软件工程角度分析，这种问题通常由以下原因导致：

代码路径分支：content 输出和 tool_call 输出走了不同的代码路径，其中一条路径遗漏了封装逻辑
历史遗留代码：可能在迭代过程中，tool_call 功能是后期添加的，复用了旧的输出接口
测试覆盖不足：缺少对原始 HTTP 响应流的协议一致性测试，仅测试了最终解析结果
多团队协作：流式输出模块和 Tool Call 模块可能由不同团队开发，接口约定不清晰

对客户端的影响

chat.nvim 解析器行为

chat.nvim 的 SSE 解析器期望每一行输入都是合法的 data: {...} 格式，当遇到裸文本时会出现以下问题：

-- 简化的解析逻辑
local function parse_sse_line(line)
  local data = line:sub(7)  -- 去掉 "data: " 前缀
  return vim.json.decode(data)  -- 裸文本会导致这里报错
end

当输入行为 ts from you under 时：

line:sub(7) 返回 ` from you under`（或原样返回，如果行长度不足 7）
vim.json.decode() 尝试解析非 JSON 字符串，抛出异常
异常可能导致整个流式处理中断，Tool Call 无法完成

实际影响范围

影响项	严重程度	说明
JSON 解析失败	高	`vim.json.decode()` 抛出异常
Tool Call 识别失败	高	arguments 内容不完整，无法调用工具
流式输出中断	中	可能触发错误处理逻辑，提前终止
用户体验下降	中	功能不可用或响应异常
错误日志污染	低	产生大量解析错误日志

临时容错方案

在无法修改服务端的情况下，客户端可以增加容错逻辑，过滤非法数据行：

local function safe_parse_sse(line)
  -- 严格过滤：只处理以 "data: " 开头的行
  if not line:match("^data: ") then
    vim.log.warn("跳过非法 SSE 行：" .. line)
    return nil
  end
  
  local ok, result = pcall(function()
    local content = line:sub(7)
    if content == "[DONE]" then
      return "DONE"
    end
    return vim.json.decode(content)
  end)
  
  if not ok then
    vim.log.warn("JSON 解析失败：" .. result)
    return nil
  end
  
  return result
end

-- 在 on_stdout 回调中使用
on_stdout = function(_, data)
  for line in data:gmatch("[^\n]+") do
    local parsed = safe_parse_sse(line)
    if parsed then
      handle_chunk(parsed)
    end
  end
end

该方案的核心思想是严格过滤 + 静默丢弃，遇到非法数据行时记录警告日志但不中断处理流程。这样可以保证在服务端修复问题之前，客户端仍能正常工作。

调试与验证方法

保存原始响应

使用 curl 直接请求并保存完整响应，便于离线分析：

curl -N \
  https://coding.dashscope.aliyuncs.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "glm-5",
    "messages": [
      {"role": "user", "content": "请读取当前目录下的 LICENSE 文件"}
    ],
    "stream": true,
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "read_file",
          "parameters": {
            "type": "object",
            "properties": {
              "filepath": {"type": "string"}
            }
          }
        }
      }
    ]
  }' \
  > raw_response.txt

参数说明：

-N：禁用缓冲，实时输出
raw_response.txt：保存完整原始响应

分析响应内容

# 统计总行数
wc -l raw_response.txt

# 查看非 data: 开头的行（非法行）
grep -v "^data: " raw_response.txt

# 统计非法行数量
grep -cv "^data: " raw_response.txt

# 查看非法行的上下文（前后各 2 行）
grep -v "^data: " -B 2 -A 2 raw_response.txt

# 提取所有 data: 行并验证 JSON 格式
grep "^data: " raw_response.txt | \
  sed 's/^data: //' | \
  while read line; do
    echo "$line" | jq . 2>/dev/null || echo "INVALID: $line"
  done

验证 Tool Call 完整性

# 提取所有 tool_calls 相关的行
grep "tool_calls" raw_response.txt

# 检查 arguments 字段是否完整
grep "arguments" raw_response.txt | \
  sed 's/^data: //' | \
  jq '.choices[0].delta.tool_calls[0].function.arguments'

如果 arguments 字段显示不完整或解析失败，说明存在数据污染。

结论与建议

问题定性

该问题属于服务端协议层实现缺陷，具体表现为：

非客户端问题：chat.nvim 的 SSE 解析逻辑符合 OpenAI 规范
非网络问题：裸文本稳定出现，非传输错误
非偶发问题：每次 Tool Call 必现，具有可复现性
协议级错误：违反 SSE 协议规范，混合输出不同格式数据

根本原因

Tool Call 的 arguments 在流式生成过程中未被正确封装进 SSE 消息格式，导致原始 token 直接泄漏到 HTTP 响应流中。这反映了服务端在流式输出模块和 Tool Call 模块的集成测试不足。

解决建议

对服务端（阿里云）：

修复 arguments 输出路径，确保所有输出经过 SSE 封装层
增加协议一致性测试，验证响应流符合 SSE 规范
提供问题追踪和修复时间表

对客户端（chat.nvim）：

增加 SSE 行过滤逻辑，容忍非法数据
记录详细的解析错误日志，便于问题诊断
考虑增加协议一致性检查，主动检测服务端问题

后续跟进

建议将原始响应日志提交给阿里云技术支持，附上：

完整的 raw_response.txt 文件
请求参数和调用时间
问题复现步骤
期望的正确输出格式

参考资料

job.nvim raw 参数导致 JSON 解析失败

Tue, 10 Mar 2026 00:00:00 +0000

起因
问题复现
问题分析
对比两种模式
- 默认模式（raw = false）
- Raw 模式（raw = true）
解决方案
实际案例
总结

起因

最近在使用 job.nvim 执行一些命令时，遇到了一个奇怪的问题。当我执行一个返回 JSON 数据的命令时，发现 JSON 数据无法被正确解析，总是报错 unexpected end of JSON。经过调试后发现，问题出在 job.nvim 的 raw 参数默认值上。

问题复现

假设我们有一个命令，它会输出一个较大的 JSON 数据：

local job = require('job')
local result = {}

local jobid = job.start({ 'some-command-that-outputs-json' }, {
  on_stdout = function(id, data)
    for _, line in ipairs(data) do
      table.insert(result, line)
    end
  end,
  on_exit = function(id, code, signal)
    local json_str = table.concat(result, '')
    local ok, decoded = pcall(vim.json.decode, json_str)
    if not ok then
      print('JSON decode failed: ' .. decoded)
    else
      print('JSON decoded successfully')
      vim.print(decoded)
    end
  end,
})

执行上述代码后，可能会看到类似以下的错误：

JSON decode failed: Expected object key string but found null at character 1024

或者在解析时直接报错：

JSON decode failed: Expected value but found T_END at character 1

问题分析

要理解这个问题，需要先了解 job.nvim 的 raw 参数的作用。查看 job.nvim 的源码，可以看到：

--- @class JobOpts
--- @field on_stderr? function
--- @field on_exit? fun(id: integer, code: integer, signin: integer)
--- @field on_stdout? function
--- @field cwd? string
--- @field detached? boolean
--- @field clear_env? boolean
--- @field env? table<string, string|number>
--- @field encoding? string
--- @field raw? boolean

raw 参数默认是 nil（即 false），这意味着使用行缓冲模式。在这种模式下，数据会通过 buffered_data 函数处理：

---@param eof string
---@param data string
local function buffered_data(eof, data)
  data = data:gsub('\r\n', '\n')
  local std_data = vim.split(data, '\n')
  if #std_data > 1 then
    std_data[1] = eof .. std_data[1]
    eof = std_data[#std_data] == '' and '' or std_data[#std_data]
    table.remove(std_data, #std_data)
  elseif #std_data == 1 then
    if std_data[1] == '' and eof ~= '' then
      std_data = { eof }
      eof = ''
    elseif std_data[1] == '' and eof == '' then
      std_data = {}
    elseif std_data[#std_data] ~= '' then
      eof = std_data[#std_data]
      std_data = {}
    end
  end
  return eof, std_data
end

这个函数的逻辑是：

将 \r\n 替换为 \n
按换行符 \n 分割数据
处理不完整的行，保存到 eof 变量中等待下一次数据

问题在于：大多数 JSON 输出是不包含换行符的单行数据，或者是一个格式化的多行 JSON。当 JSON 数据较大时，可能会被系统分成多个数据块（chunk），但每个数据块内部可能没有换行符。在这种情况下，buffered_data 函数会：

如果数据块中没有换行符，会将整个数据块视为一个”不完整的行”，保存到 eof 中
此时 std_data 是空的，不会触发 on_stdout 回调
只有当下一个数据块到来或者 EOF 时，才会将之前保存的数据输出

这样就导致了数据在缓冲区中累积，但 on_stdout 回调可能不会及时接收到数据。更糟糕的是，如果 JSON 数据本身就包含换行符（格式化的 JSON），会被错误地分割成多行。

对比两种模式

默认模式（raw = false）

-- Default: line-buffered mode
uv.read_start(stdout, function(_, data)
  if data then
    local stdout_data
    _jobs['jobid_' .. current_id].state.stdout_eof, stdout_data =
      buffered_data(
        _jobs['jobid_' .. current_id].state.stdout_eof,
        data
      )
    if #stdout_data > 0 then
      vim.schedule(function()
        if opts.encoding then
          stdout_data = vim.tbl_map(function(t)
            return vim.fn.iconv(t, opts.encoding, 'utf-8')
          end, stdout_data)
        end
        opts.on_stdout(current_id, stdout_data)
      end)
    end
    return
  end
  -- ... EOF handling
end)

Raw 模式（raw = true）

-- Raw mode: no buffering, pass raw data chunks directly
if opts.raw then
  uv.read_start(stdout, function(_, data)
    if data then
      vim.schedule(function()
        if opts.encoding then
          data = vim.fn.iconv(data, opts.encoding, 'utf-8')
        end
        if nparams == 2 then
          opts.on_stdout(current_id, { data })
        else
          opts.on_stdout(current_id, { data }, 'stdout')
        end
      end)
    else
      -- EOF
      if stdout and not stdout:is_closing() then
        stdout:close()
      end
    end
  end)
end

可以看到，raw = true 模式下：

不进行行缓冲处理
直接将原始数据块传递给回调函数
数据可能会被分成多个块，每个块都是不完整的

解决方案

针对 JSON 数据解析的场景，有以下几种解决方案：

方案一：使用 raw 模式并手动拼接数据

local job = require('job')
local result = {}

local jobid = job.start({ 'some-command-that-outputs-json' }, {
  raw = true,  -- 使用原始模式
  on_stdout = function(id, data)
    -- data 是一个包含原始数据块的列表
    for _, chunk in ipairs(data) do
      table.insert(result, chunk)
    end
  end,
  on_exit = function(id, code, signal)
    local json_str = table.concat(result, '')
    local ok, decoded = pcall(vim.json.decode, json_str)
    if not ok then
      print('JSON decode failed: ' .. decoded)
    else
      print('JSON decoded successfully')
      vim.print(decoded)
    end
  end,
})

方案二：在默认模式下正确处理数据

如果 JSON 数据是单行输出（minified JSON），需要在 on_exit 回调中处理缓冲区中剩余的数据：

local job = require('job')
local result = {}

local jobid = job.start({ 'some-command-that-outputs-json' }, {
  on_stdout = function(id, data)
    for _, line in ipairs(data) do
      -- 如果 JSON 是格式化的多行，需要保留换行符
      table.insert(result, line)
    end
  end,
  on_exit = function(id, code, signal)
    -- 拼接所有行，如果是 minified JSON，不需要换行符
    -- 如果是格式化 JSON，需要添加换行符
    local json_str = table.concat(result, '\n')
    local ok, decoded = pcall(vim.json.decode, json_str)
    if not ok then
      print('JSON decode failed: ' .. decoded)
    else
      print('JSON decoded successfully')
      vim.print(decoded)
    end
  end,
})

方案三：使用 luv 的 stream API

如果需要更精细的控制，可以直接使用 vim.loop (或 vim.uv) 的 stream API：

local uv = vim.uv or vim.loop

local stdout = uv.new_pipe()
local result = {}

local handle, pid = uv.spawn('some-command', {
  stdio = { nil, stdout, nil },
}, function(code, signal)
  stdout:close()
  handle:close()

  local json_str = table.concat(result, '')
  local ok, decoded = pcall(vim.json.decode, json_str)
  if not ok then
    print('JSON decode failed: ' .. decoded)
  else
    print('JSON decoded successfully')
    vim.print(decoded)
  end
end)

uv.read_start(stdout, function(err, data)
  if data then
    table.insert(result, data)
  end
end)

实际案例

在我开发的 chat.nvim 插件中，调用 AI API 时返回的就是 JSON 数据。最初使用默认模式时，遇到了数据解析失败的问题。查看调试日志：

[ 14:23:42:123 ] [ Info  ] Received chunk 1: {"id":"chatcmpl-123","object":"chat.completion","created":1234567890
[ 14:23:42:125 ] [ Info  ] Received chunk 2: ,"model":"gpt-4","choices":[{"index":0,"message":{"role":"assistant"
[ 14:23:42:127 ] [ Info  ] Received chunk 3: ,"content":"Hello"},"finish_reason":"stop"}]}

可以看到，JSON 数据被分成了 3 个数据块，每个块都不完整。在默认模式下，这些数据会被缓冲，等待换行符，但 JSON 数据中没有换行符，导致数据一直在缓冲区中。使用 raw = true 后，可以正确地接收并拼接这些数据块：

local job = require('job')
local chunks = {}

job.start(cmd, {
  raw = true,
  on_stdout = function(id, data)
    for _, chunk in ipairs(data) do
      table.insert(chunks, chunk)
    end
  end,
  on_exit = function(id, code, signal)
    local json_str = table.concat(chunks, '')
    -- 现在可以正确解析 JSON
    local response = vim.json.decode(json_str)
    -- 处理响应数据
  end,
})

总结

job.nvim 的 raw 参数默认为 false，使用行缓冲模式，适合处理以行为单位的文本输出（如日志、命令输出等）。但如果要处理二进制数据或单行的大型 JSON 数据，应该设置 raw = true，然后在回调函数中手动拼接数据块。理解 raw 参数的作用对于正确处理外部命令的输出非常重要：

raw = false（默认）：行缓冲模式，按换行符分割数据，确保每次回调传递完整的行
raw = true：原始模式，直接传递数据块，适合处理二进制数据或需要手动拼接的场景

在使用 job.nvim 处理 JSON 数据时，建议使用 raw = true 并在 on_exit 回调中拼接所有数据块后再进行解析。

为什么仍然在使用 job.nvim

Wed, 25 Feb 2026 00:00:00 +0000

起因
使用 Lua 重写 job API
独立成 job.nvim
为什么不切换到 vim.system
写在最后

起因

job.nvim 发布了 1.5 版本，和往常一样，我在 Reddit 上发布了版本更新文章，也很感谢有不少正面的反馈。但让我无法理解的是，有些人似乎很难沟通，他们一再强调 Neovim 有内置的 jobstart() 和 vim.system()，为什么还要创建一个新的插件？即使解释了原因，他们仍然无法理解。我想这可能是我说得不够清楚，因此在这里整理一下前因后果。说起 Job 函数，要从最早期的 Neovim 版本说起。Neovim 增加了一个 jobstart() Vim Script 函数，那时候 Vim 还没有 Job 功能，后来 Vim 才增加了 job_start() 函数，但其调用方式与 Neovim 并不一致。早期的 Neovim 主要还是以使用 VimL 为主。于是我给 SpaceVim 添加了一个 Job API，以兼容早期 Neovim 的 jobstart() 和 Vim 的 job_start() 函数。

commit 44ad1cb4fe6a8d9ccae49b71994e6182bbcaa968
Author: wsdjeg <wsdjeg@163.com>
Date:   Fri Mar 31 21:09:38 2017 +0800

    Add job api for vim and neovim

这样，就可以使用相同的函数同时兼容 Vim 和 Neovim。

let s:JOB = SpaceVim#api#import('job')
let s:command = ['echo', 'hello world']
function! s:stdout(id, data, event)
    " data 是一个字符串列表
    for line in a:data
        echo line
    endfor
endfunction
call s:JOB.start(s:command, {
    \ 'on_stdout' : function('s:stdout'),
    \ }
    \ )

在这个过程中，前后还遇到过很多兼容性问题。Neovim 的 jobstart() 函数的 stdout callback 在数据过大时会被截断，具体的 buffer size 我记不清了，有个 issue 讨论过这个问题。于是，我在这个 API 中增加了 data_eol 检测，以确保 callback 函数被调用时传入的是完整的数据。当然，后来的 Neovim 官方文档里也写了如何处理这种数据被截断的情况，详见 :h channel_buffered。

使用 Lua 重写 job API

随着 Neovim 对 Lua 的支持越来越多，我后来使用 Lua 重写了 Job API，但仍然将其内置在 SpaceVim 里。重写之后，调用就可以直接使用 Lua 了。

commit 879129388ab22b64c5a5cf0df83799084cab96fc
Author: Eric Wong <wsdjeg@outlook.com>
Date:   Wed Jul 5 22:58:01 2023 +0800

    feat(api): add lua job api
    
    close https://github.com/neovim/neovim/issues/20856

调用方式变成了 Lua：

local job = require('spacevim.api.job')

local jobid = job.start(vim.g.test_ctags_cmd, {
  on_stdout = function(id, data, event)
    vim.print(id)
    vim.print(data)
    vim.print(event)
  end,
  on_stderr = function(id, data, event)
    vim.print(id)
    vim.print(data)
    vim.print(event)
  end,
  on_exit = function(id, code, signal)
    vim.print(id)
    vim.print('exit code', code)
    vim.print('exit signal', signal)
  end,
})

独立成 job.nvim

随着 SpaceVim 项目停止维护，我把我常用的功能插件独立成了各个单独的 Neovim 插件，其中就包括了 job.nvim。我自己写的很多需要异步执行命令的 Neovim 插件都依赖这个 job.nvim，这样就不需要在每个插件仓库里单独维护执行外部命令的模块了。使用起来也比原来的 SpaceVim 内置 Lua Job API 更简洁一些：

local job = require('job')
local function on_exit(id, code, signal)
    print('job ' .. id .. ' exit code:' .. code .. ' signal:' .. signal)
end

local cmd = { 'echo', 'hello world' }
local jobid1 = job.start(cmd, {
    on_stdout = function(id, data)
        vim.print(data)
    end,
    on_exit = on_exit,
})

vim.print(string.format('jobid is %s', jobid1))

local jobid = job.start({ 'cat' }, {
    on_stdout = function(id, data)
        vim.print(data)
    end,
    on_exit = function(id, code, signal)
        print('job ' .. id .. ' exit code:' .. code .. ' signal:' .. signal)
    end,
})

job.send(jobid, { 'hello' })

job.chanclose(jobid, 'stdin')

为什么不切换到 vim.system

我不太记得 vim.system 是什么时候加入到 Neovim 的了，其前后应该也功能迭代过几个版本。为什么我还在继续维护 job.nvim 而不切换到 vim.system 呢？

没有对 stdout 数据进行拼接处理，容易有截断数据，而且传给 callback 函数的数据是 string 而非像 jobstart 那样是 string 列表。当然，数据类型都是次要的事情，使用 split 函数很容易得到列表，但是未做数据拼接这点，在写 callback 函数时会增加很多额外的代码量。
callback 函数内无法确认到底是哪个 job 调用触发的这个 callback 函数，应该像 jobstart() 的 stdout callback 函数那样，传入一个 jobid 参数。

我创建 job.nvim 的主要原因是：在旧的 Neovim 版本中，没有 vim.system。第一个版本是 job.vim，它使用 VimL，并以与 Neovim 的 jobstart 相同的 API 支持 Neovim 和 Vim。我需要为不同的 job 的 stdout 使用相同的 callback 函数。例如，在我的插件管理器 https://github.com/wsdjeg/nvim-plug 中，当同时克隆 8 个插件时，我需要在 job 退出前显示每个 job 的进度。因此在 stdout callback 函数中，我需要知道是哪个 job 触发了这个 callback 函数。据我所知，即使现在的 vim.system 的 stdout callback 也不支持这个功能。两种写法，哪种更简单方便，一目了然：使用 vim.system:

local function on_stdout(err, data)
  --- 首先，这里需要对 data 判断数据的完整性，然后参考以下鬼方法来拼接：
  --    There are two ways to deal with this:
  --    - 1. To wait for the entire output, use |channel-buffered| mode.
  --    - 2. To read line-by-line, use the following code: >vim
  -- let s:lines = ['']
  -- func! s:on_event(job_id, data, event) dict
  --   let eof = (a:data == [''])
  --   " Complete the previous line.
  --   let s:lines[-1] .= a:data[0]
  --   " Append (last item may be a partial line, until EOF).
  --   call extend(s:lines, a:data[1:])
  -- endf

  -- 然后，拼接完成后，再执行逐行提取
  for _, line in ipairs(data) do
    local progress = string.match(line, '%d*%%')

    -- 然后在这个地方，你就会发现，无法判断这到底是哪个 Job 触发的 callback 函数了。
  end
end

-- clone plugin A
vim.system({ 'git', 'clone', url_a }, { stdout = on_stdout })

-- clone plugin B
vim.system({ 'git', 'clone', url_b }, { stdout = on_stdout })

使用 job.nvim:

local job = require('job')
local jobs = {}
local function on_stdout(id, data)
  for _, line in ipairs(data) do
    print(
      string.format(
        'repo %s clone progress %s',
        jobs[id],
        string.match(line, '%d*%%')
      )
    )
  end
end

-- clone plugin A
local id1 = job.start({ 'git', 'clone', url_a }, {
  on_stdout = on_stdout,
})

jobs[id1] = 'A'

-- clone plugin B
local id2 = job.start({ 'git', 'clone', url_b }, {
  on_stdout = on_stdout,
})

jobs[id2] = 'B'

写在最后

也许，job.nvim 在许多年后会停止维护，那一定是我找到了更合适的内置替代方案。至少目前，vim.system 的实现还没有完全满足我的使用需求。最后，我终于理解 avante.nvim 的作者为什么删掉 Reddit 账号了。吵架真的很烦。 https://www.reddit.com/r/neovim/comments/1rdgfxg/comment/o7bzfzc/ vim.system 的设计本身就有问题。我自己写了将近二三十个异步调用命令的插件，难道我遇到的问题还不够多吗？有些人一再给我强调可以在 exit_cb 里面区分 job，难道调用常驻命令时，要等它们执行完毕才能看到结果吗？那就让我们看看以后的版本 vim.system 会不会增加这样的参数传入，或者会不会有类似的新的内置函数出现吧。

从零开始理解如何制作自己的 AI 助手

Wed, 25 Feb 2026 00:00:00 +0000

与服务器互动的基本原理
消息角色（role）
那些”新概念”文件到底是什么？

大约一年前，我开始关注 AI 相关的内容。从一开始的简单代码补全，到后来的文本对话，再到工具调用，新技术层出不穷，确实令人兴奋。但最近我发现，有些人刻意制造新概念，试图将它们包装成新技术来吸引流量，这让我感到十分反感。于是，我决定从零开始学习 AI 相关知识，并着手开发 AI 相关的 Neovim 插件。整个过程踩了不少坑，但也逐渐理解了用户与 AI 之间的沟通逻辑。因此，我想把这些内容整理成文字，帮助大家更好地理解用户与 AI 沟通时的底层逻辑，同时也便于区分什么是真正的新技术，什么是人为包装的伪概念。那就从简单的 DeepSeek 官网开发者文档开始吧。

与服务器互动的基本原理

与大模型之间的沟通，通常是通过 API 请求完成的。比如向 DeepSeek 发送一句 Hello!，实际上执行的命令是：

curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${DEEPSEEK_API_KEY}" \
  -d '{
        "model": "deepseek-chat",
        "messages": [
          {"role": "system", "content": "You are a helpful assistant."},
          {"role": "user", "content": "Hello!"}
        ],
        "stream": false
      }'

得到的回复大致如下：

{
  "id": "930c60df-bf64-41c9-a88e-3ec75f81e00e",
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "Hello! How can I help you today?",
        "role": "assistant"
      }
    }
  ],
  "created": 1705651092,
  "model": "deepseek-chat",
  "object": "chat.completion",
  "usage": {
    "completion_tokens": 10,
    "prompt_tokens": 16,
    "total_tokens": 26
  }
}

为了方便展示，我移除了一些额外内容，只保留核心部分。实际上发送给服务器的消息数据是：

[
  { "role": "system", "content": "You are a helpful assistant." },
  { "role": "user", "content": "Hello!" }
]

而得到的回复也是一个单独的消息：

{
  "role": "assistant",
  "content": "Hello! How can I help you today?"
}

此时，如果我们想要保留会话历史并继续发送内容 What's the weather in SF?，就需要将服务器返回的消息追加到消息列表中，然后添加新的用户消息。于是，我们发送给服务器的消息变成这样：

[
  { "role": "system", "content": "You are a helpful assistant." },
  { "role": "user", "content": "Hello!" },
  { "role": "assistant", "content": "Hello! How can I help you today?" },
  { "role": "user", "content": "What's the weather in SF?" }
]

服务器除了返回文本内容外，有时还会返回 tool_call。这意味着返回的 JSON 中包含要调用的函数名称和参数，你收到的消息大致如下：

{
  "id": "call_123abc",
  "type": "function",
  "function": {
    "name": "get_weather",
    "arguments": "{\"location\": \"San Francisco\", \"unit\": \"celsius\"}"
  }
}

然后，你的助手软件实际上会做的是：根据这个 tool_call 内容调用对应的本地功能函数，执行完成后，将结果连同上面的 tool_call 一起再次“自动”发送给服务器。于是，发送给服务器的消息大致如下：

[
  { "role": "system", "content": "You are a helpful assistant." },
  { "role": "user", "content": "Hello!" },
  { "role": "assistant", "content": "Hello! How can I help you today?" },
  { "role": "user", "content": "What's the weather in SF?" },
  {
    "role": "assistant",
    "tool_calls": [
      {
        "id": "call_123",
        "type": "function",
        "function": {
          "name": "get_weather",
          "arguments": "{\"location\": \"San Francisco\"}"
        }
      }
    ]
  },
  {
    "role": "tool",
    "tool_call_id": "call_123",
    "content": "{\"temperature\": 18, \"conditions\": \"Sunny\", \"humidity\": 65}"
  }
]

服务器给你返回的内容如果任然是 tool_call 那么就可以继续调用本地工具执行完成后返回给服务器。这样的“自动”请求步骤循环下去，就形成了一个自动化的智能助手假象。直到服务器返回的内容不再是 tool_call 而是 content，就可以将内容前台展示给用户了：

{
  "role": "assistant",
  "content": "The weather in San Francisco is currently 18°C and sunny with 65% humidity."
}

以上内容就是一个最基本的智能助手低层网络请求的逻辑。

消息角色（role）

从上面的请求消息内容可以看到，消息的角色（role）目前有四种：system、user、assistant、tool。各角色详解： user：这是用户输入的内容，对应聊天界面中输入框输入的信息。 assistant：服务器返回的内容，有两种形式：

content：文本消息内容，直接显示在聊天界面
tool_call：函数调用指令，告诉客户端需要执行什么功能

tool：当客户端收到 tool_call 后，执行相应功能并将结果以 tool 角色发送给服务器。 system：（这里需要重点澄清）很多应用没有提供设置 system 角色的界面，但这个角色不是简单的“底层内容”，而是对话的“基础指令集”。它的主要作用是：

设定助手的行为准则：如”你是一个专业的编程助手”
定义回答风格：如”用简洁的语言回答，避免冗长”
设置安全边界：如”不回答涉及暴力、违法内容的问题”
提供上下文信息：如”当前项目使用 TypeScript 5.0”

一个标准的 system 消息示例：

{
  "role": "system",
  "content": "你是一个专业的软件开发助手。回答问题时请提供代码示例，并解释关键概念。如果用户的问题涉及不道德或违法内容，请礼貌拒绝。"
}

那些”新概念”文件到底是什么？

我开头所说的伪新概念，指的是目前在社区中流传的各种”配置文件”，比如：

实际存在的配置文件

AGENTS.md

实际用途：为AI编码代理提供项目上下文和指令
类比：项目的”README for agents”
现状：已被6万多个开源项目使用，确实有实际价值
示例内容：项目结构、构建命令、编码规范等

CLAUDE.md

实际用途：Claude Code的配置文件，定义AI子代理的行为
位置：通常位于 .claude/ 目录下
功能：配置工具调用、代码风格偏好等

过度包装的概念

SOUL.md（灵魂文件）

宣称功能：定义AI代理的”性格”、”价值观”、”沟通风格”
实际本质：就是加了营销术语的 system 指令
示例：原本的 system 消息换个文件名就成了”灵魂”

SKILLS.md（技能文件）

宣称功能：列出AI能执行的所有”技能”
实际本质：工具函数（tool_call）的文档化列表
问题：与代码中的工具定义重复，维护成本高

如何看待这些概念

文件类型	实际价值	创新程度
AGENTS.md	高	中等（提供了标准化格式）
CLAUDE.md	中	低（平台特定配置）
SOUL.md	低	极低（换名不换药）
SKILLS.md	低	极低（文档化工具列表）

核心观点

技术本质没变：这些文件底层还是通过 system 消息或工具定义来实现
创新 vs 包装：
- 真创新：AGENTS.md 提供了标准化的项目上下文传递方式
- 伪概念：SOUL.md 等只是给现有技术换了个好听的名字
开发建议：
- 使用 AGENTS.md 提升AI编码效率 ✓
- 不要被”灵魂”、”技能”等营销术语迷惑 ✗
- 理解底层的 system 和 tool_call 机制才是关键

实际开发中的选择

# 推荐的配置方式

## 1. 核心配置（必需）

- `system` 消息：定义助手基本行为
- 工具函数：实际可用的功能

## 2. 项目配置（推荐）

- AGENTS.md：项目级AI辅助配置

## 3. 避免过度设计

- 不需要 SOUL.md、SKILLS.md 等冗余文件
- 保持配置简洁，避免维护负担

真正的技术创新应该解决实际问题，而不是发明新名词。理解了消息传递的底层机制，就能一眼看穿哪些是真正有用的工具，哪些只是华丽的包装。

Neovim 智能对话伙伴 chat.nvim

Tue, 03 Feb 2026 00:00:00 +0000

安装及配置 chat.nvim
使用操作界面
多 AI 提供商支持
picker.nvim 集成
内置工具支持
会话管理
- 并行会话
IM 集成
HTTP API
- API 端点
- 使用示例
快捷键
总结

很长一段时间，AI 一直是一个非常热门的话题。衍生出来的工具也非常的多，从我接触的顺序来看，从最早的 tabline 补全到后来的 GitHub Copilot 补全。再到后来的 ChatGPT 以及之后来的各自类似的 Chat 工具。前面我使用最多的还是网页版的 ChatGPT，使用过程中最大的一个问题就是请求结果渲染展示一直是有问题的。尤其是让他展示 markdown 源码时。比如：上述图片 Usage 实际上也在代码块里面是，但是由于 markdown 内还有代码块，导致解析展示出问题。正是由于这个原因，我制作了 Neovim AI 聊天插件 chat.nvim，我需要以纯文本展示请求结果的完整内容。

安装及配置 chat.nvim

使用任意插件管理器，比如 nvim-plug:

local deepseek_api_key = 'xxxxxxxxxxx'
local free_chatgpt_api_key = 'xxxxxxxxxxxxxxx'
require('plug').add({
  {
    'wsdjeg/chat.nvim',
    depends = {
      {
        'wsdjeg/job.nvim', -- Required
        'wsdjeg/picker.nvim', -- Optional but recommended
      },
    },
  },
})

使用操作界面

chat.nvim 默认是上下分屏两个浮窗，分别为输入窗口和结果展示窗口。如图：

多 AI 提供商支持

chat.nvim 内置支持多种 AI 服务提供商：

DeepSeek - DeepSeek AI
GitHub AI - GitHub AI
Moonshot - Moonshot AI
OpenRouter - OpenRouter
Qwen - Alibaba Cloud Qwen
SiliconFlow - SiliconFlow
Tencent Hunyuan - 腾讯混元
BigModel - BigModel AI
Volcengine - 火山引擎
OpenAI - OpenAI
LongCat - LongCat AI
CherryIN - CherryIN AI
YuanJing - 元境 AI

同时还支持自定义提供商，你可以创建 ~/.config/nvim/lua/chat/providers/<provider_name>.lua 来添加新的 AI 服务。

picker.nvim 集成

chat.nvim 自带了一些 picker.nvim 插件的拓展，目前支持的拓展有：

:Picker chat - 搜索历史对话
:Picker chat_provider - 搜索并切换 provider
:Picker chat_model - 搜索并切换当前 provider 提供的模型

内置工具支持

chat.nvim 支持丰富的内置工具，让 AI 可以直接与编辑器交互：

文件操作工具

@read_file - 读取文件内容（支持指定行范围）
@find_files - 搜索文件
@search_text - 搜索文件内容（支持正则表达式、文件类型过滤等）
@git_diff - 查看 git diff 信息

网页工具

@web_search - 网络搜索（支持 Firecrawl、Google、SerpAPI）
@fetch_web - 获取网页内容

记忆系统

chat.nvim 实现了三层记忆系统，灵感来自认知心理学：

工作记忆 (Working Memory) ⚡ - 当前会话的任务和决策（最高优先级）
日常记忆 (Daily Memory) 📅 - 临时任务和短期目标（7-30天后自动过期）
长期记忆 (Long-term Memory) 💾 - 永久知识存储（事实、偏好、技能）

其他工具

@set_prompt - 设置系统提示词
@plan - 任务计划管理
@zettelkasten_create - 创建笔记（需要 zettelkasten.nvim）
@zettelkasten_get - 获取笔记（需要 zettelkasten.nvim）

会话管理

chat.nvim 提供了完整的会话管理功能：

:Chat - 打开当前会话
:Chat new - 创建新会话
:Chat prev / :Chat next - 切换会话
:Chat clear - 清空当前会话
:Chat delete - 删除当前会话
:Chat save <path> - 保存会话到文件
:Chat load <path> - 从文件或 URL 加载会话
:Chat share - 分享会话到 pastebin
:Chat preview - 在浏览器中预览会话

并行会话

chat.nvim 支持同时运行多个独立的聊天会话：

每个会话可以使用不同的 AI 模型
会话之间保持独立的对话历史和设置
使用 :Chat prev 和 :Chat next 快速切换

IM 集成

chat.nvim 支持多种第三方聊天平台集成，可以将 Neovim 的 AI 对话能力扩展到各个平台：

平台	图标	双向通信	特点
Discord	💬	✅ 是	完整的机器人功能，会话绑定
飞书	🐦	✅ 是	飞书机器人，消息轮询
钉钉	📱	✅ 是*	Webhook（单向）或 API（双向）
企业微信	💼	✅ 是*	企业微信 Webhook 或 API
Telegram	✈️	✅ 是	Bot API，支持群组和私聊

Discord 集成

通过 Discord 集成，你可以：

在 Discord 频道中与 AI 助手交互
使用 :Chat bridge discord 绑定当前会话
使用 /session 命令确认绑定
通过提及机器人或回复消息来触发对话

飞书集成

飞书集成支持：

双向消息通信
自动轮询新消息
长消息支持（最多 30,720 字符）

消息同步

通过这些集成，可以实现 Neovim 与各平台的消息同步：这些集成功能让 chat.nvim 成为一个多平台的 AI 对话中心，不仅可以在 Neovim 内使用，还可以作为各种聊天平台的智能助手。

HTTP API

chat.nvim 内置了 HTTP 服务器功能，提供 RESTful API 接口：

http = {
  host = '127.0.0.1',
  port = 7777,
  api_key = 'your-secret-key',
}

API 端点

POST / - 发送消息到指定会话
GET /sessions - 获取所有活跃会话列表
GET /session - 获取会话的 HTML 预览（需要 id 参数）

使用示例

# 发送消息
curl -X POST http://127.0.0.1:7777/ \
  -H "X-API-Key: your-secret-key" \
  -H "Content-Type: application/json" \
  -d '{"session": "my-session", "content": "Hello from curl!"}'

# 获取会话列表
curl -H "X-API-Key: your-secret-key" http://127.0.0.1:7777/sessions

这使得外部应用可以轻松集成 chat.nvim 的对话能力，比如 CI/CD 流水线、监控系统等。

快捷键

在输入窗口中：

<Enter> - 发送消息
q - 关闭聊天窗口
<Tab> - 切换输入和结果窗口
Ctrl-C - 取消当前请求
Ctrl-N - 新建会话
r - 重试上次取消的请求
alt-h / alt-l - 上一个/下一个会话

在结果窗口中：

q - 关闭聊天窗口
<Tab> - 切换输入和结果窗口

总结

从最初为了解决 markdown 渲染问题而开发的聊天插件，到现在支持多种 AI 提供商、内置工具系统、三层记忆架构、多平台集成、HTTP API 等功能，chat.nvim 已经发展成为一个功能强大的 Neovim AI 助手。它不仅能帮助你在编辑器内高效地与 AI 对话，还能通过各种工具直接操作文件、搜索网络、管理记忆，真正成为了开发者的智能伙伴。更多详细信息，请访问 chat.nvim GitHub 仓库。

Neovim buffer 删除插件 bufdel.nvim

Wed, 28 Jan 2026 00:00:00 +0000

为什么再写一个 bufdel 插件
bufdel.nvim 的核心设计
删除之后，切到哪个 buffer
用户命令Bdelete/Bwipeout
一个 Vim 本身的限制说明
自定义用户事件
和其他插件的简单对比
写在最后

在使用 Neovim 的过程中，「删除 buffer 但不破坏窗口布局」一直是一个高频需求。社区里已经有不少相关插件，比如 bufdelete.nvim、nvim-bufdel、mini.bufremove，以及 snacks.bufdelete。但是在我自己长期使用过程中，总觉得缺少了我需要的功能。于是，我写了一个新的插件：bufdel.nvim。这篇文章简单聊聊它解决了什么问题、有哪些设计取舍，以及它和现有方案的区别。

为什么再写一个 bufdel 插件

先说结论：bufdel.nvim 设计初衷是为了删除 buffer 这个操作的每一步更加可控。我写这个插件，主要有几个原因：

bufdelete.nvim 已经 archived bufdelete.nvim 是一个非常优秀的插件，我也之前也使用过一段时间。但它目前已经被标记为 archived，不再维护。我希望有一个持续维护、可扩展的替代方案，同时保留它最核心、最优雅的设计。
我需要更灵活的 buffer 选择方式很多插件只支持按照 buffer number 删除，但是再实际使用中，我经常需要：
- 按照 buffer name 删除
- 按照正则表达式匹配到的 buffer 名称删除
- 按照特定的条件函数删除（比如：未修改、已列出、非当前 buffer）
删除之后，切换到哪个 buffer，应该是可控的前面提到的几个插件大多数在删除 buffer 后，选择切换到 bufnr('#')。但我更希望能明确指定下一个 buffer 是哪个或者通过函数，完全自定义切换逻辑。

bufdel.nvim 的核心设计

一个核心 API：delete(buffers, opt) bufdel.nvim 只暴露一个核心函数，但是它支持的参数非常灵活。不少其他的插件会设计两个 API 函数 delete 和 wipeout，其实完全可以合并，通过 opt 内一个选项区分。
```
require('bufdel').delete(buffers, opt)
```
buffers 参数：你想怎么选 buffer 都行 buffers 支持多种形式：
- 单个 buffer number
- buffer 名称（字符串）
- Vim 正则（匹配 buffer name）
- table（混合 bufnr / bufname / regex）
- 函数过滤器
比如，删除所有已列出、已保存的非当前 buffer：
```
require('bufdel').delete(function(buf)
  return not vim.bo[buf].modified
    and vim.bo[buf].buflisted
    and buf ~= vim.api.nvim_get_current_buf()
end, { wipe = true })
```
这类逻辑，在很多其他插件里是做不到的。
正则匹配 buffer 名称如果你想清理一类文件，比如所有 .txt buffer：
```
require('bufdel').delete('.txt$', { wipe = true })
```
这在日常清理临时文件、日志文件时非常方便。

删除之后，切到哪个 buffer

这是 bufdel.nvim 的一个重点特性。

使用函数自定义切换逻辑（推荐）

require('bufdel').delete(filter, {
  wipe = true,
  switch = function(deleted_buf)
    return vim.fn.bufnr('#') -- 切换到 alternate buffer
  end,
})

你可以在这里实现任何策略，只要返回一个有效的 buffer number。

内置几种常用策略如果不想写函数，也可以直接用字符串：
```
switch = 'alt'
```
当前支持：
- alt：alternate buffer（#）
- current：保持当前 buffer
- lastused：最近使用的 buffer
- next / prev：下一个 / 上一个 buffer
直接指定 buffer number
```
switch = 3
```

用户命令`Bdelete`/`Bwipeout`

bufdel.nvim 提供了两个命令：

:Bdelete

:Bwipeout

行为和 :bdelete / :bwipeout 一致，但不会改变窗口布局。示例：

:Bdelete
:Bdelete 3
:Bdelete 2 5 7
:3,6Bdelete

一个 Vim 本身的限制说明

和原生 :bdelete 一样：纯数字的 buffer 名称不能作为用户命令参数使用。比如：

:e 123
:Bdelete 123

这时必须使用 bufnr，而不是 bufname。

自定义用户事件

bufdel.nvim 会在删除 buffer 前后触发两个事件：

User BufDelPre

User BufDelPost

示例：

vim.api.nvim_create_autocmd('User', {
  pattern = 'BufDelPost',
  callback = function(ev)
    -- 被删除的 bufnr 在 ev.data.buf 中
  end,
})

如果删除失败，BufDelPost 不会触发。

和其他插件的简单对比

下面是基于我个人使用需求的一个对比表：

Feature / Plugin	bufdel.nvim	bufdelete.nvim	nvim-bufdel	snacks.bufdelete	mini.bufremove
Preserve window layout	✓	✓	✓	✓	✓
Delete by bufnr	✓	✓	✓	✓	✓
Delete by bufname	✓	✓	✓	✓	✗
User Command	✓	✓	✓	✗	✗
Lua filter function	✓	✗	✗	✓	✗
Regex buffer matching	✓	✗	✗	✗	✗
Post-delete buffer switch	✓	✓	✓	✗	✗
User autocmd hooks	✓	✓	✗	✗	✗

如果你发现表格里有不准确的地方，欢迎直接提 issue。

写在最后

bufdel.nvim 并不是一个“什么都做”的插件，相反，我刻意让它保持：

功能边界清晰
API 简单
逻辑可控

如果你：

经常清理 buffer
在意窗口布局
希望对 buffer 删除过程有更多掌控

那它可能正好适合你。 👉 GitHub：wsdjeg/budel.nvim 如果你觉得有用，欢迎 star ⭐

Neovim 日历插件 calendar.nvim

Sun, 04 Jan 2026 00:00:00 +0000

插件安装
基本使用
记录一些坑
最终效果图

早在写 zettelkasten.nvim 插件的时候，我就想做一个日历试图，用来查看笔记的日期。可能是因为需求不是那么的迫切，所以一直拖着没有写这样功能。趁着这次假日，抽空写了这样一个日历插件 calendar.nvim，功能目前还是非常简单的，只是一个简单的日历月视图。这算是 2026 年我的第一个 Neovim 插件，这篇文字主要介绍 calendar.nvim 插件的安装使用以及制作这一插件遇到的一些问题。

插件安装

calendar.nvim 是使用 Lua 实现的 Neovim 插件，零依赖，可以使用任意插件管理器直接安装，比如：nvim-plug

require('plug').add({
  {
    'wsdjeg/calendar.nvim',
  },
})

基本使用

插件的默认配置如下：

require('calendar').setup({
  mark_icon = '•',
  keymap = {
    next_month = 'L',      -- 下个月
    previous_month = 'H',  -- 上个月
    next_day = 'l',        -- 后一天
    previous_day = 'h',    -- 前一天
    next_week = 'j',       -- 下一周
    previous_week = 'k',   -- 前一周
    today = 't',           -- 跳到今天
  },
  highlights = {
    current = 'Visual',
    today = 'Todo',
    mark = 'Todo',
  },
})

记录一些坑

nvim_buf_set_extmark 函数中 col 等参数指的并不是屏幕 column 列表，而是字符串的字节，
overlay virt_text 的高亮会清除掉当前位置的 extmark hl_group 高亮

最终解决逻辑是给每一个需要标记的位置按照如下逻辑添加 virt_text，其高亮参数传输一个高亮列表.

local hls = { highlights.mark }

if is_totay() then
  table.insert(hls, highlights.today)
end

if is_current() then
  table.insert(hls, highlights.current)
end

vim.api.nvim_buf_set_extmark(buf, ns, col, {
  virt_text = { { mark_icon, hls } },
})

最终效果图

这里展示了一个添加了 zettelkasten 拓展的日历：

local zk_ext = {}

function zk_ext.get(year, month)
  local notes = require('zettelkasten.browser').get_notes()
  local marks = {}
  for _, note in ipairs(notes) do
    local t = vim.split(note.id, '-')
    if tonumber(t[1]) == year and tonumber(t[2]) == month then
      table.insert(
        marks,
        {
          year = tonumber(t[1]),
          month = tonumber(t[2]),
          day = tonumber(t[3]),
        }
      )
    end
  end

  return marks
end

require('calendar.extensions').register(zk_ext)

最终的效果图如下：

文件路径大小写敏感导致 Lua 模块重载

Sun, 28 Dec 2025 00:00:00 +0000

事情起因
寻找原因
如何修复？
总结

事情起因

时隔十年，再次被 Windows 系统的路劲大小写问题坑了一把。记得上一次被坑是因为写 Vim Script 的 autoload 脚本时出现的问题。最近使用 Lua 重新写了 ChineseLinter.vim 这个插件，最开始的文件结构：文件：plugins/chineselinter.lua

return {
  'wsdjeg/ChineseLinter.nvim',
  dev = true,
  opts = {
    ignored_errors = { 'E015', 'E013', 'E020', 'E021' },
  },
  cmds = { 'CheckChinese' },
  desc = 'Chinese Document Language Standards Checking Tool',
}

按照以上配置，无论如何 ignored_errors 配置都无法起效。

寻找原因

上述插件在载入时没有报错，说明被成功载入并且执行了 setup 函数。我试着用单独的脚本来测试，并且打入一些日志：

vim.opt.runtimepath:append("D:/wsdjeg/job.nvim")
vim.opt.runtimepath:append("D:/wsdjeg/logger.nvim")
vim.opt.runtimepath:append("D:/wsdjeg/nvim-plug")

require('plug').setup({

    bundle_dir = 'D:/bundle_dir',
    raw_plugin_dir = 'D:/bundle_dir/raw_plugin',
    -- ui = 'notify',
    http_proxy = 'http://127.0.0.1:7890',
    https_proxy = 'http://127.0.0.1:7890',
    enable_priority = false,
    enable_luarocks = true,
    max_processes = 16,
    dev_path = 'D:/wsdjeg',
})

require("plug").add({
	{
		"wsdjeg/ChineseLinter.nvim",
		dev = true,
		opts = {
			ignored_errors = { "E015", "E013", "E020", "E021" },
		},
		cmds = { "CheckChinese" },
		desc = "Chinese Document Language Standards Checking Tool",
	},
})

日志结果如下：

[ 23:35:32:449 ] [ Info  ] [ cnlint ] module is loaded
[ 23:35:32:450 ] [ Info  ] [ cnlint ] setup function is called
[ 23:35:32:450 ] [ Info  ] [   plug ] load plug: ChineseLinter.nvim in 4.3624ms
[ 23:35:32:451 ] [ Info  ] [ cnlint ] module is loaded
[ 23:35:32:451 ] [ Info  ] [ cnlint ] check function is called

不难看出 ChineseLinter 模块被载入了两次，第一次载入及setup函数是 nvim-plug 在执行，执行后计算的载入时间，第二次是执行 CheckChinese 命令时，而这一命令是在 plugin/ChineseLinter.lua 内定义的：

vim.api.nvim_create_user_command("CheckChinese", function(opt)
	require("ChineseLinter").check()
end, { nargs = "*" })

问题就在这里，这个命令内 require('ChineseLinter') 不应该再次载入模块文件，因为前面 nvim-plug 已经执行过一次了，正常情况下 package.loaded 内会缓存模块。看一下 nvim-plug 载入 Lua 插件的逻辑，它会给 plugSpec 自动设置一个模块名称，以便于自动执行 require(plugSpec.module).setup(plugSpec.opts)。问题就在于这个 module 名称生成函数原先是：

local function get_default_module(name)
  return name
    :lower()
    :gsub('[%.%-]lua$', '')
    :gsub('^n?vim-', '')
    :gsub('[%.%-]n?vim', '')
end

也就是说，按照上述载入插件方式，nvim-plug 执行的是 require('chineselinter')，这在 Windows 系统下, 因为文件 lua/ChineseLinter/init.lua 已存在，那么上述 require 函数就会读取这个模块。而 :CheckChinese 命令实际上调用的模块是 require('ChineseLinter')。因为 Lua 的模块名称实际上是大小写敏感的，就会再次去寻找模块文件以载入。

如何修复？

我查阅了几个插件管理器，他们的获取模块名称的函数基本上逻辑类似，都使用了 lower() 函数：

lazy.nvim

---@param name string
---@return string
function M.normname(name)
  local ret = name:lower():gsub("^n?vim%-", ""):gsub("%.n?vim$", ""):gsub("[%.%-]lua", ""):gsub("[^a-z]+", "")
  return ret
end

实际上，最好是不要自动去将模块的名字全部小写，按照仓库的名称来最合适，去除掉前后缀，修改 nvim-plug 如下：

diff --git a/lua/plug/loader.lua b/lua/plug/loader.lua
index d0fc7b6..957fcb7 100644
--- a/lua/plug/loader.lua
+++ b/lua/plug/loader.lua
@@ -68,8 +68,7 @@ end
 --- @param name string
 --- @return string
 local function get_default_module(name)
-    return name:lower()
-        :gsub('[%.%-]lua$', '')
+    return name:gsub('[%.%-]lua$', '')
         :gsub('^n?vim-', '')
         :gsub('[%.%-]n?vim', '')
 end
@@ -94,6 +93,13 @@ function M.parser(plugSpec)
     plugSpec.name = check_name(plugSpec)
     if not plugSpec.module then
         plugSpec.module = get_default_module(plugSpec.name)
+        log.info(
+            string.format(
+                'set %s default module name to %s',
+                plugSpec.name,
+                plugSpec.module
+            )
+        )
     end
     if #plugSpec.name == 0 then
         plugSpec.enabled = false

考虑到 Windows 系统的大小写敏感，以及 Shift 键这么难按，我将插件的名称以及其内模块的名称都改成了小写，修改后插件的安装方式：

return {
  'wsdjeg/chineselinter.nvim',
  dev = true,
  opts = {
    ignored_errors = { 'E015', 'E013', 'E020', 'E021' },
  },
  cmds = { 'CheckChinese' },
  desc = 'Chinese Document Language Standards Checking Tool',
}

总结

上述核心问题在于 Lua 的 require() 函数读取模块缓存时判断的是 package.load[key]，这里的 key 是大小写敏感的。而发现缓存不存在时，依照 key 去载入文件时，在 Windows 系统下路劲又是不敏感的，会导致同一个模块被不同的大小写模块名称多次载入。

Neovim 悬浮滚动条 scrollbar.nvim

Thu, 25 Dec 2025 00:00:00 +0000

scrollbar.nvim 简介
安装 scrollbar.nvim
插件的配置

scrollbar.nvim 简介

好几年前，我使用 Vim Script 实现过一个悬浮侧栏插件 scrollbar.vim，前段时间该插件使用 Lua 进行了重写并改名称为 scrollbar.nvim，重写后的插件只支持 Neovim。 scrollbar.nvim 会在当前窗口的右侧使用浮窗绘制一个滚动条，其位置依据当前窗口显示的内容在整个文件中所在的行数，并且随着鼠标移动、滚屏等操作上下移动。

安装 scrollbar.nvim

使用 nvim-plug 进行安装：

require('plug').add({
    {
        'wsdjeg/scrollbar.nvim'
    }
})

或者使用 luarocks 进行安装：

luarocks install scrollbar.nvim

插件的配置

require('scrollbar').setup({
  max_size = 10,
  min_size = 5,
  width = 1,
  right_offset = 1,
  excluded_filetypes = {
    'startify',
    'git-commit',
    'leaderf',
    'NvimTree',
    'tagbar',
    'defx',
    'neo-tree',
    'qf',
  },
  shape = {
    head = '▲',
    body = '█',
    tail = '▼',
  },
  highlight = {
    head = 'Normal',
    body = 'Normal',
    tail = 'Normal',
  },
  debug = false,
})

如何正确地使用 ftplugin 目录

Tue, 23 Dec 2025 00:00:00 +0000

前面再阅读一些插件源码时，发现一个问题，很多插件的使用了 ftplugin 这个目录，其内的脚本文件中直接使用了 setlocal xx=xx 这样的语法。在早期的 Neovim 或者 Vim 版本中这样确实没有问题，但是随着 Neovim 功能特性增加。这样写就会容易出错。实际上，直到目前为止 Neovim 和 Vim 的官方文档 :h ftplugin 内的示例还是：

" Only do this when not done yet for this buffer
if exists("b:did_ftplugin")
  finish
endif
let b:did_ftplugin = 1
setlocal textwidth=70

Neovim 插件的 ftplugin 目录是一个特殊的文件夹，其内的文件会在 FileType 事件触发是被载入。看一下 Neovim 的源码，ftplugin 目录下的文件是如何被载入的。

augroup filetypeplugin
  au FileType * call s:LoadFTPlugin()

  func! s:LoadFTPlugin()
    if exists("b:undo_ftplugin")
      exe b:undo_ftplugin
      unlet! b:undo_ftplugin b:did_ftplugin
    endif

    let s = expand("<amatch>")
    if s != ""
      if &cpo =~# "S" && exists("b:did_ftplugin")
	" In compatible mode options are reset to the global values, need to
	" set the local values also when a plugin was already used.
	unlet b:did_ftplugin
      endif

      " When there is a dot it is used to separate filetype names.  Thus for
      " "aaa.bbb" load "aaa" and then "bbb".
      for name in split(s, '\.')
        " Load Lua ftplugins after Vim ftplugins _per directory_
        " TODO(clason): use nvim__get_runtime when supports globs and modeline
        " XXX: "[.]" in the first pattern makes it a wildcard on Windows
        exe $'runtime! ftplugin/{name}[.] ftplugin/{name}_*. ftplugin/{name}/*.'
      endfor
    endif
  endfunc
augroup END

以上内容不难看出，Neovim 实际上是监听了 FileType 这个事件，然后根据 expand('<amatch>') 的值来执行 :runtime 命令。但是，随着 Neovim 和 Vim 增加了设置非当前 buffer 的 option 这一功能后。就会出现这样问题，当 FileType 事件触发时，触发的 buffer 并非是当前 buffer。那么在 ftplugin 内如果使用了 setlocal 这样的命令，有可能会设置错了缓冲区。 test_ft.lua

local log = require("logger").derive("ft")
log.info("nvim_get_current_buf() is " .. vim.api.nvim_get_current_buf())
log.info("nvim_get_current_win() is " .. vim.api.nvim_get_current_win())
log.info("-----------------------------------------------------")
local real_current_win = vim.api.nvim_get_current_win()
local newbuf = vim.api.nvim_create_buf(true, false)

local events = {}

for _, v in ipairs(vim.fn.getcompletion("", "event")) do
	if not vim.endswith(v, "Cmd") then
		table.insert(events, v)
	end
end

local id = vim.api.nvim_create_autocmd(events, {
	group = vim.api.nvim_create_augroup("test_ft", { clear = true }),
	pattern = { "*" },
	callback = function(ev)
		log.info("-----------------------------------------------------")
		log.info("event is " .. ev.event)
		log.info("ev.buf is " .. ev.buf)
		log.info("nvim_get_current_buf() is " .. vim.api.nvim_get_current_buf())
		log.info("nvim_get_current_win() is " .. vim.api.nvim_get_current_win())
		log.info("real_current_win's buf is" .. vim.api.nvim_win_get_buf(real_current_win))
	end,
})

vim.api.nvim_open_win(newbuf, false, { split = "above" })
vim.api.nvim_set_option_value("filetype", "test123", { buf = newbuf })
vim.api.nvim_del_autocmd(id)
log.info("-----------------------------------------------------")
log.info("nvim_get_current_buf() is " .. vim.api.nvim_get_current_buf())
log.info("nvim_get_current_win() is " .. vim.api.nvim_get_current_win())

[ 23:50:19:932 ] [ Info  ] [     ft ] nvim_get_current_buf() is 7
[ 23:50:19:932 ] [ Info  ] [     ft ] nvim_get_current_win() is 1000
[ 23:50:19:932 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:50:19:933 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:50:19:933 ] [ Info  ] [     ft ] event is WinNew
[ 23:50:19:933 ] [ Info  ] [     ft ] ev.buf is 7
[ 23:50:19:933 ] [ Info  ] [     ft ] nvim_get_current_buf() is 7
[ 23:50:19:933 ] [ Info  ] [     ft ] nvim_get_current_win() is 1008
[ 23:50:19:933 ] [ Info  ] [     ft ] real_current_win's buf is7
[ 23:50:19:934 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:50:19:934 ] [ Info  ] [     ft ] event is BufWinEnter
[ 23:50:19:934 ] [ Info  ] [     ft ] ev.buf is 9
[ 23:50:19:934 ] [ Info  ] [     ft ] nvim_get_current_buf() is 9
[ 23:50:19:934 ] [ Info  ] [     ft ] nvim_get_current_win() is 1008
[ 23:50:19:934 ] [ Info  ] [     ft ] real_current_win's buf is7
[ 23:50:19:953 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:50:19:953 ] [ Info  ] [     ft ] event is Syntax
[ 23:50:19:953 ] [ Info  ] [     ft ] ev.buf is 9
[ 23:50:19:953 ] [ Info  ] [     ft ] nvim_get_current_buf() is 9
[ 23:50:19:953 ] [ Info  ] [     ft ] nvim_get_current_win() is 1008
[ 23:50:19:953 ] [ Info  ] [     ft ] real_current_win's buf is7
[ 23:50:19:954 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:50:19:954 ] [ Info  ] [     ft ] event is FileType
[ 23:50:19:954 ] [ Info  ] [     ft ] ev.buf is 9
[ 23:50:19:954 ] [ Info  ] [     ft ] nvim_get_current_buf() is 9
[ 23:50:19:954 ] [ Info  ] [     ft ] nvim_get_current_win() is 1008
[ 23:50:19:954 ] [ Info  ] [     ft ] real_current_win's buf is7
[ 23:50:19:954 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:50:19:954 ] [ Info  ] [     ft ] event is OptionSet
[ 23:50:19:954 ] [ Info  ] [     ft ] ev.buf is 0
[ 23:50:19:954 ] [ Info  ] [     ft ] nvim_get_current_buf() is 9
[ 23:50:19:954 ] [ Info  ] [     ft ] nvim_get_current_win() is 1008
[ 23:50:19:954 ] [ Info  ] [     ft ] real_current_win's buf is7
[ 23:50:19:954 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:50:19:954 ] [ Info  ] [     ft ] nvim_get_current_buf() is 7
[ 23:50:19:954 ] [ Info  ] [     ft ] nvim_get_current_win() is 1000

可以看到，在 event 触发 callback 函数内 nvim_get_current_win 和 nvim_get_current_buf 都临时被修改了。测试一下，不开窗口效果呢？

local log = require("logger").derive("ft")
log.info("nvim_get_current_buf() is " .. vim.api.nvim_get_current_buf())
log.info("nvim_get_current_win() is " .. vim.api.nvim_get_current_win())
log.info("-----------------------------------------------------")
local real_current_win = vim.api.nvim_get_current_win()
local newbuf = vim.api.nvim_create_buf(true, false)

local events = {}

for _, v in ipairs(vim.fn.getcompletion("", "event")) do
	if not vim.endswith(v, "Cmd") then
		table.insert(events, v)
	end
end

local id = vim.api.nvim_create_autocmd(events, {
	group = vim.api.nvim_create_augroup("test_ft", { clear = true }),
	pattern = { "*" },
	callback = function(ev)
		log.info("-----------------------------------------------------")
		log.info("event is " .. ev.event)
		log.info("ev.buf is " .. ev.buf)
		log.info("nvim_get_current_buf() is " .. vim.api.nvim_get_current_buf())
		log.info("nvim_get_current_win() is " .. vim.api.nvim_get_current_win())
		log.info("real_current_win's buf is" .. vim.api.nvim_win_get_buf(real_current_win))
	end,
})

-- vim.api.nvim_open_win(newbuf, false, { split = "above" })
vim.api.nvim_set_option_value("filetype", "test123", { buf = newbuf })
vim.api.nvim_del_autocmd(id)
log.info("-----------------------------------------------------")
log.info("nvim_get_current_buf() is " .. vim.api.nvim_get_current_buf())
log.info("nvim_get_current_win() is " .. vim.api.nvim_get_current_win())

[ 23:53:49:058 ] [ Info  ] [     ft ] nvim_get_current_buf() is 10
[ 23:53:49:058 ] [ Info  ] [     ft ] nvim_get_current_win() is 1000
[ 23:53:49:058 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:53:49:078 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:53:49:078 ] [ Info  ] [     ft ] event is Syntax
[ 23:53:49:078 ] [ Info  ] [     ft ] ev.buf is 12
[ 23:53:49:078 ] [ Info  ] [     ft ] nvim_get_current_buf() is 12
[ 23:53:49:078 ] [ Info  ] [     ft ] nvim_get_current_win() is 1001
[ 23:53:49:078 ] [ Info  ] [     ft ] real_current_win's buf is10
[ 23:53:49:079 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:53:49:079 ] [ Info  ] [     ft ] event is FileType
[ 23:53:49:079 ] [ Info  ] [     ft ] ev.buf is 12
[ 23:53:49:079 ] [ Info  ] [     ft ] nvim_get_current_buf() is 12
[ 23:53:49:079 ] [ Info  ] [     ft ] nvim_get_current_win() is 1001
[ 23:53:49:079 ] [ Info  ] [     ft ] real_current_win's buf is10
[ 23:53:49:079 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:53:49:079 ] [ Info  ] [     ft ] event is OptionSet
[ 23:53:49:079 ] [ Info  ] [     ft ] ev.buf is 0
[ 23:53:49:079 ] [ Info  ] [     ft ] nvim_get_current_buf() is 12
[ 23:53:49:079 ] [ Info  ] [     ft ] nvim_get_current_win() is 1001
[ 23:53:49:079 ] [ Info  ] [     ft ] real_current_win's buf is10
[ 23:53:49:079 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:53:49:079 ] [ Info  ] [     ft ] nvim_get_current_buf() is 10
[ 23:53:49:079 ] [ Info  ] [     ft ] nvim_get_current_win() is 1000

这窗口 1001 是什么鬼？临时隐藏窗口？

local log = require("logger").derive("ft")
log.info("nvim_get_current_buf() is " .. vim.api.nvim_get_current_buf())
log.info("nvim_get_current_win() is " .. vim.api.nvim_get_current_win())
log.info("-----------------------------------------------------")
local real_current_win = vim.api.nvim_get_current_win()
local newbuf = vim.api.nvim_create_buf(true, false)

local events = {}

for _, v in ipairs(vim.fn.getcompletion("", "event")) do
	if not vim.endswith(v, "Cmd") then
		table.insert(events, v)
	end
end

local id = vim.api.nvim_create_autocmd(events, {
	group = vim.api.nvim_create_augroup("test_ft", { clear = true }),
	pattern = { "*" },
	callback = function(ev)
		log.info("-----------------------------------------------------")
		log.info("event is " .. ev.event)
		log.info("ev.buf is " .. ev.buf)
		log.info("nvim_get_current_buf() is " .. vim.api.nvim_get_current_buf())
		log.info("nvim_get_current_win() is " .. vim.api.nvim_get_current_win())
        log.info('win count is ' .. vim.fn.winnr('$'))
        log.info('winconfig is ' .. vim.inspect(vim.api.nvim_win_get_config(vim.api.nvim_get_current_win())))
		log.info("real_current_win's buf is" .. vim.api.nvim_win_get_buf(real_current_win))
	end,
})

-- vim.api.nvim_open_win(newbuf, false, { split = "above" })
vim.api.nvim_set_option_value("filetype", "test123", { buf = newbuf })
vim.api.nvim_del_autocmd(id)
log.info("-----------------------------------------------------")
log.info("nvim_get_current_buf() is " .. vim.api.nvim_get_current_buf())
log.info("nvim_get_current_win() is " .. vim.api.nvim_get_current_win())

[ 23:57:49:249 ] [ Info  ] [     ft ] nvim_get_current_buf() is 9
[ 23:57:49:249 ] [ Info  ] [     ft ] nvim_get_current_win() is 1000
[ 23:57:49:249 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:57:49:268 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:57:49:268 ] [ Info  ] [     ft ] event is Syntax
[ 23:57:49:268 ] [ Info  ] [     ft ] ev.buf is 13
[ 23:57:49:268 ] [ Info  ] [     ft ] nvim_get_current_buf() is 13
[ 23:57:49:268 ] [ Info  ] [     ft ] nvim_get_current_win() is 1001
[ 23:57:49:268 ] [ Info  ] [     ft ] win count is 2
[ 23:57:49:268 ] [ Info  ] [     ft ] winconfig is {
  anchor = "NW",
  col = 0,
  external = false,
  focusable = false,
  height = 5,
  hide = false,
  mouse = false,
  relative = "editor",
  row = 0,
  width = 168,
  zindex = 50
}
[ 23:57:49:268 ] [ Info  ] [     ft ] real_current_win's buf is9
[ 23:57:49:269 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:57:49:269 ] [ Info  ] [     ft ] event is FileType
[ 23:57:49:269 ] [ Info  ] [     ft ] ev.buf is 13
[ 23:57:49:269 ] [ Info  ] [     ft ] nvim_get_current_buf() is 13
[ 23:57:49:269 ] [ Info  ] [     ft ] nvim_get_current_win() is 1001
[ 23:57:49:269 ] [ Info  ] [     ft ] win count is 2
[ 23:57:49:270 ] [ Info  ] [     ft ] winconfig is {
  anchor = "NW",
  col = 0,
  external = false,
  focusable = false,
  height = 5,
  hide = false,
  mouse = false,
  relative = "editor",
  row = 0,
  width = 168,
  zindex = 50
}
[ 23:57:49:270 ] [ Info  ] [     ft ] real_current_win's buf is9
[ 23:57:49:270 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:57:49:270 ] [ Info  ] [     ft ] event is OptionSet
[ 23:57:49:270 ] [ Info  ] [     ft ] ev.buf is 0
[ 23:57:49:270 ] [ Info  ] [     ft ] nvim_get_current_buf() is 13
[ 23:57:49:270 ] [ Info  ] [     ft ] nvim_get_current_win() is 1001
[ 23:57:49:270 ] [ Info  ] [     ft ] win count is 2
[ 23:57:49:270 ] [ Info  ] [     ft ] winconfig is {
  anchor = "NW",
  col = 0,
  external = false,
  focusable = false,
  height = 5,
  hide = false,
  mouse = false,
  relative = "editor",
  row = 0,
  width = 168,
  zindex = 50
}
[ 23:57:49:270 ] [ Info  ] [     ft ] real_current_win's buf is9
[ 23:57:49:270 ] [ Info  ] [     ft ] -----------------------------------------------------
[ 23:57:49:270 ] [ Info  ] [     ft ] nvim_get_current_buf() is 9
[ 23:57:49:270 ] [ Info  ] [     ft ] nvim_get_current_win() is 1000

这里说明一下，即便是 nvim_open_win 没有执行，Neovim 也会新建一个 autocmd windows，使用 win_gettype() 函数可以获取值为 “autocmd”。

本地化管理 Github secrets

Thu, 04 Dec 2025 00:00:00 +0000

安装 github.nvim
使用 github.nvim 访问仓库 secrts

有这样一个需求，要给自己多个 Github 仓库增加多个仓库 secrets，以便于 Action 中使用。起初我是手动在每个仓库的设置页面逐一复制粘贴来添加的。但是这样效率明显太低，而且容易出错，此外后期若需要修改，还得要重新操作。于是我就想着是否可以使用脚本访问 Github API 来更改，查阅了 GitHub secrets API 文档，也找到了相关信息。这篇文章就是我使用 Neovim 编辑并批量更新 Github 仓库 secrets 的完整方案。

安装 github.nvim

github.nvim 是一个 GitHub REST API 的 Lua 实现，用于在 Neovim 中访问 Github API。早些年，我使用 Vim Script 写过类似的 Vim 插件 GitHub.vim，而 github.nvim 算是 github.vim 的 Lua 重新实现版本，目前也仅仅实现了部分 API，会更具个人使用需要，陆续再实现其他的 API。可以使用任意 Neovim 插件管理器安装，比如 nvim-plug,

require('plug').add({
  'wsdjeg/github.nvim',
})

当然了，你也可以使用 luarocks 安装：

luarocks install github.nvim

使用 github.nvim 访问仓库 secrts

由于 Github 的 secrts API 访问时，传输的数据都是要使用 libsodium 加密，因此需要安装 libsodium，以及对应的 Lua 模块。这里记录一下 Windows 下安装这两个工具遇到的坑：从官网下载 libsodium-1.0.20-stable-msvc.zip，解压后，需要将 libsodium\x64\Release\v143\dynamic 目录加入到环境变量 PATH 内。

vim.env.PATH = vim.env.PATH
  .. ';'
  .. [[D:\Downloads\libsodium-1.0.20-stable-msvc\libsodium\x64\Release\v143\dynamic]]

此时再使用 luarocks 安装 luasodium，需要指定 libsodium 的安装目录：

luarocks install luasodium SODIUM_INCDIR=D:\Downloads\libsodium-1.0.20-stable-msvc\libsodium\include SODIUM_DIR=D:\Downloads\libsodium-1.0.20-stable-msvc\libsodium\x64\Release\v143\dynamic

如果提示安装成功后，在 Neovim 内如果使用以下 Lua 脚本，只有最后一个会报错。

local luasodium_ffi = require'luasodium' -- ok
local luasodium_ffi = require'luasodium.ffi' -- uses the FFI API (in a C module) ok
local luasodium_c = require'luasodium.core' -- uses the C API ok
local luasodium_pureffi = require'luasodium.pureffi' -- 失败，因为他使用 `require('ffi').load('sodium')`, 应该是 libsodium

最后一个失败的原因时因为 luasodium 源码文件 lib_loader.lua 中使用了 require(‘ffi’).load(‘sodium’) – 在luasodium 修复之前，可以临时如下操作 – 将 dynamic 目录里面的 libsodium.dll 改名为 sodium.dll 我也给 luasodium 提交了一个 PR 来解决这个问题。确保上述 libsodium、luasodium、github.nvim 都安装好了之后，就可以使用以下脚本了：

local secrts = {
  {
    name = 'DOCKER_API_KEY',
    value = '12jdksjdiiwkdjsskkdj',
  },
  {
    name = 'LUAROCKS_API_KEY',
    value = 'ijnuhbygvtfcrdxesz',
  },
}
local repos = {
  'picker.nvim',
  'format.nvim',
  'tasks.nvim',
}
for _, repo in ipairs(repos) do
  for _, secrt in ipairs(secrts) do
    require('github.secrets').update_repository_secret('wsdjeg', repo, secrt)
  end
end

通过上述脚本，就给批量给自己的 Github 仓库设定 secrets，后期如果 API_KEY 修改了，只需要修改脚本后再执行一次即可。

发现 Git 仓库中幽灵文件

Sat, 29 Nov 2025 00:00:00 +0000

使用 git-ghosts 拓展
参考链接

在使用 Git 过程中，有时候会遇到这样的情况：某个以前删除的文件，不记得当时删除的 commit message 内容了，也不记得完整的文件路径，只记得文件部分名称，想要找到是哪一个 commit 删除的，发现比较难。实际上可以通过下方的命令来时间这一功能，首先使用下面的命令搜索删掉的文件路径包含 src 的文件列表：

git log --diff-filter=D --summary | rg delete | rg src

如果要使用 code-runner.nvim，执行并输出，需要设定 ps 的 runner：

require('code-runner').setup({
    runners = {
        lua = { exe = 'nvim', opt = { '-l', '-' }, usestdin = true },
        ps = { exe = 'powershell.exe', opt = { '-Command', '-' }, usestdin = true },
    },
})

快捷键调用 code-runner 输出：

[Running] powershell.exe -Command - STDIN

--------------------
 delete mode 100644 src/test/hello.c
 delete mode 100644 src/example/delete.c

[Done] exited with code=0, single=0 in 0.916431 seconds

获取到上述文件列表后，通过 git.nvim 执行以下命令，就可以打开 log 列表，列表内回车会分屏展示 commit diff。

:Git log -1 -- src/test/hello.c

使用 git-ghosts 拓展

最近，给 git.nvim 增加了一个 git-ghosts 的 picker.nvim 拓展。其实现的原理就是参考上述的命令执行顺序。先获取已删除文件的列表，回车获取改文件的最后一次 commit 的哈希值，然后执行：

:Git show <commit_hash>

参考链接

https://www.linux88.com/restore-a-deleted-document-in-git/

Neovim 中使用 luarocks

Thu, 27 Nov 2025 00:00:00 +0000

安装 luarocks
在 Neovim 内使用 luarocks
使用 nvim-plug 下载 rocks
luarocks 的限制
将插件发布到 LuaRocks
模块载入问题
排除问题
Neovim 终端中使用

luarocks 是 lua 常用的包管理器，类似于 python 的 pip。前面使用 Lua 实现了一个 Neovim 的插件管理器，而目前我自己正在维护的插件也都是使用 Lua 来实现的。因此使用 luarocks 来管理插件，同时又让插件管理器 nvim-plug 支持 luarocks 就显得很有必要了。看了下目前主流的插件管理器 lazy.nvim、rocks.nvim 也是支持 luarcoks 的。

安装 luarocks

在 Windows 下可以使用 scoop 命令进行安装：

scoop install luarocks

这里需要注意一下，上述命令会自动安装 lua 5.4，但是 Neovim 内默认使用的是 luajit 兼容的 lua 5.1。因此为了避免下载的 rocks 不兼容。可以再执行以下命令：

scoop uninstall lua
scoop install lua51

安装完成后检查一下：

luarocks config | rg deploy

输出内容：

deploy_bin_dir = "D:\\Scoop\\apps\\luarocks\\current\\rocks\\bin"
deploy_lib_dir = "D:\\Scoop\\apps\\luarocks\\current\\rocks\\lib\\lua\\5.1"
deploy_lua_dir = "D:\\Scoop\\apps\\luarocks\\current\\rocks\\share\\lua\\5.1"

在 Neovim 内使用 luarocks

在 Neovim 内使用 :lua 命令或者使用 lua 开发 Neovim 插件时，若想要使用 luarocks 安装的包，其原理就是将 luarocks 所安装的包位置加入到 package.path 和 package.cpath： nvim-plug 中实现这一步骤的逻辑如下： lua/plug/rocks/init.lua

function M.enable()
    if enabled then
        return
    end
    local ok, _ = pcall(function()
        local luarocks_config = vim.json.decode(
            vim.system({ 'luarocks', 'config', '--json' }):wait().stdout
        )
        package.path = package.path
            .. ';'
            .. luarocks_config.deploy_lua_dir
            .. [[\?.lua]]
            .. ';'
            .. luarocks_config.deploy_lua_dir
            .. [[\?\init.lua]]
            .. ';'
        package.cpath = package.cpath
            .. ';'
            .. luarocks_config.deploy_lib_dir
            .. '\\?.'
            .. luarocks_config.external_lib_extension
        -- 此处，还可以将 luarcoks bin 目录加入到 PATH
        vim.env.PATH = vim.env.PATH .. ';' .. luarocks_config.deploy_bin_dir
    end)
    if ok then
        enabled = true
    end
end

使用 nvim-plug 下载 rocks

可以在添加插件时，指定 type = 'rocks'，比如： plugins/mru.lua

return {
    'wsdjeg/mru.nvim',
    events = { 'UIEnter' },
    opts = {
        enable_cache = true,
        ignore_path_regexs = {
            '/.git/',
            '/nvim/runtime/doc/',
            '.mp3$',
            '.mp4$',
            '.png$',
            '.jpg$',
            '.exe$',
            'nvim-mru.json$',
            'tags$',
        },
        enable_logger = true,
        sort_by = 'lastenter',
    },
    type = 'rocks',
    desc = 'mru(most recently used) files',
}

参考以上方式添加插件后，nvim-plug 在安装插件时会自动调用 luarocks install plugin_name 这一命令。

luarocks 的限制

在实现完上述功能后，才发现 luarocks 这个包管理器似乎还有一些限制。比如：

不支持同时安装多个插件。因为 nvim-plug 是使用异步 job 调用外部命令的，因此支持多线程。但是起初实现后发现，当同时执行多个 luarocks install 命令时，只有第一个是成功的，后续的命令都有会报这一错误：Error: command ‘install’ requires exclusive write access。解决的办法是为 luarocks 实现单独的 tasks 序列，逐一执行，这样的话插件的安装会非常慢。一个是单线程，一个是 16 线程 (max_processes = 16)。
无法根据 plugSpec 获取的 rtp 目录位置一个最简单 plugSpec 比如 { 'wsdjeg/mru.nvim' }，默认 type 是 git，我是可以获取到该插件默认的 runtimepath 值为 plug.config.bundle_dir .. '/' .. 'wsdjeg/mru.nvim'，此时就可以根据这个目录是否存在来判断插件是否已安装。但是，这样一个 plugSpec：
```
return {
  'wsdjeg/mru.nvim',
  type = 'rocks',
}
```
将无法获取到默认的 runtimepath 目录位置，因为他的格式是
```
D:/Scoop/apps/luarocks/current/rocks/lib/luarocks/rocks-5.1/mru.nvim/1.4.0-1
```
最后面这个版本号，除非是 plugSpec 内指定，否则是无法判断到默认的值的。最终的解决方案是分析 luarocks list 命令的输出内容，返回一个类似与这样的 lua table：
```
return {
  ['mru.nvim'] = {
    rtp = 'D:/Scoop/apps/luarocks/current/rocks/lib/luarocks/rocks-5.1/mru.nvim/1.4.0-1',
  },
  ['rooter.nvim'] = {
    rtp = 'D:/Scoop/apps/luarocks/current/rocks/lib/luarocks/rocks-5.1/rooter.nvim/1.3.0-1',
  },
}
```

将插件发布到 LuaRocks

这里主要使用到两个 Github actions：

googleapis/release-please-action
nvim-neorocks/luarocks-tag-release

使用 googleapis/release-please-action 来自动打 tag 并且新建 GitHub release，可以参考之前的文章《Github 仓库自动 release》。使用 nvim-neorocks/luarocks-tag-release GitHub action 自动将 tag 上传到 luarocks.org。在仓库根目录新建文件 .github/workflows/luarocks.yml:

name: Push to Luarocks

on:
  push:
    tags: # Will upload to luarocks.org when a tag is pushed
      - "*"
  pull_request: # Will test a local install without uploading to luarocks.org
  workflow_dispatch:

jobs:
  luarocks-upload:
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v4
      - name: LuaRocks Upload
        uses: nvim-neorocks/luarocks-tag-release@v7
        env:
          LUAROCKS_API_KEY: $

存在一个问题，luarocks-tag-release 使用 copy_directories 来复制打包插件的其他文件，但是 luarocks 一旦使用了 copy_directories 这一设置，就不会复制默认的 doc 文件了。相关 issue ： luarocks/issues/1266 代码逻辑 src/luarocks/build.lua#L344-L363

模块载入问题

neovim 中直接使用 rocks 似乎还有问题，dll 文件载入时会报错，估计跟 luarocks 的包编译方式有关

D:\wsdjeg\my-blog>luarocks list | rg file -A 2
luafilesystem
   1.8.0-1 (installed) - D:\Scoop\apps\luarocks\current\rocks\lib\luarocks\rocks-5.1

然后在 Neovim 内执行 :lua require('lfs') 时，报错：

E5108: Error executing lua error loading module 'lfs' from file 'D:\Scoop\apps\luarocks\current\rocks\lib\lua\5.1\lfs.dll':
        找不到指定的模块。

stack traceback:
        [C]: at 0x7ff83ac1bdb0
        [C]: in function 'require'
        [string ":lua"]:1: in main chunk

实际上这个 dll 文件是存在的：

D:\Scoop\apps\luarocks\current\rocks\lib\lua\5.1>ls
lfs.dll

排除问题

使用 scoop 安装 dependencies,

scoop install dependencies

打开 lfs.dll 文件，发现确实是依赖问题：在 lua51 的安装目录里：

D:\Scoop\apps\lua51\current>ls
Microsoft.VC80.CRT  install.json  lua5.1.dll.manifest  lua51.dll           manifest.json
bin2c5.1.exe        liblua5.1.a   lua5.1.exe           lua51.dll.manifest  wlua5.1.exe
include             lua5.1.dll    lua5.1.exe.manifest  luac5.1.exe         wlua5.1.exe.manifest

而 Neovim 中 :lua 调用的是：

D:\Scoop\apps\neovim\current\bin>ls
dbghelp.dll  lua51.dll  nvim.exe  platforms  win32yank.exe  xxd.exe

使用 scoop 安装 luajit：

scoop install luajit

看下 luajit 的目录结构

D:\Scoop\apps\luajit/..
  2.1.1762795099-1
  current ➛ 2.1.1762795099-1
    bin
       lua51.dll
       luajit
       luajit-2.1.1762795099.exe
       luajit.exe
    include/luajit-2.1
       lauxlib.h
       lua.h
       lua.hpp
       luaconf.h
       luajit.h
       lualib.h
    lib
    share
     install.json
     manifest.json

修改 D:\Scoop\apps\luarocks\current\config.lua 为：

lua_interpreter = "D:/Scoop/apps/luajit/current/bin/luajit.exe"
lua_version = "5.1"
rocks_trees = {
   "D:/Scoop/apps/luarocks/current/rocks"
}
variables = {
   LUA = "D:/Scoop/apps/luajit/current/bin/luajit.exe",
   LUA_BINDIR = "D:/Scoop/apps/luajit/current/bin",
   LUA_INCDIR = "D:/Scoop/apps/luajit/current/include/luajit-2.1",
   LUA_DIR = "D:/Scoop/apps/luajit/current/bin"
}

重新安装 luafilesystem：

luarocks install luafilesystem --force

此时再使用 Dependencies 查看 lfs.dll：此时在 Neovim 中执行 :=require('lfs') 就会看到：

{
  _COPYRIGHT = "Copyright (C) 2003-2017 Kepler Project",
  _DESCRIPTION = "LuaFileSystem is a Lua library developed to complement the set of functions related to file systems offered by the standard Lua distribution",
  _VERSION = "LuaFileSystem 1.8.0",
  attributes = <function 1>,
  chdir = <function 2>,
  currentdir = <function 3>,
  dir = <function 4>,
  link = <function 5>,
  lock = <function 6>,
  lock_dir = <function 7>,
  mkdir = <function 8>,
  rmdir = <function 9>,
  setmode = <function 10>,
  symlinkattributes = <function 11>,
  touch = <function 12>,
  unlock = <function 13>
}

Neovim 终端中使用

为了能在 Neovim 内置终端中使用 lua，luajit，luarocks 等，给 nvim-plug 增加这样一个 patch：

diff --git a/lua/plug/rocks/init.lua b/lua/plug/rocks/init.lua
index e336791..58f391d 100644
--- a/lua/plug/rocks/init.lua
+++ b/lua/plug/rocks/init.lua
@@ -71,6 +71,8 @@ function M.enable()
             .. luarocks_config.deploy_lib_dir
             .. '\\?.'
             .. luarocks_config.external_lib_extension
+        vim.env.LUA_PATH = package.path
+        vim.env.LUA_CPATH = package.cpath
     end)
     if ok then
         enabled = true

这样在 Neovim 内置终端内使用 lua 命令，或者 luajit 命令，就会自动读取这两个变量值。

D:\wsdjeg\my-blog>lua
Lua 5.1.5  Copyright (C) 1994-2012 Lua.org, PUC-Rio
> print(require('lfs'))
table: 00000000004DCAC0
> 

D:\wsdjeg\my-blog>luajit
LuaJIT 2.1.1762795099 -- Copyright (C) 2005-2025 Mike Pall. https://luajit.org/
JIT: ON SSE3 SSE4.1 BMI2 fold cse dce fwd dse narrow loop abc sink fuse
> print(require('lfs'))
table: 0x01f72937bc70
> 
D:\wsdjeg\my-blog>echo print(require("lfs")) | nvim -l -  
table: 0x01dcba84a148

Neovim 窗口 API 参数 noautocmd 测试

Wed, 12 Nov 2025 00:00:00 +0000

最近在修改 notify.nvim 插件源码的时候有这么一段：

local win_config = {
  -- .....
}
if not vim.api.nvim_buf_is_valid(buf) then
  buf = vim.api.nvim_create_buf(false, true)
end
if not vim.api.nvim_win_is_valid(win) then
  win_config.noautocmd = true
  win = vim.api.nvim_open_win(buf, false, win_config)
else
  vim.api.nvim_win_set_config(win, win_config)
end

我把 win_config 内容省略了，主要想表达的意思是，本来我想通过一个固定的窗口配置来打开或者设置窗口的参数。但是 Neovim 的 nvim_open_win 和 nvim_win_set_config 两个函数所接受的 win_opt 选项是有区别的，已存在的窗口使用后者设置时不能够传入 noautocmd 选项（neovim#36409）。

'noautocmd' cannot be used with existing windows

于是只能分开写，在调用 nvim_open_win 时传入 noautocmd 参数。那么这个 noautocmd 到底禁用了哪些事件，以及禁用的时机时什么呢？以下为测试脚本：

local buf = vim.api.nvim_create_buf(true, false)

local log = require('logger').derive('t_no')

local aug = vim.api.nvim_create_augroup('test_noautocmd', { clear = true })

vim.api.nvim_create_autocmd(
  { 'WinEnter', 'BufWinEnter', 'BufEnter', 'WinLeave', 'TextChangedI' },
  {
    pattern = { '*' },
    group = aug,
    callback = function(ev)
      log.info(ev.event)
    end,
  }
)

vim.api.nvim_open_win(buf, true, { split = 'above', noautocmd = true })

-- [ 20:43:20:664 ] [ Info  ] [   t_no ] TextChangedI
-- [ 20:43:23:092 ] [ Info  ] [   t_no ] WinLeave
-- [ 20:43:23:093 ] [ Info  ] [   t_no ] WinEnter
-- [ 20:43:23:094 ] [ Info  ] [   t_no ] BufEnter

local buf = vim.api.nvim_create_buf(true, false)

local log = require('logger').derive('t_no')

local aug = vim.api.nvim_create_augroup('test_noautocmd', { clear = true })

vim.api.nvim_create_autocmd(
  { 'WinEnter', 'BufWinEnter', 'BufEnter', 'WinLeave', 'TextChangedI' },
  {
    pattern = { '*' },
    group = aug,
    callback = function(ev)
      log.info(ev.event)
    end,
  }
)

vim.api.nvim_open_win(buf, true, { split = 'above', noautocmd = false })

-- [ 20:44:50:454 ] [ Info  ] [   t_no ] WinLeave
-- [ 20:44:50:455 ] [ Info  ] [   t_no ] WinEnter
-- [ 20:44:50:456 ] [ Info  ] [   t_no ] BufEnter
-- [ 20:44:50:456 ] [ Info  ] [   t_no ] BufWinEnter
-- [ 20:44:51:279 ] [ Info  ] [   t_no ] TextChangedI
-- [ 20:44:52:045 ] [ Info  ] [   t_no ] WinLeave
-- [ 20:44:52:046 ] [ Info  ] [   t_no ] WinEnter
-- [ 20:44:52:048 ] [ Info  ] [   t_no ] BufEnter

如果去看 API 的源码，neovim 这段 nvim_open_win api 的源码。

Window nvim_open_win(Buffer buffer, Boolean enter, Dict(win_config) *config, Error *err)
  FUNC_API_SINCE(6) FUNC_API_TEXTLOCK_ALLOW_CMDWIN
{
#define HAS_KEY_X(d, key) HAS_KEY(d, win_config, key)
  buf_T *buf = find_buffer_by_handle(buffer, err);
  if (!buf) {
    return 0;
  }
  if ((cmdwin_type != 0 && enter) || buf == cmdwin_buf) {
    api_set_error(err, kErrorTypeException, "%s", e_cmdwin);
    return 0;
  }

  WinConfig fconfig = WIN_CONFIG_INIT;
  if (!parse_win_config(NULL, config, &fconfig, false, err)) {
    return 0;
  }

  bool is_split = HAS_KEY_X(config, split) || HAS_KEY_X(config, vertical);
  Window rv = 0;
  if (fconfig.noautocmd) {
    block_autocmds();
  }

  win_T *wp = NULL;
  tabpage_T *tp = curtab;
  assert(curwin != NULL);
  win_T *parent = config->win == 0 ? curwin : NULL;
  if (config->win > 0) {
    parent = find_window_by_handle(fconfig.window, err);
    if (!parent) {
      // find_window_by_handle has already set the error
      goto cleanup;
    } else if (is_split && parent->w_floating) {
      api_set_error(err, kErrorTypeException, "Cannot split a floating window");
      goto cleanup;
    }
    tp = win_find_tabpage(parent);
  }
  if (is_split) {
    if (!check_split_disallowed_err(parent ? parent : curwin, err)) {
      goto cleanup;  // error already set
    }

    if (HAS_KEY_X(config, vertical) && !HAS_KEY_X(config, split)) {
      if (config->vertical) {
        fconfig.split = p_spr ? kWinSplitRight : kWinSplitLeft;
      } else {
        fconfig.split = p_sb ? kWinSplitBelow : kWinSplitAbove;
      }
    }
    int flags = win_split_flags(fconfig.split, parent == NULL) | WSP_NOENTER;
    int size = (flags & WSP_VERT) ? fconfig.width : fconfig.height;

    TRY_WRAP(err, {
      if (parent == NULL || parent == curwin) {
        wp = win_split_ins(size, flags, NULL, 0, NULL);
      } else {
        switchwin_T switchwin;
        // `parent` is valid in `tp`, so switch_win should not fail.
        const int result = switch_win(&switchwin, parent, tp, true);
        assert(result == OK);
        (void)result;
        wp = win_split_ins(size, flags, NULL, 0, NULL);
        restore_win(&switchwin, true);
      }
    });
    if (wp) {
      wp->w_config = fconfig;
      if (size > 0) {
        // Without room for the requested size, window sizes may have been equalized instead.
        // If the size differs from what was requested, try to set it again now.
        if ((flags & WSP_VERT) && wp->w_width != size) {
          win_setwidth_win(size, wp);
        } else if (!(flags & WSP_VERT) && wp->w_height != size) {
          win_setheight_win(size, wp);
        }
      }
    }
  } else {
    if (!check_split_disallowed_err(curwin, err)) {
      goto cleanup;  // error already set
    }
    wp = win_new_float(NULL, false, fconfig, err);
  }
  if (!wp) {
    if (!ERROR_SET(err)) {
      api_set_error(err, kErrorTypeException, "Failed to create window");
    }
    goto cleanup;
  }

  if (fconfig._cmdline_offset < INT_MAX) {
    cmdline_win = wp;
  }

  // Autocommands may close `wp` or move it to another tabpage, so update and check `tp` after each
  // event. In each case, `wp` should already be valid in `tp`, so switch_win should not fail.
  // Also, autocommands may free the `buf` to switch to, so store a bufref to check.
  bufref_T bufref;
  set_bufref(&bufref, buf);
  if (!fconfig.noautocmd) {
    switchwin_T switchwin;
    const int result = switch_win_noblock(&switchwin, wp, tp, true);
    assert(result == OK);
    (void)result;
    if (apply_autocmds(EVENT_WINNEW, NULL, NULL, false, curbuf)) {
      tp = win_find_tabpage(wp);
    }
    restore_win_noblock(&switchwin, true);
  }
  if (tp && enter) {
    goto_tabpage_win(tp, wp);
    tp = win_find_tabpage(wp);
  }
  if (tp && bufref_valid(&bufref) && buf != wp->w_buffer) {
    // win_set_buf temporarily makes `wp` the curwin to set the buffer.
    // If not entering `wp`, block Enter and Leave events. (cringe)
    const bool au_no_enter_leave = curwin != wp && !fconfig.noautocmd;
    if (au_no_enter_leave) {
      autocmd_no_enter++;
      autocmd_no_leave++;
    }
    win_set_buf(wp, buf, err);
    if (!fconfig.noautocmd) {
      tp = win_find_tabpage(wp);
    }
    if (au_no_enter_leave) {
      autocmd_no_enter--;
      autocmd_no_leave--;
    }
  }
  if (!tp) {
    api_set_error(err, kErrorTypeException, "Window was closed immediately");
    goto cleanup;
  }

  if (fconfig.style == kWinStyleMinimal) {
    win_set_minimal_style(wp);
    didset_window_options(wp, true);
  }
  rv = wp->handle;

cleanup:
  if (fconfig.noautocmd) {
    unblock_autocmds();
  }
  return rv;
#undef HAS_KEY_X
}

从源码中不难看出，这个 noautocmd 选项只是在 nvim_open_win 这个函数调用内起作用，在最后的时候使用 unblock_autocmds 又恢复的事件的响应。

Neovim 模糊搜索插件 picker.nvim

Fri, 31 Oct 2025 00:00:00 +0000

安装和配置
基本使用
内置 source
其他插件 source
如何自定义拓展

模糊搜索插件（fuzzy finder）算是日常使用 Neovim 必不可少的插件之一。早期我在使用 Vim 时，最开始使用过 ctrlp.vim、unite.vim、leaderf、以及后来切换到的 denite.vim。因为一直是在 Windows 系统下居多，因此没使用 fzf 系列的插件，最开始的时候 Windows 默认终端支持这些命令可不是那么的友好。因此我更倾向于使用 Vim 内置窗口实现的这类插件。随着 Neovim 的浮窗功能完善，使用浮窗实现的 telescope.nvim 是我日常主要使用的工具了，我自己也实现了好一些 telescope extensions。但是 telescope 似乎太复杂了，而且个人感觉维护也变得不是那么的活跃了，因此就自己写了一个 picker.nvim

安装和配置

picker.nvim 的安装很简单，默认是没有任何仓库依赖，可以使用任意插件管理器进行安装，比如 nvim-plug：

require('plug').add({
  {
    'wsdjeg/picker.nvim',
    config = function()
      require('picker').setup({
        filter = {
          ignorecase = false, -- ignorecase (boolean): defaults to false
        },
        window = {
          width = 0.8, -- set picker screen width, default is 0.8 * vim.o.columns
          height = 0.8,
          col = 0.1,
          row = 0.1,
          current_icon = '>',
          current_icon_hl = 'CursorLine',
          enable_preview = false,
          preview_timeout = 500,
        },
        highlight = {
          matched = 'Tag',
        },
        prompt = {
          position = 'bottom', -- set prompt position, bottom or top
          icon = '>',
          icon_hl = 'Error',
          insert_timeout = 100,
          title = true, -- display/hide source name
        },
        mappings = {
          close = '<Esc>',
          next_item = '<Tab>',
          previous_item = '<S-Tab>',
          open_item = '<Enter>',
          toggle_preview = '<C-p>',
        },
      })
    end,
  },
})

以上是插件初始化时，默认的配置，也可以参考我的配置文件：nvim-config/plugins/picker.lua, 在我的配置里，我使用 picker.nvim 接管了 Neovim 默认的 vim.ui.select 函数。

基本使用

:Picker 命令看看目前支持的源（sources）
:Picker source_name 指定打开某个源进行匹配搜索。
--input 指定默认初始化输入的内容
--input=<cword> 指定以光标下的词作为默认输入内容。

默认只有四个快捷键，可以在 setup 时指定，默认是以下四个按键：

key binding	description
`Tab`	next item
`S-Tab`	previous item
`Enter`	default action
`Esc`	close picker

其他的快捷键通过 source 的 action() 函数返回定义。

内置 source

source	description
buffers	listed buffers
buftags	ctags outline for current buffer
cmd_history	results from `:history :`
colorscheme	all colorschemes
files	files in current dir
help_tags	neovim help tags source
highlights	highlight group source
jumps	jump list
lines	lines in current buffer
loclist	location list source
lsp_document_symbols	document symbols result from lsp client
lsp_references	lsp references
lsp_workspace_symbols	workspace symbols
marks	marks list
picker_config	picker config source
qflist	quickfix source
registers	registers context

其他插件 source

source	description
mru	most recent used files, need mru.nvim
project	project history, need rooter.nvim
bookmarks	all bookmarks, need bookmarks.nvim
zettelkasten	zettelkasten notes source from zettelkasten.nvim
zettelkasten_tags	zettelkasten tags source from zettelkasten.nvim
git-branch	git branch source from git.nvim
music-player	music-player source form music-player.nvim
plug	plugins source for nvim-plug
async_files	async files source, require job.nvim

如何自定义拓展

picker.nvim 的拓展实际上就是一个 Lua table：

local source = {}

---@return PickerItem[]
function source.get() end
---@param entry PickerItem
function source.default_action(entry) end

--- 只有需要使用到预览窗口，才需要定义 preview 函数。
source.preview_win = true
function source.preview(entry, win, buf) end

Github 仓库自动 release

Mon, 22 Sep 2025 00:00:00 +0000

因为仓库比较多（~~比较懒~~），不想每次都手动发布版本，写项目版本更新的内容，因此给自己的每一个仓库引入了 googleapis/release-please-action 在仓库的根目录新建文件：.github/workflows/release-please.yml

on:
  push:
    branches:
      - master

permissions:
  issues: write
  contents: write
  pull-requests: write

name: release-please

jobs:
  release-please:
    runs-on: ubuntu-latest
    steps:
      - uses: googleapis/release-please-action@v4
        with:
          # this assumes that you have created a personal access token
          # (PAT) and configured it as a GitHub action secret named
          # `MY_RELEASE_PLEASE_TOKEN` (this secret name is not important).
          token: $
          # this is a built-in strategy in release-please, see "Action Inputs"
          # for more options
          release-type: simple

然后，给仓库的 Github Action 添加权限，勾选 “Allow GitHub Actions to create and approve pull requests”，在仓库的 Settings > Actions > General。完成以上步骤以后，书写 Git commit 时，需要遵循 Conventional Commits。

为什么有那么多人讨厌清朝？

Wed, 03 Sep 2025 00:00:00 +0000

最近有点犯书荒，在搜索历史类小说的时候发现隋、唐、宋、明等朝代的小说较多，相关影视剧也是这样。相反元、清朝代的就非常少，记得还是上学期间有一些清朝宫廷剧，往后几乎很少看到。可能在汉人的眼里，清朝实际上是侵略者统治的朝代，和日本当年类似。不同的是现在的中国是满族也在期内而且人口还不少。为了民族统一，国务院甚至发文禁止使用满清一词。知乎上有这样一个问题，为什么有那么多人讨厌清朝？其中一个答案中提到了很多满清犯下恶。

畿南之屠、潼关之屠、扬州十日、嘉定三屠、昆山之屠、嘉兴之屠、江阴八十一日、常熟之屠、四川之屠、金华之屠、南昌之屠、湘潭之屠、南雄之屠、汾州之屠、大同之屠、广州之屠、潮州之屠。凡此种种，皆为历史记载有据可查之大屠也。

1644年，是中国历史上天翻地覆的一年，就在这一年清军入主中原，无数汉人的噩梦就此开始。清军入住中原后，强迫汉人剃发易服，这对于汉人来说以一种莫大的侮辱，各地人民纷纷起义反抗清朝，清朝对此采取屠城政策来强行推行“剃发易服”政策，于是乎一场场惨无人道大屠杀在中华大地上轮番上演。 1.畿南之屠清朝的建立，源于一场惨绝人寰的大屠杀，清军入关就是外族入侵，为了巩固自己的地位与文化，就通过杀戮屠城的方式威慑全国，清军入关前后不断的屠杀汉人，前后屠虐了一百多年，死亡人数在四千万至八千万之间，史称为满清大屠杀。顺治元年 (1644年)五月，清朝睿亲王多尔衮在北直隶三河、昌平、良乡等地进行的屠城，五千人被残杀。 2.潼关之屠明崇祯十七年（公元1644年正月十三日）满清“豫亲王”爱新觉罗多铎在陕西潼关进行惨绝人寰的大规模屠城，手无寸铁的士兵被多铎尽数屠杀，清军并大肆屠城，7000汉人被清军杀死，在历史上有一句对这件事的说法“潼关之屠七千“（就是屠夫多铎在潼关杀害那么多无辜的汉人）顺治元年(1644年)正月十三日，清朝“豫亲王”多铎在陕西潼关地进行的屠城，七千人被残杀。 3.扬州十日清军入关之后，满族人为了统治中国，就对汉人颁布了毫无人性的剃发令、文字狱，以及各个城镇的威慑屠杀，最惨绝人寰的要数“扬州十日”以及“嘉定三屠”，其中扬州十日是最为惨痛的，清军破城后整整屠杀了十天，被屠杀的汉人达到了80万，要比南京大屠杀多50万人。顺治二年、南明弘光元年(1645年5月20日)。清军攻破扬州，开始屠杀城内的平民百姓。史载：“诸妇女长索系颈，累累如贯珠，一步一跌，遍身泥土;满地皆婴儿，或衬马蹄，或藉人足，肝脑涂地，泣声盈野。”“初四日，天始霁。道路积尸既经积雨暴涨，而青皮如蒙鼓，血肉内溃。秽臭逼人，复经日炙，其气愈甚。前后左右，处处焚灼。室中氤氲，结成如雾，腥闻百里。”后来由城内僧人收殓的尸体就超过了八十万具。 4.嘉定三屠 “嘉定三屠”是指一场大屠杀，一场灭绝人性的全副武装的清兵对手无寸铁的汉人进行的屠杀，清朝顺治二年时清军攻破嘉定，并颁布剃发令但是当地的百姓违抗命令拒绝剃发，此事激怒了清军于是下令屠城屠城的命令，共下达了三次，屠城进行了三回，所以称“三屠”，而死亡人数更是达到了10万之众。顺治二年、南明弘光元年(1645年)在清军攻破嘉定后，清军将领李成栋三次下令对城中平民进行大屠杀。在屠城过程中，城中百姓或者悬梁自杀或者投井和跳河，被砍断手和脚的百姓在地上挣扎着。清军将一大部分逃生的百姓赶到河边，然后将他们赶进河中纷纷淹死，河里的水都不能流动了。 5.昆山之屠顺治二年、南明弘光元年(1645年)昆山县人民杀该县清委知县阎茂才，起兵反清。七月初六，清军破城，随即屠城，士民死难者达数万人。清军屠昆山的时候，有妇女千人藏匿在昆山顶上。有个小孩忍不住哭出声来，被清军发现，于是大肆屠杀这些妇女。 6.嘉兴之屠顺治二年、南明弘光元年(1645年)闰六月二十六日，浙江布政使司隶嘉兴府为反抗清军暴行，嘉兴民众揭竿而起，乡的明翰林学士屠象美、明兵科给事中李毓新主其事，时降清的明嘉兴总兵陈梧反时任大将军指挥义师，前吏部郎中钱棅助饷。二十六日城陷，逃不出的居民除大批年轻妇女被清军掳掠和一些僧人幸免外，几乎全遭屠杀。按当时人口来推，可能约五十万余人遇难。 7.江阴八十一日顺治二年、南明弘光元年(1645年)清朝颁布剃发令后，江阴人民举行了反清起义，进行反清斗争。清廷先后调动24万军队攻城，江阴人民浴血奋战，守城八十一天，击毙清三王十八将，清军死伤过十万。但终因力量悬殊，粮食罄尽，守城者全部壮烈牺牲。城破后遭到清军血腥屠杀，繁华的街市尽为废墟。 8.四川大屠杀从顺治三年(1646年)至康熙初期，清军开始侵入四川，在四川各地进行大屠杀。顺治四年(1647年)多尔衮、孝庄采取了彻底屠杀的办法作为报复，公开发布告示，宣称：民贼相混，玉石难分，或屠全城，或屠男而留女。前后十多年里共有500多万人被清军屠杀。 9.常熟之屠顺治二年、南明弘光元年(1645年)八月到九月，清军先后占领苏州和南直隶常熟之后的纵兵焚烧杀掠。在常熟大屠杀中被屠杀的百姓无法计算，沿河沿岸都是人头。 10.金华之屠顺治三年、南明隆武二年(1646年)七月十六日，清朝“贝勒”博洛在攻占浙江金华府进行的开始大规模屠城。大约有五万人被屠杀。 11.泾县之屠顺治三年、南明隆武二年(1646年)八月十七日，清朝“提督”张天禄、“池州总兵”于永绶在南直隶泾县、徽州、绩溪县等地进行的一次大规模屠城。大约有五万人被屠杀。 12.赣州之屠顺治三年、南明隆武二年(1646年)十月初四日，清朝“江西提督”金声桓、“总兵”柯永盛在江西赣州府进行的一次大规模屠城。大约有二十万人被屠杀。 13.同安之屠顺治四年(1647年)清军攻克福建厦门和同安县，然后屠城。福建同安县屠城死难5万余人，梵天寺住持无疑和尚收尸合葬于寺东北一里之地，建亭“无祠亭”，墓碑上则刻“万善同归所”。 14.平海之屠顺治四年、南明永历元年(1647年)七月，清军在福建平海卫进行大规模屠城。被屠杀的无辜百姓具体人数不详。 15.南昌之屠顺治五年(1648年)清军包围南昌。次年三月间，南昌城陷，清军屠城。八旗军把从南昌掠来的妇女分给各营，昼夜不停的轮奸。不久之后南昌被起义军夺了回来，但在顺治六年(1649年)清军再次占领江西南昌，下令进行屠杀。 16.邵武之屠顺治五年、南明永历二年(1648年)五月，清朝“福建左路总兵”王之纲在福建邵武县进行屠城，被屠杀的无辜百姓人数不详。 17.湘潭之屠顺治六年(1649年)正月二十一日清军攻入湖南湘潭和沅州(今芷江)，南明督师何腾蛟被俘。清郑亲王济尔哈朗下令在湘潭屠城，湘潭城中百姓几乎全被杀光，城中不满百人。 18.同安之屠顺治五年、南明永历二年(1648年)八月十六日，清朝“靖南将军”陈泰、“浙闽总督”陈锦、“福建提督”赵国祚在福建同安县进行大屠杀，大约有五万人被屠杀。 19.南雄之屠顺治六年(1649年)农历十二月二十九日，清军抵达南雄，年三十除夕晚上清军放火焚烧鼓楼，趁明军慌乱救火之际，攻入城内。对南雄县民大肆屠杀，“大清平、靖二藩克雄城，民尽屠戮，十存二三。 20.信丰之屠顺治六年、南明永历三年(1649年)三月初一日，清朝“梅勒章京”胶商攻克广东信丰县，进行大规模屠城。 21.蒲城之屠顺治六年、南明永历三年(1649年)四月初五日，清朝“固山额真”李国翰攻克陕西蒲城县然后进行大规模屠城。大约有一万人被屠杀。 22.曹州之屠顺治六年、南明永历三年(1649年)十月初四日，清朝梅勒章京赖恼、沂州总兵佟养量、临清总兵宜永贵等攻克山东州曹州，进行屠城。被屠杀的无辜居民人数不详。 23.汾州之屠顺治六年、南明永历三年(1649年)九月至十一月，清朝“端重亲王”博洛、“和硕亲王”满达海等在山西汾州、太谷县、泌州、泽州等地进行规模屠城。大约有四十万人被屠杀。 24.大同之屠顺治六年(1649年)清军在大同屠杀后，全城只剩下5个重案犯。清朝派来的大同知府，上书顺治帝，称既然没有了苦主，就可以释放这5个人了。这份奏折，至今保存在第一历史档案馆。 25.广州大屠杀顺治七年(1650年)尚可喜打带领清军清军攻广州，围城十个多月后广州城破。清军入城之后开始屠城，史书记载： ”可喜屠广州，孑遗无留;逸出城者，挤之海中。“ 死难十万至七十万人。 26.潮州之屠顺治十年(1653年)清军占领广东的潮州和南雄，清军之后进行下令屠杀，“纵兵屠掠，遗骸十余万”，“癸巳，郡城破，横尸遍野……收遗骸十余万，作普同塔于葫芦山”。揭阳县观音堂海德和尚等收尸聚焚于西湖山，将骨灰葬在西湖南岩。福建同安县屠城死难五万余人，梵天寺主持释无疑收尸合葬于寺东北一里之地，建亭“无祠亭“，墓碑上则刻“万善同归所”。南雄县民也遭到大肆屠杀，“大清平、靖二藩克雄城，民尽屠戮，十存二三。” “家家燕子巢空林，伏尸如山莽充斥……死者无头生被掳，有头还与无头伍。血泚焦土掩红颜，孤孩尚探娘怀乳。” 27.永昌之屠顺治十六年、南明永历十三年(1659年)闰三月，清朝“征南将军”赵布泰、“提督”线国安等在云南永昌府等地进行的一次大规模屠城。经过清军的大屠杀后，明朝年间有5000多万人，到来清朝康熙年间只剩1063万，少了2000万人。这其中虽然也有死于瘟疫和明朝内战的，但大部分还是还是被清军所杀。以史为鉴，可知兴替，可警醒世人，不再重蹈覆辙，再遭如此国耻国难！再看看我大清：首先，清朝自己发布过大量屠杀文告，其中最著名的，是清朝官方资料《清世祖实录》卷十七顺治二年六月丙寅中的记录： “自今布告之后，京城内外，直隶各省，限旬日尽行剃完。若规避惜发，巧词争辩，决不轻贷”。并宣称：“所过州县地方，有能削发投顺，开城纳款，即与爵禄，世守富贵。如有抗拒不遵，大兵一到，玉石俱焚，尽行屠戮。” 清朝在四川1649年的另一份文告，口气也非常类似：“民贼相混，玉石难分。或屠全城，或屠男而留女”。清朝另一份官方史料，《东华录》卷五顺治元年条，则记载：“不随本朝制度剃发易衣冠者，杀无赦。” 镇江知府告示则是：“一人不剃发全家斩，一家不剃全村斩”，并将反抗者的人头，集中起来恐吓人民。顺治二年（1645年），江宁巡抚土国宝宣布：“剃发、改装是新朝第一严令，通行天下，法在必行者，不论绅士军民人等，留头不留发，留发不留头！南山可移，此令不可动！ ” 在以上清朝官方的宣告中，充斥了大量“屠全城”、“尽行屠戮”、“杀无赦”、“全家斩”、“全村斩”的凶恶威胁。而下面列举的资料，则证明，清朝的公开威胁，绝不仅仅停留在口头。辽东屠杀天命九年正月，努尔哈赤下九次汗谕，清查所谓“无谷之人”，并谕令八旗官兵“应将无谷之人视为仇敌”，“捕之送来”，最后于正月二十七日下令:“杀了从各处查出送来之无谷之尼堪”。天命十年十月初三日，努尔哈赤指责汉民“窝藏奸细，接受札付，叛逃不绝”，命令八旗贝勒和总兵官以下备御以上官将，带领士卒对村庄的汉人， “分路去，逢村堡，即下马斩杀”。 “时奴贼既得辽阳，辽东八站军民不乐从胡者，多至江边…… 其后，贼大至，义民不肯剃头者，皆投鸭水(鸭绿江)以死。”朝鲜《朝鲜王朝实录》掠夺虐杀汉族奴隶崇祯十一年冬至十二年春，清军在畿辅、山东一带掠去汉民四十六万二千三百馀人，崇祯十五年冬至十六年夏，清军又“俘获人民三十六万九千名口”。(《清太宗实录》 )满清入关后，继续劫掠人口。顺治二年八月辛巳日谕兵部“俘获人口，照例给赏登城被伤之人。”(《清世祖实录》) 汉人奴隶遭受非人的虐待，大量自杀。康熙初年，“八旗家丁每岁以自尽报部者不下二千人”(《清史稿》 )，仅自杀的汉人，在满清入关前后几十年间，就不下10万人。被虐待致死的，更不在少数。由于满清的疯狂虐待，大量汉人奴隶逃亡，“只此数月之间，逃人已几数万。”(《清世祖实录》) 满清统治者为了制止逃往，强化其1626年颁布的《逃人法》，顺治帝颁订:“有隐匿逃人者斩，其邻佑及十家长、百家长不行举首，地方官不能觉察者，俱为连坐”。顺治六年又改为“隐匿逃人者免死，流徙”、“再行申饬，自此谕颁发之日为始，凡章奏中再有干涉逃人者，定置重罪，决不轻恕”。(《清世祖实录》) 华北畿南之屠畿南之屠指的是公元1644年（明崇祯十七年五月），满清睿亲王多尔衮在北直隶三河、昌平、良乡等地进行的一次大规模屠城。根据《清世祖实录》记载，1644年五月，大顺军西撤。满清军队占领畿南地区，强令汉族剃发易服。当地汉族居民纷纷揭竿而起，反对满清统治。满清朝廷派出军队弹压，对起义者和居民大肆屠戮，连老幼亦不能幸免。大约有五千人被屠杀。史称畿南之屠。曹州之屠曹州之屠指的是公元1649年（南明永历三年十月初四日），满清梅勒章京赖恼、沂州总兵佟养量、临清总兵宜永贵等在山东州曹州进行的一次大规模屠城。根据《曹州志》和《重修大名府志》等记载，1649年原明东平侯刘泽清密谋与亲信李化鲸反正归明。李化鲸部义军占领鲁西南州县，后为清军三省大军围剿，战败被俘，刘、李两人遇害。满清军入城后屠杀无遗。被屠杀的无辜居民人数不详。史称曹州之屠。大同屠杀大同之屠指的是公元1649年（南明永历三年八月二十九日），满清“皇父摄政王”多尔衮、“英亲王”阿济格、“敬谨亲王”尼堪、“端重亲王”博洛、“承泽亲王”硕塞等在山西大同府、朔州、浑源县等地进行的一次大规模屠城。根据《清世祖实录》记载，1648年（永历二年），满清“大同总兵”姜瓖反正归明，义军迅速占领晋西北、晋南广大地区，直接威胁满清朝廷。清廷调取华北地区绝大部分可以调派的军队进剿，历时将近一年才复占山西全境。姜瓖被叛徒汉奸杀害，大同城破，全城官吏兵民被屠杀。被屠杀的无辜居民人数不详。史称“大同之屠”。清军实施大同大屠杀后，全城只剩下5个重案犯。满清派来的大同知府，上书顺治，称既然没有了苦主，就可以释放这5个人了。这份奏折，至今保存在第一历史档案馆。参考文献：“清人所至，无不狼藉，尸则无完肤，人则无完发，烧杀抢掠，乃贼人之便饭矣。” 朔州之屠朔州之屠指的是公元1649年（南明永历三年八月二十九日），满清“皇父摄政王”多尔衮、“英亲王”阿济格、“敬谨亲王”尼堪、“端重亲王”博洛、“承泽亲王”硕塞等在山西大同府、朔州、浑源县等地进行的一次大规模屠城。关于朔州的这次屠城，根据《清世祖实录》记载，“顺治六年，大同、朔州、浑源三城，已经王师屠戮，人民不存”！《朔州志》：“城破，悉遭屠戮”，“王师致讨，大兵临城，玉石俱焚，家破人亡……荡然一空”。汾州之屠汾州之屠指的是公元1649年（南明永历三年九月至十一月），满清“端重亲王”博洛、“和硕亲王”满达海等在山西汾州、太谷县、泌州、泽州等地进行的一次大规模屠城。根据《清世祖实录》、《泽州志》和《明清史料》记载，1649年大同失陷后，满清派出军队对晋南地区开展大扫荡，在各地实施大屠杀。明朝巡抚姜建勋、监军道何守忠等殉国。大约有四十万人被屠杀。史称汾州之屠。江淮泾县之屠泾县之屠是顺治二年（1645）原明代泾县县令尹民兴流寓泾县，与本县县城诸生赵初浣等率众拒清，据城坚守。清军提督张天禄于八月十六日黎明，统铁骑百余，据东山发炮，城中屋瓦皆震，尹民兴走脱，赵初浣等战死。城陷，男女少长多罹难，仅遗民九十余人。县治官厅公署悉毁于兵火。史称泾县之屠或者乙酉之难。泾县之屠指的是公元1646年（南明隆武二年八月十七日前后），满清“提督”张天禄、“池州总兵”于永绶在南直隶泾县、徽州、绩溪县等地进行的一次大规模屠城。根据《明清史料》等记载，1646年皖南人民不能容忍满清政权的剃发易服而发动起义，反抗满清统治。义军攻略皖南诸县后，因兵力不足，为满清军队所败。满清军在皖南地区展开疯狂的报复性大屠杀，其中以泾县特为尤甚。大约有五万人被屠杀。史称泾县之屠或乙酉之难。江南扬州十日南明弘光元年，清朝顺治二年(1645年)发生在清军攻破扬州城后对城中平民进行大屠杀的事件。由于当时南明将领史可法对清军的殊死抵抗，在同年四月廿五日(5月20日)，清军攻占扬州后，当时大雨倾盆，多铎宣布在扬州城内进行了屠杀。当时的幸存者王秀楚所著《扬州十日记》中记载屠杀共持续十日，故名“扬州十日”。清军攻破扬州城后进行了为期十天的大肆屠杀，史载:“诸妇女长索系颈，累累如贯珠，一步一跌，遍身泥土;满地皆婴儿，或衬马蹄，或藉人足，肝脑涂地，泣声盈野。”“初四日，天始霁。道路积尸既经积雨暴涨，而青皮如蒙鼓，血肉内溃。秽臭逼人，复经日炙，其气愈甚。前后左右，处处焚灼。室中氤氲，结成如雾，腥闻百里。”后来由城内僧人收殓的尸体就超过了80万具。嘉兴大屠杀南明弘光元年(1645年)闰六月二十六日，浙江布政使司隶嘉兴府为反抗清军暴行，嘉兴民众揭竿而起，乡的明翰林学士屠象美、明兵科给事中李毓新主其事，降清的明嘉兴总兵陈梧反正任大将军指挥义师，前吏部郎中钱棅助饷。二十六日城陷，逃不出的居民除大批年轻妇女被清军掳掠和一些僧人幸免外，几乎全遭屠杀。按当时人口来推，可能约500，000余人遇难。江阴八十一日江阴八十一日是指1645年夏江阴人民为抵制剃发令，在江阴典史：阎应元、陈明遇、冯厚敦等人领导下进行的斗争。因为前后长达81天之久，故被称为“江阴八十一日”。（参考百家讲坛纪连海先生的江阴八十一日讲座）此役，10万江阴百姓面对24万清军铁骑，两百多门红衣大炮，血战孤城，抗清81日，击毙清军7万5千余人，亲王3名，大将军18名，最后城破，屠城，无一人降，城内死者九万七千余人，城外死者七万五千余人。阎应元、陈明遇、冯厚敦被后世称为“江阴抗清三公”。后世传纪对江阴的评价：“有明之季，士林无羞恶之心。居高官、享重名者，以蒙面乞降为得意；而封疆大帅，无不反戈内向。独阎、陈二典史乃于一城见义。向使守京口如是，则江南不至拱手献人矣。”此言甚当，沧江横流方显英雄本色，在各地望风披靡之时，阎应元以微末下吏凭借江阴百姓的支持，面对强敌，临危不惧，坚持了近三个月，击杀清寇数万人，重挫了清军锐气，钳制了清寇主力南下，推动了各地的抗清斗争。在城破以后，仍拚死巷战，“竟无一人降者”。清初，扬州、嘉定、江阴等城，发源于老百姓的英勇抵抗，宁为玉碎不为瓦全，在华夏反侵略史上留下光彩夺目的一页。有章服之美称之华，有礼仪之大谓之夏。誓不与鞑子同流合污。参考文献：“满城杀尽，然后封刀。……城中所存无几，躲在寺观塔上隐僻处及僧印白等，共计大小五十三人。是役也，守城八十一日，城内死者九万七千馀人，城外死者七万五千馀人。”《江阴城守纪》嘉定三屠嘉定三屠，指1645年（南明弘光元年，清朝顺治二年）清军攻破嘉定后，清军将领李成栋三次下令对城中平民进行大屠杀的事件。清军颁布剃发令，嘉定百姓拒不从命。乡绅侯峒曾带领嘉定绅民起义反清，清吴淞总兵李成栋立即领兵五千来攻。嘉定城城破，李成栋下令屠城，市民之中，悬梁者，投井者，投河者，血面者，断肢者，被砍未死手足犹动者，骨肉狼籍。妇女们惨遭强奸。如遇抵抗，军队就用长钉把抵抗妇女的双手钉在门板上，然后再肆行奸淫。大屠杀持续了一天，直到尸体堵塞了河流，大约有三万多人遇害。李成栋率军离开嘉定城。但嘉定城的劫难仍然没有结束。李成栋大屠杀后的三四天，侥幸逃脱的嘉定的幸存者开始溜回城里。他们回城后在一个叫做朱瑛的义士领导下，重新集结起来，共两千多人。朱瑛领导着幸存者们在这座残破的城市展开了一场反屠杀运动，处死了归降清军的汉奸和清军委派的官吏。李成栋又领着军士直杀入城里，把许多还在睡梦中的居民杀个精光，积尸成丘，然后放火焚尸。清军杀得兴起，嘉定又惨遭“二屠”。二十多天后，原来南明的一个名叫吴之番的将军率余部猛攻嘉定城，周边民众也纷纷响应，杀得城内清兵大溃出逃。不久，李成栋整军反扑，把吴之番数百士兵砍杀殆尽，顺带又屠杀了近二万刚刚到嘉定避乱的民众，血流成渠，是为著名的“嘉定三屠”。参考文献：“市民之中，悬梁者，投井者，投河者，血面者，断肢者，被砍未死手足犹动者，骨肉狼籍。” 清兵“悉从屋上奔驰，通行无阻。城内难民因街上砖石阻塞，不得逃生，皆纷纷投河死，水为之不流。”“日昼街坊当众奸淫。”有不从者，“用长钉钉其两手于板，仍逼淫之。”，“兵丁每遇一人，辄呼蛮子献宝，其入悉取腰缠奉之，意满方释。遇他兵，勒取如前。所献不多，辄砍三刀。至物尽则杀。”(《嘉定乙酉纪事》 ) 常熟大屠杀 “通衢小巷，桥畔河干，败屋眢井，皆积尸累累，通记不下五千馀人，而男女之被掳去者不计焉。”“沿塘树木，人头悬累累，皆全发乡民也。”(《海角遗编》) 昆山大屠杀昆山之屠的时间是是公元1645年（南明弘光元年七月初六日），昆山县人民杀该县清委知县阎茂才，起兵反清，引起满清“吴淞总兵”李成栋、“刑部侍郎”李延龄在南直隶昆山县进行的一次大规模屠城。根据《归庄年谱》、《顾炎武年谱》和《研堂见闻杂记》记载，1645年满清军队进攻昆山县，昆山县绅民在原郧阳抚院王永祚等人倡义下，起兵反清。顾炎武、归庄等爱国志士都积极参与义举。七月初六清军攻陷昆山后，大肆屠城。大约有四万人被屠杀。史称昆山之屠。参考文献：“总计城中人被屠戮者十之四，沉河堕井投缳者十之二，被俘者十之二，以逸者十之一，藏匿幸免者十之一。”(《昆新两县续修合志》卷五一兵纪)，“杀戮一空，其逃出城门践溺死者，妇女、婴孩无算。昆山顶上僧寮中，匿妇女千人，小儿一声，搜戮殆尽，血流奔泻，如涧水暴下”!((研堂见闻杂记)) 金华之屠金华之屠指的是公元1646年（南明隆武二年七月十六日），满清“贝勒”博洛在浙江金华府进行的一次大规模屠城。根据《浙东记略》、《临安旬制记》、《金华府志》和《金华县志》等记载，1646年五月，满清军队攻占浙东府县，南明钱塘江防线沦陷，鲁监国放弃绍兴，转进至海上。兴国公王之仁、大学士张国维等义士杀身殉国。金华人民在督师大学士朱大典带领下据城而战，誓死不降。满清军队攻陷金华后，借口民不顺命，屠城。大约有五万人被屠杀。史称金华之屠。赣州之屠赣州之屠指的是公元1646年（南明隆武二年十月初四日），满清“江西提督”金声桓、“总兵”柯永盛在江西赣州府进行的一次大规模屠城。根据《赣州府志》、《赣县志》、《行朝录》和《仿指南录》记载，1646年三月，满清军队从南昌南下，击破沿路明军。赣州府防守力量由各地援军组成，缺乏协同作战能力，不久后沦陷。满清军攻占赣州后，江西总督万元吉、武英殿大学士杨廷麟等与六千守城将士殉国，满清军屠城。大约有二十万人被屠杀。史称赣州之屠。平海之屠平海之屠指的是公元1647年（南明永历元年七月），清军在福建平海卫进行的一次大规模屠城。根据《明清史料》、《南明史》等记载，1647年南明绍宗皇帝殉国后，遵奉鲁监国的义师在闽浙两地依然相当活跃。是年七月，南明同安伯杨耿领兵一度收复平海卫。满清援军赶到后，杨耿兵被迫撤退，平海卫百姓惨遭屠杀。被屠杀的无辜百姓具体人数不详。史称平海之屠。邵武之屠邵武之屠指的是公元1648年（南明永历二年四月），满清“福建左路总兵”王之纲在福建邵武县进行的一次大规模屠城。根据《郑成功档案史料选集》等记载，1648年江西金声桓、王得仁反正归明后，福建义民举兵响应。义军攻占邵武县城后，复为满清兵所败，城中起而响应的绅民惨遭屠戮。被屠杀的无辜百姓人数不详。史称邵武之屠。同安之屠同安之屠指的是公元1648年（南明永历二年八月十六日），满清“靖南将军”陈泰、“浙闽总督”陈锦、“福建提督”赵国祚在福建同安县进行的一次大规模屠城。根据《郑成功档案史料选集》等记载，1648年李成栋反正后，闽南地区复归明朝旗下，但闽系将领多为排斥。是年七月满清军队进攻同安，郑成功援军因风向不利受阻。同安城破后，守城将士悉数杀身成仁，满清军队屠城，血流沟渠。大约有五万人被屠杀。史称同安之屠。湘潭大屠杀 1649年正月二十一日清军攻入湘潭，南明督师何腾蛟被俘。清郑亲王济尔哈朗下令屠城，“屠至二十六日封刀，二十九日方止”。湘潭城中百姓几乎全被杀光，城中不满百人。”(康熙三年《湘潭县志》 ) 南昌大屠杀 1648年，金声桓、王得仁在江西起兵抗清，七月初十清军包围南昌。次年三月间，南昌城陷，清军屠城。 “妇女各旗分取之，同营者迭嬲无昼夜。三伏溽炎，或旬月不得一盥拭。除所杀及道死、水死、自经死，而在营者亦十余万，所食牛豕皆沸汤微 ?集而已。饱食湿卧，自愿在营而死者，亦十七八。而先至之兵已各私载卤获连轲而下，所掠男女一并斤卖。其初有不愿死者，望城破或胜，庶几生还;至是知见掠转卖，长与乡里辞也，莫不悲号动天，奋身决赴。浮尸蔽江，天为厉霾。”(徐世溥《江变纪略》 ) 华南信丰之屠信丰之屠指的是公元1649年（南明永历三年三月初一日），满清“梅勒章京”胶商在广东信丰县进行的一次大规模屠城。根据《西江志》等记载，1649年李成栋二次入赣，为满清军所败，退守信丰。满清军攻破城池，李成栋仓促撤退，在回师过程中阵亡。满清军入城后对城中居民滥加屠杀。被屠杀的无辜居民人数不详。史称信丰之屠。南雄大屠杀雄之屠指的是公元1649年（南明永历三年十二月三十日），满清“平南王”尚可喜、“靖南王”耿继茂在广东南雄府进行的一次大规模屠城。根据《岭表纪年》、《南雄府志》记载，1649年清军从江西南下进攻广东，偷渡梅岭后，派遣间谍进入南雄放火并打开城门，满清军主力拥入。守城六千余名将士死战殉国，城内居民被屠戮殆尽。大约有两万人被屠杀。史称南雄之屠。 1649年农历十二月二十九日，清军抵达南雄，年三十除夕晚上清军放火焚烧鼓楼，趁明军慌乱救火之际，攻入城内。对南雄县民大肆屠杀，“大清平、靖二藩克雄城，民尽屠戮，十存二三。”(乾隆十八年《南雄县志》) 参考文献：“ 家家燕子巢空林，伏尸如山莽充斥。….死者无头生被掳，有头还与无头伍。血泚焦土掩红颜，孤孩尚探娘怀乳。(清军文书陈殿桂，《雄州店家歌》 ) 庚寅之劫（又称广州大屠杀）庚寅之劫，指1650年（清顺治七年，南明永历四年，庚寅年）11月24日到12月5日清朝军队在广州的屠城暴行。当年公历11月24日，清朝平南王尚可喜与靖南王耿继茂指挥的清军（汉军镶蓝旗）在围城近十个月后，经过惨烈的战斗，包括筑垒相逼，以楼车攻城，及动用荷兰炮手，终于攻破广州城，随后对据城死守的广州居民进行了长达十二天的大屠杀，据清代官方史载，这场屠城，斩“兵民万余”，又“追剿余众至海滨，溺死者无算”，不论男女老幼，一律残酷地杀死，死亡人数根据收尸的和尚统计至七十万。广州市社会科学研究所认为“七十万人”显然不可信，因为明末广州府十三县人口总共才40万人。另有意见认为当时广州人口约40万，而死难者约十万人或超过十万人。参考文献：“甲申更姓,七年讨殛。何辜生民，再遭六极。血溅天街，蝼蚁聚食。饥鸟啄肠，飞上城北。北风牛溲，堆积髑髅。或如宝塔，或如山邱。五行共尽，无智无愚，无贵无贱，同为一区。”(《祭共冢文》王鸣雷)，“可喜屠广州，孑遗无留;逸出城者，挤之海中。”(倪在田《续明纪事本末》)《广州市宗教志》:“清顺治七年(1650年)，清军攻广州，‘死难10万至70万人。’在东郊乌龙冈真修和尚雇人收拾尸骸，‘聚而殓之，埋其馀烬’合葬立碑”。意大利籍耶酥会士卫匡国(Martin Martini ，1614~1661)在《鞑靼战纪》中记述:“大屠杀从11月24日一直进行到12月5日。他们不论男女老幼一律残酷地杀死，他们不说别的，只说:‘杀!杀死这些反叛的蛮子!”荷兰使臣约翰纽霍夫(John Nieuhoff)在其《在联合省的东印度公司出师中国鞑靼大汗皇帝朝廷》一书记述:“鞑靼全军入城之后，全城顿时是一片凄惨景象，每个士兵开始破坏，抢走一切可以到手的东西;妇女、儿童和老人哭声震天;从11月26日到12月15日，各处街道所听到的，全是拷打、杀戮反叛蛮子的声音;全城到处是哀号、屠杀、劫掠;凡有足够财力者，都不惜代价以赎命，然后逃脱这些惨无人道的屠夫之手。” 潮州之屠潮州之屠指的是公元1653年（南明永历七年九月十四日），满清“靖南将军”哈哈木在广东潮州府进行的一次大规模屠城。根据《平南王元功垂范》等记载，1653年九月，是年满清“潮州总兵”郝尚久反正归明，响应李定国大军。李定国兵败西撤后，郝尚久势单力薄。满清军队在包围潮州一月有余之后，攻陷府城，郝尚久自杀殉国。满清军屠城，斩杀无算。大约有十万人被杀，史称潮州之屠。参考文献：“纵兵屠掠，遗骸十余万”，揭阳县观音堂海德和尚等收尸聚焚于西湖山，将骨灰葬在西湖南岩。福建同安县屠城死难5万余人，梵天寺主持释无疑收尸合葬于寺东北一里之地，建亭“无祠亭”，墓碑上则刻“万善同归所 ”。西南四川大屠杀清军入关后的1647年在四川公开发布告示，宣称：全城尽屠，或屠男而留女。把四川人杀光了以后，就把罪恶全部推给也杀了一点人的张献忠，还编造出张献忠杀人6个亿的历史第一大谎言！根据近年历史学者的研究，四川被害者不下300万，而被张献忠杀害的至多只有14万人，连同张献忠统制地区其它非正常死亡，最多只有30-40万人。更重要的是，在清军开始长达十几年的四川大屠杀前，张献忠已经死了。南明隆武二年( 1646 年)至永历十九年( 1665年)十一月，张献忠阵亡，满清开始侵入四川。同年满清政府贴出公告:“民贼相混，玉石难分。或屠全城，或屠男而留女”。面对四川人民顽强不屈的抵抗，此后满清用了近20年时间始占领四川。1647年清将张德胜攻入成都被杀后，相继攻伐四川的清军有高民瞻、吴三桂、李化龙等部。1660年，成都沦陷;1663年，重庆沦陷;1665年，南明下川东战役失利，全蜀沦陷。四川的反清活动被残忍地镇压后，满清“叔父摄政王”多尔衮、孝庄采取了彻底屠杀的办法作为报复，约5，400，000人遇难。最后到了“弥望千里，绝无人烟”的地步。后来清廷不得不迁移湖广的人口至四川(即有名的以湖广填四川 )。永昌之屠永昌之屠指的是公元1659年（南明永历十三年闰三月），满清“征南将军”赵布泰、“提督”线国安等在云南永昌府等地进行的一次大规模屠城。根据《清世祖实录》和《明清档案》记载，1659年满清军队进入云南，分路攻打南明防线。满清军队沿途烧杀抢掠无恶不作，永昌一带周围百里无人烟。被屠杀的无辜居民人数不详。史称永昌之屠。西北潼关之屠潼关之屠指的是公元1644年（明崇祯十七年正月十三日），满清“豫亲王”多铎在陕西潼关进行的一次大规模屠城。根据《清世祖实录》和《潼关志》记载，1644年正月十二日，李自成从潼关回援西安。留守潼关的大顺“巫山伯”马世耀向满清军队诈降，但密信为满清所获。次日，多铎诈称举行宴会，将马部官兵解除武装，手无寸铁的战俘被尽数屠杀。

满清大屠杀

扬州十日

南明弘光元年，清朝顺治二年(1645年)发生在清军攻破扬州城后对城中平民进行大屠杀的事件。由于当时南明将领史可法对清军的殊死抵抗，在同年四月廿五日(5月20日)，清军攻占扬州后，当时大雨倾盆，多铎宣布在扬州城内进行了屠杀。当时的幸存者王秀楚所著《扬州十日记》中记载屠杀共持续十日，故名“扬州十日”。清军攻破扬州城后进行了为期十天的大肆屠杀，史载:“诸妇女长索系颈，累累如贯珠，一步一跌，遍身泥土;满地皆婴儿，或衬马蹄，或藉人足，肝脑涂地，泣声盈野。”“初四日，天始霁。道路积尸既经积雨暴涨，而青皮如蒙鼓，血肉内溃。秽臭逼人，复经日炙，其气愈甚。前后左右，处处焚灼。室中氤氲，结成如雾，腥闻百里。”后来由城内僧人收殓的尸体就超过了80万具。

扬州十日记·译文 [明·王秀楚]

其他

一、剃发令：扬州十日、嘉定三屠，屠戮了3000万平民。满清强制推行剃发易服，将汉人及所有其他族人统一剃发留辫，并以此为区分满汉和尊卑等级的标志。二、文字狱：大兴文字狱150年，被凌迟杀害者无数。满清入主中原后，为了巩固统治，防止汉人反抗，设立了文字狱，对著作、诗文、书信等文字作品进行审查，摘取文字意会而成罪名。这种禁锢思想的行为造成了对知识分子的严重打压，因为文字狱而被诛九族的达到上百起。导致社会文化的发展停滞。明史案——由庄廷鑨编写《明史》而引发的清初最大的文字狱案。双目皆盲的浙江湖州富户庄廷鑨出钱购买明人朱国祯一部未完成的《明史》，然后延揽名士，增润删节，补写崇祯朝和南明史实，其父庄允诚于顺治十七年冬（公元1660年）将书刻成，即行刊书《明史辑略》。顺治十八年（公元1661年）为归安知县吴之荣告发，这时廷鑨已死，被掘墓刨棺，枭首碎骨，尸体被悬吊在杭州城北关城墙上，示众三个月，廷鑨弟廷钺被杀。所有列名参校、刻印买卖者均因此获罪，重辟70余人，凌迟18人。三、焚书：清朝乾隆年间大兴文字狱，毁灭经典书籍、科学书籍禁毁图书13600卷。焚书总数达15万册，销毁版片170余种、80000余块。对明朝不少于10000件的档案进行销毁，目前仅存3000余件。乾隆39年开始，武英殿前字纸炉日夜燃烧，严密监视下，巨量珍贵图书灰飞烟灭，随同消灭的是一个民族的大量记忆。四、闭关锁国清朝实行闭关锁国政策，限制了对外贸易和文化交流，使中国错失了学习先进科学知识和生产技术的机会，导致中国在科技和军事上远远落后于西方。五、大肆出卖中国土地，割地赔款在中外签订的多个不平等条约中，中国丧失了大片领土和主权。在面对俄罗斯小股民兵侵略时，居然和俄罗斯签订《尼布楚条约》主动放弃西伯利亚大片领土，甚至连自古属于中国的瀚海湖（贝加尔湖）也放弃！再后来，据资料记载，自1842年鸦片战争爆发后，清政府被迫和西方列强国家大大小小签订了700多份不平等条约。据不完全统计，清政府累计欠下的赔款超过了13亿两白银。其中涉及到割地面积较大的条约共有4个，分别是1858年的《瑷珲条约》将黑龙江以东、外兴安岭以南的60多万平方公里领土割让给俄罗斯； 1860年的《北京条约》将乌苏里江以东44万平方公里的领土割让给俄罗斯； 1895年的《马关条约》，割让辽东半岛、台湾岛及其附属岛屿以及澎湖列岛共近10万平方公里的领土给日本； 1861年俄罗斯逼迫清政府签下的《塔城界约》，侵占了我国自沙渍达巴哈起，至葱岭止约43万平方公里领土。六、搞愚民政策，奴化政策，贫民政策。多年的政策下，国民识字率1%都不到，而且极度贫穷、奴性。鸦片肆虐，导致中国人被称为“东亚病夫”。七、禁止汉人对外移民近代是大移民时代，欧洲人大量移民美洲澳洲，汉族本应参与大移民的浪潮，满清为了奴役压迫汉族，故意不让汉族往外移民，使汉族丢失了往外移民的机会和前途。如果满清政府没有禁止汉族往外移民，现在全世界汉族国家可能已经多出好几个。远的不说，就说巴西在清末向清政府请求移民中国人去巴西，却遭到清政府的严词拒绝。结果巴西去找日本，日本政府非常积极，移民几百万日本人去巴西。现在巴西有大量日本人，日本人在巴西拥有大量私人田地，甚至超过了日本本土，这些土地可以让日本在巴西繁衍大量人口。这一切本来都该是我们中国人的，然而却被满清故意破坏！另外满清对汉人向东南亚的移民一直是排斥，压迫，封闭的政策。如果没有满清的故意阻挠，东南亚的汉族移民根本就不会那么少，应该早就建立了数个汉族国家。比较有名的是兰芳共和国事件。汉人自力更生在东南亚建立了兰芳共和国，由于实力弱小，面临欧洲侵略者的侵略，兰芳共和国寻求清朝的保护，没醒到满清政府居然大骂汉人向外移民是反叛，支持欧洲侵略者侵略兰芳共和国。最后兰芳共和国被欧洲侵略者消灭。还有在马来半岛和苏门答腊岛，如果汉族可以自由移民完全可以在这个两个地区建国，但由于满清的一再阻挠和限制没有实现。现在当地土著越生越多汉族比例不断下降，再无独立的可能。马来西亚的汉族也由原来的40%下降为20%，印尼华人由原来的10%降为现在的3%。八：盗墓乾隆为了修陵墓，甚至去盗明十三陵，这种行为严重破坏了中国的历史文化遗产。九、压制商人明万历年间中国沿海一带已经出现了资本主义的萌芽，但满清的压制商人政策阻碍了中国经济的发展，使中国错失参与第二次工业革命的机会，导致中国落后挨打。十、民族歧视满清实行民族歧视政策，对汉人和其他族人进行不平等待遇，严重侵犯了汉族的权利和尊严。

禁止私塾

清朝通过封禁民间私塾、冷藉等措施，成功将民间识字率压制到不足1%，私自开私塾、私传所学严惩，家学所授课业严审。而且清廷焚烧、尽灭了大量科技类书籍，比如《天工开物》。

满洲国流亡政府

这个词是我最近才看到的，一篇《满洲国流亡政府代表团访日》，2024年1月23日，满洲国流亡政府代表团在日本国会众议院会馆举办《印太战略与满洲复国运动》会议。

参考资料

2019年，公安部端掉了满遗复辟分裂组织“满洲复兴协和会”，抓获了18名妄图复辟清朝的骨干分子。也就是这件事情，让塔意识到所谓“清宫文化”和“辫子戏”的危害性有多大，从19年开始，广电也开始有意识的减少甚至封杀清宫剧的拍摄，曾经霸占市场二十余年的辫子戏到了人人喊打的地步，电视上可以看到很早之前拍摄的《雍正王朝》《康熙王朝》等古早电视剧，但19年之后几乎没有啥新出的电视剧了，最新的一个是2022年的《天下长河》作者：上帝的左手链接：https://www.zhihu.com/question/593861268/answer/1903376346786272890 来源：知乎著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

Lua 可变参数

Sun, 24 Aug 2025 00:00:00 +0000

参考文章

在 Lua 中遇到需要使用可变参数时，通常这样处理：

local function add(...)
    local l = 0
    for k, v in ipairs({...}) do
        l = l + v
    end
    return l
end

print(add(1, 2, 3, 4))

-- 输出：
-- 10

但是，如果传入的参数中间有 nil 那么，结果就不是预期的了：

local function add(...)
    local l = 0
    for k, v in ipairs({...}) do
        l = l + v
    end
    return l
end

print(add(1, 2, nil, 4))
-- 输出：
-- 3

因此，在遍历参数时，推荐使用 select 函数：

local function add(...)
    local l = 0
    for i = 1, select('#', ...), 1 do
        l = l + (select(i, ...) or 0)
    end
    return l
end

print(add(1, 2, nil, 4))
-- 输出：
-- 7

参考文章

Lua 正确处理可变参数

高效处理 Markdown 中的代码块

Sun, 24 Aug 2025 00:00:00 +0000

执行代码
格式化代码

在使用 Markdown 写作时，通常会在文章中需要插入代码块。为了更高效的编辑和执行代码块，引入以下几个插件及配置。

执行代码

新建 ~/.confg/nvim/ftplugin/markdown.lua

vim.keymap.set('n', '<leader>lr', function()
    local cf = vim.fn['context_filetype#get']()

    if cf.filetype ~= 'markdown' then
        local runner = require('code-runner').get(cf.filetype)
        runner['usestdin'] = true
        runner['range'] = { cf['range'][1][1], cf['range'][2][1] }
        require('code-runner').open(runner)
    end
end, { silent = true, buffer = true })

格式化代码

vim.keymap.set('n', '<leader>bf', function()
    local cf = vim.fn['context_filetype#get']()

    if cf.filetype ~= 'markdown' then
        local command = vim.fn.printf(
            '%s,%sFormat! %s',
            cf.range[1][1],
            cf.range[2][1],
            cf.filetype
        )
        vim.cmd(command)
    end
end, { silent = true, buffer = true })

为什么停止维护 SpaceVim

Sat, 03 May 2025 00:00:00 +0000

项目的初衷
遇到的问题
停止维护的原因
归档即是新的开始
插件列表

SpaceVim 从 2016 年 12 月诞生，到 2025 年 2 月 21 日正式归档，前后将近九年。九年的时间足以让一个想法从萌芽走向成熟，也足以让一个项目逐渐找到它最合适的落点。在我看来，归档并不意味着结束，也是新的一段开始。

项目的初衷

早期，开发这个项目的时候，是想做一个开箱即用的模块化 Vim 配置，类似于 spacemacs 那样，把不同语言功能所需要的配置及插件都放到一个模块里面。使用者不再需要自己配置各种插件，只需要简单地启用对应语言或者功能的模块就可以快速搭建 Vim 的开发环境。

遇到的问题

随着功能越来越多，代码越来越臃肿，速度也变得越来越慢。如果查看 git log 的话，不难发现，很大一部分内容是做速度的优化。甚至，我也使用 Lua 重写的相当一部分的内置插件，包括状态栏、标签栏、任务管理、项目管理、多光标、快捷键导航等等。但是即便是使用 Lua 进行了重写，但是因为要兼容老版本的 Neovim 以及兼容 Vim，因此整体总的框架使用的是 Vim Script，调用 Lua 插件的时候还是使用 VimL 去调用 Lua 的代码，例如：

func! SpaceVim#test(...)
    lua require('task').start(require('spacevim').eval('a:000'))
endf

这样的话速度还是无法发挥到极致。

停止维护的原因

想使用纯 Lua 来写 Neovim 配置（nvim-config），不再兼容 Vim，因为我也很少再使用 Vim 了。
不想做 Neovim 老版本的兼容支持
单个功能插件独立维护，便于直接使用，我把原先 spacevim 中内置的很多功能，

归档即是新的开始

归档并不是结束，而是完成一个阶段性作品后的放手。正如上述原因里所描述，我希望使用 Lua 并且不再兼容老版本以及 Vim，使得代码能够更简洁。相较于再制作一个 Lua 开发的 SpaceVim，我更乐意把 SpaceVim 中日常使用较多的功能独立成单独的插件。这样也方便他人根据实际的需求选择最小化的配置。

插件列表

目前已经切换到纯 Lua 配置的 Neovim 环境了，并且原先 SpaceVim 中常用功能已单独使用 Lua 重写。个人 Neovim 配置仓库地址：nvim-config。以下是我自己制作并且日常使用的 Neovim 插件，欢迎尝试。

插件管理器 nvim-plug

仓库地址：wsdjeg/nvim-plug 这是我参考 dein.nvim 以及 Vundle.vim 写的一个异步的插件管理器，已经实现了日常我对于插件管理器的要求：

clone、pull、build 等操作都是多线程异步执行；
支持通过 autocmd、command、function 等方式触发延迟加载；
支持依赖管理、import 目录载入插件；
支持 luarocks;

对于插件管理器的界面，其实我需要的只是像 Vundle.vim，以前使用 dein.nvim 时候，dein.nvim 是默认没有 UI 界面的，当时我写了一个 dein-ui.vim 用来展示插件安装的进度。

项目管理 rooter.nvim

仓库地址：rooter.nvim 在使用 Vim 编辑代码文件时，比较常用的一个功能是根据当前文件的路径自动将当前目录切换到项目的根目录。这个功能以前我使用的是 vim-rooter 这个插件。而 rooter.nvim 正是使用 Lua 重新实现该功能的 Neovim 插件，不同的是，该插件额外提供了一些模糊搜索插件拓展，可以模糊搜索历史打开过的项目。此外，这个插件还支持设置 callback 函数，当切换项目时自动执行。

异步代码检索 flygrep.nvim

仓库地址：flygrep.nvim 日常阅读代码过程中还是经常需要搜索代码的，flygrep。插件会异步调用rg，并实时展示搜索结果。

历史文件管理 mru.nvim

仓库地址：mru.nvim 类似于 v:oldfiles，解决的问题是Windows系统下路径格式问题，同时支持各种筛选选项。此外也提供了一个 telescope 拓展。

代码格式化 format.nvim

仓库地址：format.nvim 很早以前，我使用的代码格式化插件是 neoformat，这是使用 VimScript 开发的插件，为了更快的速度体验，我使用 Lua 重新写了一个格式化插件，插件的基本逻辑参考了 neoformat。也支持 markdown 内代码块的格式化。

版本控制 git.nvim

仓库地址：git.nvim 可以这么说，这应该是我日常使用最多的插件，比如 :Git add，:Git commit，等等。

代码运行 code-runner.nvim

仓库地址：code-runner.nvim vscode 里面有一个非常著名的插件，叫做CodeRunner，就是快速运行当前文件，并在下面分屏显示运行结果。code-runner.nvim 实现了想类似的功能，不仅仅可以运行当前文件，还可以快速运行 markdown 文件内当前代码块。

书签管理 bookmarks.nvim

仓库地址：bookmarks.nvim 可以标记当前行进入书签列表，支持添加备注内容，支持使用quickfix列表展示书签，也提供了一个 telescope 拓展以便于模糊搜索书签。

tags 管理 ctags.nvim

仓库地址：ctags.nvim 自动为当前项目生成ctags数据库，同时更新 &tags 选项，以便于使用ctrl-]跳转到光标tags定义位置。

滚动侧栏 scrollbar.nvim

仓库地址：scrollbar.nvim 自动在当前窗口右侧绘制一个滚动条，提示当前文档滚动页大致的位置。

笔记插件 zettelkasten.nvim

仓库地址：zettelkasten.nvim 这是一个做笔记的插件，支持标签内链，相互索引。

日历插件 calendar.nvim

仓库地址: calendar.nvim 记笔或者待办事项的时候，很多时候需要一个日历视图，来快速看下哪一天有记录。而 calendar.nvim 就是这样一个支持拓展的简易日历视图，可以方便的查阅日历，配合拓展还可以在特定日期执行某个拓展操作。我目前最常用的是配合 zettelkasten.nvim 插件来记录和查阅每日笔记。

异步job管理 job.nvim

仓库地址：job.nvim 这是模拟 jobstart 的工具，基于libuv，可以用于异步执行命令。我的很多插件都是依赖这个job.nvim，比如插件管理器等等，需要异步执行外部命令的。

模糊搜索插件 picker.nvim

仓库地址：picker.nvim 早期在使用 Vim 时，使用过 ctrl-p、unite.vim、denite.nvim 等等插件。从 Neovim 浮窗功能出来后，逐步切换到了 telescope.nvim。但是近期发现这个插件似乎不怎么在维护了，再加上自己也有想法写一个模糊搜索插件，于是就有了 picker.nvim。

项目文件跳转 altf.nvim

仓库地址：altf.nvim 这个插件提供了一个命令 :A，可以使用这个命令在头文件和C文件、或者源文件和测试文件等之间快速跳转。

按键弹窗 record-key.nvim

仓库地址：record-key.nvim 有时候制作录屏的时候，需要展示自己按键的顺序，这个插件以弹窗的形式，在右下方展示按键的顺序。

录屏 record-screen.nvim

仓库地址：record-screen.nvim 屏幕录制的软件其实挺多的，这个插件通过后台调用 ffmpeg，支持录制声音、话筒、摄像头等等。

解决 Windows 系统下输入法问题

Wed, 23 Apr 2025 00:00:00 +0000

遇到的问题
实际原因
解决方法
使用 Neovim autocmd 自动执行 im-select
更好的解决方法

遇到的问题

最近更新 Windows 系统后，使用 ALT-Tab 快捷键切换窗口，每次切换回终端，输入法就会自动变成中文模式，非常影响 Neovim 的操作。比如：每次切换到浏览器，复制下相关内容后，到 nvim 里面来想黏贴，通常使用 "+p 快捷键就可以了，但是由于当前输入法变成了中文模式，就变成输入了 “+, Normal 模式下 “ 无用，+ 直接给换到下一行。p 按键不会直接输入到终端，反而会弹出输入法候选框。此外，由于自动切换到了中文输入，当想执行 Neovim 命令时，比如 :w<Cr> 的时候，同样的按键顺序，就会变成了：w, 未保存，同时相当于 Normal 模式下执行了一次 w 光标向前移动一个词位置。

实际原因

网上类似的讨论有很多：

https://www.v2ex.com/t/1120452
https://chunyujin.top/chunyujin/8728f196

但是并没有讲到真实的原因。在以前的系统里面（Win7），通常语言设置会有两个键盘，一个叫做美式键盘（一个灰色小的键盘图标），另外一个键盘通常就是我们的输入法，比如搜狗的红色小图标，日常最常用的快捷键是 ctrl-space 来切换的是键盘，而不是某个输入法的中英文模式。有时候，还不止两个键盘，比如同时安装了搜狗拼音、搜狗五笔，那么加上默认的美式键盘，就是三个键盘。通常使用 ctrl-space 来回切换，ctrl-shift 轮换。虽然，以前搜狗输入也好，微软输入法也好，大多数提供了内置的中英文输入切换，通常快捷键是 shift 键。而在最新版的 Windows 系统中，微软做了一件非常恶心的的事情，就是默认不给你安装美式键盘，只给你安装一个微软输入法，并且把默认的键盘切换按键ctrl-space改为win-space，同时无法改回，只能在微软输入法里面设置ctrl-space切换自己的中英文模式。

解决方法

设置 - 时间和语言 - 语言和区域 - 首选语言 - 添加语言 - 找到 English（United States）添加。此时就有两个键盘，使用 win-space 可以切换键盘。美式键盘只做英文输入，微软拼音只做中文输入，关闭管软拼音的英文模式。完成以上操作后就可以使用命令行工具 im-select 进行键盘切换了。打开命令行窗口：分别在两个键盘模式下执行一次下载的 im-select.exe 可以看到输出如下：关于这个命令的说明：

直接不带参数执行，获取当前键盘值，比如上图中，我分别先后在美式键盘和微软拼音下单独执行命令，获取到两个键盘值 1033 和 2052。
执行命令，并带上键盘值参数，切换至指定键盘，比如 im-select.exe 1033 切换至美式键盘，im-select.exe 2052 切换至微软拼音。

使用 Neovim autocmd 自动执行 im-select

local augroup = vim.api.nvim_create_augroup('wsdjeg', { clear = true })

local create_autocmd = vim.api.nvim_create_autocmd
-- 这里指定下载的 im-select.exe 的绝对路径，
-- 当然，你也可以将这个命令丢 PATH 里，个人不喜欢污染 PATH
local imselect = 'C:\\Users\\wsdjeg\\Downloads\\im-select.exe'

create_autocmd({ 'InsertLeave', 'FocusGained', 'CmdlineLeave', 'VimEnter' }, {
    pattern = { '*' },
    group = augroup,
    callback = function(_)
        -- 切换至美式键盘
        vim.system({ imselect, '1033' })
    end,
})
create_autocmd({ 'FocusLost' }, {
    pattern = { '*' },
    group = augroup,
    callback = function(_)
        -- 切换至微软拼音
        vim.system({ imselect, '2052' })
    end,
})

更好的解决方法

如果不想增加美式键盘，那么可以使用 im-select-mspy，对应的 Neovim 配置如下：

local augroup = vim.api.nvim_create_augroup('wsdjeg', { clear = true })

-- download im-select-mspy from https://github.com/daipeihust/im-select/raw/refs/heads/master/win-mspy/out/x64/im-select-mspy.exe
local imselect = 'C:\\Users\\wsdjeg\\Downloads\\im-select-mspy.exe'

local function imselect_cn()
    vim.system({ imselect, '-k=ctrl+space', '中文模式' })
end

local function imselect_en()
    vim.system({ imselect, '-k=ctrl+space', '英语模式' })
end

-- 使用 table 存储不同 buffer 的 Insert 模式下的输入法
local buffer_im = {}

create_autocmd({ 'InsertLeave' }, {
    pattern = { '*' },
    group = augroup,
    callback = function(ev)
        vim.system({ imselect }, { text = true }, function(o)
            -- 这里说明下，再 Windows Terminal 内执行该命令输出的内容默认编码是 `cp936`,
            -- 需要转码成 utf-8，同时，输出内容尾部有换行符，使用 trim 函数去除。
            buffer_im[ev.buf] = vim.trim(vim.iconv(o.stdout, 'cp936', 'utf-8'))
        end)
        imselect_en()
    end,
})
create_autocmd({ 'InsertEnter' }, {
    pattern = { '*' },
    group = augroup,
    callback = function(ev)
            local c = '英语模式'
        if buffer_im[ev.buf] and buffer_im[ev.buf] ~= '英语模式' then
            -- 此处设置快捷键，可以在输入法按键设置里面查看，我选择的是使用 ctrl-space 切换中英文
            -- 默认我记得是 shift，同时这个命令默认也是 `-k=shift`
            vim.system({ imselect, '-k=ctrl+space', buffer_im[ev.buf] })
        end
    end,
})

create_autocmd({ 'FocusGained', 'CmdlineLeave', 'VimEnter' }, {
    pattern = { '*' },
    group = augroup,
    callback = function(_)
        imselect_en()
    end,
})
create_autocmd({ 'FocusLost' }, {
    pattern = { '*' },
    group = augroup,
    callback = function(_)
        imselect_cn()
    end,
})

Neovim 历史使用文件插件 mru.nvim

Sun, 13 Apr 2025 00:00:00 +0000

起因
mru.nvim 的特点
安装与配置
LeaderF 拓展

起因

最近分享了一个自己制作 Neovim 的插件 mru.nvim，用于管理历史访问过的文件列表。有人说，这样简单的功能 Neovim 本身就有。没错，Neovim 和 Vim 一样，支持使用 v:oldfiles 获取最近浏览的文件名称列表。但是 Neovim 这一变量在 Windows 系统下面存在文件名称格式不一致的问题（neovim#25033）。比如，一些使用 v:oldfiles 的插件，如 telescope.nvim、dashboard.nvim 等，其列表内会出现一些重复的文件。

D:/hello.txt
D:\hello.txt
d:/hello.txt
d:\hello.txt

此外，阅读:h v:oldfiles 可以看到该变量虽然支持修改，但是并不会影响 shada 文件中存储的内容。因此，在 Neovim 重启后，之前对 v:oldfiles 这一变量的修改就会无效了。

mru.nvim 的特点

Windows 系统下统一的文件名格式，上述四种文件名称统一显示为 D:/hello.txt，可以避免重复显示。
可以预设置多个正则表达式，当文件名称匹配上时，阻止其被加入文件浏览历史记录。
```
require('mru').setup({
  ignore_path_regexs = { '/.git/', '/nvim/runtime/doc/' },
})
```
比如，在使用一些启动屏插件（dashboard.nvim）时，会在启动时显示近期打开过的文件，如果前面打开过一些非文本类文件，比如图片类的，这类文件可以从浏览历史中去除掉。
```
require('mru').setup({
  ignore_path_regexs = { '/.git/', '.mp3$', '.png$' },
})
```
提供了 telescope.nvim 拓展，可以使用 :Telescope mru 打开。
提供了修改 mru 文件列表的函数，Neovim 重启后任然有效。
增加了 picker.nvim 推展，可以使用 :Picker mru 打开。

安装与配置

使用 nvim-plug 插件管理器进行安装：

require('plug').add({
    {
        'wsdjeg/mru.nvim',
        config = function()
            require('mru').setup({
                enable_cache = true,
                mru_cache_file = vim.fn.stdpath('data') .. '/nvim-mru.json',
                ignore_path_regexs = { '/.git/' },
                enable_logger = true, -- require wsdjeg/logger.nvim
                -- sort file by last modified time or last enter time
                -- `lastmod`, `lastread` or `lastenter`, default is `lastenter`
                sort_by = 'lastenter',
            })
        end,
    },
})

LeaderF 拓展

当然，如果并未使用 telescope，也可以自行拓展，使用 require('mru').get() 获取历史记录文件名称列表。以 leaderf 为例：

function! s:nmru(...) abort
  return v:lua.require('mru').get()
endfunction

function! s:nmru_acp(line, args) abort
  exe 'e' a:line
endfunction
" function() wrapper
if v:version > 703 || v:version == 703 && has('patch1170')
  function! s:_SID() abort
    return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze__SID$')
  endfunction
  let s:_s = '<SNR>' . s:_SID() . '_'
  function! s:_function(fstr, ...) abort
    if a:0 > 1
      return function(substitute(a:fstr, 's:', s:_s, 'g'))
    else
      return function(a:fstr)
    endif
  endfunction
else
  function! s:_SID() abort
    return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze__SID$')
  endfunction
  let s:_s = '<SNR>' . s:_SID() . '_'
  function! s:_function(fstr) abort
    return function(substitute(a:fstr, 's:', s:_s, 'g'))
  endfunction
endif
let g:Lf_Extensions = {
    \ 'nmru': {
    \       'source': string(s:_function('s:nmru', 1))[10:-3],
    \       'accept': string(s:_function('s:nmru_acp', 1))[10:-3],
    \       'supports_name_only': 1,
    \       'supports_multi': 0,
    \ },
    \}

以上为 VimL 写的 LeaderF 拓展，尝试了使用 Lua 来写，可读性更简单，但是似乎不起作用：

local function mru()
  return require('mru').get()
end

local function mru_acp(line, args)
  vim.cmd('e ' .. line)
end
vim.g.Lf_Extensions = {
  nvimmru = {
    source = mru,
    accept = mru_acp,
    supports_name_only = true,
    supports_multi = false,
  },
}

Neovim 录制按键及屏幕

Sat, 12 Apr 2025 00:00:00 +0000

按键提示
录屏插件
硬件设备检查
仅录制屏幕
录制屏幕、麦克风、扬声器
安装配置
参考阅读

以前偶尔也会录制一些动图，使用的是 LICEcap，这也是一个开源项目，但是不能录制成视频。在网上搜到不少的录视频的软件，比较火热的是班迪录屏，但是我还是倾向于免费开源方案。

按键提示

Neovim 增加了一个 vim.on_key，这个函数在按键按下后会触发。借助这个函数及 Neovim 的悬浮窗口，实现了一个按键弹窗提示的效果插件 record-key.nvim。默认的着色是 Normal 高亮组，如果需要突出显示，可以设置为：

require('record-key').setup({
  timeout = 3000,
  max_count = 7,
  winhighlight = 'NormalFloat:Todo,FloatBorder:WinSeparator',
})

录屏插件

record-screen.nvim 是一个 Neovim 屏幕录制的插件，借助 ffmpeg 这个命令和 Neovim 的异步机制。

硬件设备检查

前面的设置是只录制桌面图像，但是在日常视频录制的过程中，还是会涉及到其他的一些设备，比如麦克风、摄像头、音响等等。首先使用 ffmpeg -list_devices true -f dshow -i dummy 命令获取设备列表：

ffmpeg version 7.1.1-full_build-www.gyan.dev Copyright (c) 2000-2025 the FFmpeg developers
  built with gcc 14.2.0 (Rev1, Built by MSYS2 project)
  configuration: --enable-gpl --enable-version3 --enable-static --disable-w32threads --disable-autodetect --enable-fontconfig --enable-iconv --enable-gnutls --enable-lcms2 --enable-libxml2 --enable-gmp --enable-bzlib --enable-lzma --enable-libsnappy --enable-zlib --enable-librist --enable-libsrt --enable-libssh --enable-libzmq --enable-avisynth --enable-libbluray --enable-libcaca --enable-libdvdnav --enable-libdvdread --enable-sdl2 --enable-libaribb24 --enable-libaribcaption --enable-libdav1d --enable-libdavs2 --enable-libopenjpeg --enable-libquirc --enable-libuavs3d --enable-libxevd --enable-libzvbi --enable-libqrencode --enable-librav1e --enable-libsvtav1 --enable-libvvenc --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxavs2 --enable-libxeve --enable-libxvid --enable-libaom --enable-libjxl --enable-libvpx --enable-mediafoundation --enable-libass --enable-frei0r --enable-libfreetype --enable-libfribidi --enable-libharfbuzz --enable-liblensfun --enable-libvidstab --enable-libvmaf --enable-libzimg --enable-amf --enable-cuda-llvm --enable-cuvid --enable-dxva2 --enable-d3d11va --enable-d3d12va --enable-ffnvcodec --enable-libvpl --enable-nvdec --enable-nvenc --enable-vaapi --enable-libshaderc --enable-vulkan --enable-libplacebo --enable-opencl --enable-libcdio --enable-libgme --enable-libmodplug --enable-libopenmpt --enable-libopencore-amrwb --enable-libmp3lame --enable-libshine --enable-libtheora --enable-libtwolame --enable-libvo-amrwbenc --enable-libcodec2 --enable-libilbc --enable-libgsm --enable-liblc3 --enable-libopencore-amrnb --enable-libopus --enable-libspeex --enable-libvorbis --enable-ladspa --enable-libbs2b --enable-libflite --enable-libmysofa --enable-librubberband --enable-libsoxr --enable-chromaprint
  libavutil      59. 39.100 / 59. 39.100
  libavcodec     61. 19.101 / 61. 19.101
  libavformat    61.  7.100 / 61.  7.100
  libavdevice    61.  3.100 / 61.  3.100
  libavfilter    10.  4.100 / 10.  4.100
  libswscale      8.  3.100 /  8.  3.100
  libswresample   5.  3.100 /  5.  3.100
  libpostproc    58.  3.100 / 58.  3.100
[dshow @ 000001f024fc6d40] "Integrated Camera" (video)
[dshow @ 000001f024fc6d40]   Alternative name "@device_pnp_\\?\usb#vid_13d3&pid_5419&mi_00#7&17d116b8&1&0000#{65e8773d-8f56-11d0-a3b9-00a0c9223196}\global"
[dshow @ 000001f024fc6d40] "麦克风阵列 (Realtek(R) Audio)" (audio)
[dshow @ 000001f024fc6d40]   Alternative name "@device_cm_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\wave_{253B9838-6E9C-47DB-A420-848E63B3931C}"
[in#0 @ 000001f024fad380] Error opening input: Immediate exit requested
Error opening input file dummy.

从上述的输出内容，不难看出，目前支持的设备仅仅有摄像头Integrated Camera和麦克风麦克风阵列 (Realtek(R) Audio)，并没有扬声器，解决方法如下：一、鼠标右键点击桌面右下角音量图标二、打开更多音量设置三、点击录制、右击立体声混声启用这时候再执行 ffmpeg -list_devices true -f dshow -i dummy 输出为：

ffmpeg version 7.1.1-full_build-www.gyan.dev Copyright (c) 2000-2025 the FFmpeg developers
  built with gcc 14.2.0 (Rev1, Built by MSYS2 project)
  configuration: --enable-gpl --enable-version3 --enable-static --disable-w32threads --disable-autodetect --enable-fontconfig --enable-iconv --enable-gnutls --enable-lcms2 --enable-libxml2 --enable-gmp --enable-bzlib --enable-lzma --enable-libsnappy --enable-zlib --enable-librist --enable-libsrt --enable-libssh --enable-libzmq --enable-avisynth --enable-libbluray --enable-libcaca --enable-libdvdnav --enable-libdvdread --enable-sdl2 --enable-libaribb24 --enable-libaribcaption --enable-libdav1d --enable-libdavs2 --enable-libopenjpeg --enable-libquirc --enable-libuavs3d --enable-libxevd --enable-libzvbi --enable-libqrencode --enable-librav1e --enable-libsvtav1 --enable-libvvenc --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxavs2 --enable-libxeve --enable-libxvid --enable-libaom --enable-libjxl --enable-libvpx --enable-mediafoundation --enable-libass --enable-frei0r --enable-libfreetype --enable-libfribidi --enable-libharfbuzz --enable-liblensfun --enable-libvidstab --enable-libvmaf --enable-libzimg --enable-amf --enable-cuda-llvm --enable-cuvid --enable-dxva2 --enable-d3d11va --enable-d3d12va --enable-ffnvcodec --enable-libvpl --enable-nvdec --enable-nvenc --enable-vaapi --enable-libshaderc --enable-vulkan --enable-libplacebo --enable-opencl --enable-libcdio --enable-libgme --enable-libmodplug --enable-libopenmpt --enable-libopencore-amrwb --enable-libmp3lame --enable-libshine --enable-libtheora --enable-libtwolame --enable-libvo-amrwbenc --enable-libcodec2 --enable-libilbc --enable-libgsm --enable-liblc3 --enable-libopencore-amrnb --enable-libopus --enable-libspeex --enable-libvorbis --enable-ladspa --enable-libbs2b --enable-libflite --enable-libmysofa --enable-librubberband --enable-libsoxr --enable-chromaprint
  libavutil      59. 39.100 / 59. 39.100
  libavcodec     61. 19.101 / 61. 19.101
  libavformat    61.  7.100 / 61.  7.100
  libavdevice    61.  3.100 / 61.  3.100
  libavfilter    10.  4.100 / 10.  4.100
  libswscale      8.  3.100 /  8.  3.100
  libswresample   5.  3.100 /  5.  3.100
  libpostproc    58.  3.100 / 58.  3.100
[dshow @ 0000020942ff6cc0] "Integrated Camera" (video)
[dshow @ 0000020942ff6cc0]   Alternative name "@device_pnp_\\?\usb#vid_13d3&pid_5419&mi_00#7&17d116b8&1&0000#{65e8773d-8f56-11d0-a3b9-00a0c9223196}\global"
[dshow @ 0000020942ff6cc0] "麦克风阵列 (Realtek(R) Audio)" (audio)
[dshow @ 0000020942ff6cc0]   Alternative name "@device_cm_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\wave_{253B9838-6E9C-47DB-A420-848E63B3931C}"
[dshow @ 0000020942ff6cc0] "立体声混音 (Realtek(R) Audio)" (audio)
[dshow @ 0000020942ff6cc0]   Alternative name "@device_cm_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\wave_{A04F0465-843E-4E64-891D-31A28192D215}"
[in#0 @ 0000020942fdd340] Error opening input: Immediate exit requested
Error opening input file dummy.

可以看到有三个设备：

Integrated Camera
麦克风阵列 (Realtek(R) Audio)
立体声混音 (Realtek(R) Audio)

当然，也可以安装开源项目 rdp/screen-capture-recorder-to-video-windows-free，安装完成后，`` 命令输出如下：

ffmpeg version 7.1.1-full_build-www.gyan.dev Copyright (c) 2000-2025 the FFmpeg developers
  built with gcc 14.2.0 (Rev1, Built by MSYS2 project)
  configuration: --enable-gpl --enable-version3 --enable-static --disable-w32threads --disable-autodetect --enable-fontconfig --enable-iconv --enable-gnutls --enable-lcms2 --enable-libxml2 --enable-gmp --enable-bzlib --enable-lzma --enable-libsnappy --enable-zlib --enable-librist --enable-libsrt --enable-libssh --enable-libzmq --enable-avisynth --enable-libbluray --enable-libcaca --enable-libdvdnav --enable-libdvdread --enable-sdl2 --enable-libaribb24 --enable-libaribcaption --enable-libdav1d --enable-libdavs2 --enable-libopenjpeg --enable-libquirc --enable-libuavs3d --enable-libxevd --enable-libzvbi --enable-libqrencode --enable-librav1e --enable-libsvtav1 --enable-libvvenc --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxavs2 --enable-libxeve --enable-libxvid --enable-libaom --enable-libjxl --enable-libvpx --enable-mediafoundation --enable-libass --enable-frei0r --enable-libfreetype --enable-libfribidi --enable-libharfbuzz --enable-liblensfun --enable-libvidstab --enable-libvmaf --enable-libzimg --enable-amf --enable-cuda-llvm --enable-cuvid --enable-dxva2 --enable-d3d11va --enable-d3d12va --enable-ffnvcodec --enable-libvpl --enable-nvdec --enable-nvenc --enable-vaapi --enable-libshaderc --enable-vulkan --enable-libplacebo --enable-opencl --enable-libcdio --enable-libgme --enable-libmodplug --enable-libopenmpt --enable-libopencore-amrwb --enable-libmp3lame --enable-libshine --enable-libtheora --enable-libtwolame --enable-libvo-amrwbenc --enable-libcodec2 --enable-libilbc --enable-libgsm --enable-liblc3 --enable-libopencore-amrnb --enable-libopus --enable-libspeex --enable-libvorbis --enable-ladspa --enable-libbs2b --enable-libflite --enable-libmysofa --enable-librubberband --enable-libsoxr --enable-chromaprint
  libavutil      59. 39.100 / 59. 39.100
  libavcodec     61. 19.101 / 61. 19.101
  libavformat    61.  7.100 / 61.  7.100
  libavdevice    61.  3.100 / 61.  3.100
  libavfilter    10.  4.100 / 10.  4.100
  libswscale      8.  3.100 /  8.  3.100
  libswresample   5.  3.100 /  5.  3.100
  libpostproc    58.  3.100 / 58.  3.100
[dshow @ 0000020d0d8f6d40] "Integrated Camera" (video)
[dshow @ 0000020d0d8f6d40]   Alternative name "@device_pnp_\\?\usb#vid_13d3&pid_5419&mi_00#7&17d116b8&1&0000#{65e8773d-8f56-11d0-a3b9-00a0c9223196}\global"
[dshow @ 0000020d0d8f6d40] "screen-capture-recorder" (video)
[dshow @ 0000020d0d8f6d40]   Alternative name "@device_sw_{860BB310-5D01-11D0-BD3B-00A0C911CE86}\{4EA69364-2C8A-4AE6-A561-56E4B5044439}"
[dshow @ 0000020d0d8f6d40] "立体声混音 (Realtek(R) Audio)" (audio)
[dshow @ 0000020d0d8f6d40]   Alternative name "@device_cm_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\wave_{A04F0465-843E-4E64-891D-31A28192D215}"
[dshow @ 0000020d0d8f6d40] "virtual-audio-capturer" (audio)
[dshow @ 0000020d0d8f6d40]   Alternative name "@device_sw_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\{8E146464-DB61-4309-AFA1-3578E927E935}"
[dshow @ 0000020d0d8f6d40] "麦克风阵列 (Realtek(R) Audio)" (audio)
[dshow @ 0000020d0d8f6d40]   Alternative name "@device_cm_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\wave_{253B9838-6E9C-47DB-A420-848E63B3931C}"
[in#0 @ 0000020d0d8dd380] Error opening input: Immediate exit requested
Error opening input file dummy.

此时多出了两个设备：

screen-capture-recorder
virtual-audio-capturer

仅录制屏幕

如果仅仅需要录制桌面，而不需要录制摄像头和声音，可以使用如下配置：

require('record-screen').setup({
    command = 'ffmpeg',
    argvs = {
        '-f',
        'gdigrab',
        '-i',
        'desktop',
        '-pix_fmt',
        'yuv420p',
        '-f',
        'mp4',
    },
})

录制屏幕、麦克风、扬声器

require('record-screen').setup({
    cmd = 'ffmpeg',
    argvs = {
        '-f',
        'dshow',
        '-i',
        'audio=麦克风阵列 (Realtek(R) Audio)',
        '-f',
        'dshow',
        '-i',
        'audio=立体声混音 (Realtek(R) Audio)',
        '-filter_complex',
        'amix=inputs=2:duration=first:dropout_transition=2',
        '-f',
        'gdigrab',
        '-r',
        '60',
        '-draw_mouse',
        '1',
        '-i',
        'desktop',
        '-pix_fmt',
        'yuv420p',
        '-f',
        'mp4',
    },
})

录制视频时，偶尔会遇到类似于 real-time buffer frame dropped 这样的错误提示，参考issue 136 提到的解决方案，增加参数 -rtbufsize 1500M

安装配置

使用 nvim-plug 插件管理器：

require('plug').add({
    {
        'wsdjeg/record-key.nvim',
        cmds = { 'RecordKeyToggle' },
        config_before = function()
            vim.keymap.set(
                'n',
                '<leader>rk',
                '<cmd>RecordKeyToggle<cr>',
                { silent = true }
            )
        end,
    },
    {
        'wsdjeg/record-screen.nvim',
        depends = {
            { 'wsdjeg/job.nvim' },
            { 'wsdjeg/notify.nvim' },
        },
        config = function()
            require('plugins.record-screen')
        end,
    },
})

插件详细配置参考文件 nvim-config/lua/plugins/record-screen.lua 通过这个配置文件，我新建了一个用户自定义命令 :RecordScreen，支持如下参数：

-camera: 录制摄像头
-speaker: 录制扬声器
--microphone: 录制麦克风

使用 :RecordScreen stop 停止录屏。

参考阅读

抛弃又贵又难用的录屏软件，3 分钟入门 FFmpeg

Neovim 自动切换至项目根目录

Sat, 22 Mar 2025 00:00:00 +0000

安装 rooter.nvim
插件配置
Telescope 拓展
插件运行日志
设置 callback 函数

在使用 Neovim 打开某个文件时，我希望 Neovim 自动把当前目录切换到该文件所在的项目根目录。其实，能实现这一功能的有不少的插件，我最早使用的是 vim-rooter，但是后来因为切换到了 Neovim，因此使用 Lua 重写了该功能，这个功能早期是 SpaceVim 的内置的，在 SpaceVim 项目停止维护后独立成单独的插件：rooter.nvim。

安装 rooter.nvim

可以使用任意插件管理器进行安装，比如 nvim-plug

require('plug').add({
  {
    'wsdjeg/rooter.nvim',
    config = function()
      require('rooter').setup({})
    end,
  },
})

插件配置

以下是默认的配置：

require('rooter').setup({
  root_patterns = { '.git/' },
  outermost = true,
  enable_cache = true,
  project_non_root = '',  -- this can be '', 'home' or 'current'
  enable_logger = true,   -- enable runtime log via logger.nvim
})

project_non_root: 配置打开非项目文件时的行为
outermost: 若设为 true，那么通过 root_patterns 检索到的多个目录时，取最外层目录。

Telescope 拓展

rooter.nvim 自带 telescope.nvim 拓展，可以使用 :Telescope project 列出过往打开过的项目。

插件运行日志

在插件运行过程中产生的日志信息，可以使用 logger.nvim 进行查看。如果有这一需求，那么在安装 rooter.nvim 时，需要添加相应的依赖插件。

require('plug').add({
  {
    'wsdjeg/rooter.nvim',
    config = function()
      require('rooter').setup({})
    end,
    depends = {
      {
        'wsdjeg/logger.nvim',
      },
    },
  },
})

设置 callback 函数

通过 reg_callback 可以设置 callback 函数，该函数会在项目切换时被调用。

local function update_ctags_option()
  local project_root = vim.fn.getcwd()
  local dir = require('util').unify_path(require('tags').cache_dir) 
        .. require('util').path_to_fname(project_root)
  table.insert(tags, dir .. '/tags')
  vim.o.tags = table.concat(tags, ',')
end
require('rooter').reg_callback(update_gtags_option)

Neovim 日志插件 logger.nvim

Sun, 16 Mar 2025 00:00:00 +0000

安装
在插件中使用

logger.nvim 提供了一个基础的日志框架，不同的插件可以共用一个日志系统。

安装

和安装其他插件一样，可以使用nvim-plug安装：

require('plug').add({
  'wsdjeg/logger.nvim',
  config = function()
    require('logger').setup({
      -- the level only can be:
      -- 0 : log debug, info, warn, error messages
      -- 1 : log info, warn, error messages
      -- 2 : log warn, error messages
      -- 3 : log error messages
      level = 0,
    })
  end,
})

在插件中使用

比如新建了一个插件 fyz.nvim，此时可以添加一个文件 lua/fyz/log.lua:

local M = {}
local logger
function M.info(msg)
  if not logger then
    pcall(function()
      logger = require('logger').derive('fyz')
      logger.info('hello world')
    end)
  else
    logger.info('hello world')
  end
end

return M

在自己的插件中就可以使用：

local log = require('fyz.log')

log.info('this is log from fyz.nvim')

可以使用 logger.viewRuntimeLog() 查看所有的日志输出，其中就会有如下一行：

[     fyz ] [23:22:50:576] [ Info  ] this is log from fyz.nvim

Neovim 任务管理插件 tasks.nvim

Sat, 01 Mar 2025 00:00:00 +0000

起因
安装及配置 tasks.nvim
常用命令

起因

关于任务（Tasks）管理，实际上早在 2020 年的时候就已经给 SpaceVim 增加了 Tasks 支持，参考的是 Vscode Tasks Manager 的实现。最早的版本使用 Vim Script 实现的，大约在 2023 年的时候增加了 Lua 实现版本，不过这些都是在 SpaceVim 内置的插件。现在，SpaceVim 已经不再维护，而这些常用的功能，我也会陆续剥离出来单独形成插件，这篇文章主要介绍 tasks.nvim

安装及配置 tasks.nvim

可以使用任意插件管理器进行安装，这里以 nvim-plug 为例：

require('plug').add({
  {
    'wsdjeg/tasks.nvim',
    depends = {
      {
        'wsdjeg/code-runner.nvim',
      },
    },
    config = function()
      require('tasks').setup({
        global_tasks = '~/.tasks.toml',
        local_tasks = '.tasks.toml',
        provider = { 'npm' },
      })
    end,
  },
})

常用命令

tasks.nvim 提供了三个常用命令：

:TasksEdit：用于打开 tasks 配置文件，默认打开的是项目配置文件，加上感叹号（:TasksEdit!）则打开全局配置文件。
:TasksList：使用分屏列出所有 tasks
:TasksSelect：选择某个 task 并执行

当然，如果你也安装了 telescope.nvim 那么，可以使用 :Telescope tasks 模糊搜索可用的 tasks.

Neovim 代码执行插件 code-runner.nvim

Fri, 28 Feb 2025 00:00:00 +0000

安装及配置
自动更新 runner 参数

Vscode 有一个非常出名的插件，叫做 Code Runner，我曾经也给 SpaceVim 添加了这么一个功能。现在将这一功能剥离出来形成一个单独独立的 neovim 插件：code-runner.nvim

安装及配置

可以使用任意插件管理器进行安装，这里以 nvim-plug 为例：

require('plug').add({
  {
    'wsdjeg/code-runner.nvim',
    config = function()
      require('code-runner').setup({
        runners = {
          lua = { exe = 'lua', opt = { '-' }, usestdin = true },
        },
        enter_win = false,
      })
    end,
  },
})

自动更新 runner 参数

借助 rooter.nvim 插件，可以在切换项目时，读取 .clang 文件内容，并且更新 c 语言的 runner。具体代码实现：

local c_runner = {
    exe = 'gcc',
    targetopt = '-o',
    usestdin = true,
    opt = { '-std=c11', '-xc', '-' },
}
require('code-runner').setup({
    runners = {
        c = { c_runner, '#TEMP#' },
    },
})
vim.keymap.set(
    'n',
    '<leader>lr',
    '<cmd>lua require("code-runner").open()<cr>',
    { silent = true }
)

-- make sure rooter.nvim plugin is loaded before code-runner

local function update_clang_flag()
    if vim.fn.filereadable('.clang') == 1 then
        local flags = vim.fn.readfile('.clang')
        local opt = { '-std=c11' }
        for _, v in ipairs(flags) do
            table.insert(opt, v)
        end
        table.insert(opt, '-xc')
        table.insert(opt, '-')
        c_runner.opt = opt
    end
end

require('rooter').reg_callback(update_clang_flag)

Neovim 插件管理器 nvim-plug

Sun, 09 Feb 2025 00:00:00 +0000

项目简介
功能特点
安装方式
- 自动安装（推荐）
- 使用 LuaRocks
基本配置
添加插件
常用命令

如果你也喜欢折腾 Neovim ，可能也会在插件管理器上花不少时间吧。我从最早的 vundle（Bundle）、plug.vim，到后来的 neobundle.vim、dein.nvim，都使用很长一段时间。使用最长时间的要算 dein.nvim，这是一个无 UI 界面的插件管理器，我甚至曾经还为该插件写过一个 dein-ui.vim 模仿 plug.vim 的界面。我写 nvim-plug 的原因其实很简单，我前面写过一篇插件管理器的运行机制《Neovim 和 Vim 插件管理器的实现逻辑》。

我想练习一下插件管理器的实现，之前看过 dein.nvim 的一些源码，里面的懒加载实现感觉很有趣。我想要一个完全可控、异步、并且不限制 UI 表现形式的插件管理器。

项目地址: wsdjeg/nvim-plug

项目简介

nvim-plug 是一个用 Lua 编写的 Neovim 插件管理器，核心目标是：

插件安装和更新必须是异步的
插件管理过程和 UI 界面分离
支持常用的插件懒加载模式

插件描述规范这一块我主要参考了 dein.nvim，之前用的比较多，也习惯了一些 key 值叫法和意义。

功能特点

完全异步调用命令

所有插件的 clone、pull、build 都是通过 job.nvim 并发执行的，不会出现卡在安装界面不能操作的情况。你可以根据网络和机器性能自由设置并行任务数量。

支持多种懒加载模式

事件: events
命令: cmds
文件类型: on_ft
按键: on_map
Vim 函数: on_func

插件什么时候加载，完全可以在配置文件里面明确，而不需要一堆额外逻辑拼出来。

UI 是可替换的

nvim-plug 并不假设你一定要用某种 UI：

默认是分屏 UI，参考的是 vundle.vim
可以切换为 notify 风格的浮动通知
也可以完全自己实现 UI 回调

插件管理器只负责状态，展示方式由你决定。

支持多种插件类型

除了 Git 仓库，还支持：

raw 脚本
LuaRocks 包
本地开发路径

一些“不是标准插件，但又需要被管理的仓库”也可以统一处理。我甚至使用这个插件管理器，管理一些上游的 GitHub 仓库（非插件），我需要定期同步到本地某个指定的位置，方便本地阅读代码。

安装方式

自动安装（推荐）

local dir = vim.fn.stdpath('data') .. '/repos/'

local function bootstrap(repo)
  if vim.fn.isdirectory(dir .. repo) == 0 then
    vim.fn.system({
      'git',
      'clone',
      '--depth',
      '1',
      'https://github.com/' .. repo .. '.git',
      dir .. repo,
    })
  end
  vim.opt.runtimepath:append(dir .. repo)
end

bootstrap('wsdjeg/job.nvim')
bootstrap('wsdjeg/logger.nvim')
bootstrap('wsdjeg/nvim-plug')

使用 LuaRocks

luarocks install nvim-plug

基本配置

require('plug').setup({
  bundle_dir = vim.fn.stdpath('data') .. '/repos',
  raw_plugin_dir = vim.fn.stdpath('data') .. '/repos/raw_plugin',
  max_processes = 5,
  base_url = 'https://github.com',
  ui = 'default',
  clone_depth = 1,
})

添加插件

require('plug').add({
  {
    'wsdjeg/scrollbar.vim',
    events = { 'VimEnter' },
  },
  {
    'wsdjeg/flygrep.nvim',
    cmds = { 'FlyGrep' },
    config = function()
      require('flygrep').setup()
    end,
  },
  {
    type = 'raw',
    url = 'https://gist.githubusercontent.com/.../markdown.vim',
    script_type = 'after/syntax',
  },
})

常用命令

:Plug install
:Plug update

从 VimScipt 切换至 Lua

Sat, 01 Feb 2025 00:00:00 +0000

为什么选择 Lua
- 学习 Lua
配置文件结构
- 初始化文件
- ftplugin
Options
事件自动命令
用户自定义命令
设置快捷键
变量类型转换
vim.g 访问全局变量的弊端

Lua 在 Neovim 中已经被当作了一等公民，目前火热的 Neovim 插件、配置基本上都是使用 Lua 来开发的。而我也是从 2016 年就开始使用 Neovim 了。这篇文章整理了一些从 VimScript 切换到 Lua 配置一些 Tips。本文写作环境：

OS：Windows 11
Neovim：v0.10.0
Terminal: Windows Terminal

为什么选择 Lua

在前面我写过两篇文字，主要是来比较 Lua（luajit）与 VimScipt 以及 Vim9Script 的运行速度。

比较的结果显而易见，Luajit 的速度比起 VimScipt 以及 Vim9Script 快很多，而我的配置还是比较重的，因此选择 Lua 将会大大提升使用体验。

学习 Lua

Lua 是一门语法非常简单的编程语言，可以查看《学习 Lua 脚本语言》。

配置文件结构

初始化文件

Neovim 的初始化文件是 ~\AppData\Local\nvim\init.lua，Linux 系统是 ~/.config/nvim/init.lua。Neovim 启动时会自动读取并执行该文件内容。

ftplugin

当打开一个文件，Neovim 通常会自动识别文件类型并且自动设定 filetype 。比如，打开 Test.java 文件，此时 ftplugin/java.lua 就会被调用执行。

Options

Neovim 提供了多种方式设置 Neovim Option。 使用 Neovim API： Neovim 提供了设置 Option 的 API 函数：nvim_set_option_value({name}, {value}, {opts})，opts 是一个 Lua table，支持的 key 包括：

scope：grobal 或者 local，类似于 :setglobal 和 :setlocal
win: 设置指定 window-ID 的 local option
buf：设置指定 buffer number 的 local option

使用 vim.o： 这类似于直接使用 :set 命令，默认是设置 global option。

vim.o.number = false         -- 禁用行号，启用行号可以设置为 true
vim.o.relativenumber = false -- 禁用相对行号

使用 vim.bo、vim.wo： 这类似于使用 :setlocal 命令，但是还是有些区别的，按照 :h vim.bo 描述，其使用的格式是：vim.bo[{bufnr}].opt_name，如果设置的 option 不是 local to buffer 就会报错，比如执行 :lua vim.bo.number = true 就会报错：

E5108: Error executing lua [string ":lua"]:1: 'buf' cannot be passed for window-local option 'number'
stack traceback:
	[C]: in function '__newindex'
	[string ":lua"]:1: in main chunk

同理，使用 vim.wo 时也会有类似的问题，因此在使用这两个方式设置 option 时，需要判断 option 是 local to window 还是 local to buffer, 一般在 help 文档里面都有。比如 :h 'number':

'number' 'nu'		boolean	(default off)
			local to window

当然，Vim 也提供了函数去判断，nvim_get_option_info2({name}, {opts}) 返回值是一个 lua table，其中 scope key 值就可以用来判断，其值可以是 global、win、buf。实际上，如果去看 Neovim 的源码，你会发现不管是 vim.o 还是 vim.bo 等只不是 API 的 wrap 而已： neovim’s options.lua#L242:

vim.o = setmetatable({}, {
  __index = function(_, k)
    return api.nvim_get_option_value(k, {})
  end,
  __newindex = function(_, k, v)
    return api.nvim_set_option_value(k, v, {})
  end,
})

因此，如果需要的话，也可以自己设置一个新的函数批量设置 option, 比如，某个插件打开了一个浮窗，浮窗内是对应的插件 buffer。

local function set_local(winid, bufnr, opts)
  for k, v in pairs(opts) do
    if vim.api.nvim_get_option_info2(k, {}).scope == 'win' then
      vim.api.nvim_set_option_value(k, v, { win = winid })
    elseif vim.api.nvim_get_option_info2(k, {}).scope == 'buf' then
      vim.api.nvim_set_option_value(k, v, { buf = bufnr })
    else
      -- skip global opt
    end
  end
end
local winid, bufnr = open_plugin_float_win()
set_local(winid, bufnr, {
  number = false,
  relativenumber = false,
  filetype = 'java',
  bufhidden = 'wipe',
})

事件自动命令

使用 VimScipt 定义自动命令（autocmd）的时候，通常我们可以这样写：

augroup test_augroup_vim
  autocmd!
  autocmd WinEnter * call s:test1()
  autocmd WinEnter * call s:test2()
augroup END

此时，如果需要清除上述两个自动命令的其中一个，就无法实现。只能使用如下脚本全部清除：

augroup text_augroup_vim
  autocmd!
augroup END

而 Neovim 提供了两个函数 nvim_create_autocmd 和 nvim_del_autocmd，演示如下：

local function test1()
  print(1)
end
local function test2()
  print(2)
end
local group =
  vim.api.nvim_create_augroup('test_augroup_neovim', { clear = true })
local autocmd_id1 = vim.api.nvim_create_autocmd({ 'WinEnter' }, {
  group = group,
  pattern = { '*' },
  callback = test1,
})
local autocmd_id2 = vim.api.nvim_create_autocmd({ 'WinEnter' }, {
  group = group,
  pattern = { '*' },
  callback = test2,
})

此时如果需要删除第二个自动命令，只需要：

vim.api.nvim_del_autocmd(autocmd_id2)

用户自定义命令

可以使用 vim.api.nvim_create_user_command({name}, {command}, {opts}) API 来新建命令。这个 API 函数接受三个参数，第一个顾名思义就是新建的命令的具体名称，第二个 command 可以是一个 string 也可以是一个 lua function。如果是 string，当执行这个命令时，这段字符串会被直接执行。如果是 Lua function，则会被传入一个 table 参数调用。第三个参数是设定命令的一些参数，类似于 :h command-attributes 比如：

vim.api.nvim_create_user_command('SayHello', function(opt)
  print('hello')
end, {
  nargs = '*',
  bang = true,
})

在上述函数内，参数 opt 是一个 Lua table，key 值包括：

{ "bang", "reg", "range", "args", "mods", "line1", "smods", "fargs", "line2", "count", "name" }

bang: 如果定义命令时，第三个参数 bang = true，那么可以在执行命令时带上感叹号。

vim.api.nvim_create_user_command('Test', function(opt)
  print(opt.bang)
end, {
  nargs = '*',
  bang = true,
})

上述定义的命令，执行 :Test 时打印 false，执行 :Test! 时打印 true，也可以在函数内判断 if opt.bang 为命令是否带感叹号赋予不一样的意义。有一些插件的命令支持两个感叹号，是如何实现的呢？比如 vim-gina Single command. Users do not need to remember tons of commands

:Gina {command} will execute a gina command or a git raw command asynchronously
:Gina! {command} will execute a git raw command asynchronously
:Gina!! {command} will execute a git raw command in a shell (mainly for :Gina!! add -p or :Gina!! rebase -i)

下面是简单的实现代码：

vim.api.nvim_create_user_command('Gina', function(opt)
  if not opt.bang then
    print('it is Gina')
  elseif opt.bang and opt.fargs[1] == '!' then
    print('it is Gina!!')
  else
    print('it is Gina!')
  end
end, {
  nargs = '*',
  bang = true,
})

nargs 可以设置为 0、1、’*‘、’?’、’+’ 五种。

vim.api.nvim_create_user_command('Test1', function(opt)
end, {
  nargs = 0,
})
vim.api.nvim_create_user_command('Test2', function(opt)
  vim.print(opt.args)
  vim.print(opt.fargs)
end, {
  nargs = 1,
})
vim.api.nvim_create_user_command('Test3', function(opt)
  vim.print(opt.args)
  vim.print(opt.fargs)
end, {
  nargs = '*',
})
vim.api.nvim_create_user_command('Test4', function(opt)
  vim.print(opt.args)
  vim.print(opt.fargs)
end, {
  nargs = '+',
})
vim.api.nvim_create_user_command('Test5', function(opt)
  vim.print(opt.args)
  vim.print(opt.fargs)
end, {
  nargs = '?',
})

nargs 为 0，执行命令如果带上参数，那么就会报错。比如：:Test1 foo 报错 E488: Trailing characters: foo。 nargs 为 1 时，如果执行 :Test2 foo zaa xss 就会发现输出内容为：

foo zaa xss
{ "foo zaa xss" }

意味着，如果设置为 1，执行命令的后面一整串字符串不管是否有空格间隔，都被当作为一个参数。 nargs 为 * 时，如果执行 :Test3 foo zaa xss 就会发现输出内容为：

foo zaa xss
{ "foo", "zaa", "xss" }

可以看出，args 还是整个字符串，但是 fargs 则是一个列表，包含了三个参数 nargs 为 + 时，如果执行 :Test4 foo zaa xss 就会发现输出内容为：

foo zaa xss
{ "foo", "zaa", "xss" }

不同的是，如果执行 :Test4 不带参数，则会报错：E471: Argument required nargs 为 ? 时，如果执行 :Test5 foo zaa xss 就会发现输出内容为：

foo zaa xss
{ "foo zaa xss" }

与设置成 1 不同的是，:Test5 可以不带参数直接执行

设置快捷键

Neovim 提供了 vim.keymap.set() 函数来设置快捷键，如果阅读源码的话，也可以发现，实际上这个函数也不过是包装了 Neovim API 函数 vim.api.nvim_buf_set_keymap 和 vim.api.nvim_set_keymap。但是原生的 API nvim_set_keymap 和 nvim_buf_set_keymap 使用起来太麻烦了，对于一些特殊按键还需要使用 nvim_replace_termcodes() 去转换。而 vim.keymap.set({mode}, {lhs}, {rhs}, {opts}) 的优势是：

differences compared to regular set_keymap:
- remap is used as opposite of noremap. By default it's true for <Plug> keymaps and false for others.
- rhs can be lua function.
- mode can be a list of modes.
- replace_keycodes option for lua function expr maps. (Default: true)
- handles buffer specific keymaps

这个 commit 移除了 <Plug> kemaps 检测, 这里是与 Vim 不一致的地方。

vim.keymap.set('i', '<Esc>', function()
  vim.cmd('noautocmd stopinsert')
  vim.api.nvim_win_close(prompt_winid, true)
  vim.api.nvim_win_close(result_winid, true)
end, { buffer = prompt_bufid })

变量类型转换

不管是从 Lua 到 VimScipt 还是从 VimScipt 到 Lua，变量类型转换是都是创建了一个副本，副本做的修改，通常无法在原变量上体现。这也是我尽量避免使用 vim.fn 原因。比如以下这段 VimScipt：

let s:a = [1, 2]
call add(s:a, 3)
echo s:a

以上输出是 [1, 2, 3]。换成 Lua：

local a = {1, 2}
vim.fn.add(a, 3)
vim.print(a) --- 输出是 {1, 2}

看一下 vim.fn 的源码：

-- vim.fn.{func}(...)
---@nodoc
vim.fn = setmetatable({}, {
  --- @param t table<string,function>
  --- @param key string
  --- @return function
  __index = function(t, key)
    local _fn --- @type function
    if vim.api[key] ~= nil then
      _fn = function()
        error(string.format('Tried to call API function with vim.fn: use vim.api.%s instead', key))
      end
    else
      _fn = function(...)
        return vim.call(key, ...)
      end
    end
    t[key] = _fn
    return _fn
  end,
})

实际上就是调用的 vim.call(key, ...) 因此应当尽量避免使用 vim.fn 调用 VimScipt 函数操作 Lua 变量，前面的示例应该改为：

local a = { 1, 2 }
table.insert(a, 3)
vim.print(a) --- 输出是 {1, 2, 3}

`vim.g` 访问全局变量的弊端

如果看了 vim.g 的源码，不难发现，实际上是通过 vim._getvar 和 vim._setvar 来分别映射 __index 和 __newindex。可以理解为，每一次访问 __index 时，调用一个 vim._getvar 获取 viml 变量，并转化为一个新的 Lua 变量。最简单的测试：

let g:wsd = { 'a' : 'a' }

print(vim.g.wsd)
print(vim.g.wsd)
-- 执行两次，打印的结果不一样
-- table: 0x0215fa040d28
-- table: 0x0215fb557f10

这就意味着，如果 VimL 字典变量发生了内部变化，之前转化的 Lua 变量并不会发生变化：

vim.cmd([[
let g:wsd = {'a' : 'a'}
]])
local a = vim.g.wsd
vim.cmd([[
let g:wsd.a = 'b'
]])
vim.print(a.a) -- 任然时 a

同样的，Lua 这边通过 vim.g 获取到的字典变量的变化，也只有在 __newindex 函数被执行时，才会同步到 VimL 的变量。

vim.g.wsd = { a = 'a' }
vim.cmd('echo g:wsd')  -- {'a' : 'a'}
vim.g.wsd.a = 'b'
vim.cmd('echo g:wsd')  -- 任然是 {'a' : 'a'}

启用 Git Commit 签名

Fri, 24 Jan 2025 00:00:00 +0000

起因
Git Commit 签名
Windows 安装 GPG
生成 GPG 密钥
设置 Git 签名程序

起因

无意间阅读到一篇文章《震惊！竟然有人在 GitHub 上冒充我的身份！》, 大致看了下 Github 网站对于 Commit 的归属的判断规则。只需要 Commit 的邮箱在某人的账号设置的邮箱列表内。那么就会将此次提交显示为是某人的归属。这就意味着，任何一个人都可以使用 git config user.email "YOUR_EMAIL" 这一命令设置成别人的邮箱，伪装成他人进行提交。

Git Commit 签名

如果只需要设置邮箱就可以伪装成用户进行提交，那不是乱套了？因此大多数软件维护者都会要求 Commit 签名。Github 其实支持多种方式签名，这里大致记录一下自己设置 GPG 签名的方案。

Windows 安装 GPG

Windows 系统下，我使用的 scoop 包管理器，通过 scoop install gpg 就可以安装好了。使用 gpg --version 看一下版本信息。

D:\wsdjeg>gpg --version
gpg (GnuPG) 2.4.7
libgcrypt 1.11.0
Copyright (C) 2024 g10 Code GmbH
License GNU GPL-3.0-or-later <https://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Home: D:\Scoop\apps\gpg\current\home
Supported algorithms:
Pubkey: RSA, ELG, DSA, ECDH, ECDSA, EDDSA
Cipher: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH,
        CAMELLIA128, CAMELLIA192, CAMELLIA256
Hash: SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
Compression: Uncompressed, ZIP, ZLIB, BZIP2

生成 GPG 密钥

参考 Github 的文档生成并上传 GPG 密钥, 上传完成后使用 https:/github.com/{username}.gpg 格式链接就可以访问你的公钥。例如我的：wsdjeg.gpg

设置 Git 签名程序

使用 where gpg 查看 gpg 命令的绝对路径：

d:\wsdjeg>where gpg
D:\Scoop\apps\gpg\current\bin\gpg.exe

清除之前的设置：

git config --global --unset gpg.format

之前导入已备份的私钥后，使用 git commit -S 一直提示没有私钥，找了很久原因才知道，原来需要设置 Git 的签名方式及程序，可能是原来设置过。

git config --global gpg.program "D:\Scoop\apps\gpg\current\bin\gpg.exe"

使用 gpg --list-secret-keys --keyid-format=long 列出 GPG 密钥：

d:\wsdjeg\my-blog>gpg --list-secret-keys --keyid-format=long
D:\Scoop\apps\gpg\current\home\pubring.kbx
------------------------------------------
sec   rsa2048/41BB7053E835C848 2021-09-21 [SC]
      9C957B574786F570AC69625041BB7053E835C848
uid                 [ unknown] Shidong Wang (Shidong's GPG key) <wsdjeg@outlook.com>
ssb   rsa2048/D3E3902EF4E8074C 2021-09-21 [E]

设置 Git 签名的 ID：

git config --global user.signingkey 41BB7053E835C848

设置 Git 默认启用 Commit 签名：

git config --global commit.gpgsign true

从零开始制作实时搜索插件

Thu, 23 Jan 2025 00:00:00 +0000

窗口界面
输入响应
按键映射
窗口内颜色高亮
输入框美化

当初，Neovim 刚刚推出异步 job 特性的时候，我就使用 Vim Script 写过一个实时检索的插件 FlyGrep.vim。最开始的实现是使用 :split 命令分屏展示搜索结果，使用 :echo 命令配合 while true getchar() 在 cmdline 内模拟输入框。但是 :split 命令分屏时，总是带动整个界面其他窗口内容的移动。随着 Neovim 增加悬浮窗口这一特性，我把 Flygrep 搜索结果窗口及底部提示状态都使用浮窗来实现，这就不会受到原先窗口界面布局的影响了。但是目前 Flygrep 的浮窗还是底部半屏窗口。现在大多数浮窗插件都是在屏幕中间打开窗口，下面就从零开始一步一步实现一个简单的实时代码检索插件。最终效果图如下：

窗口界面

首先时窗口界面，整体界面占据窗口中间 80% 区域，分上下两部分，下面窗口仅有一行，作为一个输入窗口，上面窗口作为搜索结果展示窗口。

-- 窗口位置
-- 宽度： columns 的 80%
local screen_width = math.floor(vim.o.columns * 0.8)
-- 起始位位置： lines * 10%, columns * 10%
local start_col = math.floor(vim.o.columns * 0.1)
local start_row = math.floor(vim.o.lines * 0.1)
-- 整体高度：lines 的 80%
local screen_height = math.floor(vim.o.lines * 0.8)

local prompt_bufid = vim.api.nvim_create_buf(false, true)
local prompt_winid = vim.api.nvim_open_win(prompt_bufid, true, {
  relative = 'editor',
  width = screen_width,
  height = 1,
  col = start_col,
  row = start_row + screen_height - 3,
  focusable = true,
  border = 'rounded',
  title = 'Input',
  title_pos = 'center',
  -- noautocmd = true,
})

local result_bufid = vim.api.nvim_create_buf(false, true)
local result_winid = vim.api.nvim_open_win(result_bufid, false, {
  relative = 'editor',
  width = screen_width,
  height = screen_height - 5,
  col = start_col,
  row = start_row,
  focusable = false,
  border = 'rounded',
  title = 'Result',
  title_pos = 'center',
  -- noautocmd = true,
})

输入响应

在底部窗口输入内容时，后台自动执行搜索命令，并在搜索结果窗口实时展示。这里需要监控 TextChangeI 这一事件，在事件 callback 函数内调用搜索命令。

local job = require('spacevim.api.job')

local augroup = vim.api.nvim_create_augroup('floatgrep', {
  clear = true,
})

vim.api.nvim_create_autocmd({ 'TextChangedI' }, {
  group = augroup,
  buffer = prompt_bufid,
  callback = function(ev)
    local text = vim.api.nvim_buf_get_lines(prompt_bufid, 0, 1, false)[1]
    if text ~= '' then
      local grep_cmd = {
        'rg',
        '--no-heading',
        '--color=never',
        '--with-filename',
        '--line-number',
        '--column',
        '-g',
        '!.git',
        '-e',
        text,
        '.',
      }

      job.start(grep_cmd, {
        on_stdout = function(id, data)
          if vim.fn.getbufline(result_bufid, 1)[1] == '' then
            vim.api.nvim_buf_set_lines(result_bufid, 0, -1, false, data)
          else
            vim.api.nvim_buf_set_lines(result_bufid, -1, -1, false, data)
          end
        end,
      })
    else
      vim.api.nvim_buf_set_lines(result_bufid, 0, -1, false, {})
    end
  end,
})

上述代码中，我使用了 spacevim job API，其实，我也考虑过使用 vim.system() 函数，但是异步搜索完全不调用，可能是写法有误, 使用 vim.system() 写法如下（无效）：

vim.api.nvim_create_autocmd({ 'TextChangedI' }, {
  group = augroup,
  buffer = prompt_bufid,
  callback = function(ev)
    local text = vim.api.nvim_buf_get_lines(prompt_bufid, 0, 1, false)[1]
    if text ~= '' then
      local grep_cmd = {
        'rg',
        '--no-heading',
        '--color=never',
        '--with-filename',
        '--line-number',
        '--column',
        '-g',
        '!.git',
        '-e',
        text,
        '.',
      }

      vim.system(grep_cmd, {
        stdout = function(err, data)
          vim.api.nvim_buf_set_lines(result_bufid, 0, -1, false, vim.split(data, '\n'))
        end,
      })
    end
  end,
})

按键映射

因为输入框只有一行，因此避免回车键换行，同时增加在搜索结果窗口内上下移动两个快捷键。

-- 使用 Esc 关闭整个界面
vim.keymap.set('i', '<Esc>', function()
  vim.cmd('noautocmd stopinsert')
  vim.api.nvim_win_close(prompt_winid, true)
  vim.api.nvim_win_close(result_winid, true)
end, { buffer = prompt_bufid })

-- 搜索结果行转换成文件名、光标位置
local function get_file_pos(line)
  local filename = vim.fn.fnameescape(vim.fn.split(line, [[:\d\+:]])[1])
  local linenr =
    vim.fn.str2nr(string.sub(vim.fn.matchstr(line, [[:\d\+:]]), 2, -2))
  local colum = vim.fn.str2nr(
    string.sub(vim.fn.matchstr(line, [[\(:\d\+\)\@<=:\d\+:]]), 2, -2)
  )
  return filename, linenr, colum
end
-- 使用回车键打开光标所在的搜索结果，同时关闭界面
vim.keymap.set('i', '<Enter>', function()
  vim.cmd('noautocmd stopinsert')
  -- 获取搜索结果光表行
  local line_number = vim.api.nvim_win_get_cursor(result_winid)[1]
  local filename, linenr, colum = get_file_pos(
    vim.api.nvim_buf_get_lines(
      result_bufid,
      line_number - 1,
      line_number,
      false
    )[1]
  )
  vim.api.nvim_win_close(prompt_winid, true)
  vim.api.nvim_win_close(result_winid, true)
  vim.cmd('edit ' .. filename)
  vim.api.nvim_win_set_cursor(0, { linenr, colum })
end, { buffer = prompt_bufid })

-- 使用 Tab/Shift-Tab 上下移动搜素结果
vim.keymap.set('i', '<Tab>', function()
  local line_number = vim.api.nvim_win_get_cursor(result_winid)[1]
  vim.api.nvim_win_set_cursor(result_winid, { line_number + 1, 0 })
end, { buffer = prompt_bufid })

vim.keymap.set('i', '<S-Tab>', function()
  local line_number = vim.api.nvim_win_get_cursor(result_winid)[1]
  vim.api.nvim_win_set_cursor(result_winid, { line_number - 1, 0 })
end, { buffer = prompt_bufid })

窗口内颜色高亮

-- 高亮文件名及位置

vim.fn.matchadd(
  'Comment',
  [[\([A-Z]:\)\?[^:]*:\d\+:\(\d\+:\)\?]],
  10,
  -1,
  { window = result_winid }
)

输入框美化

可以使用 extmarks 美化输入框，添加一个 > 符号，禁用行号。

vim.api.nvim_set_option_value('number', false, { win = prompt_winid })
vim.api.nvim_set_option_value('relativenumber', false, { win = prompt_winid })
local extns = vim.api.nvim_create_namespace('floatgrep_ext')
vim.api.nvim_buf_set_extmark(prompt_bufid, extns, 0, 0, {
  sign_text = '>',
  sign_hl_group = 'Error',
})

以上代码仅供参考，实际上还有很多细节并未完全考虑到，比如 callback 函数内对于未执行完成的 job 的处理、比如增加输入与搜索之间的延迟减少快速输入过程中不必要的额外执行搜索命令。完整的代码可以看：simple_float_grep

Neovim extmarks 功能介绍

Sun, 19 Jan 2025 00:00:00 +0000

什么是 extmark
相关函数
- nvim_buf_set_extmark

Neovim 一直在迭代更新，本文以 Neovim v0.10.0 版本为基础进行功能演示。

什么是 extmark

按照 :h extmark 描述 Extended marks (extmarks) 是跟踪缓冲区文本变化的的特定位置的注释。位置从 0 开始，位于第一个字符的前方。

     f o o b a r      line contents
     0 1 2 3 4 5      character positions (0-based)
    0 1 2 3 4 5 6     extmark positions (0-based)

Neovim winbar 设置

Tue, 14 Jan 2025 00:00:00 +0000

什么是 winbar
使用 lua 设置 winbar
redraw_winbar 函数实现
存在的一些问题

什么是 `winbar`

Neovim 0.8.0 就增加了 'winbar' 这一选项。winbar 实际上类似于状态栏（statusline），只不过 winbar 是显示在每一个窗口的顶部。它的设置格式与状态栏也完全一致。这里做了一个简单的示例效果图：

" 使用全局状态栏，状态栏只在底部显示，水平分割窗口将不再显示状态栏。
set laststatus=3
" 隐藏顶部标签栏
set showtabline=0

使用 lua 设置 winbar

前面也提到了 Neovim 实际上早就增加了 winbar，我是因为习惯了现有的状态栏和标签栏，不太像改变操作习惯。最近正好想尝试使用一下 winbar 特性，因为之前写过自定义的标签栏、状态栏，因此配置起来还算顺手。详细代码可以看我的 Github 仓库：wsdjeg/winbar.nvim 实现的逻辑也比较简单，监控指定的 Neovim 事件，在 callback 函数内调用 redraw_winbar 函数。

local augroup = vim.api.nvim_create_augroup('winbar.nvim', {
  clear = true,
})
vim.api.nvim_create_autocmd({ 'BufWinEnter' }, {
  group = augroup,
  pattern = '*',
  callback = function(e)
    redraw_winbar()
  end,
})

我看过 fgheng/winbar.nvim 插件的代码，最后一次更新时间是 2022 年七月，在他的插件里 setup 函数直接这样写：

function M.setup(opts)
    config.set_options(opts)
    local winbar = require('winbar.winbar')

    winbar.init()
    if opts.enabled == true then
        vim.api.nvim_create_autocmd({ 'DirChanged', 'CursorMoved', 'BufWinEnter', 'BufFilePost', 'InsertEnter', 'BufWritePost' }, {
            callback = function()
                winbar.show_winbar()
            end
        })
    end
end

这会存在一个非常严重问题，就是如果使用者不小心调用了两次甚至多次 setup 函数，那么就会发现，实际上定义了多个重复的 autocmd。因此不管是使用 Lua 来创建 autocmd 还是早期 Vim 下使用 Vim Script 创建 autocmd，都建议使用 augroup。

`redraw_winbar` 函数实现

简单到极致的实现：

local function redraw_winbar()
  local file_name = vim.fn.expand('%:t')

  if file_name == '' then
    return
  end

  local value = '%#SpaceVim_winbar#' .. file_name .. ' %#SpaceVim_winbar_Normal#' .. default_conf.winbar_seperator .. '%#Normal#'

  vim.api.nvim_set_option_value('winbar', value, { scope = 'local' })
end

这里面其实有很多功能可以去做的，比如：

排除 filetype

local file_name = vim.fn.expand('%:t')
local ft = vim.filetype.match({ filename = file_name })
for _, v in ipairs(excluded_filetypes) do
  if v == ft then
    return
  end
end

文件名按正则表达式排除

local excluded_regex = [[\.txt$]]
local re = vim.regex(excluded_regex)
local file_name = vim.fn.expand('%:t')
for _, v in ipairs(excluded_filetypes) do
  if re:match(file_name) then
    return
  end
end

存在的一些问题

callback 函数内无法获取到触发这一事件的 windows ID，因为说白了，winbar 是一个 local to window 的选项，通过指定 winid 去修改其值才是最保险的。

自定义 quickfix 窗口格式

Fri, 10 Jan 2025 00:00:00 +0000

老旧方法
使用 quickfixtextfunc

在 Neovim 或者 Vim 中，QuickFix 窗口内的内容默认的格式是：

<filename>|<lnum> col <col>|<text>

最近有需求修改 QuickFix 窗口内容的格式，使其更加美观一些，修改前，QuickFix 窗口打开后内容如下：而修改后最终展示的效果如下：下面展示了两种修改方法，一个是在老旧的 Vim 内实现的方法，另外一个是借助 Vim 8.2 的 qftf 选项实现的方式。

老旧方法

早在 Vim 7.4 之前，可以使用 autocmd 来手动修改，其实现的逻辑是监控 BufReadPost 事件

function! QuickFixFormat()
  let qflist = map(getqflist(),
    \ 'extend(v:val, {"filename" : bufname(v:val.bufnr)})')
  let prefix_len = 2 + max(map(copy(qflist),
    \ 'strchars(v:val.filename . v:val.lnum)'))
  let fmt = '%-' . prefix_len . 's' . '%s'
  setlocal modifiable
  call setline('1', map(qflist,
    \ 'printf(fmt, v:val.filename . ":" . v:val.lnum, "| " . v:val.text)'))
  setlocal nomodifiable nomodified
endfunction
augroup QuickFixFormat
  autocmd!
  autocmd BufReadPost quickfix call QuickFixFormat()
augroup END

上述代码中，还可以把分隔符 | 修改成占据整行的竖线 │，以实现完整分割线效果。完成窗口内容修改后，还存在一个问题，QuickFix 窗口里内容的高亮是通过 Vim 默认的 syntax/qf.vim 文件实现的，在这里需要覆盖默认的 qf FileType 的语法高亮： Vim 可以新建 ~/.vim/syntax/qf.vim 文件，Neovim 是 ~/.config/nvim/syntax/qf.vim。

if exists('b:current_syntax')
    finish
endif
syn match	qfFileName	"^[^│]*" contains=qfLineNr
syn match	qfSeparator	"│"
syn match	qfLineNr	":\d*" contained

" The default highlighting.
hi def link qfFileName	Directory
hi def link qfLineNr	LineNr
hi def link qfSeparator	VertSplit

let b:current_syntax = 'qf'

使用 `quickfixtextfunc`

上面的方法是强制修改 QuickFix Buffer 内容实现的格式化，Vim 8.2 提供了 quickfixtextfunc 选项，可以通过设定这一选项来实现格式化 QuickFix 窗口，修改第一段代码为：

function! QuickFixFormat(info)
	let qflist = getqflist({'id' : a:info.id, 'items' : 1}).items
  let qflist = map(qflist,
    \ 'extend(v:val, {"filename" : bufname(v:val.bufnr)})')
  let prefix_len = 2 + max(map(copy(qflist),
    \ 'strchars(v:val.filename . v:val.lnum)'))
  let fmt = '%-' . prefix_len . 's' . '%s'
  return map(qflist,
    \ 'printf(fmt, v:val.filename . ":" . v:val.lnum, "│ " . v:val.text)')
endfunction
set quickfixtextfunc=QuickFixFormat

可以通过 if exists('&quickfixtextfunc') 来检测当前 Vim 或者 Neovim 是否支持 quickfixtextfunc 选项。

《误杀3》观后感

Wed, 08 Jan 2025 00:00:00 +0000

关于剧情
剧中人物

结束了一天的工作，晚饭后去酒店旁边的电影院看了《误杀3》。

关于剧情

看完重生，再来开这个确实觉得剧情太容易猜到剧情的发展了，看就没太大悬念了。不同于重生里面以毒品为话题，这部电影是以拐卖儿童这一敏感话题展开的，先不谈拍的好坏。起码让这个话题被更多的人关注到加以防范也算是起到一丁点的好处，让社会跟相关部门更多地关注到这个问题那就更好了。回过头来再想想整部电影的剧情，感觉其中还是处处提供了线索，看的过程中还是能感觉出来一些人物的心理活动的。

剧中人物

郑炳睿

一开始确实没想到他原来居然是人贩子，求生其实是生命的本能。人类虽然是高等动物，通过思想可以客服本能，但是还是会有人没办法克服，会依靠本能去做一些决定。为了能活下去而参与贩卖人口等等，后来还是为了能活下去选择按下女儿那边炸弹的遥控器。虽然几个镜头也极力体现他对女儿的疼爱，比如看到女儿被伤害，哭的眼泪口水哒哒的。关于这个角色心理的选择，我觉得有一个大的转变，从一开始怕死，而选择按下女儿那边炸弹遥控器，到后来奋不顾身地为女儿挡枪。但是上面图片中的介绍真是扯淡, 郑炳睿出手爆杀人贩？？？他才是人贩子。图片剧情简介也完全是跟剧情实际情况截然相反。

李慧萍

电影开头第一眼，这女孩丢失八成跟她有关系，肯定是人贩子。后来证实下来确实是她参与的，但是没想到的是她原来也是是为了复仇。前后出镜截然两种不同风格人物，演员在演演员。

张景贤

误解了，一开始福利院收娃的长头发我以为是他。加上半夜出来杀郑炳睿，我还以为他是达蒙的人。后来看到原来他的妻子是梁素娥，才知道他也是要复仇的。

雅英

我脸盲，看了好几次才把她跟丢失娃的母亲对上号。

吴达毅

最后杀他的是谁？

施福安和Tinaya

没啥感触，死得其所。

阿卢

第一个镜头，就看到仇恨的眼光，审判室里的大笑也没看懂，直到知道他也是丢失儿童的家属，一切才显得那么理所当然。

达蒙

最后啥他的人是谁？

门多萨

一开始以为他是一无是处的领导。

梁素娥

最有感触的还是梁素娥的剧情，感觉词穷了，不知道该怎么写。第一次出镜的时候，感觉挺好看，一张混血儿脸，心善，“我也是孩子母亲，我一定会找到真相”，台词可能我记错了，但是我想她所想表达的意思以及她所坚持的事情一定是这样的，也为此付出了生命，也包括还没出生的孩子。

阿佐

开第一枪的男警察？

阿婕

不记得谁了，女警察？

郑婷婷

最后开枪的是谁？

Neovim quickfix 窗口内的一些快捷键

Mon, 30 Dec 2024 00:00:00 +0000

删除单行或者多行
结果过滤（Filter）

Neovim 的 quickfix 窗口还是比较常用的功能，在这里，我实现了一些 quickfix 窗口内常用的快捷键。

删除单行或者多行

在 quickfix 窗口内，默认情况下 Normal 模式下的 dd 和 Visual 模式下的 d 快捷键是不可用的，会提示:

E21: Cannot make changes, 'modifiable' is off

但是有时候，会感觉 quickfix 展示的结果太多了，有些内容不是我所需要的。使用如下代码实现了 Normal 模式下 dd 删除光标下的结果，Visual 模式下 d 删除选中行的结果。

local group = vim.api.nvim_create_augroup('quickfix_mapping', {
  clear = true,
})

vim.api.nvim_create_autocmd({ 'FileType' }, {
  pattern = 'qf',
  group = group,
  callback = function(ev)
    vim.keymap.set('n', 'dd', function()
      local qflist = vim.fn.getqflist()
      local line = vim.fn.line('.')
      table.remove(qflist, line)
      vim.fn.setqflist(qflist)
      vim.cmd(tostring(line))
    end, { buffer = ev.buf })
  end,
})

local function table_remove(t, from, to)
  local rst = {}
  for i = 1, #t, 1 do
    if i < from or i > to then
      rst[#rst + 1] = t[i]
      -- else
      -- i = to + 1
    end
  end
  return rst
end

vim.api.nvim_create_autocmd({ 'FileType' }, {
  pattern = 'qf',
  group = group,
  callback = function(ev)
    vim.keymap.set('v', 'd', function()
      local esc = vim.api.nvim_replace_termcodes('<esc>', true, false, true)
      vim.api.nvim_feedkeys(esc, 'x', false)
      local qflist = vim.fn.getqflist()
      local from = vim.fn.getpos("'<")[2]
      local to = vim.fn.getpos("'>")[2]
      if from > to then
        from, to = to, from
      end
      qflist = table_remove(qflist, from, to)
      vim.fn.setqflist(qflist)
      vim.cmd(tostring(from))
    end, { buffer = ev.buf })
  end,
})

结果过滤（Filter）

这里主要是为了实现一个功能，移除文件路径匹配输入表达式的结果。

local group = vim.api.nvim_create_augroup('quickfix_mapping', {
  clear = true,
})
vim.api.nvim_create_autocmd({ 'FileType' }, {
  pattern = 'qf',
  group = group,
  callback = function(ev)
    vim.keymap.set('n', 'c', function()
      local input_pattern = vim.fn.input('filter pattern:')
      -- vim.cmd('noautocmd normal! :')
      local re = vim.regex(input_pattern)
      local qf = {}
      for _, item in ipairs(vim.fn.getqflist()) do
        if not re:match_str(vim.fn.bufname(item.bufnr)) then
          table.insert(qf, item)
        end
      end
      vim.fn.setqflist(qf)
    end, { buffer = ev.buf })
  end,
})

上述代码，设定的快捷键为 c, 按下快捷键后会弹出一个出入提示，输入一段字符串，可以是 Vim 正则，回车后会移除 quickfix 窗口中文件名称匹配字符串的结果。如果需要保留文件名匹配字符串的结果，可以增加一个新的快捷键，比如 C，代码如下：

local group = vim.api.nvim_create_augroup('quickfix_mapping', {
  clear = true,
})
vim.api.nvim_create_autocmd({ 'FileType' }, {
  pattern = 'qf',
  group = group,
  callback = function(ev)
    vim.keymap.set('n', 'C', function()
      local input_pattern = vim.fn.input('filter pattern:')
      -- vim.cmd('noautocmd normal! :')
      local re = vim.regex(input_pattern)
      local qf = {}
      for _, item in ipairs(vim.fn.getqflist()) do
        if re:match_str(vim.fn.bufname(item.bufnr)) then
          table.insert(qf, item)
        end
      end
      vim.fn.setqflist(qf)
    end, { buffer = ev.buf })
  end,
})

上述功能汇总为插件 quickfix.nvim.

Vim/Neovim 中使用正则表达式

Sun, 29 Dec 2024 00:00:00 +0000

元字符
替换变量
函数式
与 Perl 正则表达式的区别
贪婪模式和非贪婪模式
Neovim 中使用正则表达式

2018 年 8 月 28 日，我在 CSDN 博客上面发表过一篇文章：《Vim 中使用正则表达式》。随着 CSDN 账号的注销，这篇文章已经无法在更新，于是将文章迁移至个人博客，并加以更新，增加 Neovim 相关内容。经常在网上看到有人抱怨 Vim 的正则表达式太奇怪，无法接受。我倒是觉得 Vim 的正则表达式比较容易理解。可能是因为我最早接触的正则表达式就是 Vim 的正则表达式吧，正好借此机会整理下 Vim 的正则表达式相关的内容。首先，在哪些情况下会用到正则表达式？使用正则表达式的命令最常见的就是 / 和 ? 命令。其格式如下：

/正则表达式
?正则表达式

另一个很有用的命令就是 :s[ubstitute]（替换）命令，将第一个//之间的正则表达式替换成第二个//之间的字符串。

:s/正则表达式/替换字符串/选项

在学习正则表达式时可以利用 / 命令来练习。

元字符

元字符	说明
`.`	匹配任意字符
`[abc]`	匹配方括号中的任意一个字符。可以使用 `-` 表示字符范围，如`[a-z0-9]`匹配小写字母和阿拉伯数字。
`\d`	匹配阿拉伯数字，等同于`[0-9]`。
`[^abc]`	在方括号内开头使用^符号，表示匹配除方括号中字符之外的任意字符。
`\d`	匹配阿拉伯数字，等同于[0-9]。
`\D`	匹配阿拉伯数字之外的任意字符，等同于[^0-9]。
`\x`	匹配十六进制数字，等同于[0-9A-Fa-f]。
`\X`	匹配十六进制数字之外的任意字符，等同于[^0-9A-Fa-f]。
`\w`	匹配单词字母，等同于[0-9A-Za-z_]。
`\W`	匹配单词字母之外的任意字符，等同于[^0-9A-Za-z_]。
`\t`	匹配字符。
`\s`	匹配空白字符，等同于[ \t]。
`\S`	匹配非空白字符，等同于[^ \t]。

如果需要查找一些特殊字符，如 *、.、/ 等，可以在这些字符前面添加 \，表示这些不是元字符，而是普通字符。比如：\/d 匹配的是 /d这两个字符，而不是匹配任意数字。 表示数量的元字符

元字符	说明
`*`	匹配0-任意个
`\+`	匹配1-任意个
`\?`	匹配0-1个
`\{n,m}`	匹配n-m个
`\{n}`	匹配n个
`\{n,}`	匹配n-任意个
`\{,m}`	匹配0-m个

表示位置的符号

元字符	说明
`$`	匹配行尾
`^`	匹配行首
`\<`	匹配单词词首
`\>`	匹配单词词尾

使用示例

命令	描述
`/char\s\+[A-Za-z_]\w*;`	查找所有以char开头，之后是一个以上的空白，最后是一个标识符和分号
`/\d\d:\d\d:\d\d`	查找如 17:37:01 格式的时间字符
`:g/^\s*$/d`	删除只有空白的行
`:s/\<four\>/4/g`	将所有的 four 替换成 4，但是 fourteen 中的 four 不替换

替换变量

在正规表达式中使用 $ 和 $ 符号括起正规表达式，即可在后面使用\1、\2 等变量来访问 $和 $ 中的内容。 使用示例

命令	描述
`/$a\+$[^a]\+\1`	查找开头和结尾处a的个数相同的字符串，如 aabbbaa，aaacccaaa，但是不匹配 abbbaa
`:s/$http:\/\/[-a-z\._~\+%\/]\+$/<a href="\1">\1<\/a>/`	将 url 替换为 http://url的格式
`:s/$\w\+$\s\+$\w\+$/\2\t\1`	将 data1 data2 修改为 data2 data1

函数式

在替换命令 :s/{pattern}/{string}/[flags] 中可以使用函数表达式来书写替换内容，格式为

:s/替换字符串/\=函数式

在函数式中可以使用 submatch(1)、submatch(2) 等来引用 \1、\2 等的内容，而submatch(0)可以引用匹配的整个内容。 使用例

:%s/\<id\>/\=line(".")

将各行的 id 字符串替换为行号

:%s/^\<\w\+\>/\=(line(".")-10) .".". submatch(1)

将每行开头的单词替换为 (行号-10).单词的格式，如第11行的 word 替换成 1. word

与 Perl 正则表达式的区别

Vim语法	Perl语法	含义
`\+`	`+`	1-任意个
`\?`	`?`	0-1个
`\{n,m}`	`{n,m}`	n-m个
`$` 和 `$`	`(` 和 `)`	分组

贪婪模式和非贪婪模式

在 Vim 里，默认是贪婪模式，即 a.*b 会尽可能多滴匹配字符，在 ahdbjkbkls 中匹配 ahdbjkb 而不是 ahdb。
如果是非贪婪的，可以使用 \{-} 代替 *，即 a.\{-}b 匹配 ahdb 而不是 ahdbjkb。

Neovim 中使用正则表达式

Neovim 目前主要的配置语言是 Lua，并且 Lua 并没有 VimL 的 =~# 和 =~ 比较符。但是 Neovim 提供了一个 vim.regex Lua 模块。 vim.regex 模块常见的使用方式：

if vim.regex('http[s]*://'):match_str(str) then
    -- do something
end

local str = 'abc12332324def'

local r1 = vim.regex('\\d\\+')

print(r1:match_str(str))

print(str:sub(r1:match_str(str)))

local a, b = r1:match_str(str)

print(str:sub(a + 1, b))

Neovim 状态栏及标签栏点击事件

Sat, 28 Dec 2024 00:00:00 +0000

什么是 tablineat
测试标签栏点击事件
多次点击存在的问题

什么是 tablineat

熟悉 Vim 或者 Neovim 的用户对于其状态栏（statusline）和标签栏（tabline）应该也不陌生，对于这两个 UI 组件上面的点击事件，早期是只有 tabline 上面支持点击操控 Vim 的标签页。很早以前，就有用户想在 vim-airline 插件的标签栏实现 Buffer 切换的功能，但是似乎直到现在，Vim 都未增加该功能。 2016 年，Neovim 增加了 tablineat 特性，使得用户可以在自定义状态栏和标签栏时，指定某个区域设定对应的点击事件回调函数，以此实现监控状态栏和标签栏的点击事件。可以使用 has('tablineat') 检测当前 Neovim 是否支持该特性。以下内容摘自 :h statusline

@ N   Start of execute function label. Use %X or %T to end the label,
      e.g.: %10@SwitchBuffer@foo.c%X.  Clicking this label runs the
      specified function: in the example when clicking once using left
      mouse button on "foo.c", a `SwitchBuffer(10, 1, 'l', '    ')`
      expression will be run.  The specified function receives the
      following arguments in order:
      1. minwid field value or zero if no N was specified
      2. number of mouse clicks to detect multiple clicks
      3. mouse button used: "l", "r" or "m" for left, right or middle
         button respectively; one should not rely on third argument
         being only "l", "r" or "m": any other non-empty string value
         that contains only ASCII lower case letters may be expected
         for other mouse buttons
      4. modifiers pressed: string which contains "s" if shift
         modifier was pressed, "c" for control, "a" for alt and "m"
         for meta; currently if modifier is not pressed string
         contains space instead, but one should not rely on presence
         of spaces or specific order of modifiers: use |stridx()| to
         test whether some modifier is present; string is guaranteed
         to contain only ASCII letters and spaces, one letter per
         modifier; "?" modifier may also be present, but its presence
         is a bug that denotes that new mouse button recognition was
         added without modifying code that reacts on mouse clicks on
         this label.
      Use |getmousepos()|.winid in the specified function to get the
      corresponding window id of the clicked item.

测试标签栏点击事件

按照前面的帮助文档描述的内容，可以使用格式 %N@function_name@text%X 来指定区域监控点击事件，回调函数的名称为两个 @ 标记之间的字符串，% 与 @ 之间的数字作为第一个参数。写一个测试函数，看一看点击事件的具体执行效果：

function! OnClick(a, b, c, d) abort
  echom a:a
  echom a:b
  echom a:c
  echom '>' . a:d . '<'
endfunction

set tabline=xxxxxxx%1@OnClick@11111%X%2@OnClick@22222%X

将以上文件保存为 vim 文件并执行 :so % 后，状态栏变成了 xxxxxxx1111122222, 鼠标左键单击 11111 区域，看到如下输出。

1
1
l
>    <

上述四行分别对应函数的四个参数:

第一个参数是 % 与 @ 之间的数字
第二个参数是鼠标点击的次数
第三个参数是鼠标键位, 可以是左键（l）、右键（r）或者中键（m）
第四个参数对应的时按下的组合键，Ctrl 键（c）、Shift 键（s）、Alt 键（a）、Meta 键（m）
最后一个参数是对应的 shift/alt/ctrl。

多次点击存在的问题

在使用前面的测试脚本测试的过程中，发现第二个参数返回的是点击的次数，其结果不是完全可预期的。为了更加方便测试，将测试的脚本修改如下：

function! OnClick(a, b, c, d) abort
  echom '点击次数：' .. a:b
endfunction

set tabline=xxxxxxx%1@OnClick@11111%X%2@OnClick@22222%X

多次点击后，其结果如下：

点击次数：1
点击次数：2
点击次数：3
点击次数：4
点击次数：1
点击次数：2
点击次数：3
点击次数：4
点击次数：1
点击次数：2
点击次数：1
点击次数：2
点击次数：3
点击次数：4
点击次数：1
点击次数：2

上面的输出可以看到，当连续点击时，回调函数会在每次点击时被调用。并且点击次数会增加，当间隔时间超过 mousetime 时，点击次数计数归零，间隔时间可以查阅 :h mousetime, 默认为 500 毫秒。

代码格式化插件 format.nvim

Wed, 25 Dec 2024 00:00:00 +0000

前因
插件的安装
自定义 formatter
插件的使用
Markdown 代码块格式化

前因

最近，我在 Reddit 上面分享了一个新的代码格式化的插件 format.nvim，回复大多是是在问为什么要做这个插件以及跟现有插件的区别。在 SpaceVim v2.3.0 之前，一直使用的代码格式化插件是 neoformat, 这个插件是使用 Vim 脚本写的，同时支持 Neovim 和 Vim。但是美中不足的地方是这个插件执行格式化命令是调用 Vim 的 system() 函数，当命令执行消耗时间很长时，就会卡住界面无法进行下一步操作。我也尝试过给 neoformat 增加异步支持，但是最终还是决定重新开发一个插件，主要市考虑到以下几个原因：

Lua 尤其是 luajit 速度相较于 Vim 脚本要快很多，相关比较文章可以查看我前面写的使用 Lua 重写 SpaceVim 内置插件和Vim9Script 与 Lua 的速度比较
做一个格式化插件的框架，尽可能减少默认的 formatter，提供接口自行定义。
不需要太过复杂的功能，仅仅是异步执行指定命令并更新 Neovim 缓冲区。

其实 neoformat 的插件代码实现逻辑还是非常好的，因此我也是参考了 neoformat 的实现逻辑，使用 Lua 来实现了这个异步代码格式化的插件 format.nvim。这个插件使用了 SpaceVim 的 job api 可以异步执行格式化命令，使得 Neovim 的操作更加顺畅。

插件的安装

可以使用任意插件管理器，比如nvim-plug来进行安装：

require('plug').add({
  {
    'wsdjeg/format.nvim',
    cmds = { 'Format' },
    depends = {
      { 'wsdjeg/job.nvim' },
      { 'wsdjeg/notify.nvim' },
    },
  },
})

对于 SpaceVim 用户来说，只需要在启用 format 模块的时候，指定格式化方法为 format.nvim 即可，配置如下：

[[layers]]
  name = 'format'
  format_method = 'format.nvim'

自定义 formatter

以 Lua 语言为例，设置使用 stylua 命令进行格式化：

require('format').setup({
    custom_formatters = {
        lua = {
            exe = 'stylua',
            args = { '-' },
            stdin = true,
        },
    },
})

插件的使用

格式化整个文件

format.nvim 只提供了一个命令 :Fromat, 执行该命令时就可以根据当前文件的文件类型选择对应的 formatter 对整个 Buffer 进行格式化。

选中区域进行格式化

:Format 命令支持指定区域进行格式化，因此可以在 Neovim 中选中几行代码进行格式化。

指定文件类型

通常执行 :Format 命令时，会读取当前 Buffer 的 &filetype 选项，但是如果需要指定其他文件类型，比如 java，可以使用如下格式执行命令：

:Format! <filetype>

指定格式化工具

如果一个文件类型有多个 formatters，可以在执行改命令时指定一个 formatter 的名字，比如 :Format prettier

同时指定文件类型、格式化工具，比如选中 markdown 内一段代码块进行格式化：

:Format! <filetype> <formatter>

Markdown 代码块格式化

前面提到 :Format 命令支持指定区域格式，这里需要借助一个插件 context_filetype.vim。通过这个插件获取到代码块的区域和文件类型，传给 Format 命令。以下示例使用 <Leader>f 格式化光标所在的代码块：

function! s:format_code_block() abort
  let cf = context_filetype#get()
  if cf.filetype !=# 'markdown'
    let command = printf('%s,%sFormat! %s', cf.range[0][0], cf.range[1][0], cf.filetype)
    exe command
  endif
endfunction
nnoremap <silent> <Leader>f <cmd><sid>format_code_block()<cr>

在 SpaceVim 中使用卢曼卡片盒笔记法做笔记

Wed, 11 Dec 2024 00:00:00 +0000

起因
基于 Neovim 的 zettelkasten 插件
Vim 的支持
参考文章：

起因

前段时间整理自己的个人维基发现笔记太零散，很难快速定位到自己需要的笔记。以往借助自己的 flygrep 插件根据记忆的关键字倒是可以找到相关的内容，但是随着笔记越来越多，关键字筛选已经不足以快速定位了。于是就想找一个更好的方式来组织管理日常的笔记，后来就了解到了《卢曼卡片盒笔记法》

基于 Neovim 的 zettelkasten 插件

最开始，我是想找一个三端（手机、电脑、网页）同步的笔记软件，但是似乎没有合适的。因为都是文本编辑，而且如果要使用卡片盒笔记法的话，那么笔记就需要遵循一定的格式。日常使用 Neovim 也非常多，几乎文本的编辑都是在 Neovim 内完成的，索性就不再舍近求远去找笔记软件了，就直接在 Neovim 内完成。检索了下 Github 发现还是有不少现成的插件实现，但是功能似乎都不是很完善。因此自己 Fork 了一个插件，在这个插件的基础上做了一些功能的改进和增加，有兴趣的话欢迎尝试：vim-zettelkasten。

基于 Tags 的 ZkBrowser

浏览笔记列表时，展示笔记的引用数量以及被引用数量，同时列出笔记包含的 Tags 列表，如下图所示：同时，在 ZkBrowser 窗口内支持的快捷键包括：

快捷键	功能描述
`q`	退出 ZkBrowser 窗口
`<LeftRelease>`	鼠标左键点击 Tag，筛选包含该 Tag 的笔记
`gf`	打开光标 ID 下的笔记
`Ctrl-l`	清除 Tags 筛选，列出所有笔记
`Ctrl-]`	使用 preview-window 窗口预览笔记
`[I`	使用 quickfix-window 列出 References
`F2`	打开 Tags 列表侧栏

侧栏的效果图如下，可以在侧栏窗口中使用回车键或者鼠标左键点击 Tag 实现筛选：侧栏中，标签按照首字母归类，鼠标左键点击归类的字母，可以折叠这些标签。

使用 Telescope 检索 Tags

当笔记 Tags 非常多的时候，可以使用 telescope.nvim 进行检索，检索后默认的回车键行为是列出包含该 Tag 的所有笔记。默认的快捷键为 SPC m z g。

使用 Telescope 检索标题

笔记的标题（Title）也可以使用 telescope.nvim 进行检索，默认的快捷键是 SPC m z f。

补全笔记 ID

在编辑笔记过程中，可以使用快捷键 ctrl-x ctrl-u 来打开补全窗口，补全引用的笔记 ID。

笔记模板的筛选

如果是使用 SpaceVim，可以通过 zettelkasten 模块选项设置笔记模板的文件夹，新建一些常用的笔记模板，比如：

[[layers]]
  name = 'zettelkasten'
  zettel_dir = 'D:\me\zettelkasten'
  zettel_template_dir = 'D:\me\zettelkasten_template'

通常基于默认新建笔记直接使用 SPC m z n 快捷键即可，如果需要基于其他模板来新建，可以使用快捷键 SPC m z t 调用 Telescope 检索常用模板。

Vim 的支持

因为 SpaceVim 默认是兼容 Neovim 和 Vim 的，因此后面是有计划让这个插件也支持 Vim 的，但是为了减少重复实现的一些代码，可能是需要 Vim 有 +lua 特性。

参考文章：

《好东西》观后感

Mon, 25 Nov 2024 00:00:00 +0000

关于“善意的谎言”
一些其他想法

新的工作环境感觉不是想象中那么理想，但是也在努力去适应。最近感觉也比较压抑，本来周末想去看的一部电影，因为一些事情耽搁了，今晚抽空一个人去电影院看了。正如电影的名字一样，即便是生活很多时候不是很如意，但是有些人还是很善于发现身边的一些“好东西”。可能是因为自己工作的原因，很多时候太过追求结果，而忽略了过程中一些美好的事情。

关于“善意的谎言”

曾今的我一直固执的认为谎言就是谎言，没有善恶之分，因为总有方式更好地呈现事实。但很多时候，一些善意的谎言其实可以让事情变得更加简单。

一些其他想法

其实，说实在的，电影不是特别的好看，很多情节、对话太过于刻意。就感觉正常的两个人对话，不该是这样，很多时候刻意的制造一些“鸡汤”类的说教，或者刻意的制造一些搞笑的对话。但是，其中确实有很多“鸡汤”值得去好好想想，比如： 1、小女孩上台表演前的那段对话，有时候因为害怕别人的眼光、说辞、看法，而退缩，其实，这个社会上，在意你的人，真的没有你想象的那么多。可能明天，他就会忘记你所做的事。 2、又比如小孩的作文，我最喜欢的、以及出现了两次的跟幻想相关的话题。我觉得小孩子还没有这样的思想，更多的是电影呈现给观众的一些观点。是的，即便是现在，后面的生活，还有很多年，你永远不会知道自己最喜欢的将会是什么，还是要保留一些幻想。

《重生》：揭穿人性假面

Sun, 08 Sep 2024 00:00:00 +0000

周末跟家人们去看了一部电影，小朋友们选了柯南，我就去看了张家辉主演的《重生》。

剧中角色:

安渡（阮经天饰）

安渡缉毒组小队长，被其舅舅安佩长期长期压抑不得势再加上自幼经历悲惨，造成了阴暗的性格，被权力、金钱迷失倒也正常。人性这种东西其实很奇怪，不能去深究其好坏。

张耀（张家辉饰）

张耀的剧情也算还能理解，想要在监狱里替换掉沙旺，并且通过各种检查，没有安渡他们的安排跟支持几乎不可能。

巴莱（马浴柯饰）

完全没有想到的是南茜和巴莱也是也是提前安排好的碟中谍角色。

删除 Telegram 账号

Sat, 24 Aug 2024 00:00:00 +0000

前不久，删除了用了很久的 Telegram 账号 @wsdjeg。为了避免非本人使用该用户名带来不必要的麻烦，原来的用户名转移给了一个无管理员的公共的 Channel。个人是非常抵触使用手机号注册和登录的软件，因为手机号实际上运营商是可以二次销售的。大学期间至今，前面大概有三个手机号已经停机不用了，但是现在搜了下，居然有别人已经用它来注册了微信。此外，如果提供足够的材料或者“特殊情况”下，运营商可以重新制作一张 SIM 卡，原 SIM 会废弃。那么新卡就可以接受验证信息，这就意味着，对于账号的所有权，你没有绝对的控制权。此外，删除 Telegram 另一个原因是在于自己，我想远离不必要的争执。不管是什么原因，有可能是对方问题。也有可能是自己的问题。但是这些都并不重要，因为这种争执对于自己来说。似乎没有任何用处。只会徒增烦恼、浪费时间。可能是因为匿名状态下更加肆无忌惮吧。

Vim Script 的新语法

Wed, 21 Aug 2024 00:00:00 +0000

字符串的连接符
函数的参数
闭包（closure）

对于 Vim Script 的语法的认知似乎还停留在《笨方法学 Vim Script》的年代，在接触 Neovim 以及使用 Lua 写插件之前一直都是使用 Vim Script。即使是现在部分插件为了兼容 Vim，任然会使用 Vim 脚本实现一个兼容版本。随着 Vim 版本的更新，实际上以及引入了很多新的语法格式。

字符串的连接符

查看了下自己以往写的 Vim 脚本，string 的连接符仍然是使用单个点，实际上 Vim 早就支持使用 .. 符号来连接字符串。

let s:foo = 'abc' . 'def'

" 可以改成

let s:foo = 'abc' .. 'def'

函数的参数

在函数内部调用传入的参数，过往最常用的无外乎 a:0、 a:000 或者 a:foo 等等。 a: 实际上是一个 dict 变量, 可以看下具体包含哪些 key:

function! s:foo(x, y, ...)
  echom a:
endfunction

1,2call s:foo(1, 2, 3)

执行 so % 输出如下：

{'0': 1, '000': [3], '1': 3, 'y': 2, 'firstline': 1, 'x': 1, 'lastline': 2}
{'0': 1, '000': [3], '1': 3, 'y': 2, 'firstline': 1, 'x': 1, 'lastline': 2}

从上面的输出不难看出 a: 字典变量中 key 包括:

0: 可变参数数量, 可变参数是 1 个 3
000: 可变参数组成的列表
x 或者 y: 特定名称的参数

此外还有两个特殊 key 值，firstline 和 lastline, 这个是传入的 range, 同时这意味着在定义函数时，参数名称不可以是 firstline 和 lastline。否则会有如下错误：

E125: Illegal argument: firstline

在 Vim 8.1.1310 中，增加了 optional-function-argument, 具体写法如下：

function! s:foo(x, y = 3, ...)
  echom a:
endfunction

call s:foo(1)

{'0': 0, '000': [], 'y': 3, 'firstline': 1, 'x': 1, 'lastline': 1}

上面的输出可以看出，在调用 s:foo 函数时，虽然只传入了一个参数，但是在函数内部 a: 任然有一个 y key，其值为默认值 3。

闭包（closure）

闭包在其他很多编程语言里面都有类似的写法，可以理解为一个函数工厂，根据“环境变量”返回一个特定环境下的函数。在 Vim 7.4.2120 中给 :function 定义增加了 closure 属性。示例如下：

function! s:foo(x)
  function! s:xy(y) closure
    return pow(a:y, a:x)
  endfunction
  return funcref('s:xy')
endfunction

let s:a = s:foo(2)
let s:b = s:foo(3)

echo s:a(2)
echo s:b(2)

若不使用 closure 关键字，在函数 s:xy 内部是无法调用 a:x 的。其实，在 Lua 中也可以实现类似的功能：

local function foo(x)
  return function(y)
    return y^x
  end
end

local a = foo(2)
local b = foo(3)

print(a(2))
print(b(2))

以上两种输出结果都是：

4.0
8.0

龙迹之城散人玩家攻略

Wed, 21 Aug 2024 00:00:00 +0000

定期活动
装备合成技巧
符文提升技巧
龙子提升技巧
异兽提升
兽神出战

已经不是第一次玩传奇类氪金游戏了，基本上都是前期氪金买的东西，后期一文不值，并且有可能可以白嫖。意味着，前期氪金很多，后期跟不上氪的话，会很容易被追上。这里记录一下散人（微氪）玩家的玩法。

定期活动

这游戏根据天数，会定期出活动，这里根据我自己的目前所在区服来更新。有可能与老区或者新区有不一样的。

第一天：开区

新建角色选法师、或者道士，战士不适合微氪玩。赞助拿前三个赞助就够了，在吃 10 元红包，凑满 100，领取 98 连冲奖励。主线任务、红包任务做完。任务做完，灵符一分不用，只买第一天两个赞助对应的称号跟衣服，第八天这些灵符会返回来。第二到第五天每天吃100红包，灵符传奇币全攒着，武魂只升级到10，神器2。异兽、符文、英雄之心，不要合成，材料全留着。

第八天：狂暴降临

以前第八天是灵符抽技能活动，现在改版了，变成了狂暴直氪，前四个任务是额度到了就可以领取，第五个是需要抽奖抽到一个才能领取。微氪抽奖就算了，这次我只开通了第四个赞助，拿了一个狂暴装备，同时天赋里面可以用98万灵符购买紫电神雷技能。

第十五天：末日降临

末日是直氪卷轴开岛上箱子。500 元可以拿三件末日、一个狐狸、四个特权。可以五天每天 100 元直氪末日卷轴，顺便拿 98 元连冲奖励及 5 天连冲装扮。

第一岛选“元宝专享”
第二岛选“遗迹特权”
第三岛选末日
第四岛选“灵石专享”
第五岛选末日
第六岛选狐狸战灵
第七岛选“魔石专享”
第八岛选末日

第二十二天：秒杀直购

秒杀活动有点类似与狂暴，前四个任务也是五百额度，包括：兽神装备、妖狱特权、三件秒杀、三个技能觉醒。

第二十九天：神罚套装

神罚套装的活动跟第十五天的末日活动几乎是一样的，因此也是 500 元拿三件神罚、三个特权、一个精灵幻化、一件兽神装备任选，也是五天每天 100 元直氪末日卷轴，顺便拿 98 元连冲奖励及 5 天连冲装扮。

第一岛选“灵符加成”
第二岛选“禁地双倍”
第三岛选神罚
第四岛选“传奇专享”
第五岛选神罚
第六岛选圣光精灵
第七岛选“兽神装备任选”
第八岛选神罚

第三十六天：炎阳套装

炎阳套装和前面的秒杀类似，前四个任务是五百，包括：8阶军装刀、“传奇回收”、“经验专享”、“传奇回收Ⅱ”、超级幸运、三件炎阳。

周年庆活动

完成每日任务，周年庆商店里面的东西可以全部兑换出来，包括六个英雄、一个狐狸、苍血真龙皓月各一件，升星石等等。

装备合成技巧

每个部位三个属性，锻造时，两个单字锻造成双字，双字+单字锻造成终极。锻造时左边为主装备、右边为附装备，锻造失败附装备损毁。因此稀有属性单字，或者包含稀有属性的双字应该放在左边，与稀有属性匹配的双字要直接熔炼掉。这样才能最大化装备收益。下面列出装备各部位属性，三个字自上而下稀有程度递减：

武器	属性	匹配
血	吸血	爆裂（爆 + 攻），全熔炼
爆	暴击几率	怒血（血 + 攻）
攻	攻击增伤	破天（血 + 爆）

衣服	属性	匹配
防	物伤减免、魔伤减免	不灭（抗 + 反）
抗	暴击抵抗	金刚
反	反伤	神体

头盔	属性	匹配
防	物伤减免、魔伤减免	天命（护 + 闪）
护	破甲抵抗	玄体
闪	吸血抵抗	龙体

项链	属性	匹配
血	吸血	斩神（破 + 攻），全熔炼
破	无视双防	怒血（血 + 攻）
攻	攻击增伤	弑天（血 + 破）

手镯	属性	匹配
固	暴伤减免	天怒（破 + 闪）
破	无视双防	无双
闪	吸血抵抗	爆破

戒指	属性	匹配
攻	攻击增伤	戮魔（爆 + 狂）
爆	暴击几率	灭神
狂	暴击增伤	破天

鞋子	属性	匹配
防	物伤减免、魔伤减免	破军
御	暴击抵抗	真魂（防 + 护）
护	破甲抵抗	神体

腰带	属性	匹配
防	物伤减免、魔伤减免	天命（御 + 护）
御	暴击抵抗	不灭
护	破甲抵抗	混元

符文提升技巧

符文一共有八个，按照最低级别提供套装属性，符文主要来自于试炼之地的boss、禁地。

试炼之地：乾，坤，离，坎，兑，
禁地：震，艮，巽

龙子提升技巧

龙子主要来自于龙眠神殿 Boss、禁地，

禁地：睚眦、蒲牢、霸下
龙眠神殿：其他 6 个

异兽提升

异兽主要来自于灵犀 Boss 爆落，活动里面七天登录送、60 连重送任选：

七天登录送：圣兽白虎、雪域狂狮、荆棘地龙、圣兽青龙, 地龙比白虎和狂狮高一阶，青龙比地龙高一阶
任选开：暗殿麒麟

兽神出战

妖狱进地图的条件依赖于出战的兽神级别，优先让最高级出战，点击兽神，会显示兽神装扮是否齐全，提示是否被其他兽神装备了。出战最高级别兽神后，进入地图，只打最高级别的boss。

使用 GitHub 进行身份验证时要小心

Mon, 12 Aug 2024 00:00:00 +0000

起因
授权登录时需要的权限
查看 Github 账户已授权网站
国内版 Github?

起因

很早以前，我注册过一个叫做“黑客派”的论坛，后来这个论坛改名为“链滴”。当时论坛提供了使用 Github 账号授权登录，由于早期并未注意过 GitHub 登录授权的权限问题。被站长直接控制 Github 账号去执行 star 和 follow 操作，相关帖子可以看：https://v2ex.com/t/534800 谷歌搜索已无主站入口：直接搜索最新网址，发现一篇道歉信排名靠前，可想此事当时影响挺大的。但是非注册用户点击却无法阅读，啥意思？只给注册用户道歉？使用 web achive 服务拉取到道歉信内容：最近我尝试登录这个账号并提交账号注销申请，按照他的网站说明：来去自由·关于支持永久停用账号。但是似乎并不是那么回事。申请注销时提示更新失败 - Can not deactivate moderator account。于是只能手动将自己以往再次网站发的帖子全部改成：在体用账号帖子留言后，账号被封禁，而不是被停用。最后，我们再看下链滴作者 D 的博客 https://88250.b3log.org 评论系统，使用 Github 登录时所需要的权限：

授权登录时需要的权限

在初次注册登录时，都会出现以下界面，可以点击右侧红框下拉按钮，展开所有的权限。实际上，如果仅用于注册网站，需要一个唯一的注册ID的话，获取邮箱地址的权限就足够了。图片中显示了 julia 语言论坛授权登录权限信息：

查看 Github 账户已授权网站

在 Github 账户设置界面依次点击：Integrations -> Applications -> Authorized OAuth Apps: 如果需要看各自的授权权限点开即可查看: 如果认为该权限太高，可以点击右侧的 Revoke access。

国内版 Github?

最后，我们来看看号称国内版 Github 的码云使用 Github 授权时需要的权限：请问要读写用户的 Followers 做什么？

请停止复制我的个人网站

Sun, 11 Aug 2024 00:00:00 +0000

今天使用 Google 搜索自己之前发过的一篇文章“停用 v2ex 账号”，发现搜索结果如下。奇怪的是，有一个域名为 jbwqfy.com 的网站居然是全站复制了我的个人博客。打开其首页，我今日刚发的文章他都有，基本上是实时同步了，目前无法查明原因。 whois 查询结果显示如下，并没有什么有效信息。

从 GitHub Page 切换至 Cloudflare Page

Sun, 11 Aug 2024 00:00:00 +0000

新建 Cloudflare Page
使用最新版 Jekyll 及插件
自定义域名

大概是 2023 年 9 月份，将网站从 Github Page 服务切换到了 Cloudflare Page。一开始切换的原因是因为 Github 强制用户使用两步验证才能登录，失去了对 Github 账号的访问权限，因此将网站移到了 Cloudflare Page 服务上。

新建 Cloudflare Page

登录 Cloudflare 后，在左侧点击 Workers & Pages -> Create -> Connect to Git, 选择对应的仓库，值得开心的是这里可以选择私有仓库。Github Page 服务免费用户无法使用私有仓库托管 Jekyll 静态网站。构建设定：

Build command: bundle exec jekyll build
Build output directory: /_site
Root directory: /docs
Build comments on pull requests: Enabled

使用最新版 Jekyll 及插件

原先使用的 github-pages 对应的 Jekyll 版本太老，语法高亮的插件 rouge 也非常老旧。在这里既然已经手动执行命令构建，那么可以使用一些比较新的插件，而不受 Github Page 的限制。修改 docs/Gemfile 为：

source "https://rubygems.org"
gem "jekyll"
gem 'jekyll-redirect-from'
gem 'rouge', '~> 4.2'
gem 'jekyll-paginate'

自定义域名

原先购买的域名已经转移到了 Cloudflare 上面了，这样一来域名的解析及网站的托管都在同一个平台，也方便管理。

Vim9Script 与 Lua 的速度比较

Sat, 10 Aug 2024 00:00:00 +0000

前面写过一篇Lua 与 VimL 速度比较的文章，里面对 Lua 与 VimL 脚本计算速度做了比较。随着 Vim 的更新并且推出了新的脚本语言 Vim9Script，也想看一下这个新的脚本语言写法及执行效率到底如何。任然参考上一篇文章中的比较方式，Vim9Script 实现的函数如下：

vim9script
def V9Fibo(N: string)
  var start = reltime()
  var t = str2nr(N)
  var b = 0
  while t > 0
    t = t - 1
    var a = 1
    b = 1
    var c = 73
    while c > 0
      c = c - 1
      var tmp = a + b
      a = b
      b = tmp
    endwhile
  endwhile
  var sec = reltimefloat(reltime(start))
  echo b
  echom printf('Vim9Fibo(%s): %.6g sec', N, sec)
enddef

defcompile

command! -nargs=+ TestV9Func V9Fibo(<f-args>)

新建一个 vim 文件，写入上述内容。使用 :so % 载入脚本，分别执行如下测试命令：

:TestV9Func 1000
:TestV9Func 10000000

本地测试结果：

Vim9Fibo(1000): 0.007455 sec
Vim9Fibo(10000000): 69.937198 sec

在前一篇文章中比较的是 Vim Script 和 Lua 的速度，其结果是：

Fibo(1000): 0.410364 sec
Fibo(10000000): 1470.280914 sec
LuaFibo(1000): 9.052000e-4 sec
LuaFibo(10000000): 1.235385 sec

测试结果不难看出，Vim9Script 相较于老版本的 Vim script 确实有很大的速度提升。计算参数1000时，从 0.41s 提升到了 0.0074s；计算参数一千万时，从 1470s 提升到了 69s。但是相较于 Lua 的 9.0e-4s 和 1.23s 的测试结果，还是相差太多。

Neovim 和 Vim 插件管理器的实现逻辑

Thu, 08 Aug 2024 00:00:00 +0000

插件的本质
目录结构及载入时机
懒加载的实现逻辑
总结

Neovim 或者 Vim 的插件管理器有很多，最开始的时候我使用的是 Vundle.vim, 后来尝试过 vim-plug 和 neobundle.vim，目前使用的是 dein.vim。当然了，网上搜一下，其实还有很多其他的插件管理器，然而并没有发现什么特别吸引我的功能，所以也就没有什么动力切换了。相较于切换插件管理器，其实我更想好好研究一下插件管理器的实现逻辑，于是看了一些文档及插件管理器的源码，整理这篇文章。

插件的本质

我所理解的 Vim 或者 Neovim 的插件本质是一系列的 Vim 文件按照一定的目录结构组织起来的集合。 Neovim 中增加了 plugin/、color/ 等目录下 lua 文件的识别。不管是 Vim 还是 Neovim，插件管理器添加一个插件的本质就是将插件所在的目录加入到 runtimepath 选项，所谓的懒加载（lazy load）实际上是在适当的时机下触发前面这一步骤。所以，很早以前，还没有插件管理器时，很多时候只是将插件下载到某一个目录，并在 vimrc 中将目录添加到 runtimepath 中。

set runtimepath+=/path/to/plugin_directory

目录结构及载入时机

阅读 :h runtimepath 可以看到标准的插件的目录结构包括：

filetype.lua    filetypes
autoload/       automatically loaded scripts
colors/         color scheme files
compiler/       compiler files
doc/            documentation
ftplugin/       filetype plugins
indent/         indent scripts
keymap/         key mapping files
lang/           menu translations
lua/            lua modules
menu.vim        GUI menus
pack/           packages
parser/         treesitter syntax parsers
plugin/         plugin scripts
queries/        treesitter queries
rplugin/        remote-plugin scripts
spell/          spell checking files
syntax/         syntax files
tutor/          tutorial files

在说明每一个目录的功能之前，我认为有必要了解一下 Vim 启动时的文件载入顺序。假定，我们有一个 hello-vim 插件，其目录为 ~/wsdjeg/bundle/hello-vim，示例 vimrc 文件：

set nocompatible
set rtp+=~/wsdjeg/bundle/hello-vim
filetype plugin indent on
syntax on

当启动 Vim 时，它将逐行读取并执行 vimrc 文件。其中 set rtp 这一行就是将插件 hello-vim 的目录加入到 runtimepath 内。下一行 filetype plugin indent on，这个命令包含了三层意思：

启动文件类型自动识别，比如打开 *.md 文件时，自动识别并设置 filetype 为 markdown。
设置 filetype 时，根据 &filetype 的值，自动读取并执行 runtimepath 中每一个目录下 ftplugin/ 子目录里对应的 vim 文件
设置 filetype 时，根据 &filetype 的值，自动读取并执行 runtimepath 中每一个目录下 indent/ 子目录里对应的 vim 文件

关于 :filetype 命令的使用，:h :filetype-overview 显示如下帮助文档：

Overview:					*:filetype-overview*

command			detection	plugin		indent ~
:filetype on			on		unchanged	unchanged
:filetype off			off		unchanged	unchanged
:filetype plugin on		on		on		unchanged
:filetype plugin off		unchanged	off		unchanged
:filetype indent on		on		unchanged	on
:filetype indent off		unchanged	unchanged	off
:filetype plugin indent on	on		on		on
:filetype plugin indent off	unchanged	off		off

To see the current status, type: >
	:filetype
The output looks something like this: >
	filetype detection:ON  plugin:ON  indent:OFF

那么，使用以上的简单的 vimrc 启动 Vim 时，文件的载入顺序为：

vimrc
~/wsdjeg/bundle/hello-vim/plugin/*.vim

如果 hello-vim/ 目录下有 filetype.vim 文件，或者存在 ftdetect/ 子目录，其内 *.vim 文件也会被执行。

`autoload/` 目录

关于 autoload/ 内的 Vim 文件载入机制，我们来做这样一个测试：文件名: ~/.SpaceVim.d/autoload/test_autoload.vim，假定 ~/.SpaceVim.d/ 已经加入 runtimepath。

echom "hi one"

function! test_autoload#hi()
  echom "hi two"
endfunction

echom "hi three"

启动 Vim 后，发现上述三句 echom 语句都没有执行，这也说明了 autoload 内的文件默认是不会自动执行的。此时如果执行函数 call test_autoload#hi()。就会发现如下输出：

hi one
hi three
hi two

注意下输出的顺序，hi three 在 hi two 前面。这是因为当调用 test_autoload#hi() 函数时，Vim 是根据函数的名称，确认下函数是否已定义，如果未定义，则去找到对应的 Vim 文件读取并逐行执行，执行完了后才会调用函数。前面执行过了 call test_autoload#hi() 函数后，如果再次调用。此时输出只会有一行：

hi two

那么问题来了，如果我再次调用一个不存在的函数 call test_autoload#no() 函数，会发生什么呢？

hi one
hi three
E117: Unknown function: test_autoload#no

也很好理解，这个 test_autoload#no() 函数未定义， Vim 根据函数名称会再次去读取并逐行执行 Vim 文件，也就导致了 Vim 文件中的脚本被重复执行了。不受控的重复执行肯定不行的，那么如何规避呢？可以像下面这样修改：

if exists('s:loaded')
  finish
endif

" 有很多插件喜欢用 g:plugin_xxx_loaded, 个人感觉，非必要不使用暴露给脚本外部的变量跟函数。

let s:loaded = 1

echom "hi one"

function! test_autoload#hi()
  echom "hi two"
endfunction

echom "hi three"

`plugin/` 目录

在 Vim 启动时默认的配置文件 vimrc 读取完成后, 此时会对 runtimepath 下每一个目录下的 plugin/ 子目录进行遍历。其内所有的 Vim 文件会被逐一读取并执行。 Neovim 增加了 plugin/ 目录下 lua 文件的支持。

`ftplugin/` 目录

这个目录就是 Vim 自带的 on_ft 加载机制，当 filetype 被设定时会自动载入 ftplugin/<filetype>.vim，Neovim 还支持 Lua 格式文件 ftplugin/<filetype>.lua。

懒加载的实现逻辑

很多插件管理器都实现了一个叫做 Lazy load（懒加载）的功能，那么这个功能到底是如何实现，其本质逻辑是什么呢？

通过命令加载 `on_cmd`

当执行某个命令时加载，这种实现逻辑实际上新建一个新的命令，在命令中载入插件，并根据其参数再次调用命令。比如 call dein#add('wsdjeg/FlyGrep.vim', {'on_cmd' : 'FlyGrep'}) 此时会定义如下命令： dein.vim/autoload/dein/parse.vim#L342

function! s:generate_dummy_commands(plugin) abort
  let a:plugin.dummy_commands = []
  for name in a:plugin.on_cmd
    " Define dummy commands.
    let raw_cmd = 'command '
          \ . '-complete=customlist,dein#autoload#_dummy_complete'
          \ . ' -bang -bar -range -nargs=* '. name
          \ . printf(" call dein#autoload#_on_cmd(%s, %s, <q-args>,
          \  expand('<bang>'), expand('<line1>'), expand('<line2>'))",
          \   string(name), string(a:plugin.name))

    call add(a:plugin.dummy_commands, [name, raw_cmd])
    silent! execute raw_cmd
  endfor
endfunction

在上述例子中，FlyGrep.vim 插件载入之前，执行的命令 :FlyGrep 实际上时调用 dein#autoload#_on_cmd 函数

根据函数加载 `on_func`

当调用插件的函数时动态载入插件，其实我感觉这个功能有点多余。因为 autoload/ 目录下的 Vim 脚本文件在 Vim 启动时是不会自动执行的。只有在调用对应的函数时才会载入并执行。可能是为了更加极致的 Lazy load, 让非载入的插件完全隐藏吧。那么 on_func 这个功能到底是如何实现的呢？ (Neo)Vim 有一个事件叫做 FuncUndefined，是在调用不存在的函数时触发. 下面是一段简单的 on_func 实现。

let s:lazy_plugins = []
function! Plug(path, opt)
  if !empty(a:opt)
    " 直接 添加 rtp
    return
  endif
  call add(s:lazy_plugins, [a:path, a:opt])
endfunction
function! s:on_func(f)
  for [path, opt] in s:lazy_plugins
    if opt.on_func =~# a:f
      " 载入路径 path 的插件
    endif
  endfor
endfunction
augroup test_on_func
  autocmd!
  autocmd FuncUndefined * call s:on_func(expand('<afile>'))
augroup END

call Plug('~/.SpaceVim.d/hello-vim', {
    \ 'on_func' : 'hello#'
    \ })

根据事件加载 `on_event`

（Neo）Vim 有很多事件（event），这些事件在特定的时机会被触发。根据事件加载指的是设置某些插件在特定的事件触发时再载入系统。相较于前面的 on_cmd 和 on_func 的实现，on_event 的实现相对简单一些，仅仅是监控事件的发生与否，对于发生时的 <amatch> 及 <afile> 不做判断。以下为简单的实现逻辑:

let s:lazy_plugins = []
augroup test_on_event
autocmd!
augroup END
function! s:load(path)
  " 载入路径为 path 的插件
endfuntion
function! Plug(path, opt)
  if !empty(a:opt)
    call s:load(a:path)
    return
  endif
  if has_key(a:opt, 'on_event')
    for event in a:opt.on_event
      exe printf('autocmd test_on_event %s call s:load("%s")', event, a:path)
    endfor
  endif
endfunction

call Plug('~/.SpaceVim.d/hello-vim', {
    \ 'on_event' : ['InsertEnter', 'WinEnter']
    \ })

根据文件类型加载 `on_ft`

根据文件类型加载插件，实际上可以理解为一种特殊的 on_event 懒加载模式。前面也说到 on_event 懒加载不判断触发事件时的 <amatch> 和 <afile> 值。而 on_ft 模式的懒加载底层逻辑是只监听 FileType 这一种事件，并且在事件触发时判断 <amatch> 值。 on_ft 懒加载的简单实现代码如下：

let s:lazy_plugins = []
augroup test_on_ft
autocmd!
augroup END
function! s:load(path)
  " 载入路径为 path 的插件
endfuntion
function! Plug(path, opt)
  if !empty(a:opt)
    call s:load(a:path)
    return
  endif
  if has_key(a:opt, 'on_ft)
    for ft in a:opt.on_ft
      exe printf('autocmd test_on_ft FileType %s call s:load("%s")', ft, a:path)
    endfor
  endif
endfunction

call Plug('~/.SpaceVim.d/hello-vim', {
    \ 'on_ft' : ['java', 'python']
    \ })

根据按键加载 `on_map`

以下这段摘自 dein.vim 的源码：

function! s:generate_dummy_mappings(plugin) abort
  let a:plugin.dummy_mappings = []
  let items = type(a:plugin.on_map) == v:t_dict ?
        \ map(items(a:plugin.on_map),
        \   { _, val -> [split(val[0], '\zs'),
        \                dein#util#_convert2list(val[1])]}) :
        \ map(copy(a:plugin.on_map),
        \  { _, val -> type(val) == v:t_list ?
        \     [split(val[0], '\zs'), val[1:]] : [['n', 'x'], [val]] })
  for [modes, mappings] in items
    if mappings ==# ['<Plug>']
      " Use plugin name.
      let mappings = ['<Plug>(' . a:plugin.normalized_name]
      if stridx(a:plugin.normalized_name, '-') >= 0
        " The plugin mappings may use "_" instead of "-".
        call add(mappings, '<Plug>(' .
              \ substitute(a:plugin.normalized_name, '-', '_', 'g'))
      endif
    endif

    for mapping in mappings
      " Define dummy mappings.
      let prefix = printf('dein#autoload#_on_map(%s, %s,',
            \ string(substitute(mapping, '<', '<lt>', 'g')),
            \ string(a:plugin.name))
      for mode in modes
        let raw_map = mode.'noremap <unique><silent> '.mapping
              \ . (mode ==# 'c' ? " \<C-r>=" :
              \    mode ==# 'i' ? " \<C-o>:call " : " :\<C-u>call ")
              \ . prefix . string(mode) . ')<CR>'
        call add(a:plugin.dummy_mappings, [mode, mapping, raw_map])
        silent! execute raw_map
      endfor
    endfor
  endfor
endfunction

不难看出，on_map 的实现机制跟 on_cmd 有点类似，实际上时定义了新的快捷键映射，触发时去调用 dein#autoload#on_map 函数。再在这个函数内载入对应的插件，载入完成后使用 feedkey() 函数去模拟按下触发的快捷键映射。

总结

本文主要介绍了 (neo)vim 插件的基本目录结构以及各个目录下文件的载入机制。充分利用好这些机制后，即便是没有使用懒加载机制的情况下也可以大大的提高插件的初始化体验。除此之外，本文还简单介绍了目前常见的几种赖加载机制的实现底层原理。最后，说明一下，文中示例代码仅限于体现功能实现的基本逻辑，并未做额外的条件判断及错误捕获，并不适用于直接使用。

实时调整 Neovim 的颜色主题

Sat, 03 Aug 2024 00:00:00 +0000

需求背景
早期功能实现
- 在主题设定后方直接修改
- 使用 ColorScheme 事件调用覆写函数。
使用 cpicker.nvim 实时调色

需求背景

如果日常使用 Neovim 较多的话，选择一个喜欢的颜色主题还是非常不错的。Github 上面有很多 Neovim 主题插件。但是在使用过程中会遇到这样情况，比如：“我觉得这个主题某个字段高亮颜色看着不喜欢，想做一个微调”。一般遇到这种情况大多数人会 Fork 仓库进行修改，或者在配置文件设定主题后方进行覆盖。

早期功能实现

以上的这个功能需求，其实很久以前就有了，早期我的解决方法非常简单, 有两种：

在主题设定后方直接修改

早期的配置文件比较简单，我都是在主题设定后方直接修改的，比如：

colorschem one
hi VertSplit guibg=#282828 guifg=#181A1F

这种修改方式也存在弊端，就是在启动 Neovim 后，如果执行 :colorscheme 命令切换主题，那配置文件中的微调将不再生效。

使用 `ColorScheme` 事件调用覆写函数。

autocmd ColorScheme * call s:fix_colorscheme()

function! s:fix_colorscheme()
  " 使用 g:colors_name 判断主题名称
  " 再此使用 highlight 命令修改高亮组
endfunction

这就解决了前面提到的切换主题后不再生效的问题。但是调整的过着无法在 Vim 里面完成，可能需要借助外部的调色板，调整好后把 hex 值写进配置文件。

使用 cpicker.nvim 实时调色

前面介绍过我的 cpicker.nvim 插件，随着这个插件做出来后，借助它的调色板，又实现了一个实时调整高亮组的功能。并且，调整的结果会存住下来。重启 Neovim 后，对应的颜色主题的修改还任然存在。操作步骤如下：

将光标移动到需要调色的位置
使用 :CpickerCursorChangeHighlight 命令调出调色板浮窗，此时调色板默认颜色就是刚刚光标所在位置前景色。
上下移动光标至对应元素，左右进行调整，此时背景窗口中原先的字段高亮也会跟着变化。
调整完成后，使用 q 按键关闭调色板浮窗。

到此时已经调整完成，如果重启 Neovim 后，对当前这个主题调整任然会生效。我录制了一个修改颜色及重启 Neovim 并设定颜色主题的动画：对于调整过的颜色主题，如果需要清除掉调整，只需要执行:CpickerClearColorPatch 命令。

悬浮滚动条插件 scrollbar.vim

Tue, 30 Jul 2024 00:00:00 +0000

插件简介
问题反馈
安装及使用

插件简介

今天给大家分享一下我的 “新” 插件: scrollbar.vim。这是一个支持 Neovim 和 Vim 的悬浮滚动条插件，使用的是 Neovim 的 floating windows 或者 Vim 的 popup windows 特性。相关内容可以阅读: Neovim 的 :h api-floatwin 或者 Vim 的 :h popup-window。之所以前面的新字加上引号，是因为实际上这个插件早在三年多前就已经在 SpaceVim 中使用了，是参考 Xuyuanp/scrollbar.nvim 逻辑重新使用 Vim Script 实现的。在 SpaceVim 仓库下执行：:Git log autoload/SpaceVim/plugins/scrollbar.vim

* f1617ae12 - Add scrollbar support (#3826) (Wang Shidong 3 years, 10 months ago)

随着后来对该插件进行不断的完善，以及针对新版本的 Neovim 重新实现的一个新的 Lua 版本，目前插件已经基本稳定，可以独立使用，其代码执行的基本逻辑如下：

if has('nvim-0.9.0')
  lua require('spacevim.plugin.scrollbar').show()
else
  call SpaceVim#plugins#scrollbar#show()
endif

问题反馈

目前，插件的维护及开发还是在 SpaceVim 的 bundle/scrollbar.vim 目录中，使用 Github Action 同步到单独的仓库以便于直接使用。如果在使用过程中遇到问题，或者有新的想法建议，欢迎在 issue tracker 留言反馈。

安装及使用

如果你是 SpaceVim 用户，只需要在 ui 模块内启用 scrollbar 即可：

[[layers]]
  name = 'ui'
  enable_scrollbar = true

对于非 SpaceVim 用户，也可以使用你喜欢的插件管理器进行安装，比如：

vim-plug

Plug 'wsdjeg/scrollbar.vim'

lazy.vim

-- lazy.nvim
{
  "wsdjeg/scrollbar.vim",
  event = "VeryLazy",
}

关于 Neovim 插件开发的指南

Mon, 29 Jul 2024 00:00:00 +0000

今天，在 Neovim 中文电报群有人分享了一个仓库 nvim-best-practices@24e835c，是关于 Neovim 插件开发的一些“指南”，或者可以说是“建议”，当然我也回复了我的想法，抱歉，语言有些过激。

花花里胡巧的限制，我只看了开头就看不下去了，举例，命令要分成子命令，
这个除了浪费一层判断，没啥用。本来只定义一个FooInstall命令，
实际上在底层c就已经判断出来对应的函数。结果按照他这样，
需要在viml或者lua这边判断下到底这个命令是做什么的
跟谷歌的viml style guide相比差远了。另外手机上打开毫无阅读体验可谈。

起初本来不是特别在意，只在群里回复一下就算了，因为习惯每个人都有，只要 “can work” 就没必要纠结对与错了，因为毕竟也不会影响到自己的习惯。但是随着浏览发现，居然要把这一内容合并到 Neovim 主仓库。那我觉得就对我自己包括后来的 Neovim 用户都会有很大的影响。因此我觉得有必要针对这个指南，写一些东西了。逐行看一下，因为 Pull Request 的分支的一直在变动，而且是 force push，:(，因此原文在文章中有直接文字体现。

*lua-plugin.txt*                     Nvim

:h lua-plugin 很容易让人误解，也很难将内容与这个关键词联想在一起。如果是针对于命令定义、按键映射定义的建议，那么就不局限于 Lua 了。而且，这个不是某个 plugin 的文档，而是插件开发的建议，:h plugin-dev 或者 :h plugin-dev-guide 感觉更加合适一些。

                            NVIM REFERENCE MANUAL

		  Guide to developing Lua plugins for Nvim


                                       Type |gO| to see the table of contents.

==============================================================================
Introduction                                                       *lua-plugin*

This is a guide for getting started with Nvim plugin development. It is not
intended as a set of rules, but as a collection of recommendations for good
practices.

For a guide to using Lua in Nvim, please refer to |lua-guide|.

==============================================================================
Type safety                                            *lua-plugin-type-safety*

Lua, as a dynamically typed language, is great for configuration. It provides
virtually immediate feedback.
But for larger projects, this can be a double-edged sword, leaving your plugin
susceptible to unexpected bugs at the wrong time.

You can leverage LuaCATS https://luals.github.io/wiki/annotations/
annotations, along with lua-language-server https://luals.github.io/ to catch
potential bugs in your CI before your plugin's users do.

------------------------------------------------------------------------------
Tools						 *lua-plugin-type-safety-tools*

- lua-typecheck-action https://github.com/marketplace/actions/lua-typecheck-action
- luacheck https://github.com/lunarmodules/luacheck for additional linting

==============================================================================
User commands					     *lua-plugin-user-commands*

Many users rely on command completion to discover available user commands. If
a plugin pollutes the command namespace with lots of commands, this can
quickly become overwhelming.

Example:

- `FooAction1 {arg}`
- `FooAction2 {arg}`
- `FooAction3`
- `BarAction1`
- `BarAction2`

Instead of doing this, consider gathering subcommands under scoped commands
and implementing completions for each subcommand.

Example:

- `Foo action1 {arg}`
- `Foo action2 {arg}`
- `Foo action3`
- `Bar action1`
- `Bar action2`

对于这点，我其实是持否定态度的。命令在定义时，其执行内容与字符串名字已经进行了绑定。在调用命令时，底层 c 逻辑就已经判断出要去执行哪一个函数。如果使用子命令，无疑要增加一个命令功能的分析，显得有些浪费。如果一个插件只提拱了有限的几个命令, 比如：FooInstall、FooUninstall，很明显就可以看出这两个命令的功能，根本没必要使用子命令。当然，什么样情况下建议使用子命令呢？当多个命令的字面内容非常接近且难以区分时时，比如：

FooInstall1
FooInstall2

这种情况下，建议用子命令，比如 FooInstall 1，FooInstall 2 或者，

Foo
install 1

, Foo install 2

------------------------------------------------------------------------------
Subcommand completions example   *lua-plugin-user-commands-completions-example*

In this example, we want to provide:

- Subcommand completions if the user has typed `:Foo ...`
- Argument completions if they have typed `:Foo {subcommand}`

First, define a type for each subcommand, which has:

- An implementation: A function which is called when executing the subcommand.
- An optional command completion callback, which takes the lead of the
  subcommand's arguments.

>lua
    ---@class FooSubcommand
    ---@field impl fun(args:string[], opts: table)
    ---@field complete? fun(subcmd_arg_lead: string): string[]
<
Next, we define a table mapping subcommands to their implementations and
completions:
>lua
    ---@type table<string, FooSubcommand>
    local subcommand_tbl = {
        action1 = {
            impl = function(args, opts)
              -- Implementation (args is a list of strings)
            end,
            -- This subcommand has no completions
        },
        action2 = {
            impl = function(args, opts)
                -- Implementation
            end,
            complete = function(subcmd_arg_lead)
                -- Simplified example
                local install_args = {
                    "first",
                    "second",
                    "third",
                }
                return vim.iter(install_args)
                    :filter(function(install_arg)
                        -- If the user has typed `:Foo action2 fi`,
                        -- this will match 'first'
                        return install_arg:find(subcmd_arg_lead) ~= nil
                    end)
                    :totable()
            end,
            -- ...
        },
    }
<
Then, create a Lua function to implement the main command:
>lua
    ---@param opts table :h lua-guide-commands-create
    local function foo_cmd(opts)
        local fargs = opts.fargs
        local subcommand_key = fargs[1]
        -- Get the subcommand's arguments, if any
        local args = #fargs > 1 and vim.list_slice(fargs, 2, #fargs) or {}
        local subcommand = subcommand_tbl[subcommand_key]
        if not subcommand then
            vim.notify("Foo: Unknown command: " .. subcommand_key, vim.log.levels.ERROR)
            return
        end
        -- Invoke the subcommand
        subcommand.impl(args, opts)
    end
<
See also |lua-guide-commands-create|.

Finally, we register our command, along with the completions:
>lua
    -- NOTE: the options will vary, based on your use case.
    vim.api.nvim_create_user_command("Foo", foo_cmd, {
        nargs = "+",
        desc = "My awesome command with subcommand completions",
        complete = function(arg_lead, cmdline, _)
            -- Get the subcommand.
            local subcmd_key, subcmd_arg_lead = cmdline:match("^Foo[!]*%s(%S+)%s(.*)$")
            if subcmd_key
                and subcmd_arg_lead
                and subcommand_tbl[subcmd_key]
                and subcommand_tbl[subcmd_key].complete
            then
                -- The subcommand has completions. Return them.
                return subcommand_tbl[subcmd_key].complete(subcmd_arg_lead)
            end
            -- Check if cmdline is a subcommand
            if cmdline:match("^Foo[!]*%s+%w*$") then
                -- Filter subcommands that match
                local subcommand_keys = vim.tbl_keys(subcommand_tbl)
                return vim.iter(subcommand_keys)
                    :filter(function(key)
                        return key:find(arg_lead) ~= nil
                    end)
                    :totable()
            end
        end,
        bang = true, -- If you want to support ! modifiers
    })
<
==============================================================================
Keymaps							   *lua-plugin-keymaps*

Avoid creating keymaps automatically, unless they are not controversial. Doing
so can easily lead to conflicts with user |mapping|s.

NOTE: An example for uncontroversial keymaps are buffer-local |mapping|s for
      specific file types or floating windows.

A common approach to allow keymap configuration is to define a declarative DSL
https://en.wikipedia.org/wiki/Domain-specific_language via a `setup` function.

However, doing so means that

- You will have to implement and document it yourself.
- Users will likely face inconsistencies if another plugin has a slightly
  different DSL.
- |init.lua| scripts that call such a `setup` function may throw an error if
  the plugin is not installed or disabled.

As an alternative, you can provide |<Plug>| mappings to allow users to define
their own keymaps with |vim.keymap.set()|.

- This requires one line of code in user configs.
- Even if your plugin is not installed or disabled, creating the keymap won't
  throw an error.

Another option is to simply expose a Lua function or |user-commands|.

However, some benefits of |<Plug>| mappings over this are that you can

- Enforce options like `expr = true`.
- Expose functionality only for specific |map-modes|.
- Expose different behavior for different |map-modes| with a single |<Plug>|
  mapping, without adding impurity or complexity to the underlying Lua
  implementation.

NOTE: If you have a function that takes a large options table, creating lots
      of |<Plug>| mappings to expose all of its uses could become
      overwhelming. It may still be beneficial to create some for the most
      common ones.

------------------------------------------------------------------------------
Example					      *lua-plugin-plug-mapping-example*

In your plugin:
>lua
    vim.keymap.set("n", "<Plug>(SayHello)", function()
        print("Hello from normal mode")
    end, { noremap = true })

    vim.keymap.set("v", "<Plug>(SayHello)", function()
        print("Hello from visual mode")
    end, { noremap = true })
<
In the user's config:
>lua
    vim.keymap.set({"n", "v"}, "<leader>h", "<Plug>(SayHello)")
<
==============================================================================
Initialization					    *lua-plugin-initialization*

Newcomers to Lua plugin development will often put all initialization logic in
a single `setup` function, which takes a table of options.
If you do this, users will be forced to call this function in order to use
your plugin, even if they are happy with the default configuration.

Strictly separated configuration and smart initialization allow your plugin to
work out of the box.

NOTE: A well designed plugin has minimal impact on startup time.
      See also |lua-plugin-lazy-loading|.

Common approaches to a strictly separated configuration are:

- A Lua function, e.g. `setup(opts)` or `configure(opts)`, which only overrides the
  default configuration and does not contain any initialization logic.
- A Vimscript compatible table (e.g. in the |vim.g| or |vim.b| namespace) that your
  plugin reads from and validates at initialization time.
  See also |lua-vim-variables|.

Typically, automatic initialization logic is done in a |plugin| or |ftplugin|
script. See also |'runtimepath'|.

==============================================================================
Lazy loading					      *lua-plugin-lazy-loading*

When it comes to initializing your plugin, assume your users may not be using
a plugin manager that takes care of lazy loading for you.
Making sure your plugin does not unnecessarily impact startup time is your
responsibility. A plugin's functionality may evolve over time, potentially
leading to breakage if users have to hack into the loading mechanisms.
Furthermore, a plugin that implements its own lazy initialization properly will
likely have less overhead than the mechanisms used by a plugin manager or user
to load that plugin lazily.

------------------------------------------------------------------------------
Defer `require` calls			*lua-plugin-lazy-loading-defer-require*

|plugin| scripts should not eagerly `require` Lua modules.

For example, instead of:
>lua
    local foo = require("foo")
    vim.api.nvim_create_user_command("MyCommand", function()
        foo.do_something()
    end, {
      -- ...
    })
<
which will eagerly load the `foo` module and any other modules it imports
eagerly, you can lazy load it by moving the `require` into the command's
implementation.
>lua
    vim.api.nvim_create_user_command("MyCommand", function()
        local foo = require("foo")
        foo.do_something()
    end, {
      -- ...
    })
<
NOTE: For a Vimscript alternative to `require`, see |autoload|.

NOTE: In case you are worried about eagerly creating user commands, autocommands
      or keymaps at startup:
      Plugin managers that provide abstractions for lazy-loading plugins on
      such events will need to create these themselves.

------------------------------------------------------------------------------
Filetype-specific functionality		     *lua-plugin-lazy-loading-filetype*

Consider making use of |filetype| for any functionality that is specific to a
filetype, by putting the initialization logic in a `ftplugin/{filetype}.lua`
script.

------------------------------------------------------------------------------
Example				     *lua-plugin-lazy-loading-filetype-example*

A plugin tailored to Rust development might have initialization in
`ftplugin/rust.lua`:
>lua
    if not vim.g.loaded_my_rust_plugin then
        -- Initialize
    end
    -- NOTE: Using `vim.g.loaded_` prevents the plugin from initializing twice
    -- and allows users to prevent plugins from loading
    -- (in both Lua and Vimscript).
    vim.g.loaded_my_rust_plugin = true

    local bufnr = vim.api.nvim_get_current_buf()
    -- do something specific to this buffer,
    -- e.g. add a |<Plug>| mapping or create a command
    vim.keymap.set("n", "<Plug>(MyPluginBufferAction)", function()
        print("Hello")
    end, { noremap = true, buffer = bufnr, })
<
==============================================================================
Configuration				             *lua-plugin-configuration*

Once you have merged the default configuration with the user's config, you
should validate configs.

Validations could include:

- Correct types, see |vim.validate()|
- Unknown fields in the user config (e.g. due to typos).
  This can be tricky to implement, and may be better suited for a |health|
  check, to reduce overhead.

==============================================================================
Troubleshooting					   *lua-plugin-troubleshooting*

------------------------------------------------------------------------------
Health checks			       	    *lua-plugin-troubleshooting-health*

Provide health checks in `lua/{plugin}/health.lua`.

Some things to validate:

- User configuration
- Proper initialization
- Presence of Lua dependencies (e.g. other plugins)
- Presence of external dependencies

See also |vim.health| and |health-dev|.

------------------------------------------------------------------------------
Minimal config template             *lua-plugin-troubleshooting-minimal-config*

It can be useful to provide a template for a minimal configuration, along with
a guide on how to use it to reproduce issues.

==============================================================================
Versioning and releases                        *lua-plugin-versioning-releases*

Consider

- Using SemVer https://semver.org/ tags and releases to properly communicate
  bug fixes, new features, and breaking changes.
- Automating versioning and releases in CI.
- Publishing to luarocks https://luarocks.org, especially if your plugin
  has dependencies or components that need to be built; or if it could be a
  dependency for another plugin.

------------------------------------------------------------------------------
Further reading		       *lua-plugin-versioning-releases-further-reading*

- Luarocks <3 Nvim https://github.com/nvim-neorocks/sample-luarocks-plugin

有点强推 Luarocks。

------------------------------------------------------------------------------
Tools			                 *lua-plugin-versioning-releases-tools*

- luarocks-tag-release
  https://github.com/marketplace/actions/luarocks-tag-release
- release-please-action
  https://github.com/marketplace/actions/release-please-action
- semantic-release
  https://github.com/semantic-release/semantic-release

这些内容写在 wiki 或者一些单独的文章里足够了，合并到 Neovim 文档里面显得有些过了。并不是每个人都用 git 或者 github。

==============================================================================
Documentation                                        *lua-plugin-documentation*

Provide vimdoc (see |help-writing|), so that users can read your plugin's
documentation in Nvim, by entering `:h {plugin}` in |command-mode|.

------------------------------------------------------------------------------
Tools			                       *lua-plugin-documentation-tools*

以上两个 tag 完全可以合并，每个内容太少了点，最后这一大段，看了满屏 tag。


- panvimdoc https://github.com/kdheepak/panvimdoc

Neovim 调色板插件 cpicker.nvim

Sun, 14 Jul 2024 00:00:00 +0000

启用插件
操作界面
后续计划

因为偶尔需要修改 Neovim 的高亮，涉及到颜色调整，以往使用的是外部工具，来回切换非常麻烦。也找了一些 Neovim/Vim 的插件，但是使用的感觉确实不尽如人意。因此，自己实现了一个简便版本的调色板插件 cpicker.nvim，该插件存储于 Github 。

启用插件

可以使用任意插件管理器进行安装，比如我的 nvim-plug:

require('plug').add({
  {
    'wsdjeg/cpicker.nvim',
    depends = {
      { 'wsdjeg/logger.nvim' },
      { 'wsdjeg/notify.nvim' },
    },
  },
})

操作界面

操作快捷键：

按键	功能描述
`h` / `<Left>`	减小光标下的值
`l` / `<Right>`	增加光标下的值
`<Enter>`	复制光标下的颜色值

后续计划

目前支持的格式包括：RGB、HSL、HSV、CMYK，计划再增加一些常用的格式。
增加颜色混合调整面板

Neovim 缓冲区（buffer）相关事件

Sun, 07 Jul 2024 00:00:00 +0000

起因
获取可用事件列表
事件的触发时机
- BufAdd
- BufNew
- BufNewFile
测试示例

起因

最近在使用 SpaceVim 的标签栏（tabline）时发现，对于新增的空内容的缓冲区（buffer），标签栏上方并不会列出。检查源码发现标签栏跟踪缓冲区新增的代码只监听了：BufNewFile 跟 BufReadPost 事件。

vim.api.nvim_create_autocmd({ 'BufNewFile', 'BufReadPost' }, {
  callback = vim.schedule_wrap(function(event)
    if
      vim.api.nvim_buf_is_valid(event.buf)
      and index(right_hide_bufs, event.buf) == -1
      and index(visiable_bufs, event.buf) == -1
      and index(left_hide_bufs, event.buf) == -1
    then
      table.insert(right_hide_bufs, event.buf)
    end
  end),
  group = tabline_augroup,
})

测试发现 :enew 命令及 :new 命令并不会触发这两个事件。修改源码增加监听 BufNew 事件。虽然问题是修复了，但是我觉得有必要整理下缓冲区相关事件的触发时机。

获取可用事件列表

可以使用命令 :echo getcompletion('Buf', 'event') 快速查看当前 Neovim 版本支持的缓冲区事件列表。

事件的触发时机

BufAdd

新增一个缓冲区至缓冲区列表
将一个 unlisted 缓冲区添加进 listed 缓冲区列表
修改 listed 缓冲区列表中某个缓冲区的名称

BufNew

新增一个缓冲区
修改缓冲区的名称

BufNewFile

当开始编辑一个不存在的文件时

测试示例

通过一些实例来测试事件触发的时机，测试代码如下：需要忽略掉 *Cmd 事件，避免文件读写失败。

local log = require("spacevim.logger").derive("logevent")
local group = vim.api.nvim_create_augroup("logevent", { clear = true })
vim.api.nvim_create_autocmd(
	vim.tbl_filter(function(e)
		return not vim.endswith(e, "Cmd")
	end, vim.fn.getcompletion("Buf", "event")),
	{
		callback = vim.schedule_wrap(function(event)
			log.debug(event.event .. event.buf)
		end),
		group = group,
	}
)

执行命令：:new

[ logevent ] [13:20:39:562] [ Debug ] BufNew5
[ logevent ] [13:20:39:562] [ Debug ] BufAdd5
[ logevent ] [13:20:39:562] [ Debug ] BufAdd5
[ logevent ] [13:20:39:562] [ Debug ] BufLeave4
[ logevent ] [13:20:39:562] [ Debug ] BufEnter5
[ logevent ] [13:20:39:562] [ Debug ] BufWinEnter5

执行命令：:enew

[ logevent ] [13:22:42:452] [ Debug ] BufNew6
[ logevent ] [13:22:42:452] [ Debug ] BufAdd6
[ logevent ] [13:22:42:452] [ Debug ] BufAdd6
[ logevent ] [13:22:42:452] [ Debug ] BufLeave4
[ logevent ] [13:22:42:452] [ Debug ] BufWinLeave4
[ logevent ] [13:22:42:452] [ Debug ] BufHidden4
[ logevent ] [13:22:42:452] [ Debug ] BufEnter6
[ logevent ] [13:22:42:452] [ Debug ] BufWinEnter6

执行命令: :echo bufadd('')

[ logevent ] [13:47:57:482] [ Debug ] BufNew6

echo nvim_create_buf(v:false, v:true)

[ logevent ] [14:25:06:555] [ Debug ] BufNew5

echo nvim_create_buf(v:true, v:true)

[ logevent ] [14:26:32:389] [ Debug ] BufNew11
[ logevent ] [14:26:32:389] [ Debug ] BufAdd11
[ logevent ] [14:26:32:389] [ Debug ] BufAdd11

当打开一个文件后，执行 :set nobuflisted, 在执行 :set buflisted

[ logevent ] [14:38:15:888] [ Debug ] BufDelete4
[ logevent ] [14:38:19:857] [ Debug ] BufAdd4
[ logevent ] [14:38:19:857] [ Debug ] BufAdd4

打开一个存在的文件：:e README.md

[ logevent ] [14:44:15:717] [ Debug ] BufNew8
[ logevent ] [14:44:15:717] [ Debug ] BufAdd8
[ logevent ] [14:44:15:717] [ Debug ] BufAdd8
[ logevent ] [14:44:15:717] [ Debug ] BufLeave4
[ logevent ] [14:44:15:717] [ Debug ] BufWinLeave4
[ logevent ] [14:44:15:717] [ Debug ] BufHidden4
[ logevent ] [14:44:15:717] [ Debug ] BufReadPre8
[ logevent ] [14:44:15:717] [ Debug ] BufReadPost8
[ logevent ] [14:44:15:717] [ Debug ] BufReadPost8
[ logevent ] [14:44:15:717] [ Debug ] BufEnter8
[ logevent ] [14:44:15:717] [ Debug ] BufWinEnter8

打开一个不存在的新文件: :e newfile.txt

[ logevent ] [14:45:56:519] [ Debug ] BufNew10
[ logevent ] [14:45:56:519] [ Debug ] BufAdd10
[ logevent ] [14:45:56:519] [ Debug ] BufAdd10
[ logevent ] [14:45:56:519] [ Debug ] BufLeave4
[ logevent ] [14:45:56:519] [ Debug ] BufWinLeave4
[ logevent ] [14:45:56:519] [ Debug ] BufHidden4
[ logevent ] [14:45:56:519] [ Debug ] BufNewFile10
[ logevent ] [14:45:56:519] [ Debug ] BufEnter10
[ logevent ] [14:45:56:519] [ Debug ] BufWinEnter10

上述功能，做成了一个独立的 Neovim 插件：wsdjeg/logevent.nvim 可以使用 nvim-plug 直接安装：

require('plug').add({
  'wsdjeg/logevent.nvim',
})

(Neo)Vim 括号补全插件比较

Thu, 27 Jun 2024 00:00:00 +0000

起因
实现逻辑及功能比较
维护状态

起因

输入模式下，成对符号的自动补全一直是比较常用的功能。使用了很多年 delimitMate ，基本功能正常，但是偶尔会出现卡屏现象，等一段时间或者按下 ctrl-c 可以结束卡屏，但是会输入很多个 <Plug>delimitMate( 。但是这一现象并无法百分百重现。想着这么多年过去了，会不会有新的更好用的插件，于是搜了下，目前已知的括号补全插件有：

delimitMate
neopairs.vim：需要 exists('#CompleteDone') == 1
nvim-autopairs：需要 Neovim 0.7.0+
mini.pairs
auto-pairs
autoclose.nvim
ultimate-autopair.nvim

实现逻辑及功能比较

auto-pairs

仓库中 Vim 脚本只有 plugin/auto-pairs.vim (673 行)。监听 BufEnter 事件，映射 g:AutoPairs 所设定的成对符号。

neopairs.vim

通过监听 CompleteDone 事件，判断补全 item 的结尾是否匹配设定的成对符号。

nvim-autopairs

是使用 Lua 实现的 Neovim 插件。在 nvim-autopairs.setup 函数里使用以下三组事件监听来实现补全。

local group = api.nvim_create_augroup('autopairs_buf', { clear = true })
api.nvim_create_autocmd({ 'BufEnter', 'BufWinEnter' }, {
  --- M.on_attach
})
api.nvim_create_autocmd('BufDelete', {
  ---
})
api.nvim_create_autocmd('FileType', {
  ---
})

在 M.on_attach 函数里，主要有一个 expr 映射及一个 InsertCharPre 事件监听：

local enable_insert_auto = false -- 初始化是否插入的 flag
local expr_map = function(key)
    api.nvim_buf_set_keymap(bufnr, 'i', key, '', {
      expr = true
      --- 设定 expr 映射
    })
end
for _, rule in pairs(rules) do
   -- 根据每个规则映射快捷键，并计算是 enable_insert_auto 值
end
if enable_insert_auto then
    api.nvim_create_autocmd('InsertCharPre', {
      --- 如果 enable_insert_auto 为 true， 则监听 InsertCharPre 事件
    })
end

维护状态

repo	Github stars	Issues	pull requests	last commit
auto-pairs	4.1k	138 Open / 155 Closed	27 Open / 53 Closed	Feb 27, 2019
delimitMate	2k	47 Open / 219 Closed	5 Open / 36 Closed	Dec 14, 2020
nvim-autopairs	3k	12 Open / 287 Closed	1 Open / 157 Closed	May 20 2024
neopairs.vim	31	0 Open / 4 Closed	0 Open / 0 Closed	Mar 16, 2016

mini.pairs 仓库有2个：mini.nvim、mini.pairs。因为 mini.nvim 仓库实际上是由几十个独立插件组合而成，其 Issues 跟 pull requests 列表应对到 mini.pairs 上到底有多少，无法评估。 auto-pairs 有一个较活跃的 fork 版本LunarWatcher/auto-pairs，目前维护状态正常：

Lua 与 Vim Script 之间函数相互调用

Tue, 11 Jun 2024 00:00:00 +0000

起因
基本兼容逻辑
Vim Script 中调用 Lua
Lua 中调用 Vim Script 函数

起因

在使用 Neovim 之前，一直使用的是 Vim Script 写 Vim 脚本。随着 Neovim 的出现，以及 Lua 的速度优势，于是将之前写的插件使用 Lua 进行重写了。在这里记录一些从 Vim Script 切换到 Lua 遇到的一些问题，以及前后兼容的写法。

基本兼容逻辑

个人比较看重脚本的向后兼容，在非必要的情况下，对外的接口函数不会改变，通过以下一个示例大致展示了如何做到前后版本的脚本兼容。比如，早期的 Vim Script 脚本实现的脚本如下： autoload/test.vim

function! test#test(name)
  echo "hello " . name
endfunction

那么，对于 Neovim 新版本的支持，可以使用 Lua 实现类似的功能： lua/test.lua

local M = {}

function M.test(name)
  print('hello ' .. name)
end

return M

为了让前面的 test.vim 使用 Lua 函数，可以做如下修改：

function! test#test(name)
  if has('nvim')
    lua require('test').test(vim.api.nvim_eval('name'))
  else
    echo "hello " . name
  endif
endfunction

以上函数存在一个问题，就是每次调用时，都会去检测一次版本，可以将脚本修改为：

if has('nvim')
  function! test#test(name)
    lua require('test').test(vim.api.nvim_eval('name'))
  endfunction
else
  function! test#test(name)
    echo "hello " . name
  endfunction
endif

这样一来，版本检测仅仅在这个脚本文件被读取载入时才执行一次，在这之后 test#test(name) 这个函数的本体仅限于一行代码。

lua require('test').test(vim.api.nvim_eval('name'))

Vim Script 中调用 Lua

上述的示例中只有一种调用方式，即使用 :lua 命令，该命令使用有两种方式。

lua print('hello')

lua << EOF
  print('hello')
EOF

此外，使用 :lua 命令，如果遇到 Vim Script 函数原先需要有返回值的话，比较麻烦，可以使用 luaeval() 函数，比如：

function! test#test(name)
  call luaeval("require('test').test(vim.api.nvim_eval('name'))")
  " 也可以使用 return 返回值
  return luaeval("require('test').test(vim.api.nvim_eval('name'))")
endfunction

Neovim 0.5.0 增加了 v:lua，可以更加方便地在 Vim Script 中调用 Lua, 示例如下：

function! test#test(name)
  " 这里可以直接使用参数，而不需要使用 nvim_eval
  return v:lua.require('test').test(a:name)
endfunction

Lua 中调用 Vim Script 函数

Neovim 提供了 vim.fn 以及 nvim_call_function(fn, argv)。

-- built-in functions
vim.fn.executable(var)

-- User autoload function
vim.fn['test#test'](name)

对于 Vim 的 funcref 变量，可以使用如下方式调用：

function! s:test_hello(name)
  
endfunction

let s:fn = function('s:test_hello')

function! test#run(fn)
  if type(a:fn) == 2
    let fn = string(a:fn)[10:-3]
  elseif type(a:fn) == type('')
    let fn = a:fn
  endif
  call v:lua.require('test').run(fn)
endf

更新 Neovim 遇到的问题

Mon, 11 Mar 2024 00:00:00 +0000

起因
升级 Neovim
不兼容的改动
切回稳定版

起因

因为在维护 SpaceVim 这一项目，虽然我自己目前日常使用 neovim-0.9.5，但是还有不少用户会使用 neovim-nightly 版本。因此，升级至每日构建版本测试 SpaceVim。

升级 Neovim

Windows 下升级也比较简单，使用 scoop 命令即可：

scoop uninstall neovim
scoop install neovim-nightly

不兼容的改动

安装后，启动一堆错误，也做了一部分修复，commits 如下：

* 2ad0da42 - perf(treesitter): add default setup function (Eric Wong 49 minutes ago)
* f8b280e0 - fix(flygrep): remove `t_ve` option (Eric Wong 68 minutes ago)
* c46968d5 - fix(colorscheme): link WinSeparator to VertSplit (Eric Wong 79 minutes ago)
* 9ee8606e - fix(telescope): fix deoplete autocmd (Eric Wong 82 minutes ago)
* 74c93c6c - chore(treesitter): update nvim-treesitter to 0.9.1 for Nvim-0.8.x (Eric Wong 2 hours ago)

`vim.o.v_te` 报错

原先，在我的代码里有很多通过设置 &v_te 选项来实现修改光标的造型。但是升级到新版本后，就报如下错误：

Error detected while processing function SpaceVim#plugins#flygrep#open:
line    1:
E5108: Error executing lua C:\Users\wsdjeg\.SpaceVim\/lua/spacevim/plugin/flygrep.lua:780: Unknown option 't_ve'
stack traceback:
	[C]: in function '__index'
	C:\Users\wsdjeg\.SpaceVim\/lua/spacevim/plugin/flygrep.lua:780: in function 'open'
	[string ":lua"]:1: in main chunk

检查了下源码，原来是因为执行了 vim.o.v_te，尝试做了一些测试，增加exists()判断，可恨的是 exists('&t_ve') 居然返回 1。那么就无法判断了，只能是删除这些设置。

窗口分割高亮 `VertSplit` 失效

更新后，分割窗口的竖线没有高亮了。查了下 :hi VertSplit，输出结果显示高亮设置正常。看了 :h hl-VertSplit 才知道，原来分割窗口的高亮组名称修改了。修改成了 WinSeparator。因此在 ColorScheme 的 autocmd 内增加了：

hi link WinSeparator VertSplit

`treesitter` 高亮报错

这是我遇到最无语的错误。每当打开 lua 文件、help 文件就会弹出报错 treesitter parser 不存在。起初我以为是 nvim-treesitter 的问题，更新并增加配置禁用所有的高亮都不行。报错如下：

Error detected while processing function startify#open_buffers[13]..<SNR>276_open_buffer[12]..BufReadPost Autocommands for "*":
Error executing lua callback: ...s\neovim-nightly\current\share\nvim\runtime\filetype.lua:30: Error executing lua: ...s\neovim-nightly\current\share\nvim\runtime\filetype.lua:31: function startify#open_buffers[13]..<SNR>276_open_buffer[12]..BufReadPost Autocommands for "*"..FileType Autocommands for "*"..function <SNR>1_LoadFTPlugin[20]..script D:\Scoop\apps\neovim-nightly\current\share\nvim\runtime\ftplugin\lua.lua: Vim(runtime):E5113: Error while calling lua chunk: ...rrent\share\nvim\runtime/lua/vim/treesitter/language.lua:104: no parser for 'lua' language, see :help treesitter-parsers
stack traceback:
	[C]: in function 'error'
	...rrent\share\nvim\runtime/lua/vim/treesitter/language.lua:104: in function 'add'
	...t\share\nvim\runtime/lua/vim/treesitter/languagetree.lua:112: in function 'new'
	...ightly\current\share\nvim\runtime/lua/vim/treesitter.lua:41: in function '_create_parser'
	...ightly\current\share\nvim\runtime/lua/vim/treesitter.lua:108: in function 'get_parser'
	...ightly\current\share\nvim\runtime/lua/vim/treesitter.lua:416: in function 'start'
	...ovim-nightly\current\share\nvim\runtime\ftplugin\lua.lua:2: in main chunk

执行 :help treesitter-parsers 同样报错，理解为打开 help 文件也报错，同只执行 :h。

Error detected while processing modelines[274]..FileType Autocommands for "*"..function <SNR>1_LoadFTPlugin[20]..script D:\Scoop\apps\neovim-nightly\current\share\nvim\runtime\ftplugin\help.lua:
E5113: Error while calling lua chunk: ...rrent\share\nvim\runtime/lua/vim/treesitter/language.lua:104: no parser for 'vimdoc' language, see :help treesitter-parsers
stack traceback:
	[C]: in function 'error'
	...rrent\share\nvim\runtime/lua/vim/treesitter/language.lua:104: in function 'add'
	...t\share\nvim\runtime/lua/vim/treesitter/languagetree.lua:112: in function 'new'
	...ightly\current\share\nvim\runtime/lua/vim/treesitter.lua:41: in function '_create_parser'
	...ightly\current\share\nvim\runtime/lua/vim/treesitter.lua:108: in function 'get_parser'
	...ightly\current\share\nvim\runtime/lua/vim/treesitter.lua:416: in function 'start'
	...vim-nightly\current\share\nvim\runtime\ftplugin\help.lua:2: in main chunk

于是，禁用 SpaceVim 的 treesitter 模块，任然报错。查看了 neovim-nightly 的源码，发现，原来在这几个文件里面默认增加了：vim.treesitter.start()

D:\Scoop\apps\neovim-nightly\current\share\nvim\runtime\ftplugin\help.lua
D:/Scoop/apps/neovim-nightly/0.10.0-2559/share/nvim/runtime/ftplugin/lua.lua
等等，懒得去一个个搜了。

执行 cat D:/Scoop/apps/neovim-nightly/0.10.0-2559/share/nvim/runtime/ftplugin/lua.lua，发现就两行代码，也没有任何条件判断跟 error handle。

-- use treesitter over syntax
vim.treesitter.start()

切回稳定版

说实话，没空去这样试错。

scoop uninstall neovim-nightly
scoop install neovim
nvim --version
NVIM v0.9.5
Build type: RelWithDebInfo
LuaJIT 2.1.1703942320
Compilation: C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/cl.exe /MD /Zi /O2 /Ob1  -W3 -wd4311 -wd4146 -DUNIT_TESTING -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE -D_WIN32_WINNT=0x0602 -DMSWIN -DINCLUDE_GENERATED_DECLARATIONS -ID:/a/neovim/neovim/.deps/usr/include/luajit-2.1 -ID:/a/neovim/neovim/.deps/usr/include -ID:/a/neovim/neovim/.deps/usr/include -ID:/a/neovim/neovim/build/src/nvim/auto -ID:/a/neovim/neovim/build/include -ID:/a/neovim/neovim/build/cmake.config -ID:/a/neovim/neovim/src -ID:/a/neovim/neovim/.deps/usr/include -ID:/a/neovim/neovim/.deps/usr/include -ID:/a/neovim/neovim/.deps/usr/include -ID:/a/neovim/neovim/.deps/usr/include -ID:/a/neovim/neovim/.deps/usr/include -ID:/a/neovim/neovim/.deps/usr/include -ID:/a/neovim/neovim/.deps/usr/include

   system vimrc file: "$VIM\sysinit.vim"
  fall-back for $VIM: "C:/Program Files (x86)/nvim/share/nvim"

Run :checkhealth for more info

修复 git clone 问题: gnutls_handshake() failed

Fri, 23 Feb 2024 00:00:00 +0000

前因
尝试诊断
重新编译

前因

今天在 wsl 内将 ~/.SpaceVim 仓库的远程地址设置成 https://spacevim.org/git/repos/SpaceVim/ 后，再执行 git pull 出现错误：

fatal: unable to access 'https://spacevim.org/git/repos/SpaceVim/': gnutls_handshake() failed: Error in the pull function.

但是，恢复成 github 或者 gitlab 仓库地址后，就又可以执行 git pull 了。

尝试诊断

执行如下命令，看看网络链接到底怎么回事：

GIT_CURL_VERBOSE=1 git pull

输出为：

29:04.865626 http.c:664              == Info: Couldn't find host spacevim.org in the (nil) file; using defaults
29:04.884061 http.c:664              == Info:   Trying 104.21.53.107:443...
29:05.085433 http.c:664              == Info:   Trying 2606:4700:3037::ac43:d405:443...
29:05.085549 http.c:664              == Info: Immediate connect fail for 2606:4700:3037::ac43:d405: Network is unreachable
29:05.085601 http.c:664              == Info:   Trying 2606:4700:3032::6815:356b:443...
29:05.085623 http.c:664              == Info: Immediate connect fail for 2606:4700:3032::6815:356b: Network is unreachable
29:05.118268 http.c:664              == Info: Connected to spacevim.org (104.21.53.107) port 443 (#0)
29:05.138108 http.c:664              == Info: found 372 certificates in /etc/ssl/certs
29:05.138186 http.c:664              == Info: GnuTLS ciphers: NORMAL:-ARCFOUR-128:-CTYPE-ALL:+CTYPE-X509:-VERS-SSL3.0
29:05.138223 http.c:664              == Info: ALPN, offering h2
29:05.138240 http.c:664              == Info: ALPN, offering http/1.1
29:05.149601 http.c:664              == Info: gnutls_handshake() failed: Error in the pull function.
29:05.149680 http.c:664              == Info: Closing connection 0
fatal: unable to access 'https://spacevim.org/git/repos/SpaceVim/': gnutls_handshake() failed: Error in the pull function.

重新编译

删除已有 git:

sudo apt uninstall git

下载 git 源码

wget "https://mirrors.edge.kernel.org/pub/software/scm/git/git-2.9.5.tar.xz"
tar -xvf git-2.9.5.tar.xz

安装依赖

sudo apt-get update
sudo apt-get install curl jq -y
sudo apt-get install build-essential autoconf dh-autoreconf -y
sudo apt-get install libcurl4-openssl-dev gettext -y

编译

make configure
./configure --prefix=/usr --with-openssl
make -j4

安装

sudo make install

《热辣滚烫》观后感

Thu, 15 Feb 2024 00:00:00 +0000

最近刷视频总是刷到热辣滚烫的相关内容，趁着假日就来看看咯，确实挺不错：

剧中杜乐莹总是毫无保留地对朋友真心付出，即便是知道对方有私心在，仍然坚持按照内心想法去做，确实难能可贵。短短两小时的电影，看到主角为了自己的梦想所做出的改变，和所坚持的，有些汗颜，似乎我也快忘记了自己的梦想。

从 Github 迁移到 Gitlab

Wed, 27 Sep 2023 00:00:00 +0000

起因
尝试 Gitlab 的 page 功能
最终方案 cloudflare page

起因

大概一周多之前，登录 Github 网页版时候总是提示要启用两步验证。因为比较忙，也没太在意，就点了忽略。等到最近两天，直接是不让登录了，必须要启用两步验证才可以登录。着急要处理事情，结果不让登录，手上也没有能进行两步验证的工具。这样的体验让我感到非常的暴躁。一向不喜欢受制于乱七八糟的规则，决定把项目和仓库转移出去。对于我来说，GitHub 也好，Gitlab 也好，仅仅是一个存储版本控制仓库的地方，实在难以理解这类平台总喜欢折腾出各种花俏功能做什么。也正式这个原因，让我决定把仓库转移到 Gitlab，因为我还保留有原 Github 账号的 ssh 密钥。因此可以在本地继续推送代码，于是清空了仓库，并备注了对应的 Gitlab 的仓库地址。

尝试 Gitlab 的 page 功能

Gitlab 也提供了类似于 Github page 的功能，只不过他的自定义域名管理非常让人不爽，逻辑居然是重定向到项目的固定域名。于是，每次访问 spacevim.org 时，都给我重定向到

https://spacevim-spacevim-c3011a6b21af70a6e8848d17c11652755bdad5d4e36c3.gitlab.io/

经过多次尝试后，果断放弃了。

最终方案 cloudflare page

因为域名在 Cloudflare 上，并且该平台也提供了静态网站构建的功能，因此，没必要舍近求远，直接使用 cloudflare page，并且把本站及 SpaceVim 的官网也一并移过来。在构建本站时候，一直遇到一个错误：

Liquid Exception: incompatible character encodings: ASCII-8BIT and UTF-8

谷歌搜了一堆答案，要么是在 default.html 内增加 <meta charset="utf-8" />, 要么是在 _config.yml 里面增加 encoding: utf-8。尝试下来都不行。感谢 vimzh 群友依云提供的答案，在构建时，增加环境变量：export LANG=C.UTF-8

非常棒的安卓输入法 fcitx-android

Wed, 07 Jun 2023 00:00:00 +0000

初识 fcitx5-android
fcitx5-android 特点

大概一个多月以前，我看到过这样一篇文字《几款流行拼音输入法的“用户体验”评测(Win)》。而我自己手机上一直使用的是华为版的百度输入法，虽然我不知道这个输入法到底会上传哪些内容，但是个人感觉还是不安全，因为打字输入涉及的东西太多。聊天信息、密码等等，这些内容不应该存储在不可控的服务器上。

初识 fcitx5-android

于是，我找到了这样一款手机输入法 fcitx5-android。Fcitx 的旧全名是“Free Chinese Input Tool of X”的首字母缩写，相信大家并不陌生，它是 Linux 系统下面一款开源、免费的输入法框架。早期我在使用 Ubuntu/ArchLinux 时候都是使用的这款输入法。非常开心有人将这一输入法移植到了安卓平台。 fcitx5-android 的安装方式也比较简单，可以直接从 F-Droid 网站直接下载 APK 安装包。切记，根据自己的手机选择对应的 CPU 架构，一般手机都是 arm64-v8a。

fcitx5-android 特点

目前 fcitx5-android 只支持全键盘输入模式，恰巧我也是习惯于全键盘输入，因此使用倒是没有任何障碍。而我比较看重的功能特点主要包括：

隐私策略

fcitx5-android 不要求联网权限，也不收集任何个人信息。这一点是我切换该输入法的最核心原因，因为日常输入涉及的内容还是比较多的，因此对于哪些动辄上传收集输入信息的输入法还是比较反感的。

操作可配置性

一些键盘的操作习惯也是可以设置的。比如：

输入标点、数字的方式
长按空格键行为
振动时长
默认展开工具栏，这点比较喜欢
长按延迟时间

更多功能就不一一罗列了，可以自行安装后打开配置界面查看。

界面可配置性

在主题设置界面，可以设置按键按下的水波纹特效，以及是否显示按键边框，甚至按键的横向边距、纵向边距、圆角半径都可以设置。

Neo-tree.nvim 糟糕的体验

Wed, 31 May 2023 00:00:00 +0000

安装 neo-tree
插件配置
遇到的问题
插件优势

文件树插件也是我日常非常常用的插件之一。先前尝试过 nvim-tree，今天晚上花了一晚上时间测试了下 Neo-tree.nvim，测试版本为：Neo-tree.nvim@e3b4ef0。总的来说体验不是很好。 测试环境：

操作系统：Window 11
Neovim 版本：NVIM 0.9.1

安装 neo-tree

我的插件系统比较简单，直接下载 neo-tree.zip 至 bundle 文件夹，并手动更新 RTP。

插件配置

参考 readme 上的介绍，直接完整复制默认配置，修改几个重要的配置，比如宽度、位置、自动关闭窗口等待。

遇到的问题

1、设置 Neo-tree 的初始化路径失败；我给 SpaceVim 增加了这个插件的支持，目前有一个快捷键SPC b t无法实现。按照文档所说:Neotree dir=%:p:h无效，打开后根目录任然是当前目录。 2、设置快捷键不是很方便；在配置文件里，action 都是一些预设值的 string。 3、SPC f o 快捷键每次弹窗需要确认是否切换目录。我是经常会同时编辑不同的 git 仓库文件，SPC f o 设置为打开文件树并定位到当前文件位置，即为 :Neotree reveal，但是每次一旦切换不同项目时都会弹窗提示：

File is not in cmd， change to xxxxx
y/n

而且使用的是 insert 模式，我需要按下 y<Cr> 两下按键，应该提供一个设置选项，自动切换目录而不需要用户手动确认。并且，就算确认，完全可以使用 getchar() 函数。

插件优势

当然了，这个插件也不是完全没有优势，个人感觉优势在： 1、支持多种 source，比如 buffers、git status 等，后续如果有机会，看看是否支持自定义。 2、git 状态的更新，使用的是异步函数，这点比 defx-git 要好一些，后者是我目前使用 defx 的一个痛点。最后，暂时还是切换回 defx，期待 neo-tree 新的改进，后续有机会再尝试。

我的 Neovim 之旅

Wed, 24 May 2023 00:00:00 +0000

初始 Neovim
Neovim 异步 job 特性
Neovim 定时器
悬浮窗口支持
Neovim 内置终端的使用

初始 Neovim

在接触 Neovim 之前，我的主力编辑器一直是 Vim。在 Vim 增加 +job 特性之前， Vim 的所有函数都是在主线程内完成的，当执行某个需要很长时间的操作时，Vim 会卡住等待上一个操作完成。这样的体验是非常不符合个人习惯的。因此，Geoff Greer 给 Vim 提交过异步执行的补丁，源码可以查阅Floobits/vim。同时，Thiago Padilha 也给 Vim 提交过类似的补丁，但是都因各种原因被拒绝，其实这也是我不太喜欢的一个 Vim 开发的弊端。后来，Thiago Padilha 发起了 Neovim 项目，做了如下改进：

增加异步 job 特性
悬浮窗口支持
增加 timer 支持
增加终端真色支持
增加 RPC 通讯支持
增加内置终端模拟器

虽然，以上的一些功能 Vim 后续也增加了，但是部分功能却是用了另外一种完全不兼容的方式。

Neovim 异步 job 特性

Neovim 的异步 job 特性主要是提供了一个异步执行外部命令的函数。并且通过回调函数来响应输出的结果。比如：

call jobstart(['echo'])

Neovim 定时器

Neovim 增加了一个定时器功能，主要涉及函数为 timer_start()，其函数原型为：

timer_start({time}, {callback} [, {options}])

悬浮窗口支持

以往 Vim 支持垂直、水平分屏，而分屏时窗口的布局、屏幕内容都会发生改变。悬浮窗口提供了一种在不改变当前窗口布局的前提下，打开额外的窗口以展示新的内容。 Neovim 和 Vim 的分屏又是完全不一样的函数。因此我写了一个函数，来统一调用 Neovim 或者 Vim 的悬浮窗口。

if has('nvim')
  let s:FLOAT = SpaceVim#api#import('neovim#floating')
else
  let s:FLOAT = SpaceVim#api#import('vim#floating')
endif
call s:FLOAT.open_win(bufnr('%'), v:true,
  \ {
  \ 'relative': 'editor',
  \ 'width'   : &columns,
  \ 'height'  : &lines * 30 / 100,
  \ 'row': 0,
  \ 'col': &lines - (&lines * 30 / 100) - 2
  \ })

Neovim 内置终端的使用

可以通过 :terminal 命令打开内置终端。在终端窗口内，可以使用 Ctrl-\ Ctrl-n 切换到 Normal 模式。目前，内置的:terminal命令不支持分屏模式，可以借助split-term.vim插件。该插件增加了如下的使用方式：

水平/垂直分屏打开终端
指定分屏终端窗口初始化大小
在新的标签页打开终端

优化内置终端的插件有很多种：

https://github.com/voldikss/vim-floaterm
https://github.com/numToStr/FTerm.nvim

虽然这些插件都挺不错的，但是个人感觉没有必要那么复杂。目前，就个人而言，我仅仅使用了 Neovim 的悬浮窗口配合 termopen 函数。

shell.vim#L153-L292

let s:SYSTEM = SpaceVim#api#import('system')
let s:FLOAT = SpaceVim#api#import('neovim#floating')
let s:WIN = SpaceVim#api#import('vim#window')
function! s:open_default_shell(open_with_file_cwd) abort
  if a:open_with_file_cwd
    if getwinvar(winnr(), '&buftype') ==# 'terminal'
      let path = getbufvar(winbufnr(winnr()), '_spacevim_shell_cwd', SpaceVim#plugins#projectmanager#current_root())
    else
      let path = expand('%:p:h')
    endif
  else
    let path = SpaceVim#plugins#projectmanager#current_root()
    " if the current file is not in a project, the projectmanager return empty
    " string. Then use current directory as default cwd.
    if empty(path)
      let path  = getcwd()
    endif
  endif

  " look for already opened terminal windows
  let windows = []
  windo call add(windows, winnr())
  for window in windows
    if getwinvar(window, '&buftype') ==# 'terminal'
      exe window .  'wincmd w'
      if getbufvar(winbufnr(window), '_spacevim_shell_cwd') ==# l:path
        " startinsert do not work in gvim
        if has('nvim')
          startinsert
        else
          normal! a
        endif
        return
      else
        " the opened terminal window is not the one we want.
        " close it, we're gonna open a new terminal window with the given l:path
        exe 'wincmd c'
        break
      endif
    endif
  endfor

  if s:default_position ==# 'float' && exists('*nvim_open_win')
    let s:term_win_id =  s:FLOAT.open_win(bufnr('%'), v:true,
          \ {
            \ 'relative': 'editor',
            \ 'width'   : &columns,
            \ 'height'  : &lines * s:default_height / 100,
            \ 'row': 0,
            \ 'col': &lines - (&lines * s:default_height / 100) - 2
            \ })

    exe win_id2win(s:term_win_id) .  'wincmd w'
  else
    " no terminal window found. Open a new window
    let cmd = s:default_position ==# 'float' ?
          \ 'topleft split' :
          \ s:default_position ==# 'top' ?
          \ 'topleft split' :
          \ s:default_position ==# 'bottom' ?
          \ 'botright split' :
          \ s:default_position ==# 'right' ?
          \ 'rightbelow vsplit' : 'leftabove vsplit'
    exe cmd
    let lines = &lines * s:default_height / 100
    if lines < winheight(0) && (s:default_position ==# 'top' || s:default_position ==# 'bottom')
      exe 'resize ' . lines
    endif
  endif
  let w:shell_layer_win = 1
  for open_terminal in s:open_terminals_buffers
    if bufexists(open_terminal)
      if getbufvar(open_terminal, '_spacevim_shell_cwd') ==# l:path
        exe 'silent b' . open_terminal
        " clear the message
        if has('nvim')
          startinsert
        else
          normal! a
        endif
        return
      endif
    else
      " remove closed buffer from list
      call remove(s:open_terminals_buffers, 0)
    endif
  endfor

  " no terminal window with l:path as cwd has been found, let's open one
  if s:default_shell ==# 'terminal'
    if exists(':terminal')
      if has('nvim')
        if s:SYSTEM.isWindows
          let shell = empty($SHELL) ? 'cmd.exe' : $SHELL
        else
          let shell = empty($SHELL) ? 'bash' : $SHELL
        endif
        enew
        call termopen(shell, {'cwd': l:path})
        " @bug cursor is not cleared when open terminal windows.
        " in neovim-qt when using :terminal to open a shell windows, the orgin
        " cursor position will be highlighted. switch to normal mode and back
        " is to clear the highlight.
        " This seem a bug of neovim-qt in windows.
        "
        " cc @equalsraf
        if s:SYSTEM.isWindows && has('nvim')
          stopinsert
          startinsert
        endif
        let s:term_buf_nr = bufnr('%')
        call extend(s:shell_cached_br, {getcwd() : s:term_buf_nr})
      else
        " handle vim terminal
        if s:SYSTEM.isWindows
          let shell = empty($SHELL) ? 'cmd.exe' : $SHELL
        else
          let shell = empty($SHELL) ? 'bash' : $SHELL
        endif
        let s:term_buf_nr = term_start(shell, {'cwd': l:path, 'curwin' : 1, 'term_finish' : 'close'})
      endif
      call add(s:open_terminals_buffers, s:term_buf_nr)
      let b:_spacevim_shell = shell
      let b:_spacevim_shell_cwd = l:path

      " use WinEnter autocmd to update statusline
      doautocmd WinEnter
      setlocal nobuflisted nonumber norelativenumber

      " use q to hide terminal buffer in vim, if vimcompatible mode is not
      " enabled, and smart quit is on.
      if !empty(g:spacevim_windows_smartclose)  && !g:spacevim_vimcompatible
        exe 'nnoremap <buffer><silent> ' . g:spacevim_windows_smartclose . ' :hide<CR>'
      endif
      startinsert
    else
      echo ':terminal is not supported in this version'
    endif
  elseif s:default_shell ==# 'VimShell'
    VimShell
    imap <buffer> <C-d> exit<esc><Plug>(vimshell_enter)
  endif
endfunction

写给自己·关于健康

Mon, 22 May 2023 00:00:00 +0000

上周，听到一则让我很吃惊的消息。陈浩（左耳朵耗子）因突发心梗辞世，享年只有四十七岁。正常情况下，四十多岁正是事业、家庭黄金时间。当财富、声望都积累足够的时候，却没有时间去享受自己奋斗的果实，确实让人觉得惋惜。其实，对于左耳朵耗子了解的并不多，甚至可以说完全不了解。这几天，不管是朋友圈，还是推特，抑或是订阅的一些博客，都在发文纪念他。也正是读了这些文字才有了一些了解。其实，这类事情之前已经遇到过好几次了。比如：司徒正美。想来，真的是健康是一，财富、声望、家庭等等一切都是零。也正是因此，最近才开始关注一些生活习惯方面的资料。包括不限于：

健康学习到150岁 - 人体系统调优不完全指南

饮食

1、早餐：以往有时候因为熬夜，第二天早上起来的较晚，会错过酒店的早餐时间。又或者是因为早上赶时间，早餐只是应付式地吃一点，甚至是来不及吃。

给自己定一个闹铃，每天早餐预留充足时间

2、夜宵：拒绝夜宵，晚上9点后，不再进食

睡眠

睡眠时间一直是一个大问题，应该是自15年之后，每天睡觉几乎都是11点半到12点半甚至1点。想控制到10点之前，似乎是不现实的，后面尽量控制在11点-7点半，保证至少8小时睡眠。

运动

貌似没有什么适合自己的运动了。以前偶尔还去爬山，上次去宜兴竹海，只到半山腰就下来了。

停用 v2ex 账号

Mon, 15 May 2023 00:00:00 +0000

贴子和回复无法删除
未经允许公布用户邮箱和手机号
以往发的文字无法修改
“随意”移贴
随意删号
霸道降权
针对 v2ex/faq 上的回复
如何删除V2EX账号

2016 年第一次接触 v2ex 的时候，觉得这个论坛做的还是非常不错的，相比老式的 BBS 论坛界面要舒服多了。于是，注册了一个账号：

https://www.v2ex.com/member/wsdjeg V2EX 第 167678 号会员，加入于 2016-04-11 13:08:11 +08:00

随着使用时间的增加，慢慢发现也许 V2EX 这样的“个人网站”并不适合我。罗列了一些存在的问题，以及个人的一些看法。

贴子和回复无法删除

这就存在一个文字版权问题了，自己发的贴子，都无权决定他的删除与否，简直可笑。

未经允许公布用户邮箱和手机号

再次说明了这个网站实际上就是一个个人维护、开放注册的个人网站，而且站长肆意妄为。来自百度取证的证据分享

以往发的文字无法修改

个人认为，人的认知和观点是会随着时间的推移、知识的积累、以及所经历的事情发生改变的。所以偶尔回头去翻看自己写下的文字，还是希望有一个更新、修改的功能。当然，可以使用类似于 Git 仓库一样，保留修改记录。

“随意”移贴

这里，我把“随意”加上了引号是因为可能有些人会认为这不是随意移贴，而是基于“某些规则”，但是希望这个规则可以公开，并且接受大众修改意见。否则，这给人的感觉 v2ex 就是一个站长私人的网站，只不过给了注册用户部分的编辑权限。比如：当你发了一个帖子，讨论正火热的时候，管理员可以将帖子移至“水生火热”(https://www.v2ex.com/go/flamewar)标签下，这个标签下的内容，非登录用户似乎是无法查阅的，会自动跳转至首页。

随意删号

可以看看这篇文章因用 AI 生成的内容回复帖子，V2EX 账号直接被封。且不说这个规则是否合理，对于十年的老用户，而且是活跃的老用户，你（@Livid ）他妈的说删就删，谁敢再这个网站上写东西？

霸道降权

社交类的平台，想必大家也不陌生。我自己以往就使用过QQ空间、人人网、朋友圈等等。这些平台有一个特点，你的好友、你所关注的人，他们的更新，会严格按照时间线展示给你。但是 v2ex 这种降权就会很霸道，他会让你的更新出现在2天前、3天前、甚至更久之前的时间线上。结果就不言而喻了，其他人可能不会那么容易看到你所写的内容。还有一些其他原因，后面想到再更新上来。

针对 v2ex/faq 上的回复

v2ex/faq 页面可能会修改，这里保留了 2024 年 8 月的内容：

我是否可以编辑或者移动自己的主题？

在主题发布之后的 300 秒内，你可以自由地编辑自己的主题，或者将其移动到其他节点。但是在 300 秒（5 分钟）之后，
就不可以再进行这些操作了。对于编辑的限制是为了让大家对发表在 V2EX 的言论更加负责。

简直是荒谬的理论，把完全不相干的两个事情强行联系起来。

如何删除V2EX账号

基于这些原因，即日起停用 v2ex 账号，写到这才发现，原来 v2ex 的账号，还不提供删除功能，这也太牛氓了。 v2ex 贴子(https://v2ex.com/t/1063942)链接已被移至水生火热，非登录用户无法访问，内容如下：使用谷歌搜索“如何删除V2EX账号”可以看到不少人遇到类似的问题。

母亲节·常回家看看

Sun, 14 May 2023 00:00:00 +0000

五一期间没有来得及回家，这次周末正好是母亲节。周五晚上工作结束后，回了一趟老家，已经快半年没有回去了。周六早上，带爷爷、奶奶、妈妈一起去扬州世博园玩玩。避开五一假期，也是另外一番景色。

中午在宝能广场吃的“老土灶民间菜”，感觉他们家菜的口味还是挺不错的，而且也比较实惠。吃完饭回家回家后陪爷爷奶奶还有妈妈打麻将，老年人爱好挺简单的。我记得我上次打牌还是去年11月份，手生的很。礼拜天，是母亲节，今天中午选的是无锡融创茂的泰妃餐厅。

介绍我的新插件 gfr.vim

Sun, 07 May 2023 00:00:00 +0000

为什么要开发 gfr.vim
gfr.vim 的功能特点
如何安装
如何使用
后续计划

今天向大家分享一个我刚写的 Vim 插件 gfr.vim。名字取自三个词语缩写：Grep, Filter, Replace。顾名思义，这个插件提供的功能包括文本搜索、结果筛选以及文本替换功能。

为什么要开发 gfr.vim

Vim 文本搜索的插件已经非常多了，我自己也使用过很多种插件。比如：ack.vim、ag.vim、grepper.vim 等等。这些插件都提供了类似的功能，即为搜索制定的文字，并将结果输出到 Vim 的 quickfix window。甚至，我之前还制作过一款实时异步搜索，并展示搜索结果的插件 flygrep.vim。但是以上这些插件仅仅支持搜索指定文本的结果，不具备二次检索和替换的功能。

gfr.vim 的功能特点

异步执行

这个插件中，我比较常用的命令是 :Grep。实际上，Vim 本身也有 :grep 和 :vimgrep 命令，功能是相同的，都是执行搜索命令，并且把搜索的结果展示在 quickfix 窗口内。但是 Vim 自带的 :grep 和 :vimgrep 命令是单线程的，如果搜索的文件夹内内容非常多会卡住当前 Vim 的操作界面，体验不是很好。

兼容 Vim/Neovim

Vim 和 Neovim 的一些内置函数还是有些差异的，而 gfr.vim 集成了 SpaceVim 的 API，可以同时兼容 Vim 和 Neovim。

弹窗消息界面

gfr.vim 使用了 SpaceVim 的 notify API，对于一些插件通知消息，在 Vim 右上方使用浮窗提示。

如何安装

和其他常用插件一样，你可以使用任意一个插件管理器来安装，比如使用 plug.vim：

Plug 'wsdjeg/gfr.vim'

在插件列表添加上面这段即可，启动 Vim 后执行 :PlugInstall。

如何使用

gfr.vim 提供了如下命令：

:Grep: 搜索指定的文本，该命令后面的参数即为需要搜索的文本，比如 :Grep hello 指的就是搜索 hello。如果直接调用:Grep，并且不带任何参数，那么会弹出一个输入框，可供输入需要搜索的文本。
:Filter：检索上一次搜索的结果，可以理解为二次筛选。对于上一次搜索或者检索的结果，进行再一次的筛选。
:GrepSave：将当前的搜索结果保存至命名标签，以便于快速访问。
:GrepResum：使用:GrepResum 标签名可以快速打开以往的搜索结果
:Replace：对搜索到的结果执行文本替换

后续计划

目前，这个插件只支持 grep 命令，后续计划增加 ag、rg 等命令支持。

将微信朋友圈移至静态网站

Thu, 04 May 2023 00:00:00 +0000

归因
我需要的“朋友圈”
博客相册生成

五一期间花了一点点时间将微信朋友圈“移植”到博客相册，今天抽空整理了下这个过程，并记录。

归因

微信朋友圈14年左右开始使用，至今已经十年了，出于以下原因放弃：

不开放，只能微信里面，其他地方无法查看。
图片损伤，上传到朋友圈的照片会自动压缩，无法存储原图。
审查机制，不过多解释，虽然不喜欢讨论政治等敏感话题
永久存储，不确定哪一天微信会关闭
无法发链接，格式太受限
无法更新，过往内容无法更新

我需要的“朋友圈”

开放的，输入网址即可访问，而非仅限于在微信内
内容自由的，自己可控的
安全的，内容存储于私密仓库，安全，易备份。
格式自由，虽然不需要富文本那么花俏，但是简单的 markdown 语法还是需要的
可更新
日志独立，可关联

博客相册生成

最起初，只有三五个相册的时候，相册页面的内容是纯手工写的。后来，当把朋友圈老照片都转移过来后，手工操作的话就不合适了。因为相册的内容比较简单：

{日期}

{context}

{gallery}

{location}

因此，基于dev#autodocAPI 写了一个脚本:

let s:AUTODOC = SpaceVim#api#import('dev#autodoc')
let s:AUTODOC.autoformat = 0

function! Gengallery() abort
  let s:AUTODOC.begin = '^<!-- wsdjeg.net gallery start -->$'
  let s:AUTODOC.end = '^<!-- wsdjeg.net gallery end -->$'
  let s:AUTODOC.content_func = function('s:generate_gallery')
  call s:AUTODOC.update()
endfunction

function! s:generate_gallery() abort
  let content = []
  call extend(content, s:gallery_list())
  let content += ['']
  return content
endfunction


function! s:gallery_list() abort
  let text = []
  let gallery_dirs = globpath('docs/uploads', '*', 1, 1)
  let previous_t = ''
  for gpath in gallery_dirs
    if empty(previous_t) || matchstr(gpath, '\d\+')  !=# previous_t 
      call extend(text, s:dir_to_g(gpath), 0)
      let previous_t = matchstr(gpath, '\d\+')
    endif
  endfor
  return text
endfunction


function! s:dir_to_g(d) abort
  let t = []
  let y = str2nr(matchstr(a:d, '\d\d\d\d'))
  let m = str2nr(matchstr(a:d, '\d\d\d\d\zs\d\d'))
  let d = matchstr(a:d, '\d\d\d\d\d\d\zs\d\d')
  call add(t, '### ' . y . '年' . m . '月' .  (empty(d) ? '' : d . '日'))
  call add(t, '')
  " 如果存在 text.txt 文件，读取内容，写入文字
  if filereadable(a:d . '/text.txt')
      call extend(t, readfile(a:d . '/text.txt'))
      call add(t, '')
  endif
  call add(t, '{% include image-gallery-nofilename.html folder="' . substitute(a:d[5:], '\', '/', 'g') . '" %}')
  call add(t, '')

  " 如果存在 location 文件，读取内容，写入地址
  if filereadable(a:d . '/location')
      call add(t, '> <i class="fa fa-map-marker"></i> ' . readfile(a:d . '/location')[0])
      call add(t, '')
  endif
  return t
endfunction

五一假期·苏州一日游

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

最近在改写插件 tagbar 的日志系统，采用 SpaceVim 内置的日志插件。但是在调用 debug 函数时发现日志一直无法写入。代码逻辑非常简单，lua 文件逻辑： lua/spacevim/logger.lua

local M = {}


function M.test()
  local derive = {
    _debug_mode = false,
  }

  function derive.debug(msg)
    if derive._debug_mode then
      print(msg)
    end
  end
  return derive
end

return M

vim script 这边只定义了一个函数： autoload/testl.vim

function! testl#test() abort
  return luaeval('require("testluaeval").test()')
endfunction

测试步骤：

let tlog = testl#test()
let tlog._debug_mode = v:true
call tlog.debug('hello')

运行到此处发现，消息并没有被打印。于是在 neovim 仓库提交了issue。得到的回复是，目前 neovim 还不支持 bindeval，但是支持 closures。因此逻辑上做了如下改动： lua/spacevim/logger.lua

local M = {}


function M.test()
  local derive = {
    _debug_mode = false,
  }

  function derive.debug(msg)
    if derive._debug_mode then
      print(msg)
    end
  end
  function derive.start_debug()
    derive._debug_mode = true
  end
  function derive.stop_debug()
    derive._debug_mode = false
  end
  return derive
end

return M

vim script 这边只定义了一个函数： autoload/testl.vim

function! testl#test() abort
  return luaeval('require("testluaeval").test()')
endfunction

测试步骤：

let tlog = testl#test()
call tlog.start_debug()
call tlog.debug('hello')

通过以上的改动，测试步骤可以达到预期效果。

《忠犬八公》观后感

Fri, 31 Mar 2023 00:00:00 +0000

结束了一周的出差，周五到家后，习惯性的看看有什么好看的电影上映。正好看到《忠犬八公》上映。刚开始还有一些疑惑，因为这部电影我记得很早以前就看过。仔细看来原来是大陆拍的，以前看的另外一个版本。晚饭后，一家人一起去，正好赶上 7:20 这场。可能是因为以前看过了，对剧情也大概有了心理预知，所以剧情上倒没有什么特别大的感触。但是期间一些细节也让我感触很多：

教授第一次发飙讲的那段话，其实也很在理。人生匆匆几十年（现在已经过一小半了），没有什么比喜欢更重要。
教授妻子嘴上太伤人，但是其实内心还是很关心教授和八筒，也许她喜欢八筒只是爱屋及乌。
教授送儿子这段，父亲和母亲表达爱的方式还是有区别的。突然让我想到父亲送我上大学的那天，临走时，我秦楚地看到，父亲的眼睛很红。也是，以往都是离家很近上学。上了大学之后，包括现在工作了以后，回去的机会太少了。
儿子一直被误会在瞎折腾，倔强的坚持着他人看不懂的东西，最后实现自己的目标时开心。想想也是，很多时候，自己觉得对即可。
而最让我感触的，还是回忆结束后最后一段，看到满屋的报纸后，可以想象“八筒”日复一日的等了多久。

小狗的想法要比人类简单太多太多了，他的忠诚值得善待！

《保你平安》观后感

Fri, 24 Mar 2023 00:00:00 +0000

今天晚上正好有时间，去看了下最新出来的电影《保你平安》。其实在看这部电影之前，已经对剧情做了大致的了解。一开始，把这部剧当作一个喜剧来看的，看着看着代入感就太强了。现在的网络环境确实挺糟糕的。虽然做到了实名制，但是实际上对于大众来说。网络论坛上出现的各种角色还是匿名的。你无法判断他到底是谁。只能说，其实网络也不是法外之地，希望在网络上发表各种言论时。还是要有敬畏心理，慎言！

使用 Lua 重写 SpaceVim 内置插件

Sat, 22 Oct 2022 00:00:00 +0000

最近如果你关注 Neovim 的社区，就会发现使用 Lua 开发的插件越来越多。 Neovim 默认就支持 luajit，早些时候，做过一次 luajit 与 vim script 速度的比较。以下是一个测试的 Vim Script 脚本。

function! Fibo(N) abort
    let t = a:N
    let b = 0
    while t > 0
        let t = t - 1
        let a = 1
        let b = 1
        let c = 73
        while c > 0
            let c = c - 1
            let tmp = a + b
            let a = b
            let b = tmp
        endwhile
    endwhile
    echo b
endfunction

function! LuaFibo(N) abort
lua << EOF
local a, b, r, c, t
t = vim.api.nvim_eval("str2nr(a:N)")
while t > 0 do
        t = t - 1
        a = 1
        b = 1
        c = 73
        while c > 0 do
                c = c - 1
                r = a + b
                a = b
                b = r
        end
end

print(string.format("%d", b))
EOF
endfunction
function! s:test(...) abort
        " for func in a:000
                let start = reltime()
                call call(a:1,[a:2])
                let sec = reltimefloat(reltime(start))
                echom printf('%s(%d): %.6g sec', a:1, a:2, sec)
        " endfor
endfunction

command! -nargs=+ TestFunc call s:test(<f-args>)

载入以下脚本后执行如下命令可看到测试结果:

:TestFunc Fibo 1000
:TestFunc Fibo 10000000
:TestFunc LuaFibo 1000
:TestFunc LuaFibo 10000000

本地测试结果：

Fibo(1000): 0.410364 sec
Fibo(10000000): 1470.280914 sec
LuaFibo(1000): 9.052000e-4 sec
LuaFibo(10000000): 1.235385 sec

通过以上简单的测试，可以明显看到 luajit 的速度比 Vim script 速度要快很多。随着 Neovim 对 Lua 的推崇，已经出现了很多使用 Lua 开发的插件。同时，一些知名的 Vim 插件也被使用 Lua 进行重写。 SpaceVim 中又不少内置的插件，比如flygrep、iedit、task-manager 等等。这些插件原先使用的是 Vim script，为的是兼容 Vim 和 Neovim。在最新版的 SpaceVim 中，部分插件已经使用 lua 重写了。当然了，原先的 Vim script 写的版本也保留下来了，以便于兼容 Vim。目前已经重写的插件包括：

flygrep: 实时异步代码检索，根据输入的内容，实时展示代码搜索结果。
iedit: 类似于 emacs 的 iedit-mode，提供了多光标编辑的支持。
todomanager: 项目待办事项管理

使用 Vim 作为 SSH 客户端

Mon, 10 Oct 2022 00:00:00 +0000

在 Windows 下之前一直使用 xshell 作为 ssh 客户端。自从 Neovim 和 Vim 都增加了内置终端后，于是就把 xshell 这个软解卸载了。使用 Neovim 内置的函数来实现 SSH 连接。首先，需要启用 SpaceVim 的 ssh 模块：

[[layers]]
    name = 'ssh'

模块选项

ssh_port: 设置服务器的 ssh 端口
ssh_address: 设置服务器的地址或者 ip
ssh_user: 设置默认的用户名

示例：

[[layers]]
    name = 'ssh'
    ssh_command = 'D:\Programs\Git\usr\bin\ssh.exe'
    ssh_user = 'root'
    ssh_address = '192.168.1.10'
    ssh_port = '8097'

快捷键

快捷键	功能描述
`SPC S o`	打开 ssh 窗口

安装并设置 Shadowsocks

Fri, 03 Jun 2022 00:00:00 +0000

首先需要下载 shadowsocks-rust。可以使用 curl 直接下载：

curl -fLo shadowsocks.tar.xz https://github.com/shadowsocks/shadowsocks-rust/releases/download/v1.15.0-alpha.4/shadowsocks-v1.15.0-alpha.4.x86_64-unknown-linux-gnu.tar.xz

解压：

tar -xf shadowsocks.tar.xz

解压完，在当前目录可以看到一个 ssserver 文件，添加可执行权限：

sudo chmod +x ssserver

新建配置文件 config.json

{
    "server": "my_server_ip",
    "server_port": 8388,
    "password": "mypassword",
    "method": "aes-256-gcm",
    "local_address": "127.0.0.1",
    "local_port": 1080
}

执行如下命令：

nohup ./ssserver -c config.json &

重新启用知乎账号

Fri, 20 May 2022 00:00:00 +0000

为什么注销知乎
为什么重新启用知乎

为什么注销知乎

早在 2022 年的时候，我注销了自己的知乎老账号，有很长一段时间没再使用知乎。早期知乎使用还是比较多的，上面也不少内容还是很有帮助的。但是不知道从什么时候开始，知乎每天推送的都是各种故事文字，或者推送一些容易让人产生负面情绪的内容。说到这，让我想起来以前似乎有个 Facebook 员工暴露社交平台推送的算法，似乎刻意将一些容易让人产生愤怒，或者其他反差情绪的内容。或者推送一些有争议性的话题，以引起激烈的讨论。

为什么重新启用知乎

其实，如果从文章质量上来还，知乎上面还是有很多优质内容的，只不过需要自己精心去筛选阅读。我的回答：

如何构建自己的笔记系统？

想对微博说 FUCK

Tue, 17 May 2022 00:00:00 +0000

今天下班后，回来本来想上微博看看最近有什么新鲜的事情。结果出现了这样一幕：瞬间感觉人都不好了。很多好友，历史消息都还没有任何备份。所以说，现在完全不能依赖这类所谓的社交软件。后台管理员有无限大的权限。

nvim-tree.lua 使用初体验

Mon, 09 May 2022 00:00:00 +0000

使用 Vim 有很长一段时间了，我记得最早期的时候，还是在网上看各种 Vim 配置的教程。而这些教程里面，大部分都会提到一个叫做文件树（File Explorer）的功能。文件树插件，也是我日常使用 Vim 必备的插件。刚开始接触 Vim 的时候，那时候插件还很少，只有内置的 netrw。后来接触到了 nerdtree 以及 Shougo 的vimfiler，包括 Shougo 使用 neovim remote 插件特性重写的 defx.nvim。目前，SpaceVim 已经支持了以上这些文件树插件，可以通过 filemanager 选项进行设置：

[options]
    filemanager = "nerdtree"

Neovim 这一项目目前默认支持 lua，很多插件被使用 lua 重写，文件树也不例外。最近就看到一个不错的文件树插件nvim-tree.lua，计划给 SpaceVim 也增加这个插件支持。在次之前，先体验一下这个插件到底有哪些功能：测试版本：nvim-tree.lua@9049f364 启用 nvim-tree:

[options]
    filemanager = "nvim-tree"

存在的问题

如果当前目录修改后，再使用 :NvimTreeFindFile 无法发现当前文件。
禁用默认的快捷键

尝试搜索文档和issues，最终只找到一个：Default keymaps cannot be unset。里面有一段回复：

vim.g.nvim_tree_disable_default_keybindings = 1

但是，设置后，启动就警告：

[NvimTree] Following options were moved to setup, see bit.ly/3vIpEOJ: nvim_tree_disable_default_keybindings

如何使用 SpaceVim 的 Job API

Tue, 03 May 2022 00:00:00 +0000

因为 Vim8 和 Neovim 实现的 job 函数存在很大的区别，并且使用的方式也是不一样的。在制作插件时，如果需要同时兼容 Vim 和 Neovim 就会存在很大的麻烦。因此，在 SpaceVim 中，实现了一个 job API，使用示例如下：

let  s:JOB = SpaceVim#api#import('job')
let s:command = ['echo', 'hello world']
function! s:stdout(id, data, event)
    " the data is a list of string
    for line in a:data
        echo line
    endfor
endf
call s:JOB.start(s:command, {
    \ 'on_stdout' : function('s:stdout'),
    \ }
    \ )

这个 API 的实现，参考了 neovim job 的模型。支持如下参数：

on_stdout
on_stderr
on_exit

使用 Vim 作为聊天客户端

Mon, 02 May 2022 00:00:00 +0000

目前，使用较多的聊天室是 SpaceVim 的 gitter 聊天室，但是这个平台网页访问比较慢。因此做了vim-chat，可以在 Vim/Neovim 里面快速打开聊天室进行沟通。如果有兴趣的，可以自行尝试。这个插件目前开发是在 spacevim 的主仓库，自动更新独立仓库，因此有两种使用方式。你可以在 spacevim 里启用 chat 模块，也可以单独安装vim-chat插件。

下载安装winrar，并激活去广告

Sat, 19 Feb 2022 00:00:00 +0000

下载
激活
去广告

下载

在 winrar官网（https://www.rarlab.com/download.htm）下载，并安装。

激活

在winrar目录新建rarreg.key文件，输入以下内容并保存：

RAR registration data

wncn
Unlimited Company License
UID=1b064ef8b57de3ae9b52
64122122509b52e35fd885373b214a4a64cc2fc1284b77ed14fa20
66ebfca6509f9813b32960fce6cb5ffde62890079861be57638717
7131ced835ed65cc743d9777f2ea71a8e32c7e593cf66794343565
b41bcf56929486b8bcdac33d50ecf7739960627351a9ef03353a0e
592b327cd80645472f0ee622d1915028a9e05298e593db36384f0f
f46afd5fed9b0bd095d1788266b81494b976f78fb1c551ca60a054
b17ad853ab902058b42c6887e1b3d40e0b45abf37de02106056887

去广告

下载 ResourceHacker.exe, 运行该工具打开winrar安装目录内的winrar.exe文件：
定位到String Table（字符串）

定位并打开80：2052

删除1277所在整行，点击运行，然后保存。

在 SpaceVim 中启自动保存

Sun, 06 Feb 2022 00:00:00 +0000

前因
基本配置

使用 Vim 有一段时间了，SpaceVim 也陆续出了好几个版本。自动保存这个功能一直没有加上，其实并不是没有这个需求，而是没有找到合适的逻辑去实现。最新版SpaceVim新增了自动保存的功能，当然这一功能默认是关闭的。下面来简单介绍一下如何启用自动保存功能。

前因

再使用Vim编辑代码时，经常会出现无意间关闭了Vim，或者各种插件问题导致Vim不能正常工作。忘记保存文件而导致文件编辑内容丢失。不知道大家有没有遇到过，我自己时遇到过好多次。最近，刚刚用上win11，发现office左上角自带了一个自动保存按钮。突然脑洞大开，是时候给SpaceVim也增加这一功能了。再网上搜索了vim自动保存，发现有不少的插件提供这一功能，总的来说有如下两种逻辑： 1、将文件定期保存到指定的备份文件夹，比如~/.vim/backup 2、定期执行:w命令。我更倾向于后者。

基本配置

自动保存功能，包含在edit模块里面，可以通过如下配置进行设置：

[[layers]]
    name = 'edit'
    autosave_timeout = 300000
    autosave_events = ['InsertLeave', 'TextChanged']
    autosave_all_buffers = false

目前 edit 模块支持如下配置选项：

autosave_timeout: 设置自动保存的时间间隔，默认是0，表示未开启定时自动保存。这个选项设定的值需要是毫秒数，并且需要小于100*60*1000 (100 分钟) 且大于1000（1分钟）。比如设定成每隔5分钟自动保存一次：
```
[[layers]]
  name = 'edit'
  autosave_timeout = 300000
```
autosave_events: 设定自动保存依赖的Vim事件，默认是空表。比如需要在离开插入模式时或者内容改变时自动保存：
```
[[layers]]
  name = 'edit'
  autosave_events = ['InsertLeave', 'TextChanged']
```
autosave_all_buffers: 设定是否需要保存所有文件，默认是只保存当前编辑的文件，如果该选项设定成true则保存所有文件。
```
[[layers]]
  name = 'edit'
  autosave_all_buffers = true
```
autosave_location: 设定保存文件的位置，默认为空，表示保存为原始路径。也可以设定成一个备份文件夹，自动保存的文件保存到指定的备份文件夹里面，而不修改原始文件。
```
[[layers]]
  name = 'edit'
  autosave_location = '~/.cache/backup/'
```

Window 7 下安装 nodejs

Sat, 02 Oct 2021 00:00:00 +0000

安装 nodejs

安装 nodejs

在 Windows 下使用 scoop install nodejs 后，发现安装的是 nodejs16，运行提示：

无法定位程序输入点GetHostNameW于动态链接库WS2_32.dll上。

估计是版本太新，系统不兼容，尝试 scoop uninstall nodejs 和 scoop install nodejs-lst，之后运行还是这鬼样子。google搜了一圈，没找到合适的解释。直接：

scoop uninstall nodejs-lst
scoop install nodejs11

配置 zig 的 Vim 开发环境

Sun, 03 Jan 2021 00:00:00 +0000

安装zig语言
基本运行
语言语法
代码格式化

安装zig语言

我使用的是 Win7 操作系统，从官网下载最新版 zig-windows-x86_64-0.7.1+dfacac916.zip，解压后，发现： zig 目录下只有一个 zig.exe 命令，没有其他的了，这就简单了，直接把这个目录加 PATH 就行，因为我使用的是 SpaceVim，不需要修改系统环境变量，直接载入 lang#zig 模块。

[[layers]]
    name = 'lang#zig'

在启动函数加一句：

let $PATH .= ';D:\zig'

完成以上的步骤，基本上可以在 Vim 里面使用 zig 语言相关命令了。

基本运行

在 SpaceVim 里面，运行当前 zig 文件的快捷键是 SPC l r，这个快捷键实际上是异步运行 zig run 加上当前文件名。第一次运行，发现时间是9秒，不知道为什么会这么慢，但是后来的时间都是 0.14 秒左右，可能跟我的电脑有关，比较老了。

语言语法

基本环境搭建好了，那么就是开始学习基本语法了，瞅了一眼官方文档，发现有一些内容跟 rust 很像，不过总体来说，感觉语法还是有点复杂。

代码格式化

zig 命令提供了一个 zig fmt 的子命令，想测试下如何格式化代码，执行直接报错，zig run 没问题：这种奇葩问题不该只有我一个人遇到吧，于是谷歌搜了一波，发现两个 github 的 issue：#725，#4605 Github issue 已开，等坑被填了再来试试： #7654

字符串编辑距离算法

Tue, 24 Mar 2020 00:00:00 +0000

代码实现
- 参考资料

代码实现

fn get_distance(s1: String, s2: String) -> i32 {
    let chars1 = s1.chars().collect::<Vec<char>>();
    let chars2 = s2.chars().collect::<Vec<char>>();
    let len1 = s1.chars().count();
    let len2 = s2.chars().count();
    let mut d = vec![vec![0i32; len1 + 1]; len2 + 1];
    for i in  0 .. len1 {
        d[i][0] = i as i32;
    }
    for i in  0 .. len2 {
        d[0][i] = i as i32;
    }
    for i in 1 .. len1 + 1 {
        for j in 1 .. len2 + 1 {
            let mut cost = 1;
            if chars1[i-1] == chars2[j-1] {
                cost = 0;
            }
            let delete = d[i-1][j] + 1;
            let insert = d[i][j-1] + 1;
            let substitution = d[i-1][j-1] + cost;
            d[i][j] = min(delete, insert, substitution);

        }
    }
    d[len1][len2]
}
fn min(d: i32, i: i32, s: i32) -> i32 {
    let temp = if d > i { i } else { d };
    if s < temp {
        s
    } else {
        temp
    }
}

pub fn main() {
    println!("{}", get_distance("wsdjeg".to_string(), "wdsjgh".to_string()));
}

参考资料

编辑距离 Edit distance

Rust 模块与项目文件组织

Sun, 22 Mar 2020 00:00:00 +0000

什么是模块
引入文件
- 同级目录相互访问
- 引用本地crate
参考文章

什么是模块

刚开始接触Rust的时候很多示例代码都是单文件的，随着学习的深入，单个文件里面的代码量越来越大。此时就需要将单个文件拆分成多个文件。Rust里面关键字mod可以用来定义一个模块，或者载入一个模块文件。

引入文件

假定，我们拥有如下文件结构：

rustmod
├── Cargo.toml
└── src
    └── main.rs

此时，新建一个文件src/util.rs，加入如下内容：

pub fn hello_mod() {
    println!("{}", "hello mod");
}

此时，就可以在main.rs内使用mod util引入util.rs文件了：

mod util;
fn main() {
    util::hello_mod();
}

以上代码块，使用mod util;载入模块文件，同时在main函数里调用util::hello_mod()函数，需要说明的是，该函数需要使用pub 关键字进行申明。

同级目录相互访问

rustmod
├── Cargo.toml
└── src
    ├── main.rs
    ├── function.rs
    └── util.rs

比如，在编写 function.rs 内代码时，偶尔需要使用到uril.rs里面一些常用的工具函数，该如何操作呢？

// rustmod/src/function.rs
use crate::util;
fn hello_function() {
    util::hello_mod();
}

引用本地crate

假定有如下目录结构：

rustmod
├── Cargo.toml
└── src
    ├── main.rs
    ├── function.rs
    └── util.rs
xxx
├── Cargo.toml
└── src
    └── lib.rs

修改rustmod/Cargo.toml：

[package]
name = "testmod"
version = "0.1.0"
authors = ["Shidong Wang"]
edition = "2018"

[dependencies]
xxx = {path= "../xxx" }

此时，就可以在rustmod/src/main.rs内通过extern crate xxx;来引入xxx，修改main.rs：

extern crate xxx;
use xxx::xxx_func;
fn main() {
    xxx_func();
}

参考文章

Rust 读取标准输入

Tue, 17 Mar 2020 00:00:00 +0000

起因
基本实现
参考资料

起因

在写一个 rust 小工具，需要通过参数读取文件内容，以往使用的一些工具，除了支持通过参数读取指定文件内容之外，还支持读取 stdin。比如：

cat test.py | python
python test.py

基本实现

use std::io::{self, BufRead};

fn main() {
    let stdin = io::stdin();
    for line in stdin.lock().lines() {
        println!("{}", line.unwrap());
    }
}

参考资料

How can I read a single line from stdin?

Rust 字符串算法

Sun, 15 Mar 2020 00:00:00 +0000

在搜索 Rust 相关资料，无意间看到 v2ex 上面的一些字符串相关的问题，于是使用 rust 来测试下。

第 1 期: 前端算法精选-字符串系列

题目给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。

示例 1：

输入: “abcabcbb” 输出: 3 解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3

示例 2：

输入: “bbbbb” 输出: 1 解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。

示例 3：

输入: “pwwkew” 输出: 3 解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。请注意，你的答案必须是子串的长度，”pwke” 是一个子序列，不是子串。

pub fn main() {
    println!("{}", find_longest("aaaa"));
}

fn find_longest(st: &str) -> i32 {
    let mut i = 1;
    let mut rst = 1;
    let mut temp: String = String::new();
    for c in st.chars() {
        if temp.contains(c) {
            i = 1;
            temp.clear();
            temp.push(c);
        } else {
            i += 1;
            temp.push(c);
        }
        if i > rst {
            rst = i;
        }
    }
    rst - 1
}

Vim 字典补全插件

Sat, 14 Mar 2020 00:00:00 +0000

起因
简单实现
命令行工具

起因

因为需要书写一些英文文档，有些英文单词太长，因此需要一个英文单词补全工具。之前在 Linux 系统下面使用了 look 命令，和 noco-look 插件。但是换到 Windows 下之后，发现居然没有 look 这个命令。恰巧，最近在学习 rust，于是就用 rust 简单写了一个字典补全的 Vim 插件：vim-async-dict

简单实现

因为现有的工具已经非常齐全了，因此并未从头实现，补全框架使用的是 deoplete，只需要新建一个 dict source：

from os.path import expanduser, expandvars
import re
import subprocess
from .base import Base

class Source(Base):
    def __init__(self, vim):
        Base.__init__(self, vim)

        self.name = 'dict'
        self.mark = '[D]'
        self.min_pattern_length = 3

命令行工具

有了 source 之后，需要在新建一个命令行工具，接受 2 个参数，查询词和字典文件路径：

impl Config {
    #[allow(dead_code)]
    fn new(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("not enough arguments");
        }
        let query = args[1].clone();
        let filename = args[2].clone();
        Ok(Config { query, filename })
    }
}

rust 格式化整理

Sat, 07 Mar 2020 00:00:00 +0000

基本用法
进制转换
对齐方式

基本用法

pub fn main() {
    println!("{}", "ssss");
}

进制转换

pub fn main() {
    println!("{}", 1); // 默认用法,打印Display
    println!("{:o}", 9); // 八进制
    println!("{:x}", 255); // 十六进制 小写
    println!("{:X}", 255); // 十六进制 大写
    println!("{:p}", &0); // 指针
    println!("{:b}", 15); // 二进制
    println!("{:e}", 10000f32); // 科学计数(小写)
    println!("{:E}", 10000f32); // 科学计数(大写)

    println!("{:?}", "test"); // 打印Debug
    println!("{:#?}", ("test1", "test2")); // 带换行和缩进的Debug打印

    println!("{a} {b} {b}", a = "x", b = "y"); // 命名参数
}

对齐方式

>: 右对齐
<: 左对齐
^: 居中对齐

pub fn main() {
    // @question 关于字符串对齐
    println!("{0:>0w$}", 9, w=6); // 八进制
}

format_string := <text> [ format <text> ] *
format := '{' [ argument ] [ ':' format_spec ] '}'
argument := integer | identifier

format_spec := [[fill]align][sign]['#'][0][width]['.' precision][type]
fill := character
align := '<' | '^' | '>'
sign := '+' | '-'
width := count
precision := count | '*'
type := identifier | ''
count := parameter | integer
parameter := integer '$'

开始学习 Rust

Sun, 01 Mar 2020 00:00:00 +0000

写在前面
1. 第一个程序
2. 基本语法
3. 其他数据类型
4 错误处理
- 4.1 不可恢复错误 panic!
- 4.2 可恢复错误 Result
5 包、crate和模块
- 5.1 包和 crate
- 5.2 模块
6 测试
- 6.1 单元测试(unit tests)
- 6.2 集成测试(integration tests)
7 生命周期

写在前面

rust 这门语言刚出来时，非常火，当时还没有中文的教程，官方仅有的一篇英文教程和examples。于是对着英文教程，靠着自己蹩脚的英语啃了一遍。但是过了这么久，并且期间没在使用这门语言，已经基本忘记了，唯一记得的就是 rust 里面提出了一个叫做“借”的概念，当时被绕了很久。 rust的安装非常简单，在windows下，只需要下载 rustup-init.exe 后运行安装即可。

1. 第一个程序

main.rs:

fn main() {
    println!("Hello, world!");
}

运行非常简单，使用rustc main.rs即可编译出一个可执行运行文件。 println 的一些用法：

fn main() {
    println!("{}, {}!", "Hello", "world"); // Hello, world!
    println!("{0}, {1}!", "Hello", "world"); // Hello, world!
    println!("{greeting}, {name}!", greeting="Hello", name="world"); // Hello, world!
    
    let y = String::from("Hello, ") + "world!";
    println!("{}", y); // Hello, world!
}

2. 基本语法

2.1 注释

rust 的注释有两种，单行注释，和快注释：

fn main() {
    // 单行注释
    println!("hello"); // 行尾注释
    /*
    块注释
    */
}

2.2 变量

rust 中包括局部变量和全局变量，默认都是局部变量，并且都是不可变变量，可以使用 mut 标记为可变变量。

局部变量

let a; // 声明变量，但并不赋值
let b = true; // 声明 bool 变量，并赋值
let c: bool = true;
let (x, y) = (1, 2);
a = 122;

let mut d = 1;
d = 20;

全局变量

rust中使用static关键字申明全局变量，全局变量的生命周期是整个程序，必须显式标明类型，不支持类型推导；

// 不可变静态变量
static N: i32 = 64;

// 可变静态变量
static mut M: i32 = 10;

常量

常量的申明使用const，和全局变量一样，生命周期也是整个程序。

const N: i32 = 10;

2.3 函数

函数使用fn来申明，例如：

fn test_func() {
    println!("hi");
}

函数的参数需要指定类型，例如：

fn test_func(a: i32, b: i32) {
    println!("the sum is:{}", a + b);
}

函数的返回值默认是()，如果需要有返回值，需要在函数签名里使用->指定：

fn test_func(a: i32, b: i32) -> i32 {
    println!("the sum is:{}", a + b);
    a + b
    // 等同于 return a + b;
}

Rust 是基于表达式的语言，程序的最后一句话需要省略分号，作为返回值，当然 rust 也支持使用 return 提前返回，但是需要加上分号。 rust是一个基于表达式的语言，不过它也有语句。 rust只有两种语句：声明语句和表达式语句，其他的都是表达式。基于表达式是函数式语言的一个重要特征，表达式总是返回值。可以利用元组(tuple)返回多个值:

fn plus_one(a: i32) -> (i32, i32) {
    (a, &a + 1)
}

fn main() {
    let (add_num, result) = plus_one(10);
    println!("{} + 1 = {}", add_num, result); // 10 + 1 = 11
}

函数指针也可以作为变量使用

fn hello() {
    println!("hello world!");
}

fn main() {
    let b = hello;
    b();
}

高阶函数

Rust 还支持高阶函数 (high order function)，允许把闭包作为参数来生成新的函数：

fn add_one(x: i32) -> i32 { x + 1 }

fn apply<F>(f: F, y: i32) -> i32
    where F: Fn(i32) -> i32
{
    f(y) * y
}

fn factory(x: i32) -> Box<Fn(i32) -> i32> {
    Box::new(move |y| x + y)
}

fn main() {
    let transform: fn(i32) -> i32 = add_one;
    let f0 = add_one(2i32) * 2;
    let f1 = apply(add_one, 2);
    let f2 = apply(transform, 2);
    println!("{}, {}, {}", f0, f1, f2);

    let closure = |x: i32| x + 1;
    let c0 = closure(2i32) * 2;
    let c1 = apply(closure, 2);
    let c2 = apply(|x| x + 1, 2);
    println!("{}, {}, {}", c0, c1, c2);

    let box_fn = factory(1i32);
    let b0 = box_fn(2i32) * 2;
    let b1 = (*box_fn)(2i32) * 2;
    let b2 = (&box_fn)(2i32) * 2;
    println!("{}, {}, {}", b0, b1, b2);

    let add_num = &(*box_fn);
    let translate: &Fn(i32) -> i32 = add_num;
    let z0 = add_num(2i32) * 2;
    let z1 = apply(add_num, 2);
    let z2 = apply(translate, 2);
    println!("{}, {}, {}", z0, z1, z2);
}

where 关键字的使用

约束的trait增加后，代码看起来就变得诡异了，这时候需要使用where从句：

use std::fmt::Debug;
fn foo<T: Clone, K: Clone + Debug>(x: T, y: K) {
    x.clone();
    y.clone();
    println!("{:?}", y);
}

// where 从句
fn foo<T, K>(x: T, y: K) where T: Clone, K: Clone + Debug {
    x.clone();
    y.clone();
    println!("{:?}", y);
}

// 或者
fn foo<T, K>(x: T, y: K)
    where T: Clone,
          K: Clone + Debug {
    x.clone();
    y.clone();
    println!("{:?}", y);
}

发散函数

发散函数（diverging function）是rust中的一个特性。发散函数不返回，它使用感叹号!作为返回类型表示：

fn main() {
  println!("hello");
  diverging();
  println!("world");
}

fn diverging() -> ! {
  panic!("This function will never return");
}

2.4 基本数据类型

布尔值(bool)
字符(char)
有符号整型(i8, i16, i32, i64, i128)
无符号整型(u8, u16, u32, u64, u128)
指针大小的有符号/无符号整型(isize/usize，取决于计算机架构，32bit 的系统上，isize 等价于i32)
浮点数(f32, f64)
数组(arrays)

数组(arrays)的长度是可不变的，动态/可变长数组可以使用 Vec (非基本数据类型)。

元组(tuples)，由相同/不同类型元素构成，长度固定。

元组的长度也是不可变的，更新元组内元素的值时，需要与之前的值的类型相同。

切片(slice)，指向一段内存的指针。

切片并没有拷贝原有的数组，只是指向原有数组的一个连续部分，行为同数组。访问切片指向的数组/数据结构，可以使用&操作符。

let a: [i32; 4] = [1, 2, 3, 4];

let b: &[i32] = &a; // 全部
let c = &a[0..4]; // [0, 4)
let d = &a[..]; // 全部

let e = &a[1..3]; // [2, 3]
let e = &a[1..]; // [2, 3, 4]
let e = &a[..3]; // [1, 2, 3]

字符串(str)

在 Rust 中，str 是不可变的静态分配的一个未知长度的UTF-8字节序列。 &str 是指向该字符串的切片。

let a = "Hello, world!"; //a: &'static str
let b: &str = "你好, 世界!";
// 多行字符串
let a = "line one
line two";
// 字符串转义
let a = "line one\nline two"
// 也可以在字符串字面量前加上r来避免转义
let a = r"line one\nline two"

Rust的数组是被表示为[T;N]。其中N表示数组大小，并且这个大小一定是个编译时就能获得的整数值， T表示泛型类型，即任意类型。我们可以这么来声明和使用一个数组:

let a = [8, 9, 10];
let b: [u8;3] = [8, 6, 5];
print!("{}", a[0]);

和Golang一样，Rust的数组中的N（大小）也是类型的一部分，即[u8; 3] != [u8; 4]。这么设计是为了更安全和高效的使用内存，当然了，这会给第一次接触类似概念的人带来一点点困难，比如以下代码。

fn show(arr: [u8;3]) {
    for i in &arr {
        print!("{} ", i);
    }
}

fn main() {
    let a: [u8; 3] = [1, 2, 3];
    show(a);
    let b: [u8; 4] = [1, 2, 3, 4];
    show(b);
}

以上代码编译会报错，因为 show(b); 传入的参数类型是 [u8, 4], 但是show(arr: [u8, 3]) 这个函数签名只接受[u8,3]。因此可以使用切片（Slice），一个Slice的类型是&[T] 或者 &mut [T], 因此以上代码可以改为：

fn show(arr: &[u8]) {
    for i in arr {
        print!("{} ", i);
    }
    println!("");
}

fn main() {
    let a: [u8; 3] = [1, 2, 3];
    let slice_a = &a[..];
    show(slice_a);
    let b: [u8; 4] = [1, 2, 3, 4];
    show(&b[..]);
}

字符串切片&str指向的字符串是静态分配的，在 Rust 中，有另一个堆分配的，可变长的字符串类型String(非基本数据类型)。通常由字符串切片&str通过 to_string() 或 String::from() 方法转换得到。

let s1 = "Hello, world!".to_string();
let s2 = String::from("Hello, world!");

函数(functions)

函数指针也是基本数据类型，可以赋值给其他的变量

2.5 操作符

一元操作符

顾名思义，一元操作符是专门对一个Rust元素进行操纵的操作符，主要包括以下几个:

-: 取负，用于数值类型。
*: 解引用，这是一个很有用的符号，和Deref（DerefMut）这个trait关联密切。
!: 取反。
&和&mut: 租借，borrow。向一个owner租借其使用权，分别是租借一个只读使用权和读写使用权。

二元操作符

算数操作符

算数运算符都有对应的trait的，他们都在std::ops下：

+: 加法。实现了std::ops::Add。
-: 减法。实现了std::ops::Sub。
*: 乘法。实现了std::ops::Mul。
/: 除法。实现了std::ops::Div。
%: 取余。实现了std::ops::Rem。

// 包括: + - * / %
let a = 5;
let b = a + 1; //6
let c = a - 1; //4
let d = a * 2; //10
let e = a / 2; //2 not 2.5
let f = a % 2; //1

let g = 5.0 / 2.0; //2.5

比较运算符

比较运算符其实也是某些trait的语法糖啦，不同的是比较运算符所实现的trait只有两个std::cmp::PartialEq和std::cmp::PartialOrd

// == = != < > <= >=
let a = 1;
let b = 2;

let c = a == b; //false
let d = a != b; //true
let e = a < b; //true
let f = a > b; //false
let g = a <= a; //true
let h = a >= a; //true

let i = true > false; //true
let j = 'a' > 'A'; //true

逻辑运算符

 // ! && ||
let a = true;
let b = false;

let c = !a; //false
let d = a && b; //false
let e = a || b; //true
// rust 的逻辑运算符是惰性boolean运算符
// @question 什么是惰性boolean运算符

位运算符

和算数运算符差不多的是，位运算也有对应的trait。

&: 与操作。实现了std::ops::BitAnd。
|: 或操作。实现了std::ops::BitOr。
^: 异或。实现了std::ops::BitXor。
<<: 左移运算符。实现了std::ops::Shl。
>>: 右移运算符。实现了std::ops::Shr。

// & | ^ << >>
let a = 1;
let b = 2;

let c = a & b; //0  (01 && 10 -> 00)
let d = a | b; //3  (01 || 10 -> 11)
let e = a ^ b; //3  (01 != 10 -> 11)
let f = a << b; //4  (左移 -> '01'+'00' -> 100)
let g = a >> a; //0  (右移 -> o̶1̶ -> 0)

赋值运算符

let mut a = 2;

a += 5; //2 + 5 = 7
a -= 2; //7 - 2 = 5
a *= 5; //5 * 5 = 25
a /= 2; //25 / 2 = 12 not 12.5
a %= 5; //12 % 5 = 2

a &= 2; //10 && 10 -> 10 -> 2
a |= 5; //010 || 101 -> 111 -> 7
a ^= 2; //111 != 010 -> 101 -> 5
a <<= 1; //'101'+'0' -> 1010 -> 10
a >>= 2; //101̶0̶ -> 10 -> 2

类型转换运算符: as

let a = 15;
let b = a / 2.0; //7.5
let b = (a as f64) / 2.0; //7.5

借用(Borrowing)与解引用(Dereference)操作符

Rust 引入了所有权(Ownership)的概念，所以在引用(Reference)的基础上衍生了借用(Borrowing)的概念，所有权概念不在这里展开。简单而言，引用是为已存在变量创建一个别名；获取引用作为函数参数称为借用；解引用是与引用相反的动作，目的是返回引用指向的变量本身。

// 引用/借用： & &mut

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len); // The length of 'hello' is 5.
}

fn calculate_length(s: &String) -> usize { // 获取引用作为函数参数称为借用
    s.len()
}

// 解引用： *

fn main() {
    // 获取v的第2个元素的可变引用，并通过解引用修改该元素的值。
    let v = &mut [1, 2, 3, 4, 5];
    {
        let third  = v.get_mut(2).unwrap();
        *third += 50;
    }
    println!("v={:?}", v); // v=[1, 2, 53, 4, 5]
}

2.6 流程控制

if - else if - else

let team_size = 7;
if team_size < 5 {
    println!("Small");
} else if team_size < 10 {
    println!("Medium");
} else {
    println!("Large");
}

// 条件块中有返回值时，类型需要一致，可替代C语言的三目运算符
let is_below_eighteen = if team_size < 18 { true } else { false };

match

可替代C语言的switch case。

let tshirt_width = 20;
let tshirt_size = match tshirt_width {
    16 => "S", // check 16
    17 | 18 => "M", // check 17 and 18
    19 ... 21 => "L", // check from 19 to 21 (19,20,21)
    22 => "XL",
    _ => "Not Available",
};
println!("{}", tshirt_size); // L

_表示匹配剩下的任意情况。 match 的一些其他用法：

let num = 8;
match num {

    13 => println!("正确"),

    3|4|5|6 => println!("3 或 4 或 5 或 6" ),

    14...20 => println!("14..20"),
    // ... 表示一个范围，可以是数字， `1 ... 10` 也可以是字母 `'a' ... 'z'`

    _=> println!("不正确"),

}
let pair = (0, -2);

match pair {

    (0, y) => println!("y={}", y),

    (x, 0) => println!("x={}", x),

    _ => println!("default")

}

// 配合 if 使用
match num {

    x if x != 20 => println!("14..20"),

    _=> println!("不正确"),

}

// 后置套件

let x = 4;
let y = false;

match x {
    4 | 5 if y => println!("yes"),
    _ => println!("no"),
}

// 绑定变量

match num {

    13 => println!("正确"),

    3|4|5|6 => println!("3 或 4 或 5 或 6" ),

    n @ 14...20 => println!("{}", n),

    _=> println!("不正确"),

}

while

let mut a = 1;
while a <= 10 {
	println!("Current value : {}", a);
	a += 1; // Rust不支持++/--自增自减语法
}

loop

相当于 while true

let mut a = 0;
loop {
	if a == 0 {
        println!("Skip Value : {}", a);
        a += 1;
        continue;
	} else if a == 2 {
	    println!("Break At : {}", a);
        break;
    }
	println!("Current Value : {}", a);
	a += 1;
}

// Skip Value : 0
// Current Value : 1
// Break At : 2

for a in 0..10 { //(a = 0; a <10; a++)
    println!("Current value : {}", a);
}

'outer_for: for c1 in 1..6 { //set label outer_for
    'inner_for: for c2 in 1..6 {
        println!("Current Value : [{}][{}]", c1, c2);
        if c1 == 2 && c2 == 2 { break 'outer_for; } // 结束外层循环
    }
}

let group : [&str; 4] = ["Mark", "Larry", "Bill", "Steve"];
for person in group.iter() {
    println!("Current Person : {}", person);
}

在 for 表达式中的break ‘outer_for，loop 和 while 也有相同的使用方式。

3. 其他数据类型

3.1 结构体(struct)

和元组(tuple)一样，结构体(struct)支持组合不同的数据类型，但不同于元组，结构体需要给每一部分数据命名以标志其含义。因而结构体比元组更加灵活，不依赖顺序来指定或访问实例中的值。定义结构体

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

创建实例

let user1 = User {
    email: String::from("someone@example.com"),
    username: String::from("someusername123"),
    active: true,
    sign_in_count: 1,
};

修改某个字段的值

let mut user1 = User {
    email: String::from("someone@example.com"),
    username: String::from("someusername123"),
    active: true,
    sign_in_count: 1,
};

user1.email = String::from("anotheremail@example.com");

变量与字段名同名的简写语法

fn build_user(email: String, username: String) -> User {
    User {
        email,
        username,
        active: true,
        sign_in_count: 1,
    }
}

元组结构体(tuple structs)

元组结构体有着结构体名称提供的含义，但没有具体的字段名。在参数个数较少时，无字段名称，仅靠下标也有很强的语义时，为每个字段命名就显得多余了。例如：

struct Color(i32, i32, i32);
struct Point(i32, i32);

let black = Color(0, 0, 0);
let origin = Point(3, 4);

struct Point {
    x: i32
    y: i32
}
let origin = Point {
    x: 3
    y: 4
}

3.2 枚举

定义枚举

enum IpAddrKind {
    V4,
    V6,
}

使用枚举值

let four = IpAddrKind::V4;

fn route(ip_type: IpAddrKind) { }
route(four);
route(IpAddrKind::V6);

枚举成员关联数据

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

let home = IpAddr::V4(127, 0, 0, 1);

let loopback = IpAddr::V6(String::from("::1"));

更复杂的例子

enum Message {
    Quit, //  不关联数据
    Move { x: i32, y: i32 }, // 匿名结构体
    Write(String),
    ChangeColor(i32, i32, i32),
}

match 控制流

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}


fn value_in_cents(coin: Coin) -> u32 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        },
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

Option

Option是标准库中定义的一个非常重要的枚举类型。Option 类型应用广泛因为它编码了一个非常普遍的场景，即一个值要么有值要么没值。对Rust而言，变量在使用前必须要赋予一个有效的值，所以不存在空值(Null)，因此在使用任意类型的变量时，编译器确保它总是有一个有效的值，可以自信使用而无需做任何检查。如果一个值可能为空，需要显示地使用Option来表示。 Option 的定义如下：

pub enum Option<T> {
    Some(T),
    None,
}

Option包含2个枚举项： 1) None，表明失败或没有值 2) Some(value)，元组结构体，封装了一个 T 类型的值 value 得益于Option，Rust 不允许一个可能存在空值的值，像一个正常的有效值那样工作，在编译时就能够检查出来。Rust显得更加安全，不用担心出现其他语言运行时才会出现的空指针异常的bug。例如：

let x: i8 = 5; // Rust 没有空值(Null)，因此 i8只能被赋予一个有效值。
let y: Option<i8> = Some(5); // y 可能为空，需要显示地表示为枚举类型 Option
let sum = x + y;

尝试将不可能出现无效值的 x:i8 与可能出现无效值的y: Option 相加时，编译器会报错：

error[E0277]: the trait bound `i8: std::ops::Add<std::option::Option<i8>>` is
not satisfied
 -->
  |
5 |     let sum = x + y;
  |                 ^ no implementation for `i8 + std::option::Option<i8>`
  |

总结一下，如果一个值可能为空，必须使用枚举类型Option，否则必须赋予有效值。而为了使用Option，需要编写处理每个成员的代码，当T 为有效值时，才能够从 Some(T) 中取出 T 的值来使用，如果 T 为无效值，可以进行其他的处理，通常使用 match 来处理这种情况。例如，当y为有效值时，返回x和y的和；为空值时，返回x。

fn plus(x: i8, y: Option<i8>) -> i8 {
    match y {
        None => x,
        Some(i) => x + i,
    }
}

fn main() {
    let y1: Option<i8> = Some(5);
    let y2: Option<i8> = None;
    
    let z1 = plus(10, y1);
    let z2 = plus(10, y2);
    
    println!("z1={}, z2={}", z1, z2); // z1=15, z2=10
}

if let 控制流

match 还有一种简单场景，可以简写为 if let。如下，y有值时，打印和，y无值时，啥事也不做。

fn plus(x: i8, y: Option<i8>) {
    match y {
        Some(i) => { println!("x + y = {}", x + i) },
        None => {},
    }
}

fn main() {
    let y1: Option<i8> = Some(5);
    let y2: Option<i8> = None;
    
    plus(10, y1); // x + y = 15
    plus(10, y2);
}

简写为 if let，则是

fn plus(x: i8, y: Option<i8>) {
    if let Some(i) = y {
        println!("x + y = {}", x + i);
    }
}

如果只使用 if 呢？

fn plus(x: i8, y: Option<i8>) {
    if y.is_some() {
        let i = y.unwrap(); // 获得 Some 中的 T 值。
        println!("x + y = {}", x + i);
    }
}

if let 语句也可以包含 else。

fn plus(x: i8, y: Option<i8>) {
    if let Some(i) = y {
        println!("x + y = {}", x + i);
    } else {
        println!("y is None");
    }
}

// 等价于

fn plus(x: i8, y: Option<i8>) {
    match y {
        Some(i) => { println!("x + y = {}", x + i) },
        None => { println!("y is None") },
    }
}

3.3 实现方法和接口(impl & trait)

实现方法(impl)

Rust 通过关键字 impl 在 struct、enum 或者trait 上实现方法。关联函数 (associated function) 的第一个参数通常为self参数，有3种变体：

self: 允许实现者移动和修改对象，对应的闭包特性为FnOnce。
&self: 既不允许实现者移动对象也不允许修改，对应的闭包特性为Fn。
&mut self: 允许实现者修改对象但不允许移动，对应的闭包特性为FnMut。

不含self参数的关联函数称为静态方法 (static method)。

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

impl Rectangle {
    fn square(size: u32) -> Rectangle {
        Rectangle { width: size, height: size }
    }
}


fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };
    let rect2 = Rectangle::square(10);

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
    println!(
        "The area of the rectangle is {} square pixels.",
        rect2.area()
    );
}

与结构体一样，枚举中的元素默认不能使用关系运算符进行比较 (如==, !=, >=)，也不支持像+和*这样的双目运算符，需要自己实现，或者使用match进行匹配。类似于 lua 里面的 metatables，可以通过实现一些借口函数来实现自定义结构体的运算：

struct User {
    name:String,
    age:i32,
}
impl Eq for User {
    fn eq(&self, other: User) -> bool {
        self.age == other.age
    }
}

枚举默认也是私有的，如果使用pub使其变为公有，则它的元素也都是默认公有的。这一点是与结构体不同的：即使结构体是公有的，它的域仍然是默认私有的。这里的共有/私有仍然是针对其定义所在的模块之外。此外，枚举和结构体也可以是递归的 (recursive)。例如我们可以提供一个关联函数，它接受一个维度参数并且同时作为宽和高，这样可以更轻松的创建一个正方形 Rectangle 而不必指定两次同样的值：

实现接口(trait)

trait Summary {
    fn summarize(&self) -> String;
}

impl Summary for Rectangle {
    fn summarize(&self) -> String {
        format!("{width={}, height={}}", self.width, self.height)
    }
}

// 接口也支持继承
trait Person {
    fn full_name(&self) -> String;
}

trait Employee : Person { //Employee inherit from person trait
    fn job_title(&self) -> String;
}

trait Expat {
    fn salary(&self) -> f32
}

trait ExpatEmployee : Employee + Expat { // 多继承，同时继承 Employee 和 Expat
    fn additional_tax(&self) -> f64;
}

定义在特性中的方法称为默认方法 (default method)，可以被该特性的实现覆盖。此外，特性之间也可以存在继承 (inheritance)：

trait Foo {
    fn foo(&self);

    // default method
    fn bar(&self) { println!("We called bar."); }
}

// inheritance
trait FooBar : Foo {
    fn foobar(&self);
}

struct Baz;

impl Foo for Baz {
    fn foo(&self) { println!("foo"); }
}

impl FooBar for Baz {
    fn foobar(&self) { println!("foobar"); }
}

如果两个不同特性的方法具有相同的名称，可以使用通用函数调用语法 (universal function call syntax)：关于实现特性的几条限制：

如果一个特性不在当前作用域内，它就不能被实现。
不管是特性还是impl，都只能在当前的包装箱内起作用。
带有特性约束的泛型函数使用单态化实现 (monomorphization)，所以它是静态派分的 (statically dispatched)。
impl Trait

在版本1.26 开始，Rust提供了impl Trait的写法，作为和Scala 对等的既存型别(Existential Type)的写法。在下面这个写法中，fn foo()将返回一个实作了Trait的trait。

//before
fn foo() -> Box<Trait> {
    // ...
}

//after
fn foo() -> impl Trait {
    // ...
}

相较于1.25 版本以前的写法，新的写法会在很多场合中更有利于开发和执行效率。 impl Trait 的普遍用例

trait Trait {
    fn method(&self);
}

impl Trait for i32 {
    // implementation goes here
}

impl Trait for f32 {
    // implementation goes here
}

利用Box 会意味：即便回传的内容是固定的，但也会使用到动态内存分配。利用impl Trait 的写法可以避免便用Box。

//before
fn foo() -> Box<Trait> {
    Box::new(5) as Box<Trait>
}

//after
fn foo() -> impl Trait {
    5
}

其他受益的用例闭包:

// before
fn foo() -> Box<Fn(i32) -> i32> {
    Box::new(|x| x + 1)
}

// after
fn foo() -> impl Fn(i32) -> i32 {
    |x| x + 1
}

传参：

// before
fn foo<T: Trait>(x: T) {

// after
fn foo(x: impl Trait) {

3.4 泛型(Generics)

当我们实现一个函数或者数据结构时，往往希望参数可以支持不同的类型，泛型可以解决这个问题。声明参数类型时，换成大写的字母，例如字母 T，同时使用告诉编译器 T 是泛型。函数中使用泛型

fn largest<T>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

结构体使用泛型

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

枚举使用泛型

enum Option<T> {
    Some(T),
    None,
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Result 枚举有两个泛型类型，T 和 E。Result 有两个成员：Ok，它存放一个类型 T 的值，而 Err 则存放一个类型 E 的值。这个定义使得 Result 枚举能很方便的表达任何可能成功（返回 T 类型的值）也可能失败（返回 E 类型的值）的操作。回忆一下示例 9-3 中打开一个文件的场景：当文件被成功打开 T 被放入了 std::fs::File 类型而当打开文件出现问题时 E 被放入了 std::io::Error 类型。方法中使用泛型

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

3.5 常见集合 Vec

新建

let v: Vec<i32> = Vec::new();  // 空集合
// let v = vec![1, 2, 3];  // 含初始值的集合，vec!是为方便初始化Vec提供的宏。

println!("第三个元素 {}", &v[2]); // 3
println!("第100个元素 {}", &v[100]); // panic error

assert_eq!(v.get(2), Some(&3));
assert_eq!(v.get(100), None);

v.get(2) 和 &v[2] 都能获取到 Vec 的值，区别在于 &v[2] 返回的是该元素的引用，引用一个不存在的位置，会引发错误。v.get(2) 返回的是枚举类型 Option<&T>。 v.get(2) 返回的是 Some(&3)，v.get(100) 返回的是 None。

更新

let v: Vec<i32> = Vec::new();
v.push(5);
v.push(6);
v.push(7);
v.push(8);
v.pop() //删除最后一个元素

遍历

let v = vec![100, 32, 57];
for i in &v {
    println!("{}", i);
}

let mut v2 = vec![100, 32, 57];
for i in &mut v2 {
    *i += 50;
}

if let 控制流

如果我们想修改Vec中第2个元素的值呢？可以这么写：

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];
    {
        let third  = v.get_mut(2).unwrap();
        *third += 50;
    }
    println!("v={:?}", v); // v=[1, 2, 53, 4, 5]
}

因为 v.get_mut() 的返回值是Option枚举类型，那么可以使用if let来简化代码。

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];
    if let Some(third) = v.get_mut(2) {
        *third += 50;
    }
    println!("v={:?}", v); // v=[1, 2, 53, 4, 5]
}

while let 控制流

if let可以用于单个元素的场景，while let就适用于遍历的场景了。

let mut stack = vec![1, 2, 3, 4, 5];
while let Some(top) = stack.pop() {
    println!("{}", top); // 依次打印 5 4 3 2 1
}

对于一个可变数组，Rust提供了一种简单的遍历形式—— for 循环。我们可以获得一个数组的引用、可变引用、所有权。

let v = vec![1, 2, 3];
for i in &v { .. } // 获得引用
for i in &mut v { .. } // 获得可变引用
for i in v { .. } // 获得所有权，注意此时Vec的属主将会被转移！！
// @question 为什么说使用for容易造成嵌套循环

但是，这么写很容易出现多层for循环嵌套，因此，Vec提供了一个into_iter()方法，能显式地将自己转换成一个迭代器。

3.6 常见集合 String

Rust 的核心语言中只有一种字符串类型：str，字符串切片，它通常以被借用的形式出现，&str。这里提到的字符串，是字节的集合，外加一些常用方法实现。因为是集合，增持增删改，长度也可变。

新建

let mut s1 = String::new();
let s2 = "initial contents".to_string();
let s3 = String::new();

更新

let mut s = String::from("foo");
s.push_str("bar"); // 附加字符串
s.push('!') // 附加单字符
assert_eq!(s.remove(0), 'f'); // 删除某个位置的字符

let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2;

format

let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");

let s = format!("{}-{}-{}", s1, s2, s3);
println!("{}", s); // tic-tac-toe

索引

let v = String::from("hello");
assert_eq!(Some('h'), v.chars().nth(0));

遍历

let v = String::from("hello");
for c in v.chars() {
    println!("{}", c);
}

在Rust内部，String 是一个 Vec 的封装，但是有些字符可能会占用超过2个字符，所以String不支持直接索引，如果需要索引需要使用 chars() 转换后再使用。

3.7 常见集合 HashMap

新建

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

这里使用了use引入了HashMap结构体。

访问

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

let team_name = String::from("Blue");
let score = scores.get(&team_name);

更新

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10); // 10
scores.insert(String::from("Blue"), 25); // 25
// Blue 存在则不更新，不存在则更新，因此scores['Blue'] 仍为 25
scores.entry(String::from("Blue")).or_insert(50);

4 错误处理

4.1 不可恢复错误 panic!

Rust 有 panic!宏。当执行这个宏时，程序会打印出一个错误信息，展开并清理栈数据，然后接着退出。出现这种场景，一般是出现了一些不知如何处理的场景。

直接调用

fn main() {
    panic!("crash and burn");
}

执行 cargo run 将打印出

$ cargo run
Compiling tutu v0.1.0 (/xxx/demo/tutu)
    Finished dev [unoptimized + debuginfo] target(s) in 0.28s
     Running `target/debug/tutu`
thread 'main' panicked at 'crash and burn', src/main.rs:2:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

最后2行包含了 panic!导致的报错信息，第1行是源码中 panic! 出现的位置 src/main.rs:2:5

代码bug引起的错误

fn main() {
    let v = vec![1, 2, 3];

    v[99]; // 越界
}

和之前一样，cargo run 的报错信息只有2行，缺少函数的调用栈，为了便于定位问题，可以设置 RUST_BACKTRACE 环境变量来获得更多的调用栈信息，Rust 中称之为backtrace。通过backtrace，可以看到执行到目前位置所有被调用的函数的列表。例如执行 RUST_BACKTRACE=1 cargo run，这种方式的好处在于，环境变量只作用于当前命令。

$ RUST_BACKTRACE=1 cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/tutu`
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', /rustc/xxx/src/libcore/slice/mod.rs:2717:10
stack backtrace:
   0: backtrace::backtrace::libunwind::trace
             at /cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.37/src/backtrace/libunwind.rs:88
  ...
  17: <alloc::vec::Vec<T> as core::ops::index::Index<I>>::index
             at /rustc/xxx/src/liballoc/vec.rs:1796
  18: tutu::main
             at src/main.rs:4
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

第一行的报错信息，说明了错误的原因，长度越界。紧接着打印出了函数调用栈， src/main.rs:4 -> liballoc/vec.rs:1796 -> … 在windows下，可以执行 set RUST_BACKTRACE=1 && cargo run。

release

当出现 panic 时，程序默认会开始展开（unwinding），这意味着 Rust 会回溯栈并清理它遇到的每一个函数的数据，不过这个回溯并清理的过程有很多工作。另一种选择是直接终止（abort），这会不清理数据就退出程序。那么程序所使用的内存需要由操作系统来清理。 release模式下，希望程序越小越好，可以在Cargo.toml中设置 panic 为 abort。

[profile.release]
panic = "abort"

4.2 可恢复错误 Result

处理 Result

有些错误，希望能够捕获并且做相应的处理，Rust 提供了 Result 机制来处理可恢复错误，类似于其他语言中的try catch。这是 Result<T, E>的定义

enum Result<T, E> {
    Ok(T),
    Err(E),
}

有些函数会返回Result，那怎么知道一个函数的返回对象是不是Result呢？很简单！

fn main(){
    let f: u32 = File::create("hello.txt");
}

当我们编译上面的代码时，将会报错。

= note: expected type `u32`
            found type `std::result::Result<std::fs::File, std::io::Error>`

从报错信息可以看出，File::create 返回的是一个Result<fs::File. io::Error>对象，如果没有异常，我们可以从Result::Ok获取到文件句柄。下面是一个完整的示例，创建 hello.txt 文件，并尝试写入 “Hello, world!”。

use std::fs::File;
use std::io::prelude::*;

fn main() {
    let f = File::create("hello.txt");

    let mut file = match f {
        Ok(file) => file,
        Err(error) => {
            panic!("Problem create the file: {:?}", error)
        },
    };
    match file.write_all(b"Hello, world!") {
        Ok(()) => {},
        Err(error) => {
            panic!("Failed to write: {:?}", error)
        }
    };
}

如果执行成功，可以看到在工程根目录下，多出了 hello.txt 文件。

unwrap 和 expect

Result 的处理有时太过于繁琐，Rust 提供了一种简洁的处理方式 unwrap 。即，如果成功，直接返回 Result::Ok 中的值，如果失败，则直接调用 !panic，程序结束。

let f = File::open("hello.txt").unwrap(); // 若成功，f则被赋值为文件句柄，失败则结束。

expect 是更人性化的处理方式，允许在调用!panic时，返回自定义的提示信息，对调试很有帮助。

let f = File::open("hello.txt").expect("Failed to open hello.txt");

返回 Result

我们可以实现类似于 File::open 这样的函数，让调用者能够自主绝对如何处理成功/失败的场景。

use std::io;
use std::io::Read;
use std::fs::File;

fn read_username_from_file() -> Result<String, io::Error> {
    let f = File::open("hello.txt");

    let mut f = match f {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut s = String::new();

    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e),
    }
}

上面的函数如果成功，则返回 hello.txt 的文本字符串，失败，则返回 io::Error。更简单的实现方式

use std::io;
use std::io::Read;
use std::fs::File;

fn read_username_from_file() -> Result<String, io::Error> {
    let mut f = File::open("hello.txt")?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

这种写法使用了?运算符向调用者返回错误。作用是：如果 Result 的值是 Ok，则该表达式返回 Ok 中的值且程序继续执行。如果值是 Error ，则将 Error 的值作为整个函数的返回值，好像使用了 return 关键字一样。这样写，逻辑更为清晰。

5 包、crate和模块

5.1 包和 crate

.
├── Cargo.lock
├── Cargo.toml
├── benches
│   └── large-input.rs
├── examples
│   └── simple.rs
├── src
│   ├── bin
│   │   └── another_executable.rs
│   ├── lib.rs
│   └── main.rs
└── tests
    └── some-integration-tests.rs

一个 Cargo 项目即一个包(Package)，一个包至少包含一个crate；可以包含零个或多个二进制crate（binary crate），但只能包含一个库crate(library crate)。 src/main.rs 是与包名同名的二进制 crate 的根，其他的二进制 crate 的根放置在 src/bin 目录下； src/lib.rs 是与包名同名的库 crate 的根。

5.2 模块

模块让我们可以将一个 crate 中的代码进行分组，以提高可读性与重用性。即项是可以被外部代码使用的（public），还是作为一个内部实现的内容，不能被外部代码使用（private）。

声明模块

Rust中使用mod来声明模块，模块允许嵌套，可以使用模块名作为路径使用，例如：

// src/main.rs

mod math {
    mod basic {
        fn plus(x: i32, y: i32) -> i32 { x + y}
        fn mul(x: i32, y: i32) -> i32 { x * y}
    }
}

fn main() {
    println!("2 + 3 = {}", math::basic::plus(2, 3));
    println!("2 * 3 = {}", math::basic::mul(2, 3));
}

引入作用域

使用use可以将路径引入作用域。我们在 src/lib.rs 中声明一个模块，在 src/main.rs 中调用。

// src/lib.rs

pub mod greeting {
    pub fn hello(name: &str) { println!("Hello, {}", &name) } // pub 才能外部可见
}

// src/main.rs

use tutu;

fn main() {
    tutu::greeting::hello("Jack"); // Hello, Jack
}

路径的长度可以自由定义，也可以写成

// src/main.rs

use tutu::greeting;

fn main() {
    greeting::hello("Jack");
}

src/main.rs 和 src/lib.rs 属于不同的 crate ，所以引入作用域时，需要带上包名 tutu 。

分隔模块

在 src/lib.rs 中可以使用 mod 声明多个模块，但有时为了可读性，习惯将每个模块写在独立的文件中。新建 src/greeting.rs，写入

// src/greeting.rs

pub fn hello(name: &str) { println!("Hello, {}", &name) }

在 src/lib.rs 可以这样使用，

// src/lib.rs
pub mod greeting;

pub fn func() {
    greeting::hello("Tom");
}

关键点就在于mod greeting;这一行，mod greeting后面没有具体实现，而是紧跟分号，则声明 greeting 的模块内容位于 src/greeting.rs 中。其他crate，例如 src/main.rs 中的使用方式没有任何变化。

// src/main.rs

use tutu::greeting;

fn main() {
    greeting::hello("Jack");
}

6 测试

6.1 单元测试(unit tests)

fn plus(x: i32, y: i32) -> i32 {
    x + y
}

fn main() {
    let x = 10;
    let y = 20;
    println!("{} + {} = {}", x, y, plus(x, y))
}

#[test]
fn it_works() {
    assert_eq!(4, plus(2, 2), );
}

单元测试非常简单，只需要在每一个测试用例前加上 #[test] 即可，通过 cargo test 执行用例。

$ cargo test
running 1 test
test it_works ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

更规范的写法是在每个源文件中，创建包含测试函数的 tests 模块，测试用例写在 tests 模块中，并使用 cfg(test) 标注模块。

fn plus(x: i32, y: i32) -> i32 {
    x + y
}

fn main() {
    println!("2 + 3 = {}", plus(2, 3));
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn it_works() {
        assert_eq!(4, plus(2, 2), );
    }
}

因为内部测试的代码和源码在同一文件，因而需要使用 #[cfg(test)] 注解告诉 Rust 只在执行 cargo test 时才编译和运行测试代码，因此，可以在构建库时节省时间，并减少编译文件产生的文件大小。单元测试的好处在于，可以测试私有函数。如果在独立的目录，例如 tests 下做测试，则只允许测试公开接口，即使用 pub 修饰后的模块和函数。

6.2 集成测试(integration tests)

集成测试用例和源码位于不同的目录，因而源码中的模块和函数，对于集成测试来说完全是外部的，因此，只能调用一部分库暴露的公共API。 Cargo 约定集成测试的代码位于项目根路径下的 tests 目录中， Cargo 会将 tests 中的每一个文件当做一个 crate 来编译。只有库 crate 才会向其他 crate 暴露可供调用的函数，因此在 src/main.rs 中定义的函数不能够通过 extern crate 的方式导入，所以也不能够被集成测试。 src/main.rs 定义了 main 函数，即作为一个可执行(Executable)程序入口，目的是独立运行，而非向其他 crate 提供可供调用的接口。我们将 plus 函数移动到 src/lib.rs 中，新建 tests/test_lib.rs，最终的目录结构如下

├── Cargo.toml
├── src
│   └── lib.rs
│   └── main.rs
├── tests
    └── test_lib.rs

// src/lib.rs
pub fn plus(x: i32, y: i32) -> i32 { // plus 必须是公共API，才能被集成测试。
    x + y
}

// src/main.rs

use tutu;

fn main() {
    println!("2 + 3 = {}", tutu::plus(2, 3));
}

// tests/test_lib.rs

use tutu;

#[test]
fn it_works() {
    assert_eq!(4, tutu::plus(2, 2));
}

运行 cargo test，将输出

running 1 test
test it_adds_two ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

7 生命周期

借用不改变内存的所有者（Owner），借用只是对源内存的临时引用。
在借用周期内，借用方可以读写这块内存，所有者被禁止读写内存；且所有者保证在有“借用”存在的情况下，不会释放或转移内存。
失去所有权的变量不可以被借用（访问）。
在租借期内，内存所有者保证不会释放/转移/可变租借这块内存，但如果是在非可变租借的情况下，所有者是允许继续非可变租借出去的。
借用周期满后，所有者收回读写权限
借用周期小于被借用者（所有者）的生命周期。

从 Vim 切换至 SpaceVim 的细节

Thu, 20 Feb 2020 00:00:00 +0000

准备工作
迁移成本

准备工作

在切换至 SpaceVim 之前，需要先简单了解下以下几点：

什么是 SpaceVim？

SpaceVim 是一套社区驱动的模块化 Vim 配置文件，因此还是需要安装 Vim 或者 Neovim。建议使用 Neovim，因为 Neovim 的一些功能（+py、+py3）扩展以及内置的 API 更加容易使用。

如何安装 SpaceVim？

迁移成本

相信这个是大多数 Vim 老用户顾虑和担心的事情，担心需要改变按键习惯，担心改变配置习惯。

按键习惯

SpaceVim 内置的快捷键都是以 SPC 为前缀键，不占用 Leader 键，这就意味着原先的一些以 Leader 为前缀的快捷键，可以无缝迁移过来。

配置习惯

同样是可以支持书写 Vim Script，只不过书写的位置不一样。原先可以在 ~/.vimrc 这个文件内书写 Vim Script，在 SpaceVim 内引入了一个新的概念，启动函数，这是一个当 SpaceVim 启动时候会被调用的函数，可以将 Vim 脚本写在这个函数内，比如：

function! myspacevim#init()

    let g:focus_was_lost = 0
    set notitle

endfunction

SpaceVim 下的异步任务系统

Fri, 14 Feb 2020 00:00:00 +0000

配置文件
- 基本使用
- 进阶使用

项目的构建、打包、测试通需要调用一些外部命令，比如make、ant等，SpaceVim 内置一个任务管理系统，通过分析项目的任务配置文件，获取相关命令，并且异步执行，同时根据配置按照需求展示运行结果。

配置文件

配置文件支持全局配置文件以及项目局部配置文件，分别为~/.SpaceVim.d/tasks.toml和.SpaceVim.d/tasks.toml，局部配置文件具有更高的优先权限。

基本使用

以下为一个简单的 hello world 示例：

[my-first-task]
    command = 'echo'
    args = ['hello world']

添加以上内容至 ~/.SpaceVim.d/tasks.toml后，在SpaceVim内按下SPC p t r快捷键，就会弹出如下界面：可以使用j/k按键进行上下选择，回车键执行，也可以按下任务名称前面的序号直接执行。执行效果如下：

进阶使用

对于一些复杂的任务，可以使用预定义的一些变量，来简化配置文件，比如，在一个简单的C项目里：

[in]: e:/ctest/                         
  ▶ bin/                                    
  ▼ src/                                    
        main.c                                

编译一个简单的编译当前C文件src/main.c至bin/目录，以及调用编译后的可以执行文件运行：

[file-build]
    command = 'gcc $(file) -o $(workspaceFolder)/bin/$(workspaceFolderBasename)'
[file-run]
    command = "$(workspaceFolder)/bin/$(workspaceFolderBasename)"

上面的配置文件里涉及到的变量分别是：

变量名	值
`$(file)`	`e:/ctest/src/main.c`
`$(workspaceFolder)`	`e:/ctest`
`$(workspaceFolderBasename)`	`ctest`

SpaceVim 中文官网: https://spacevim.org/cn/ 中文 Gitter 聊天室：https://gitter.im/SpaceVim/cn

心型脂肪酸结合蛋白（H-FABP）检测的临床意义

Thu, 22 Aug 2019 00:00:00 +0000

什么是 H-FABP？
与传统心肌标志物比较
H-FABP 测定的临床应用
- 急性冠脉综合征的预后价值
H-FABP 与其他项目联合检查

冠心病急性心肌梗死（AMI）是世界范围内严重威胁人类生命的疾病，早期诊断急性心肌梗死对挽救病人生命非常重要。近年来，人们提出心肌型脂肪酸结合蛋白（H-FABP）可以作为早期诊断急性心肌梗死的心肌标志物。 H-FABP 是一种低分子量胞浆蛋白，在心肌细胞中含量丰富，由于分子量较小，在急性心肌梗死后 1.3 ～ 3 小时内血浆浓度开始升高。国外一些临床研究已经证实， H-FABP 早期诊断急性心肌梗死较肌红蛋白有更好的特异性和敏感性，尤其在 AMI 早期 3 小时内有更好的诊断价值。

什么是 H-FABP？

脂肪酸结合蛋白（FABPs）是一种小的胞质蛋白，在心脏和肝脏等具有活跃脂肪酸代谢的组织中大量表达（Viswanathan 等人 2012），其主要功能是促进细胞内长链脂肪酸转运。9 种不同类型的 FABPs 家族已被确定，其中心脏型 FABP（H-FABP）是最为广泛研究的，主要是由于在心肌细胞中发现的丰富。它们的低分子量和细胞质位置的结合意味着 h-fabp 蛋白在急性心肌梗死（AMI）后最早被释放进入血液：

生物标志物	分子量 (kDa)	初始检测时间	到达峰值	回到正常值	备注
H-FABP	15kDa	30 分钟	6-12 小时	24 小时	Early rise specificity
Myoglobin	17kDa	1-3 小时	5-8 小时	16-24 小时	Early rise Low specificity
Troponin I (TnI)	22kDa	3-6 小时	14-18 小时	5-10 天	Late rise High specificity
Troponin T (TnT)	33kDa	3-6 小时	10-48 小时	10-15 天	Late rise High specificity
CK-MB	86kDa	3-8 小时	9-24 小时	48-72 小时	Late rise High specificity

与传统心肌标志物比较

与传统的心肌标志物相比较，心型脂肪酸结合蛋白在早期诊断急性心肌梗死具有更好的特异性和敏感性。

H-FABP 测定的临床应用

早期诊断急性心肌梗死：H-FABP 血浆释放特点与肌红蛋白相同，但 HFABP 在心肌细胞内的含量高于 Mb，而在血浆内的含量远低于 Mb。因此，当心肌损伤后，血浆 HFABP 迅速升高超正常上限，比 Mb 和肌钙蛋白来得快，因而更有诊断价值。近年来众多研究表明血清 H-FABP 能识别超急期急性心肌梗死，特别是胸痛发病 6 h 内的患者，对决定是否住院、冠状动脉造影、介入治疗有很大帮助。评估心肌梗死面积：Wodzig 等测定 20 例 AMI 患者的 H-FABP、Mb、肌酸激酶同工酶(CK-MB)、羟丁酸脱氢酶(HBDH)，用 H-FABP 或 Mb 曲线，与用 CK-MB 或 HBDH 评估梗死面积具有较好的一致性。H-FABP 或 Mb 可用评估肾功能正常 AMI 患者发病 24 h 内的梗死面积。评估再灌注损伤：58 例 AMI 患者行溶栓治疗，溶栓后 90min 行冠状动脉造影，溶栓前、溶栓后 60、90 min 和 180 min 分别测定 H-FABP 和 Mb 浓度。溶栓后相关血管开通者 H-FABP 和 Mb 明显高于未开通者。研究者认为: H-FABP、Mb 可作为再灌注指标，结合梗死面积分析，灵敏度和特异性可进一步提高。评估心力衰竭严重程度与预后：Setsuta 等测定 103 例慢性心衰患者 H-FABP 及 cTnI，发现 cTnI≥0. 01μg /L 而且 H-FABP≥4.5μg/L 者心血管事件(死亡、病情加重再入院)发生率高于其它患者，提示 H-FABP 联合 cTnI 能独立预测心血管事件。预测急性冠状动脉综合征心血管事件：在 ACS 发病早期的几小时内，筛选出可能发生心脏事件的高危患者很重要。最近已有报导血浆 H-FABP 浓度升高与心血管事件发生率及心血管死亡有关。Viswanathan 等入选 955 例怀疑 ACS 而肌钙蛋白阴性的患者(除外 ST 抬高性心肌梗死及新发左束支传导阻滞患者) ，于症状发生后 12 ～ 24h 检测 H-FABP，平均随访 18 个月后，H-FABP 浓度＞ 6.48 mg/L 者不良事件显著增加，提示 H-FABP 能独立预测中低危胸痛患者的心血管事件。区分心肌或骨骼肌损伤：H-FABP 主要来自心肌，少部分来自骨骼肌。心脏电除颤、器官衰竭、手术后、强体力活动如跑步、划船，骨骼肌受损伤，也会引起血中 H-FABP 浓度升高。Mb/H-FABP 比值可用于鉴别心肌损伤(比值=2 ～ 10)和骨骼肌损伤(比值=20 ～ 70)。AMI 患者，血浆 Mb/H-FABP 比值为 0 ～ 5。

急性冠脉综合征的预后价值

除了对急性冠脉综合征有重要的诊断价值外，H-FABP 在这些患者的长期预后中也显示出巨大的价值，即使与高灵敏度肌钙蛋白测定相比也是如此。 Kilcullen（JACC 2007）在 2007 年美国心脏病学会杂志上发表了一项前瞻性观察研究的详细资料，详细介绍了在英国 11 家医院中 1448 名确诊急性冠脉综合征患者的队列。患者在 ACS 症状出现 12-24 小时后，从单个血液样本中测量肌钙蛋白 I 和 H-Fabp。随访 1 年后，发现 H-Fabp 浓度的升高对急性冠脉综合征后的死亡率具有很强的预测作用， H-Fabp 能够在整个 TNI 浓度范围内识别高危患者。 6 个月时 h-fabp 和肌钙蛋白 I 均为阴性的患者死亡率为 0%，因此被认为是非常低的风险。然而，与 H-Fabp 阴性的患者相比，H-Fabp 阳性和肌钙蛋白阴性的患者在 1 年后死亡的风险明显较高。

Fig 5: Kaplan-Meier mortality curves for patients with either TnI≤0.06 μg/l (unstable angina) or TnI>0.06 μg/l (MI inclusive of STEMI/BBBMI) according to the H-FABP cut-off value of 5.8μg/l.

这些患者接受了 6 年的随访，除了肌钙蛋白阴性、H-Fabp 阳性的患者组在 6 年后死亡率最高（Pearson 等人，20109）。H-Fabp 不仅是一个独立的预后标志物，而且可以识别被认为是肌钙蛋白阴性的高危患者。

H-FABP 与其他项目联合检查

下图为不同心肌标志物组合检查对于 AMI 症状出现时间的敏感性，由图中可以看出心型脂肪酸结合蛋白和肌钙蛋白 I 联合检查具有更高的敏感性。 H-FABP、cTnI 联合诊断 ACS 有研究表明应用心型脂肪酸结合蛋白（H-FABP）与肌钙蛋白 Ⅰ（cTnI）联合诊断 ACS 研究发现，相比单纯的检测而言，能够提高检测的阳性率，同时对于检测准确性和诊断敏感性的提高具有重要价值，因此更加值得临床借鉴，意义在于通过联合检测提高诊断率，便于临床及时对患者进行准确的治疗，从而提高治疗效果，改善患者预后情况。 H-FABP、肌钙蛋白 I、超敏 C 反应泛白联合诊断 AMI hs-CRP、H-FABP、cTnT 联合检测诊断 AMI 的特异度、阳性预测值均达到了 100.0%，同时敏感度、阴性预测值也较高,达到了 97.8%。这说明心型脂肪酸结合蛋白、肌钙蛋白 T、超敏 C 反应蛋白联合检测,对于诊断急性心肌梗死具有较高的阳性预测值和特异度,其能有效降低误诊率,值得推广应用。

参考文献：

《心型脂肪酸结合蛋白（H—FABP）与肌钙蛋白 I（cTnI）联合诊断 ACS 的价值》- 中西医结合心血管病电子杂志 2017 年 4 期
《Clinical Value of H-FABP》
《心型脂肪酸结合蛋白、肌钙蛋白 T、超敏 C 反应蛋白联合检测在急性心肌梗死中的价值》- 中国医药科学杂志 2014 年 10 月第 4 卷第 19 期

右键使用 SpaceVim 打开文件

Wed, 07 Aug 2019 00:00:00 +0000

我们知道，在 Linux 命令行里，可以使用 cd 命令切换到项目所在的目录，此时启动 SpaceVim，会读取工程目录下的一些 SpaceVim 配置信息。这样的好处有很多，假定我日常需要编辑 Java Python 和 c 语言项目，那么在使用SpaceVim时不需要在用户配置里将所有的语言模块都启用了，而是只需要在 Java 项目根目录创建一个 .SpaceVim.d/init.toml 文件，在此文件里启用 lang#java 模块即可。同理，在 Python 项目根目录同样操作启用 lang#python 模块即可。但是在 windows 系统下使用 neovim-qt 时，就不太方便了，为此，添加了这一功能，可以使用 windows 自身的文件管理器，定位到项目所在位置后使用右键打开 SpaceVim 并读取项目下的 SpaceVim 配置。下面，我们来看看如何添加：

按下 Win + r 在运行弹窗理输入：regedit 回车，打开注册表编辑器：

定位到 HKEY_CLASSES_ROOT > * > shell :

右键新建项，此时可以输入一个你需要看到的名字，比如使用 SpaceVim 打开，再在这个项里新建一个 command 项，修改其默认值为：

"D:\Program Files\Neovim\bin\nvim-qt.exe" -qwindowgeometry 1310x650+20+20 "%1"

最新版 Neovim 修改为：

nvim --server \\.\pipe\nvim-pipe-123123123 --remote "%1"

需要在 Neovim 的配置文件里面增加：

pcall(function()
    vim.fn.serverstart([[\\.\pipe\nvim-pipe-123123123]])
end)

此时，就可以在右键中使用 neovim-qt 打开文件了，上面启动参数里指定了窗口位置和大小，可以自行调节。

使用 Vim 管理待办事项

Tue, 06 Aug 2019 00:00:00 +0000

简介
安装

简介

这一功能主要是方便检索源码中的待办事项。只需要在源码注释中加入相关标签即可，比如

" @todo Use new prolog plugin
" call add(plugins, ['wsdjeg/prolog-vim', { 'merged' : 0}])
call add(plugins, ['wsdjeg/prolog.vim', { 'merged' : 0}])

安装

vim-todo 这一插件分离自 SpaceVim，可以在 SpaceVim 中使用，当然也支持独立安装。可以使用任意插件管理器，比如 dein 来安装 vim-todo：

call dein#add('wsdjeg/vim-todo')

这一插件依赖于 Vim 的 +job 特性，因此需要确保你的 Vim 版本满足要求，并且需要安装一个命令行工具 rg

如何学习并使用 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、IL-6、CRP联合检查

导读

PCT作为一种新的感染性炎性标志物目前已被广泛认可。 PCT对于细菌引起的感染有较高的灵敏度和特异性，能帮助临床医生早期诊断患者是否存在或合并有细菌引起的感染，鉴别诊断感染是由细菌所致还是病毒导致，或其他原因引起的炎症反应有利于患者早期正确的治疗。

概念

降钙素原（procalcitonin，简称PCT）是一种由116个氨基酸组成的糖蛋白，是降钙素（calcitonin，简称CT）的前体肽。降钙素可被酶裂解为许多小的片断，最终形成氨基降钙素原、成熟的降钙素和钙抑肽。正常情况下，PCT主要由甲状腺C细胞合成分泌，游离形式存在于正常人血清中。在细菌感染时，肝脏的巨噬细胞和单核细胞、肺及肠道组织的淋巴细胞及内分泌细胞，在内毒素、肿瘤坏死因子-α（TNF-α）及白介素-6（IL-6）等作用下合成分泌大量的PCT，导致血清PCT水平显著升高。

临床意义

根据PCT水平及改变情况指导抗生素的使用，减少不必要的抗生素使用，降低患者费用，减少过度使用抗生素所致的细菌耐药性增加及改变情况评估感染的严重程度和预测患者的预后。 PCT是一个非常有应用价值的诊断感染状态的微生物学指标，同时也可能是细菌感染的新的治疗途径。目前导致PCT升高的疾病总的来说可以分为感染和非感染两大类：

感染类

PCT在细菌感染引起的全身性炎症反应早期（2~3h）即可升高，感染后12~24h达到高峰， PCT浓度与感染严重程度呈正相关，感染消失后恢复正常。因此对严重细菌感染的早期诊断、判断病情严重程度、预后、评价抗感染疗效、指导抗菌药物应用等方面都具有较高的临床价值。

非感染类

手术后
严重创伤
严重烧伤
持续性心源性休克
严重灌注不足，多器官功能衰竭，重症胰腺炎
严重肾功能不全
器官移植
严重肝硬化，或急慢性病毒性肝炎
新生儿出生最初几天
中暑
某些自身免疫性疾病
肿瘤晚期
横纹肌溶解症状
持续心肺复苏后
药物因素

PCT、IL-6、CRP联合检查

特别注意：没有任何一个生物标志物是绝对敏感又绝对特异的，不能单凭某个生物标志物的改变来诊断疾病，只有结合、参照患者的临床表现与其他实验室检查结果，才能做出正确的判断。联合检查是未来的趋势： 1、《感染相关生物标志物临床意义解读专家共识》指出：“多个指标的联合检测将是未来的发展趋势，可提高对感染性疾病的早期诊断率和预后判断价值。”[1] 2、PCT、IL-6、CRP相比，IL-6的敏感性优于PCT和CRP，但它的特异性比PCT差，联检项目可以优势互补，各取所长。有研究显示，针对脓毒症患者联合检测PCT+IL-6+CRP、PCT+IL-6或PCT+CRP ，有助于临床识别早期脓毒症[3]（见表1）表1 三种检测指标敏感性和特异性比较（%） 3、另一项研究PCT、CRP及 IL-6联合测定可以提高对细菌感染和病毒感染的鉴别效力，同时可有效的指导临床抗生素的使用、评估治疗效果[4]。

再见了，网易博客

Wed, 12 Dec 2018 00:00:00 +0000

用了很多年的网易博客有点舍不得，可惜后续不能再使用了，网易新推出的写作平台不是很感冒。是时候说再见了。

Ruby 模块和包

Wed, 10 Oct 2018 00:00:00 +0000

require 语句
include 语句
Mixins

模块（Module）是一种把方法、类和常量组合在一起的方式。模块（Module）为您提供了两大好处。

模块提供了一个命名空间和避免名字冲突。
模块实现了 mixin 装置。

模块（Module）定义了一个命名空间，相当于一个沙盒，在里边您的方法和常量不会与其他地方的方法常量冲突。模块类似与类，但有一下不同：

模块不能实例化
模块没有子类
模块只能被另一个模块定义

module Identifier
   statement1
   statement2
   ...........
end

模块常量命名与类常量命名类似，以大写字母开头。方法定义看起来也相似：模块方法定义与类方法定义类似。通过类方法，您可以在类方法名称前面放置模块名称和一个点号来调用模块方法，您可以使用模块名称和两个冒号来引用一个常量。实例

#!/usr/bin/ruby

# 定义在 trig.rb 文件中的模块

module Trig
   PI = 3.141592654
   def Trig.sin(x)
   # ..
   end
   def Trig.cos(x)
   # ..
   end
end

我们可以定义多个函数名称相同但是功能不同的模块：

#!/usr/bin/ruby

# 定义在 moral.rb 文件中的模块

module Moral
   VERY_BAD = 0
   BAD = 1
   def Moral.sin(badness)
   # ...
   end
end

就像类方法，当您在模块中定义一个方法时，您可以指定在模块名称后跟着一个点号，点号后跟着方法名。

require 语句

require 语句类似于 C 和 C++ 中的 include 语句以及 Java 中的 import 语句。如果一个第三方的程序想要使用任何已定义的模块，则可以简单地使用 Ruby require 语句来加载模块文件：语法

require filename

在这里，文件扩展名 .rb 不是必需的。实例

$LOAD_PATH << '.'

require 'trig.rb'
require 'moral'

y = Trig.sin(Trig::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)

在这里，我们使用 $LOAD_PATH « ’.’ 让 Ruby 知道必须在当前目录中搜索被引用的文件。如果您不想使用 $LOAD_PATH，那么您可以使用 require_relative 来从一个相对目录引用文件。注意：在这里，文件包含相同的函数名称。所以，这会在引用调用程序时导致代码模糊，但是模块避免了这种代码模糊，而且我们可以使用模块的名称调用适当的函数。

include 语句

您可以在类中嵌入模块。为了在类中嵌入模块，您可以在类中使用 include 语句：语法

include modulename

如果模块是定义在一个单独的文件中，那么在嵌入模块之前使用 require 语句引用该文件时必需的。实例假设下面的模块写在 ruby/support.rb 文件中。

module Week
   FIRST_DAY = "Sunday"
   def Week.weeks_in_month
      puts "You have four weeks in a month"
   end
   def Week.weeks_in_year
      puts "You have 52 weeks in a year"
   end
end

现在，您可以在类中引用该模块，如下所示：

#!/usr/bin/ruby
$LOAD_PATH << './ruby'
require "support"

class Decade
include Week
   no_of_yrs=10
   def no_of_months
      puts Week::FIRST_DAY
      number=10*12
      puts number
   end
end
d1=Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month
Week.weeks_in_year
d1.no_of_months

这将产生以下结果：

Mixins

在阅读本节之前，您需要初步了解面向对象的概念。当一个类可以从多个父类继承类的特性时，该类显示为多重继承。 Ruby 不直接支持多重继承，但是 Ruby 的模块（Module）有另一个神奇的功能。它几乎消除了多重继承的需要，提供了一种名为 mixin 的装置。 Mixins 向您提供了一种完美的为类添加功能的控制方式。但是，它们真正的强大在于当 mixin 中的代码开始与使用它的类中的代码交互时。让我们看看下面的示例代码，深入了解 mixin：

module A
   def a1
   end
   def a2
   end
end
module B
   def b1
   end
   def b2
   end
end

class Sample
include A
include B
   def s1
   end
end

samp=Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1

模块 A 由方法 a1 和 a2 组成。模块 B 由方法 b1 和 b2 组成。类 Sample 包含了模块 A 和 B。类 Sample 可以访问所有四个方法，即 a1、a2、b1 和 b2。因此，您可以看到类 Sample 继承了两个模块，您可以说类 Sample 使用了多重继承或 mixin 。

Ruby 代码块

Thu, 04 Oct 2018 00:00:00 +0000

yield 语句
块和方法
BEGIN 和 END 块

您已经知道 Ruby 如何定义方法以及您如何调用方法。类似地，Ruby 有一个块的概念。

块由大量的代码组成。
您需要给块取个名称。
块中的代码总是包含在大括号 {} 内。
块总是从与其具有相同名称的函数调用。这意味着如果您的块名称为 test，那么您要使用函数 test 来调用这个块。
您可以使用 yield 语句来调用块。

语法

block_name{
   statement1
   statement2
   ..........
}

在这里，您将学到如何使用一个简单的 yield 语句来调用块。您也将学到如何使用带有参数的 yield 语句来调用块。在实例中，您将看到这两种类型的 yield 语句。

yield 语句

让我们看一个 yield 语句的实例：

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

def test
   puts "在 test 方法内"
   yield
   puts "你又回到了 test 方法内"
   yield
end
test {puts "你在块内"}

您也可以传递带有参数的 yield 语句。下面是一个实例：

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

def test
   yield 5
   puts "在 test 方法内"
   yield 100
end
test {
   |i|
   puts "你在块 #{i} 内"
}

在这里，yield 语句后跟着参数。您甚至可以传递多个参数。在块中，您可以在两个竖线之间放置一个变量来接受参数。因此，在上面的代码中，yield 5 语句向 test 块传递值 5 作为参数。现在，看下面的语句：

test {|i| puts "你在块 #{i} 内"}

在这里，值 5 会在变量 i 中收到。现在，观察下面的 puts 语句：

puts "你在块 #{i} 内"

这个 puts 语句的输出是：

你在块 5 内

如果您想要传递多个参数，那么 yield 语句如下所示：

yield a, b

此时，块如下所示：

test {|a, b| statement}

参数使用逗号分隔。

块和方法

您已经看到块和方法之间是如何相互关联的。您通常使用 yield 语句从与其具有相同名称的方法调用块。因此，代码如下所示：

#!/usr/bin/ruby

def test
  yield
end
test{ puts "Hello world"}

本实例是实现块的最简单的方式。您使用 yield 语句调用 test 块。但是如果方法的最后一个参数前带有 &，那么您可以向该方法传递一个块，且这个块可被赋给最后一个参数。如果 * 和 & 同时出现在参数列表中，& 应放在后面。

#!/usr/bin/ruby

def test(&block)
   block.call
end
test { puts "Hello World!"}

BEGIN 和 END 块

每个 Ruby 源文件可以声明当文件被加载时要运行的代码块（BEGIN 块），以及程序完成执行后要运行的代码块（END 块）。

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

BEGIN {
  # BEGIN 代码块
  puts "BEGIN 代码块"
}

END {
  # END 代码块
  puts "END 代码块"
}
  # MAIN 代码块
puts "MAIN 代码块"

一个程序可以包含多个 BEGIN 和 END 块。BEGIN 块按照它们出现的顺序执行。END 块按照它们出现的相反顺序执行。当执行时，上面的程序产生产生以下结果：

BEGIN 代码块
MAIN 代码块
END 代码块

Ruby 函数

Sun, 30 Sep 2018 00:00:00 +0000

从方法返回值
return 语句
可变数量的参数
类方法
alias 语句
undef 语句

Ruby 方法与其他编程语言中的函数类似。Ruby 方法用于捆绑一个或多个重复的语句到一个单元中。方法名应以小写字母开头。如果您以大写字母作为方法名的开头，Ruby 可能会把它当作常量，从而导致不正确地解析调用。方法应在调用之前定义，否则 Ruby 会产生未定义的方法调用异常。语法

def method_name [( [arg [= default]]...[, * arg [, &expr ]])]
   expr..
end

所以，您可以定义一个简单的方法，如下所示：

def method_name
   expr..
end

您可以定义一个接受参数的方法，如下所示：

def method_name (var1, var2)
   expr..
end

您可以为参数设置默认值，如果方法调用时未传递必需的参数则使用默认值：

def method_name (var1=value1, var2=value2)
   expr..
end

当您要调用方法时，只需要使用方法名即可，如下所示：

method_name

但是，当您调用带参数的方法时，您在写方法名时还要带上参数，例如：

method_name 25, 30

使用带参数方法最大的缺点是调用方法时需要记住参数个数。例如，如果您向一个接受三个参数的方法只传递了两个参数，Ruby 会显示错误。

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

def test(a1="Ruby", a2="Perl")
   puts "编程语言为 #{a1}"
   puts "编程语言为 #{a2}"
end
test "C", "C++"
test

从方法返回值

Ruby 中的每个方法默认都会返回一个值。这个返回的值是最后一个语句的值。例如：

def test
   i = 100
   j = 10
   k = 2
end
tvar = test
puts tvar

在调用这个方法时，将返回最后一个声明的变量 k。

return 语句

Ruby 中的 return 语句用于从 Ruby 方法中返回一个或多个值。语法

return [expr[',' expr...]]

如果给出超过两个的表达式，包含这些值的数组将是返回值。如果未给出表达式，nil 将是返回值。实例

return

或

return 12

或

return 1,2,3

看看下面的实例：

#!/usr/bin/ruby

def test
   i = 100
   j = 200
   k = 300
return i, j, k
end
var = test
puts var

可变数量的参数

假设您声明了一个带有两个参数的方法，当您调用该方法时，您同时还需要传递两个参数。但是，Ruby 允许您声明参数数量可变的方法。让我们看看下面的实例：

#!/usr/bin/ruby

def sample (*test)
   puts "The number of parameters is #{test.length}"
   for i in 0...test.length
      puts "The parameters are #{test[i]}"
   end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"

在这段代码中，您已经声明了一个方法 sample，接受一个参数 test。但是，这个参数是一个变量参数。这意味着参数可以带有不同数量的变量。所以上面的代码将产生下面的结果：

类方法

当方法定义在类定义外部时，方法默认标记为 private。另一方面，定义在类定义中的方法默认标记为 public。方法默认的可见性和 private 标记可通过模块（Module）的 public 或 private 改变。当你想要访问类的方法时，您首先需要实例化类。然后，使用对象，您可以访问类的任何成员。 Ruby 提供了一种不用实例化类即可访问方法的方式。让我们看看如何声明并访问类方法：

class Accounts
   def reading_charge
   end
   def Accounts.return_date
       puts "2019"
   end
end

# 我们已经知道方法 return_date 是如何声明的。
# 它是通过在类名后跟着一个点号，点号后跟着方法名来声明的。
# 您可以直接访问类方法，如下所示：
Accounts.return_date

如需访问该方法，您不需要创建类 Accounts 的对象。

alias 语句

这个语句用于为方法或全局变量起别名。别名不能在方法主体内定义。即使方法被重写，方法的别名也保持方法的当前定义。为编号的全局变量（$1, $2,…）起别名是被禁止的。重写内置的全局变量可能会导致严重的问题。语法

alias 方法名 方法名
alias 全局变量 全局变量

实例

alias foo bar
alias $MATCH $&

在这里，我们已经为 bar 定义了别名为 foo，为 $& 定义了别名为 $MATCH。

undef 语句

这个语句用于取消方法定义。undef 不能出现在方法主体内。通过使用 undef 和 alias，类的接口可以从父类独立修改，但请注意，在自身内部方法调用时，它可能会破坏程序。语法

undef 方法名

实例下面的实例取消名为 bar 的方法定义：

undef bar

Ruby 循环

Mon, 24 Sep 2018 00:00:00 +0000

while 语句
while 修饰符
until 语句
until 修饰符
for 语句
break 语句
next 语句
redo 语句
retry 语句

Ruby 中的循环用于执行相同的代码块若干次。

while 语句

语法

while conditional [do]
   code
end

或者

<pre>
while conditional [:]
   code
end

当 conditional 为真时，执行 code。语法中 do 或 : 可以省略不写。但若要在一行内写出 while 式，则必须以 do 或 : 隔开条件式或程式区块。实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

$i = 0
$num = 5

while $i < $num  do
   puts("在循环语句中 i = #$i" )
   $i +=1
end

while 修饰符

语法

code while condition

或者

begin
  code
end while conditional

当 conditional 为真时，执行 code。如果 while 修饰符跟在一个没有 rescue 或 ensure 子句的 begin 语句后面，code 会在 conditional 判断之前执行一次。实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

$i = 0
$num = 5
begin
   puts("在循环语句中 i = #$i" )
   $i +=1
end while $i < $num

until 语句

until conditional [do]
   code
end

当 conditional 为假时，执行 code。语法中 do 可以省略不写。但若要在一行内写出 until 式，则必须以 do 隔开条件式或程式区块。实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

$i = 0
$num = 5

until $i > $num  do
   puts("在循环语句中 i = #$i" )
   $i +=1;
end

until 修饰符

语法

code until conditional

或者

begin
   code
end until conditional

当 conditional 为假时，执行 code。如果 until 修饰符跟在一个没有 rescue 或 ensure 子句的 begin 语句后面，code 会在 conditional 判断之前执行一次。实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

$i = 0
$num = 5
begin
   puts("在循环语句中 i = #$i" )
   $i +=1;
end until $i > $num

for 语句

语法

for variable [, variable ...] in expression [do]
   code
end

针对 expression 中的每个元素分别执行一次 code。实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

for i in 0..5
   puts "局部变量的值为 #{i}"
end

在这里，我们已经定义了范围 0..5。语句 for i in 0..5 允许 i 的值从 0 到 5（包含 5）。 for…in 循环几乎是完全等价于：

(expression).each do |variable[, variable...]| code end

但是，for 循环不会为局部变量创建一个新的作用域。语法中 do 可以省略不写。但若要在一行内写出 for 式，则必须以 do 隔开条件式或程式区块。实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

(0..5).each do |i|
   puts "局部变量的值为 #{i}"
end

break 语句

语法

break

终止最内部的循环。如果在块内调用，则终止相关块的方法（方法返回 nil）。实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

for i in 0..5
   if i > 2 then
      break
   end
   puts "局部变量的值为 #{i}"
end

next 语句

语法

next

跳到最内部循环的下一个迭代。如果在块内调用，则终止块的执行（yield 或调用返回 nil）。实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

for i in 0..5
   if i < 2 then
      next
   end
   puts "局部变量的值为 #{i}"
end

redo 语句

语法

redo

重新开始最内部循环的该次迭代，不检查循环条件。如果在块内调用，则重新开始 yield 或 call。实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

for i in 0..5
   if i < 2 then
      puts "局部变量的值为 #{i}"
      redo
   end
end

这将产生以下结果，并会进入一个无限循环：

retry 语句

语法

retry

如果 retry 出现在 begin 表达式的 rescue 子句中，则从 begin 主体的开头重新开始。

begin
   do_something # 抛出的异常
rescue
   # 处理错误
   retry  # 重新从 begin 开始
end

如果 retry 出现在迭代内、块内或者 for 表达式的主体内，则重新开始迭代调用。迭代的参数会重新评估。

for i in 1..5
   retry if some_condition # 重新从 i == 1 开始
end

实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

for i in 1..5
   retry if  i > 2
   puts "局部变量的值为 #{i}"
end

这将产生以下结果，并会进入一个无限循环：

ruby 流程控制

Thu, 20 Sep 2018 00:00:00 +0000

if…else 语句
if 修饰符
unless 语句
unless 修饰符
case 语句

Ruby 提供了其他现代语言中很常见的条件结构。在这里，我们将解释所有的条件语句和 Ruby 中可用的修饰符。

if…else 语句

if conditional [then]
   code...
[elsif conditional [then]
    code...]...
[else
    code...]
end

if 表达式用于条件执行。值 false 和 nil 为假，其他值都为真。请注意，Ruby 使用 elsif，不是使用 else if 和 elif。如果 conditional 为真，则执行 code。如果 conditional 不为真，则执行 else 子句中指定的 code。通常我们省略保留字 then 。若想在一行内写出完整的 if 式，则必须以 then 隔开条件式和程式区块。如下所示:

if a == 4 then a = 7 end

实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

x=1
if x > 2
   puts "x 大于 2"
elsif x <= 2 and x!=0
   puts "x 是 1"
else
   puts "无法得知 x 的值"
end

if 修饰符

语法

code if condition

如果 conditional 为真，则执行 code。实例

#!/usr/bin/ruby

$debug=1
puts "debug\n" if $debug

unless 语句

语法

unless conditional [then]
   code
[else
   code ]
end

unless 式和 if 式作用相反，即如果 conditional 为假，则执行 code。如果 conditional 为真，则执行 else 子句中指定的 code。实例

#!/usr/bin/ruby

x=1
unless x>2
   puts "x 小于 2"
 else
  puts "x 大于 2"
end

unless 修饰符

语法

code unless conditional

如果 conditional 为假，则执行 code。实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

$var =  1
print "1 -- 这一行输出\n" if $var
print "2 -- 这一行不输出\n" unless $var

$var = false
print "3 -- 这一行输出\n" unless $var

case 语句

语法

case expression
[when expression [, expression ...] [then]
   code ]...
[else
   code ]
end

case 先对一个 expression 进行匹配判断，然后根据匹配结果进行分支选择。它使用 ===运算符比较 when 指定的 expression，若一致的话就执行 when 部分的内容。通常我们省略保留字 then 。若想在一行内写出完整的 when 式，则必须以 then 隔开条件式和程式区块。如下所示:

when a == 4 then a = 7 end

因此：

case expr0
when expr1, expr2
   stmt1
when expr3, expr4
   stmt2
else
   stmt3
end

基本上类似于：

_tmp = expr0
if expr1 === _tmp || expr2 === _tmp
   stmt1
elsif expr3 === _tmp || expr4 === _tmp
   stmt2
else
   stmt3
end

实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

$age =  5
case $age
when 0 .. 2
    puts "婴儿"
when 3 .. 6
    puts "小孩"
when 7 .. 12
    puts "child"
when 13 .. 18
    puts "少年"
else
    puts "其他年龄段的"
end

Ruby 运算符

Wed, 12 Sep 2018 00:00:00 +0000

算术运算符
比较运算符
- 赋值运算符
并行赋值

算术运算符

算数运算符，顾名思义，常见的加减乘除，还有取余等：

运算符	描述	实例
+	加法 - 把运算符两边的操作数相加	a + b 将得到 30
-	减法 - 把左操作数减去右操作数	a - b 将得到 -10
*	乘法 - 把运算符两边的操作数相乘	a * b 将得到 200
/	除法 - 把左操作数除以右操作数	b / a 将得到 2
%	求模 - 把左操作数除以右操作数，返回余数	b % a 将得到 0
**	指数 - 执行指数计算	a**b 将得到 10 的 20 次方

puts 1 + 2
puts 1 * 2
puts 2 - 1
puts 2 / 2
puts 11 % 3
puts 4**3

比较运算符

假设变量 a 的值为 10，变量 b 的值为 20，那么：

运算符	描述	实例
==	检查两个操作数的值是否相等，如果相等则条件为真。	(a == b) 不为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(a != b) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(a > b) 不为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(a < b) 为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(a >= b) 不为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(a <= b) 为真。
<=>	联合比较运算符。如果第一个操作数等于第二个操作数则返回 0，如果第一个操作数大于第二个操作数则返回 1，如果第一个操作数小于第二个操作数则返回 -1。	(a <=> b) 返回 -1。
===	用于测试 case 语句的 when 子句内的相等。	(1…10) === 5 返回 true。
.eql?	如果接收器和参数具有相同的类型和相等的值，则返回 true。	1 == 1.0 返回 true，但是 1.eql?(1.0) 返回 false。
equal?	如果接收器和参数具有相同的对象 id，则返回 true。	如果 aObj 是 bObj 的副本，那么 aObj == bObj 返回 true，a.equal?bObj 返回 false，但是 a.equal?aObj 返回 true。

赋值运算符

运算符	描述	实例
=	简单的赋值运算符，把右操作数的值赋给左操作数	c = a + b 将把 a + b 的值赋给 c
+=	加且赋值运算符，把右操作数加上左操作数的结果赋值给左操作数	c += a 相当于 c = c + a
-=	减且赋值运算符，把左操作数减去右操作数的结果赋值给左操作数	c -= a 相当于 c = c - a
*=	乘且赋值运算符，把右操作数乘以左操作数的结果赋值给左操作数	c _= a 相当于 c = c _ a
/=	除且赋值运算符，把左操作数除以右操作数的结果赋值给左操作数	c /= a 相当于 c = c / a
%=	求模且赋值运算符，求两个操作数的模赋值给左操作数	c %= a 相当于 c = c % a
**=	指数且赋值运算符，执行指数计算，并赋值给左操作数	c = a 相当于 c = c a

并行赋值

Ruby 也支持变量的并行赋值。这使得多个变量可以通过一行的 Ruby 代码进行初始化。例如：

a = 10
b = 20
c = 30

使用并行赋值可以更快地声明：

a, b, c = 10, 20, 30

并行赋值在交换两个变量的值时也很有用：

a, b = b, a

如何在 Vim 内进行高效的排序

Fri, 07 Sep 2018 00:00:00 +0000

排序命令
排序函数

Vim 分别提供了排序函数 sort()、uniq() 和排序命令 :sort。机遇这两种方式，可以在 Vim 内对文本进行高效的排序。下面分两部分详细说明下这两种方式的使用方法。

排序命令

:sort 命令的用法格式如下：

:[range]sor[t][!] [b][f][i][n][o][r][u][x] [/{pattern}/]

[range] 值得是一个范围，:sort 命令会基于这个范围进行排序，当未制定范围时，会对整个文档进行排序。关于 [range] 的常用方法有下面几种：我们看到 sor[t] 最后一个字母 t 被方括号包围，表示该字母可以省略，即更简单地执行 :sor 命令。在 :sort命令紧接其后的感叹号 ! 表示是否进行反向排序，不带感叹号则是正向排序，带上则反之。在 :sort 命令紧接其后的第一个参数为可选参数，包括 b, f, i, n, o, r, u, x。首先，需要了解选项 n f x o b 之间是互斥的，也就是说不可以同时使用这些选项，换句话说。前面的这个五个选项可以和 i r u 这三项组合使用。下面分别说下这些参数的意义：

带 n 则排序基于每行的第一个十进制数 (在 {pattern} 匹配之后或之内)。数值包含前导的 ‘-‘。
带 f 则排序基于每行的第一个浮点数。浮点值相当于在文本( {pattern} 匹配的之后或之内) 上调用 str2float() 函数的结果。仅当 Vim 编译时加入浮点数支持时该标志位才有效。
带 x 则排序基于每行的第一个十六进制数 (在 {pattern} 匹配之后或之内)。忽略该数值前的 “0x” 或 “0X”。但包含前导的 ‘-‘。
带 o 则排序基于每行的第一个八进制数 (在 {pattern} 匹配之后或之内)。
带 b 则排序基于每行的第一个二进制数 (在 {pattern} 匹配之后或之内)。
带 u (u 代表 unique 唯一) 则只保留完全相同的行的第一行 (如果同时带 i，忽略大小写的区别)。没有这个标志位，完全相同的行的序列会按照它们原来的顺序被保留下来。注意：行首和行尾的的空白差异会影响唯一性的判定。

排序函数

Vim 提供两个排序相关的函数 sort() 和 uniq()，sort() 这个函数的用法如下：

sort({list} [, {func} [, {dict}]])

给定一个 List 经过排序后，返回一个结果，同样也是 List。sort() 这一函数第二个参数可以接受如下几种情况：

1 或者 i: 表示忽略大小写。
n：按照数值排序，即使用 strtod() 解析 List 内的元素，字符串、列表、字典和函数引用均视作 0。
f：按照浮点数值来排序，要求给定的 List 每一个选项都是浮点数。
一个 Funcref 变量。这个变量表示的是一个函数，则调用该函数来比较项目，该函数会使用两个项目作为参数，根据返回值确定两个项目关系。 0 表示相等，1 或者更高，表示第一个排在第二个之后，-1 或更小代表第一个排在第二个之前。

(Neo)Vim 插件开发指南

Fri, 31 Aug 2018 00:00:00 +0000

简介
基本语法
- 注释
- 变量
- 作用域
- 函数定义
插件的目录结构
Vim 自定义命令

简介

(Neo)Vim 插件开发中文指南，主要包括 Vim 脚本语法、插件开发技巧等。

基本语法

注释

在写脚本时，经常需要在源码里面添加一些注释信息，辅助阅读源码，Vim 脚本注释比较简单，是以 " 开头的，只存在行注释，不存在块注释。因此，对于多行注释，需要再每行开头添加 "。示例：

" 这是一行注释，
let g:helloworld = 1  " 这是在行尾注释

变量

在 Vim 脚本里，可以使用关键字 let 来申明变量，最基本的方式为：

" 定义一个类型是字符串的变量 g:helloworld
let g:helloworl = "sss"

前面的例子中，是定义一个字符串，Vim 脚本中支持以下几种数据类型：

类型	ID	描述
Number	0	整数
String	1	字符串
Funcref	2	函数指针
List	3	列表
Dictionary	4	字典
Float	5	浮点数
Boolean	6
None	7
Job	8
Channel	9

作用域

Vim 变量存在三种作用域，全局变量、局部变量、和脚本变量。通常，我们以不同的前缀来区别作用域，比如使用 g: 表示全局变量，s: 表示脚本变量。在一些特殊情况下，前缀是可以省略的，Vim 会为该变量选择默认的作用域。不同的情况下，默认的作用域是不一样的，在函数内部，默认作用域是局部变量，而在函数外部，默认作用域是全局变量：

let g:helloworld = 1  " 这是一个全局变量， g: 前缀未省略
let helloworld = 1    " 这也是一个全局变量，在函数外部，默认的作用域是全局的

function! HelloWorld()
  let g:helloworld = 1    " 这是函数内部全局变量
  let helloworld = 1      " 这是一个函数内部的局部变量，在函数内部，默认的作用域为局部变量
endfunction

前缀	描述
`g:`	全局变量
`l:`	局部变量，只可在函数内部使用
`s:`	脚本变量，只可以在当前脚本函数内使用
`v:`	Vim 特殊变量
`b:`	作用域限定在某一个缓冲区内
`w:`	作用域限定在窗口内部
`t:`	作用域限定在标签内部

此外，在开发 Vim 插件之前，你还需要了解 vimrc 和 Vim 插件的区别。

函数定义

可以使用 function 关键字定义函数，可缩写成 func 或者 fn, 格式：

:fu[nction][!] {name}([arguments]) [range] [abort] [dict] [closure]

当使用了参数 closure 时，函数可以访问外部的变量或者参数，比如：

function! Foo()
  let x = 0
  function! Bar() closure
    let x += 1
    return 1
  endfunction
  return funcref('Bar')
endfunction

let F = Foo()

echo F()
" 1
echo F()
" 2
echo F()
" 3

插件的目录结构

在开发插件之前，需要了解下一个插件项目的目录结构是怎样的，以及每一个目录里文件的意义是什么。插件标准的目录结构为：

autoload/               自动载入脚本
colors/                 颜色主题
plugin/                 在 Vim 启动时将被载入的脚本
ftdetect/               文件类型识别脚本
syntax/                 语法高亮文件
ftplugin/               文件类型相关插件
compiler/	              编译器
indent/                 语法对齐

下面，我们来逐一说明下每一个目录的用途： autoload/ 顾名思义，该文件夹下的脚本会在特点条件下自动被载入。这里的特定条件指的是当某一个 autoload 类型的函数被调用，并且 Vim 当前环境下并未定义该函数时。比如调用 call helloworld#init() 时，Vim 会先检测当前环境下是否定义了该函数，若没有，则在 autoload/ 目录下找 helloworld.vim 这一文件，并将其载入，载入完成后执行 call helloworld#init(). plugin/ 该目录里的文件将在 Vim 启动时被运行，作为一个优秀的 Vim 插件，应当尽量该目录下的脚本内容。通常，可以将插件的快捷键、命令的定义保留在这个文件里。 ftdetect/ ftdetect 目录里通常存放的是文件类型检测脚本，该目录下的文件也是在 Vim 启动时被载入的。在这一目录里的文件内容，通常比较简单，比如：

autocmd BufNewFile,BufRead *.helloworld set filetype=helloworld

以上脚本使得 Vim 在打开以 .helloworld 为后缀的文件时，将文件类型设置为 helloworld。通常，这个脚本的文件名是和所需要设置的文件类型一样的，上面的例子中文件的名称就是 helloworld.vim。 syntax/ 这一目录下的文件，主要是定义语法高亮的。通常文件名前缀和对应的语言类型相同，比如 Java 的语法文件文件名为 java.vim。关于如何写语法文件，将在后面详细介绍。 colors/ colors 目录下主要存储一些颜色主题脚本，当执行 :colorscheme + 主题名 命令时，对应的颜色主题脚本将被载入。比如执行 :colorscheme helloworld 时，colors/helloworld.vim 这一脚本将被载入。 compiler/ 这一名录里是一些预设的编译器参数，主要给 :make 命令使用的。在最新版的 Vim 中可以使用 :compiler! 编译器名 来为当前缓冲区设定编译器。比如当执行 :compiler! helloworld 时，compiler/helloworld.vim 这一脚本将被载入。 indent/ 在 indent 目录里，主要是一些语法对齐相关的脚本。

Vim 自定义命令

Vim 的自定义命令可以通过 command 命令来定义，比如：

command! -nargs=* -complete=custom,helloworld#complete HelloWorld call helloworld#test()

紧接 command 命令其后的 ! 表示强制定义该命令，即使前面已经定义过了同样名称的命令，也将其覆盖掉。 -nargs=* 表示，该命令可接受任意个数的参数，包括 0 个。-nargs 的取值有以下几种情况：

参数	定义
`-nargs=0`	不接受任何参数（默认）
`-nagrs=1`	只接受一个参数
`-nargs=*`	可接收任意个数参数
`-nargs=?`	可接受 1 个或者 0 个参数
`-nargs=+`	至少提供一个参数

-complete=custom,helloworld#complete 表示，改命令的补全方式采用的是自定义函数 helloworld#complete。-complete 可以接受的参数包括如下内容：

参数	描述
`-complete=augroup`	autocmd 组名
`-complete=buffer`	buffer 名称
`-complete=behave`	`:behave` 命令子选项
`-complete=color`	颜色主题
`-complete=command`	Ex 命令及参数
`-complete=compiler`	编译器
`-complete=cscope`	`:cscope` 命令子选项
`-complete=dir`	文件夹名称
`-complete=environment`	环境变量名称
`-complete=event`	自动命令的事件名称
`-complete=expression`	Vim 表达式
`-complete=file`	文件及文件夹名称
`-complete=file_in_path`	`path` 选项里的文件及文件夹名称
`-complete=filetype`	文件类型
`-complete=function`	函数名称
`-complete=help`	帮助命令子选项
`-complete=highlight`	高亮组名称
`-complete=history`	`:history` 子选项
`-complete=locale`	locale 名称（相当于命令 `locale -a` 的输出）
`-complete=mapping`	快捷键名称
`-complete=menu`	目录
`-complete=messages`	`:messages` 命令子选项
`-complete=option`	Vim 选项名称
`-complete=packadd`	可选的插件名称补全
`-complete=shellcmd`	shell 命令补全
`-complete=sign`	`:sign` 命令补全
`-complete=syntax`	语法文件名称补全
`-complete=syntime`	`:syntime` 命令补全
`-complete=tag`	tags
`-complete=tag_listfiles`	tags, file names are shown when CTRL-D is hit
`-complete=user`	user names
`-complete=var`	user variables
`-complete=custom,{func}`	custom completion, defined via {func}
`-complete=customlist,{func}`	custom completion, defined via {func}

这里主要解释一些自定义的补全函数，从上面的表格可以看出，有两种定义自定义命令补全函数的方式。 -complete=custom,{func} 和 -complete=customlist,{func}。这两种区别在与函数的返回值，前者要求是一个 string 而后者要求补全函数的返回值是 list. 自定义命令补全函数接受三个参数。

:function {func}(ArgLead, CmdLine, CursorPos)

我们以实际的例子来解释这三个参数的含义，比如在命令行是如下内容时，| 表示光标位置，我按下了 <Tab> 键调用了补全函数，那么传递给补全函数的三个参数分别是：

:HelloWorld hello|

参数名	描述
`ArgLead`	当前需要补全的部分，通常是光标前的字符串，上面的例子中是指 `hello`
`CmdLine`	指的是整个命令行内的内容，此时是 `HelloWorld hello`
`CursorPos`	指的当前光标所在的位置，此时是 16, 即为 `len('HelloWorld hello')`

下面，我们来看下定义的函数具体内容：

function! helloworld#complete(ArgLead, CmdLine, CursorPos) abort
    return join(['hellolily', 'hellojeky', 'hellofoo', 'world']
            \ "\n")
endfunction

在上面的函数里，返回的实际上是一个有四行的字符串，Vim 会自动根据 ArgLead 来筛选出可以用来补全的选项，并展示在状态栏上。此时，四行里最后一个 world 因为开头不匹配 ArgLead 所以不会被展示在状态栏上，因此补全效果只有三个可选项。 -complete=customlist,{func} 这一参数所对应的补全函数，也是接受相同的三个参数，但该函数返回的是一个 list。下面，我们来测试这个函数：

function! helloworld#complete(ArgLead, CmdLine, CursorPos) abort
    return ['hellolily', 'hellojeky', 'hellofoo', 'world']
endfunction

区别很明显，customlist 补全时不会自动根据 ArgLead 进行筛选，并且直接补全整个返回的 list，即使列表中有一个 world 完全与 ArgLead(hello) 不同，也会将其直接覆盖。因此，当使用 customlist 时，需要在函数内根据 ArgLead 进行筛选，将函数该为如下，就可以得到相同效果了：

function! helloworld#complete(ArgLead, CmdLine, CursorPos) abort
    return filter(['hellolily', 'hellojeky', 'hellofoo', 'world'], 'v:val =~ "^" . a:ArgLead')
endfunction

-bang 参数：

在定义 Vim 自定义命令时，可以通过 -bang 参数来申明这个命令接受感叹号。比如 :q 与 :q!。下面是一个实例：

fu! s:hello(bang)
  if a:bang
    echom "带有叹号"
  else
    echom "不带有叹号"
  endif
endf
command! -bang Hello call s:hello(<bang>0)

在上面的实例里，函数的参数写法为 <bang>0, 当执行:Hello! 时，传递给 s:hello 这一函数的参数是 !0 即为 1，因此，此时看到打印了”带有叹号“。其实除了写成 <bang>0, 还可以写 <bang>1, 甚至是 <bang> + 一个全局变量。比如：

let g:hello = 0
fu! s:hello(bang)
  if a:bang
    echom "带有叹号"
  else
    echom "不带有叹号"
  endif
endf
command! -bang Hello call s:hello(<bang>g:hello)

如何配置 SpaceVim

Tue, 28 Aug 2018 00:00:00 +0000

设置 SpaceVim 选项
启用/禁用模块
添加自定义插件
自定义快捷键及插件配置

本文将系统地介绍如何配置 SpaceVim，配置 SpaceVim 主要包括以下几个内容：

设置 SpaceVim 选项
启动/禁用模块
添加自定义插件
添加自定义按键映射以及插件配置

设置 SpaceVim 选项

原先，在老版本的 SpaceVim 中，默认的配置文件是 init.vim。在 init.vim 文件内，我们可以通过 let g:spacevim_* 这样的语句来设置 SpaceVim 选项。而在新版的 SpaceVim 中，我们采用了 toml 作为默认配置文件，如果不熟悉 toml 语法的，可以先阅读一下 toml 的基本语法，当然不读也没关系， toml 已经是最简单的配置文件格式了。所有的 SpaceVim 选项配置在一个字典里，key 为原先的选项名去除 g:spacevim_ 前缀：

g:spacevim_enable_guicolors -> enable_guicolors

这一选项的值可为 true 或者 false，于是，写入配置即为：

[options]
    enable_guicolors = false

一些其他选项，有的值是数字，有的是字符串，字符串的格式和 vim script 类似，可以用单引号，也可以用双引号，比如：

[options]
    enable_guicolors = false
    snippet_engine = "neosnippet"
    statusline_separator = 'arrow'
    sidebar_width = 30

启用/禁用模块

SpaceVim 内置了很多模块，每一个模块由一些插件和相关配置组成，用于提供一些特定的功能，比如提供模糊搜索的模块，提供版本控制的模块，以及提供语言开发支持的语言模块。启用或者禁用模块，需要遵循一定的语法结构，并且配到 layers 列表内，比如我现在需要启用 shell 模块，设置模块选项 default_position 和 default_height, 这两个选项分别控制这 shell 窗口打开位置和高度：

[[layers]]
    name = "shell"
    default_position = "top"
    default_height = 30

如果要禁用一个模块，需要增添一个选项 enable, 并赋值 false，默认这个是 true。比如，我需要禁用 shell 模块，可以这么写, 禁用模块时，除了 enable 这选项，其他选项可写可不写，因为已经不会生效。当然如果为了快速启用/禁用模块，可以保持其他选项不变。

[[layers]]
    name = "shell"
    enable = false

添加自定义插件

自定义插件配置语法和模块有点类似，将需要配置的插件，配置进 custom_plugins 列表。比如，我需要添加 2 个插件，可以参考以下语法：

[[custom_plugins]]
    name = "lilydjwg/colorizer"
    merged = 0

[[custom_plugins]]
    name = "tpope/vim-scriptease"
    merged = 0
    on_cmd = "Scriptnames"

大家可以看到，在添加自定义插件时，我们支持很多选项，这归功于 dein, dein 支持多种选项。

自定义快捷键及插件配置

最后，我们来说下，如果添加自定义配置，和自定义快捷键。在使用 toml 配置 SpaceVim 时，我们提供了两个选项，位于 [options] 下： bootstrap_before 和 bootstrap_after, 这两个选项接受一个字符串最为值，该字符串值得是一个 vim 方法名。顾名思义，你可以通过这两个选项定义两个 vim 方法，分别在载入配置时，和 vim 启动后被调用，在方法内，你可以加入一些 vim 脚本，比如快捷键，比如插件的选项。比如，在配置文件内加入如下内容：

[options]
    enable_guicolors = false
    snippet_engine = "neosnippet"
    statusline_separator = 'arrow'
    sidebar_width = 30
    bootstrap_before = "myspacevim#before"
    bootstrap_after = "myspacevim#after"

新建 ~/.SpaceVim.d/autoload/myspacevim.vim, 加入内容：

function! myspacevim#before() abort
    let g:neomake_enabled_c_makers = ['clang']
    nnoremap jk <esc>
endf
function! myspacevim#after() abort
endf

在上述这个方法内部，目前只定义了一个变量和快捷键，用户可以添加一些其他的 vim 脚本，比如定制一些 autocmd

augroup MySpaceVim
  au!
  autocmd FileType markdown setlocal nowrap
augroup END

也是应大多数人要求，更新的这篇文字，仓促之下，有很多内容可能还不完整，如果有什么疑问，欢迎留言。

Ruby 数据类型

Wed, 15 Aug 2018 00:00:00 +0000

数值类型(Number)

Ruby支持的数据类型包括基本的Number、String、Ranges、Symbols，以及true、false和nil这几个特殊值，同时还有两种重要的数据结构——Array和Hash。

数值类型(Number)

1、整型(Integer) 整型分两种，如果在31位以内（四字节），那为Fixnum实例。如果超过，即为Bignum实例。整数范围从 -230 到 230-1 或 -262 到 262-1。在这个范围内的整数是类 Fixnum 的对象，在这个范围外的整数存储在类 Bignum 的对象中。您可以在整数前使用一个可选的前导符号，一个可选的基础指标（0 对应 octal，0x 对应 hex，0b 对应 binary），后跟一串数字。下划线字符在数字字符串中被忽略。您可以获取一个 ASCII 字符或一个用问号标记的转义序列的整数值。实例

123                  # Fixnum 十进制
1_234                # Fixnum 带有下划线的十进制
-500                 # 负的 Fixnum
0377                 # 八进制
0xff                 # 十六进制
0b1011               # 二进制
?a                   # 'a' 的字符编码
?\n                  # 换行符（0x0a）的编码
12345678901234567890 # Bignum

#整型 Integer 以下是一些整型字面量 
#字面量（literal）：代码中能见到的值，数值，bool值，字符串等都叫字面量 
#如以下的0,1_000_000,0xa等 
a1=0 

#带千分符的整型 
a2=1_000_000 

#其它进制的表示 
a3=0xa 
puts a1,a2 
puts a3 

#puts print 都是向控制台打印字符，其中puts带回车换行符 
=begin 
这是注释，称作：嵌入式文档注释 
类似C#中的/**/ 
=end 

浮点型 Ruby 支持浮点数。它们是带有小数的数字。浮点数是类 Float 的对象，且可以是下列中任意一个。实例

123.4                # 浮点值
1.0e6                # 科学记数法
4E20                 # 不是必需的
4e+20                # 指数前的符号

#浮点型 
f1=0.0 
f2=2.1 
f3=1000000.1 
puts f3  

算术操作加减乘除操作符：+-*/；指数操作符为** 指数不必是整数，例如

#指数算术 
puts 2**(1/4)#1与4的商为0，然后2的0次方为1 
puts 16**(1/4.0)#1与4.0的商为0.25（四分之一），然后开四次方根 

字符串类型 Ruby 字符串简单地说是一个 8 位字节序列，它们是类 String 的对象。双引号标记的字符串允许替换和使用反斜线符号，单引号标记的字符串不允许替换，且只允许使用 \\ 和 \' 两个反斜线符号。实例

#!/usr/bin/ruby -w

puts 'escape using "\\"';
puts 'That\'s right';

实例

#!/usr/bin/ruby -w

puts 'escape using "\\"';
puts 'That\'s right';

这将产生以下结果：

escape using "\"
That's right

您可以使用序列 #{ expr } 替换任意 Ruby 表达式的值为一个字符串。在这里，expr 可以是任意的 Ruby 表达式。

#!/usr/bin/ruby -w

puts "Multiplication Value : #{24*60*60}";

这将产生以下结果：

Multiplication Value : 86400

#!/usr/bin/ruby -w

name="Ruby" 
puts name 
puts "#{name+",ok"}" 

输出结果为：

Ruby
Ruby,ok

反斜线符号下表列出了 Ruby 支持的反斜线符号：

符号	表示的字符
\n	换行符 (0x0a)
\r	回车符 (0x0d)
\f	换页符 (0x0c)
退格键	(0x08)
\a	报警符 Bell (0x07)
\e	转义符 (0x1b)
\s	空格符 (0x20)
\nnn	八进制表示法 (n 是 0-7)
\xnn	十六进制表示法 (n 是 0-9、a-f 或 A-F)
\cx, \C-x	Control-x
\M-x	Meta-x (c \| 0x80)
\M-\C-x	Meta-Control-x
\x	字符 x

如需了解更多有关 Ruby 字符串的细节，请查看 Ruby 字符串（String）。数组数组字面量通过[]中以逗号分隔定义，且支持range定义。（1）数组通过[]索引访问（2）通过赋值操作插入、删除、替换元素（3）通过+，－号进行合并和删除元素，且集合做为新集合出现（4）通过«号向原数据追加元素（5）通过*号重复数组元素（6）通过｜和&符号做并集和交集操作（注意顺序）实例

#!/usr/bin/ruby
ary = [ "fred", 10, 3.14, "This is a string", "last element", ]
ary.each do |i|
    puts i
end

运行实例 » 这将产生以下结果：

fred
10
3.14
This is a string
last element

如需了解更多有关 Ruby 数组的细节，请查看 Ruby 数组（Array）。哈希类型 Ruby 哈希是在大括号内放置一系列键/值对，键和值之间使用逗号和序列 => 分隔。尾部的逗号会被忽略。实例

#!/usr/bin/ruby

hsh = colors = { "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
hsh.each do |key, value|
    print key, " is ", value, "\n"
end

运行实例 » 这将产生以下结果：

green is 240
red is 3840
blue is 15

如需了解更多有关 Ruby 哈希的细节，请查看 Ruby 哈希（Hash）。范围类型一个范围表示一个区间。范围是通过设置一个开始值和一个结束值来表示。范围可使用 s..e 和 s…e 来构造，或者通过 Range.new 来构造。使用 .. 构造的范围从开始值运行到结束值（包含结束值）。使用 … 构造的范围从开始值运行到结束值（不包含结束值）。当作为一个迭代器使用时，范围会返回序列中的每个值。范围 (1..5) 意味着它包含值 1, 2, 3, 4, 5，范围 (1…5) 意味着它包含值 1, 2, 3, 4 。实例

#!/usr/bin/ruby

(10..15).each do |n|
    print n, ' '
end

这将产生以下结果：

10 11 12 13 14 15

Ruby 基本语法

Sun, 12 Aug 2018 00:00:00 +0000

程序中的空白
程序中的行尾
标识符
保留字
Here Document
BEGIN 语句
END 语句
注释

让我们编写一个简单的 Ruby 程序。所有的 Ruby 文件扩展名都是 .rb。所以，把下面的源代码放在 test.rb 文件中。实例

#!/usr/bin/ruby -w
puts "Hello, Ruby!";

在这里，假设您的 /usr/bin 目录下已经有可用的 Ruby 解释器。现在，尝试运行这个程序，如下所示：

$ ruby test.rb

这将会产生下面的结果：

Hello, Ruby!

您已经看到了一个简单的 Ruby 程序，现在让我们看看一些 Ruby 语法相关的基本概念：

程序中的空白

在 Ruby 代码中的空白字符，如空格和制表符一般会被忽略，除非当它们出现在字符串中时才不会被忽略。然而，有时候它们用于解释模棱两可的语句。当启用 -w 选项时，这种解释会产生警告。实例：

a + b 被解释为 a+b （这是一个局部变量）
a  +b 被解释为 a(+b) （这是一个方法调用）

程序中的行尾

Ruby 把分号和换行符解释为语句的结尾。但是，如果 Ruby 在行尾遇到运算符，比如 +、- 或反斜杠，它们表示一个语句的延续。

标识符

标识符是变量、常量和方法的名称。Ruby 标识符是大小写敏感的。这意味着 Ram 和 RAM 在 Ruby 中是两个不同的标识符。 Ruby 标识符的名称可以包含字母、数字和下划线字符（ _ ）。

保留字

下表列出了 Ruby 中的保留字。这些保留字不能作为常量或变量的名称。但是，它们可以作为方法名。

BEGIN	do	next	then
END	else	nil	true
alias	elsif	not	undef
and	end	or	unless
begin	ensure	redo	until
break	false	rescue	when
case	for	retry	while
class	if	return	while
def	in	self	__FILE__
defined?	module	super	__LINE__

Here Document

“Here Document” 是指建立多行字符串。在 « 之后，您可以指定一个字符串或标识符来终止字符串，且当前行之后直到终止符为止的所有行是字符串的值。如果终止符用引号括起，引号的类型决定了面向行的字符串类型。请注意« 和终止符之间必须没有空格。下面是不同的实例：

#!/usr/bin/ruby -w
# -*- coding : utf-8 -*-

print <<EOF
    这是第一种方式创建here document 。
    多行字符串。
EOF

print <<"EOF";                # 与上面相同
    这是第二种方式创建here document 。
    多行字符串。
EOF

print <<`EOC`                 # 执行命令
	echo hi there
	echo lo there
EOC

print <<"foo", <<"bar"	      # 您可以把它们进行堆叠
	I said foo.
foo
	I said bar.
bar

这将产生以下结果：

    This is the first way of creating
    her document ie. multiple line string.
    This is the second way of creating
    her document ie. multiple line string.
hi there
lo there
        I said foo.
        I said bar.

BEGIN 语句

语法

BEGIN {
   code
}

声明 code 会在程序运行之前被调用。实例

#!/usr/bin/ruby

puts "This is main Ruby Program"

BEGIN {
   puts "Initializing Ruby Program"
}

这将产生以下结果：

Initializing Ruby Program
This is main Ruby Program

END 语句

语法

END {
   code
}

声明 code 会在程序的结尾被调用。实例

#!/usr/bin/ruby

puts "This is main Ruby Program"

END {
   puts "Terminating Ruby Program"
}
BEGIN {
   puts "Initializing Ruby Program"
}

这将产生以下结果：

Initializing Ruby Program
This is main Ruby Program
Terminating Ruby Program

注释

注释会对 Ruby 解释器隐藏一行，或者一行的一部分，或者若干行。您可以在行首使用字符（ # ）：

# 我是注释，请忽略我。

或者，注释可以跟着语句或表达式的同一行的后面：

name = "Madisetti" # 这也是注释

您可以注释多行，如下所示：

# 这是注释。
# 这也是注释。
# 这也是注释。
# 这还是注释。

下面是另一种形式。这种块注释会对解释器隐藏 =begin/=end 之间的行：

=begin
这是注释。
这也是注释。
这也是注释。
这还是注释。
=end

初识 Ruby 编程语言

Thu, 09 Aug 2018 00:00:00 +0000

一直想再多接触一些脚本语言，之前写了一段时间 python 和 lua，感觉都非常不错。之所以要再学习 Ruby，主要是看到 Ruby 的一些语法上的灵活性。 Ruby 支持代码块、修饰符等这些在其他语言里似乎都没有，最简单的示例：

#!/usr/bin/ruby

$debug=1
puts "debug\n" if $debug

新建了一个 Ruby 的笔记仓库，用来记录 Ruby 学习资料。 https://github.com/wsdjeg/ruby-tutorial-cn

Vim 中文文档规范检查插件

Wed, 01 Aug 2018 00:00:00 +0000

初心
使用说明
协作开发

初心

经常使用 markdown 进行中文写作，包括但不限于写一些文档。对于中文排版目前没有非常好的检查工具。因此做了 chinese_linter.vim 这个插件，目的在于提示中文文档中一些常见的排版错误。

使用说明

在编辑中文文档时，使用如下命令即可检查，错误信息将被展示在 Vim 的 location list 窗口

:CheckChinese

目前支持如下错误代码：

错误代码	描述
E001	中文字符后存在英文标点
E002	中英文之间没有空格
E003	中文与数字之间没有空格
E004	中文标点之后存在空格
E005	行尾含有空格

该插件才开始做，目前仅仅实现了以上五种规范检查，后面会添加更多的规范检查，欢迎尝试。

协作开发

目前这个项目发布在 github 上面，如果有熟悉 Vim 脚本的同学，也欢迎参与，感谢！ wsdjeg/ChineseLinter.vim

为什么要学习 Vim？

Sun, 25 Mar 2018 00:00:00 +0000

Vim 的特点

接触过好几种编辑器、IDE，最终感觉还是 Vim 最适合。学会了 Vim 之后，几乎没有任何动力去换其他编辑器（ Neovim 除外）。相信有很多 Vim 用户和我一样，对 Vim 存在这种感觉。

Vim 的特点

极简的思想 其实，Vim 代表的是一种 KISS 的 Geek 思想，而不仅仅是炫耀。这种思想是指：“选择你需要的，舍弃那些你不需要的”，一种极简思想。一个臃肿的工具，也许可以提供 100% 的功能，但是，实际上你只需要 10% 的功能，其余 90% 功能，你可能都没有心思去研究。那为什么不丢弃臃肿的 90%，轻装上阵呢？当然，适当的展示，活跃社区气氛，吸引新人入坑 Vim 是我辈使命。 Vim 模式 Vim 不同于其他编辑器的地方，就是她提供的模式化编辑，和文本对象。任何 IDE 或者编辑器模拟的 Vim 插件，无非是实现了这两个功能。通过模式，Vim 赋予了同一个按键多种功能，大大提高了按键的功效，可以让我们双手集中在键盘中央区域，提高效率。另外，Vim 将一切文本看成对象，比如删除一个单词，diw（ delete in word ）等等这一类用法，我可以理解为 Vim 语。记得以前看过一段文字，大致内容是这样的：你只有折腾 Vim 累死过 3 次，你才能真正的喜欢上它，不然你就会选择放弃，最终回到 IDE。在 Vim 的世界里，一切都需要自己动手，所以，他不适合不喜欢折腾的人，如果你对它没有 200% 的好奇心，不要玩，不然你一定会摔键盘. 为什么说 Vim 写代码快？前提你累死过 3 次，成功配置了 Vim。那么开始神奇的 Vim 之旅。你就发现:

你删代码比队友快: “first blood”
自动补全比队友快
在 20 个 G 的文件堆里定位代码各种秒杀你队友
在 vim 中完成各种 shell，秒杀你队友 “ Killing spree ”!
优雅的更新升级，删除 Vim 插件（前提 Vundle ） “ Dominating ”!
随性的自定义快捷键，完全属于你自己的风格，一个配置文件随身带着走。或者压缩 Vim 文件包带着走，想去哪就去哪，不用等你队友带节奏。Unstoppable ！
你队友还在用鼠标？那你已经进化了。Wicked Sick ！！
什么？开始用 Vim Markdown 来写文档了？我草，你已经超神了！！ God Like ！！！
你已经离不开 Vim 了。从最开始被各种折腾到想要砸键盘的你，如今你已经爱上他了。aM-m-m-m….（重复 8 次） Monster Kill
你注定和 Vim 过完这一生！……Holy Shit

于是你开始对自己以前的一些行为出现质疑：

删除一行 dd 不就行了，为什么要鼠标选中一行之后按下 backspace ？
清除一行内容 S 不就行了，为什么还要鼠标选中一行然后按下 backspace ？
给一行末尾补分号 A; 不就好了，为什么还要鼠标移过去末尾点一下然后按下;？
然后给 n 行末尾补分号，VNj 选中多行 :normal .（点可以重复上次操作）不就好了，为什么要鼠标一个一个点了然后一个个补？
复制 a 行插入到 b 行后，dd 掉 a 行在 b 行那按下 p 不就好了。为什么要鼠标选中 a，ctrl+x，然后到 b 的末尾按下回车，然后 ctrl-v ？

所以，同为喜欢 Vim 的你，让我们一起来说 Vim 语吧!

Vim 下多光标编辑 iedit 模式

Tue, 23 Jan 2018 00:00:00 +0000

什么是 iedit 模式
如何启动 iedit 模式
iedit 模式模式快捷键

原文链接：https://blog.csdn.net/wsdjeg/article/details/79138641

什么是 iedit 模式

iedit 模式是 SpaceVim 中最新实现的一个多光标编辑模式，取名 iedit 借鉴了 emacs 的 iedit-mode，这一模式给 vim 增添了多光标编辑功能。效果图如下：

如何启动 iedit 模式

在 SpaceVim 中有三种方式启动 iedit 模式：

Normal 模式下直接按下快捷键 SPC s e 会匹配光标所在的单词，并启动 iedit 模式。
Visual 模式下按下快捷键 SPC s e 会匹配所选择的单词，并启动 iedit 模式。
Highlight Symbol 模式按下 e 键会更具以选择的匹配位置来启动 iedit 模式。

iedit 模式模式快捷键

模式转变:

Key Binding	From	to
`SPC s e`	normal or visual	iedit-Normal

iedit-Normal 模式快捷键: iedit-Normal 模式模仿 vim Normal 模式，以下的这些快捷键仅限于 iedit-Normal 模式.

Key Binding	Description
Esc	go back to Normal mode
i	switch to iedit-Insert mode, same as i
a	switch to iedit-Insert mode, same as a
I	go to the beginning of the current occurrence and switch to iedit-Insert mode
A	go to the end of the current occurrence and switch to iedit-Insert mode
	Move cursor to left
	Move cursor to right
0	go to the beginning of the current occurrence
$	go to the end of the current occurrence
D	delete the occurrences
S	delete the occurrences and switch to iedit-Insert mode
gg	go to first occurrence
G	go to last occurrence
n	go to next occurrence
N	go to previous occurrence

iedit-Insert 模式快捷键: iedit-Insert 模式借鉴与 vim Insert 模式下的快捷键，也借鉴了 emacs 和 bash 命令行下的快捷键：

Key Binding	Description
Esc	go back to iedit-Normal mode
	Move cursor to left
	Move cursor to right
	delete words before cursor
	delete words after cursor

Vim 从入门到精通

Mon, 27 Mar 2017 00:00:00 +0000

简介
基础
用法
技巧
调试
杂项

本文翻译自：mhinz/vim-galore, 部分内容有增改。

简介

什么是 Vim？

Vim 是一个历史悠久的文本编辑器，可以追溯到 qed。 Bram Moolenaar 于 1991 年发布初始版本。 Linux、Mac 用户，可以使用包管理器安装 Vim，对于 Windows 用户，可以使用 scoop 包管理器进行下载安装。该版本可轻易添加 python 、python3 、lua 等支持，只需要安装 python、lua 即可。项目在 Github 上开发，项目讨论请订阅 vim_dev 邮件列表。通过阅读 Why, oh WHY, do those #?@! nutheads use vi? 来对 Vim 进行大致的了解。

Vim 哲学

Vim 采用模式编辑的理念，即它提供了多种模式，按键在不同的模式下作用不同。你可以在普通模式 下浏览文件，在插入模式下插入文本，在可视模式下选择行，在命令模式下执行命令等等。起初这听起来可能很复杂，但是这有一个很大的优点：不需要通过同时按住多个键来完成操作，大多数时候你只需要依次按下这些按键即可。越常用的操作，所需要的按键数量越少。和模式编辑紧密相连的概念是 操作符 和动作。操作符 指的是开始某个行为，例如：修改、删除或者选择文本，之后你要用一个动作来指定需要操作的文本区域。比如，要改变括号内的文本，需要执行 ci( （读做 change inner parentheses）；删除整个段落的内容，需要执行 dap （读做：delete around paragraph）。如果你能看见 Vim 老司机操作，你会发现他们使用 Vim 脚本语言就如同钢琴师弹钢琴一样。复杂的操作只需要几个按键就能完成。他们甚至不用刻意去想，因为这已经成为肌肉记忆了。这减少认识负荷并帮助人们专注于实际任务。

入门

Vim 自带一个交互式的教程，内含你需要了解的最基础的信息，你可以通过终端运行以下命令打开教程：

$ vimtutor

不要因为这个看上去很无聊而跳过，按照此教程多练习。你以前用的 IDE 或者其他编辑器很少是有“模式”概念的，因此一开始你会很难适应模式切换。但是你 Vim 使用的越多，肌肉记忆将越容易形成。 Vim 基于一个 vi 克隆，叫做 Stevie，支持两种运行模式：”compatible” 和 “nocompatible”。在兼容模式下运行 Vim 意味着使用 vi 的默认设置，而不是 Vim 的默认设置。除非你新建一个用户的 vimrc 或者使用 vim -N 命令启动 Vim，否则就是在兼容模式下运行 Vim！请大家不要在兼容模式下运行 Vim。下一步

创建你自己的 vimrc。
在第一周准备备忘录。
通读基础章节了解 Vim 还有哪些功能。
按需学习！Vim 是学不完的。如果你遇到了问题，先上网寻找解决方案，你的问题可能已经被解决了。Vim 拥有大量的参考文档，知道如何利用这些参考文档很有必要：获取离线帮助。
浏览附加资源。

最后一个建议：使用插件之前，请先掌握 Vim 的基本操作。很多插件都只是对 Vim 自带功能的封装。

精简的 vimrc

Vim 启动是会按照一定的优先顺序来搜索配置文件，这个顺序，可以通过 :version 命令查看。下面分 Windows 系统，和 *niux 系统分别来说明 Vim 是如何载入配置文件的。

Windows 系统

   system vimrc file: "$VIM\vimrc"
     user vimrc file: "$HOME\_vimrc"
 2nd user vimrc file: "$HOME\vimfiles\vimrc"
 3rd user vimrc file: "$VIM\_vimrc"
      user exrc file: "$HOME\_exrc"
  2nd user exrc file: "$VIM\_exrc"
  system gvimrc file: "$VIM\gvimrc"
    user gvimrc file: "$HOME\_gvimrc"
2nd user gvimrc file: "$HOME\vimfiles\gvimrc"
3rd user gvimrc file: "$VIM\_gvimrc"
       defaults file: "$VIMRUNTIME\defaults.vim"
    system menu file: "$VIMRUNTIME\menu.vim"

我们只看上面这一段，Vim 会优先读取 user vimrc file: $HOME\_vimrc, 当这一文件不存在是， Vim 再去寻找 2nd user vimrc file: $HOME\vimfiles\vimrc; 倘若这个文件还是不存在，那么 Vim 会去继续寻找 3rd user vimrc file: $VIM\_vimrc。了解以上顺序后，就不会再因为 Vim 总是不读取配置文件而感到烦恼了。

Linux 或者 Mac OS

同 Windows 系统类似，也可以使用 :version 命令查看 vim 载入配置的优先顺序。

     系统 vimrc 文件: "/etc/vimrc"
     用户 vimrc 文件: "$HOME/.vimrc"
 第二用户 vimrc 文件: "~/.vim/vimrc"
      用户 exrc 文件: "$HOME/.exrc"
       defaults file: "$VIMRUNTIME/defaults.vim"
         $VIM 预设值: "/etc"
  $VIMRUNTIME 预设值: "/usr/share/vim/vim81"

你可以在网上找到许多精简的 vimrc 配置文件，我的版本可能并不是最简单的版本，但是我的版本提供了一套我认为良好的，非常适合入门的设置。最终你需要阅读完那些设置，然后自行决定需要使用哪些。:-) 精简的 vimrc 地址：minimal-vimrc 如果你有兴趣，这里是我（原作者）的 vimrc。建议：大多数插件作者都维护不止一个插件并且将他们的 vimrc 放在 Github 上展示（通常放在叫做 “vim-config” 或者 “dotfiles” 的仓库中），所以当你发现你喜欢的插件时，去插件维护者的 Github 主页看看有没有这样的仓库。

我正在使用什么样的 Vim

使用 :version 命令将向你展示当前正在运行的 Vim 的所有相关信息，包括它是如何编译的。第一行告诉你这个二进制文件的编译时间和版本号，比如：7.4。接下来的一行呈现 Included patches: 1-1051，这是补丁版本包。因此你 Vim 确切的版本号是 7.4.1051。另一行显示着一些像 Tiny version without GUI 或者 Huge version with GUI 的信息。很显然这些信息告诉你当前的 Vim 是否支持 GUI，例如：从终端中运行 gvim 或者从终端模拟器中的 Vim 内运行 :gui 命令。另一个重要的信息是 Tiny 和 Huge。Vim 的特性集区分被叫做 tiny，small，normal，big and huge，所有的都实现不同的功能子集。 :version 主要的输出内容是特性列表。+clipboard 意味这剪贴板功能被编译支持了，-clipboard 意味着剪贴板特性没有被编译支持。一些功能特性需要编译支持才能正常工作。例如：为了让 :prof 工作，你需要使用 huge 模式编译的 Vim，因为那种模式启用了 +profile 特性。如果你的输出情况并不是那样，并且你是从包管理器安装 Vim 的，确保你安装了 vim-x，vim-x11，vim-gtk，vim-gnome 这些包或者相似的，因为这些包通常都是 huge 模式编译的。你也可以运行下面这段代码来测试 Vim 版本以及功能支持：

" Do something if running at least Vim 7.4.42 with +profile enabled.
if (v:version > 704 || v:version == 704 && has('patch42')) && has('profile')
  " do stuff
endif

备忘录

为了避免版权问题，我只贴出链接：

或者在 Vim 中快速打开备忘录：vim-cheat40。

基础

缓冲区，窗口，标签

Vim 是一个文本编辑器。每次文本都是作为缓冲区的一部分显示的。每一份文件都是在他们自己独有的缓冲区打开的，插件显示的内容也在它们自己的缓冲区中。缓冲区有很多属性，比如这个缓冲区的内容是否可以修改，或者这个缓冲区是否和文件相关联，是否需要同步保存到磁盘上。窗口是缓冲区上一层的视窗。如果你想同时查看几个文件或者查看同一文件的不同位置，那样你会需要窗口。请别把他们叫做分屏。你可以把一个窗口分割成两个，但是这并没有让这两个窗口完全分离。窗口可以水平或者竖直分割并且现有窗口的高度和宽度都是可以被调节设置的，因此，如果你需要多种窗口布局，请考虑使用标签。 标签页 （标签）是窗口的集合。因此当你想使用多种窗口布局时候请使用标签。简单的说，如果你启动 Vim 的时候没有附带任何参数，你会得到一个包含着一个呈现一个缓冲区的窗口的标签。顺带提一下，缓冲区列表是全局可见的，你可以在任何标签中访问任何一个缓冲区。

已激活、已载入、已列出、已命名的缓冲区

用类似 vim file1 的命令启动 Vim 。这个文件的内容将会被加载到缓冲区中，你现在有一个已载入的缓冲区。如果你在 Vim 中保存这个文件，缓冲区内容将会被同步到磁盘上（写回文件中）。由于这个缓冲区也在一个窗口上显示，所以他也是一个已激活的缓冲区。如果你现在通过 :e file2 命令加载另一个文件，file1 将会变成一个隐藏的缓冲区，并且 file2 变成已激活缓冲区。使用 :ls 我们能够列出所有可以列出的缓冲区。插件缓冲区和帮助缓冲区通常被标记为不可以列出的缓冲区，因为那并不是你经常需要在编辑器中编辑的常规文件。通过 :ls! 命令可以显示被放入缓冲区列表的和未被放入列表的缓冲区。 未命名的缓冲区是一种没有关联特定文件的缓冲区，这种缓冲区经常被插件使用。比如 :enew 将会创建一个无名临时缓冲区。添加一些文本然后使用 :w /tmp/foo 将他写入到磁盘，这样这个缓冲区就会变成一个已命名的缓冲区。

参数列表

全局缓冲区列表是 Vim 的特性。在这之前的 vi 中，仅仅只有参数列表，参数列表在 Vim 中依旧可以使用。每一个通过 shell 命令传递给 Vim 的文件名都被记录在一个参数列表中。可以有多个参数列表：默认情况下所有参数都被放在全局参数列表下，但是你可以使用 :arglocal 命令去创建一个新的本地窗口的参数列表。使用 :args 命令可以列出当前参数。使用 :next，:previous，:first，:last 命令可以在切换在参数列表中的文件。通过使用 :argadd，:argdelete 或者 :args 等命令加上一个文件列表可以改变参数列表。偏爱缓冲区列表还是参数列表完全是个人选择，我的印象中大多数人都是使用缓冲区列表的。然而参数列表在有些情况下被大量使用：批处理使用 :argdo！一个简单的重构例子：

:args **/*.[ch]
:argdo %s/foo/bar/ge | update

这条命令将替换掉当前目录下以及当前目录的子目录中所有的 C 源文件和头文件中的“foo”，并用“bar”代替。相关帮助：:h argument-list

按键映射

使用 :map 命令家族你可以定义属于你自己的快捷键。该家族的每一个命令都限定在特定的模式下。从技术上来说 Vim 自带高达 12 中模式，其中 6 种可以被映射。另外一些命令作用于多种模式：

递归	非递归	模式
`:map`	`:noremap`	normal, visual, operator-pending
`:nmap`	`:nnoremap`	normal
`:xmap`	`:xnoremap`	visual
`:cmap`	`:cnoremap`	command-line
`:omap`	`:onoremap`	operator-pending
`:imap`	`:inoremap`	insert

例如：这个自定义的快捷键只在普通模式下工作。

:nmap <space> :echo "foo"<cr>

使用 :nunmap <space> 可以取消这个映射。对于更少数，不常见的模式（或者他们的组合），查看 :h map-modes。到现在为止还好，对新手而言有一个问题会困扰他们：:nmap 是递归执行的！结果是，右边执行可能的映射。你自定义了一个简单的映射去输出“Foo”：

:nmap b :echo "Foo"<cr>

但是如果你想要映射 b （回退一个单词）的默认功能到一个键上呢？

:nmap a b

如果你敲击a，我们期望着光标回退到上一个单词，但是实际情况是“Foo”被输出到命令行里！因为在右边，b 已经被映射到别的行为上了，换句话说就是 :echo "Foo"<cr>。解决此问题的正确方法是使用一种 非递归 的映射代替：

:nnoremap a b

经验法则：除递归映射是必须的，否则总是使用非递归映射。通过不给一个右值来检查你的映射。比如:nmap 显示所以普通模式下的映射，:nmap <leader> 显示所有以 <leader> 键开头的普通模式下的映射。如果你想禁止用标准映射，把他们映射到特殊字符 <nop> 上，例如：:noremap <left> <nop>。相关帮助：

:h key-notation
:h mapping
:h 05.3

映射前置键

映射前置键（Leader 键）本身就是一个按键映射，默认为 \\。我们可以通过在 map 中调用 <leader> 来为把它添加到其他按键映射中。

nnoremap <leader>h :helpgrep<space>

这样，我们只需要先按 \\ 然后按 h 就可以激活这个映射 :helpgrep<space>。如果你想通过先按 空格 键来触发，只需要这样做：

let g:mapleader = ' '
nnoremap <leader>h :helpgrep<space>

此处建议使用 g:mapleader，因为在 Vim 脚本中，函数外的变量缺省的作用域是全局变量，但是在函数内缺省作用域是局部变量，而设置快捷键前缀需要修改全局变量 g:mapleader 的值。另外，还有一个叫 <localleader> 的，可以把它理解为局部环境中的 <leader>，默认值依然为 \\。当我们需要只对某一个条件下（比如，特定文件类型的插件）的缓冲区设置特别的 <leader> 键，那么我们就可以通过修改当前环境下的 <localleader> 来实现。注意：如果你打算设置 Leader 键，请确保在设置按键映射之前，先设置好 Leader 键。如果你先设置了含有 Leader 键的映射，然后又修改了 Leader 键，那么之前映射内的 Leader 键是不会因此而改变的。你可以通过执行 :nmap <leader> 来查看普通模式中已绑定给 Leader 键的所有映射。请参阅 :h mapleader 与 :h maploacalleader 来获取更多帮助。

寄存器

寄存器就是存储文本的地方。我们常用的「复制」操作就是把文本存储到寄存器，「粘贴」操作就是把文本从寄存器中读出来。顺便，在 Vim 中复制的快捷键是 y，粘贴的快捷键是 p。 Vim 为我们提供了如下的寄存器：

类型	标识	读写者	是否为只读	包含的字符来源
Unnamed	`"`	vim	否	最近一次的复制或删除操作 (`d`, `c`, `s`, `x`, `y`)
Numbered	`0`至`9`	vim	否	寄存器 `0`: 最近一次复制。寄存器 `1`: 最近一次删除。寄存器 `2`: 倒数第二次删除，以此类推。对于寄存器 `1` 至 `9`，他们其实是只读的最多包含 9 个元素的队列。这里的队列即为数据类型 queue
Small delete	`-`	vim	否	最近一次行内删除
Named	`a`至`z`, `A`至`Z`	用户	否	如果你通过复制操作存储文本至寄存器 `a`，那么 `a` 中的文本就会被完全覆盖。如果你存储至 `A`，那么会将文本添加给寄存器 `a`，不会覆盖之前已有的文本
Read-only	`:`与`.`和`%`	vim	是	`:`: 最近一次使用的命令，`.`: 最近一次添加的文本，`%`: 当前的文件名
Alternate buffer	`#`	vim	否	大部分情况下，这个寄存器是当前窗口中，上一次访问的缓冲区。请参阅 `:h alternate-file` 来获取更多帮助
Expression	`=`	用户	否	复制 VimL 代码时，这个寄存器用于存储代码片段的执行结果。比如，在插入模式下复制 `<c-r>=5+5<cr>`，那么这个寄存器就会存入 10
Selection	`+`和`*`	vim	否	`*` 和 `+` 是剪贴板寄存器
Drop	`~`	vim	是	最后一次拖拽添加至 Vim 的文本（需要 “+dnd” 支持，暂时只支持 GTK GUI。请参阅 `:help dnd` 及 `:help quote~`）
Black hole	`_`	vim	否	一般称为黑洞寄存器。对于当前操作，如果你不希望在其他寄存器中保留文本，那就在命令前加上 `_`。比如，`"_dd` 命令不会将文本放到寄存器 `"`、`1`、`+` 或 `*` 中
Last search pattern	`/`	vim	否	最近一次通过 `/`、`?` 或 `:global` 等命令调用的匹配条件

只要不是只读的寄存器，用户都有权限修改它的内容，比如：

:let @/ = 'register'

这样，我们按 n 的时候就会跳转到单词”register” 出现的地方。有些时候，你的操作可能已经修改了寄存器，而你没有察觉到。请参阅 :h registers 获取更多帮助。上面提到过，复制的命令是 y，粘贴的命令是 p 或者 P。但请注意，Vim 会区分「字符选取」与「行选取」。请参阅 :h linewise 获取更多帮助。 行选取：命令 yy 或 Y 都是复制当前行。这时移动光标至其他位置，按下 p 就可以在光标下方粘贴复制的行，按下 P 就可以在光标上方粘贴至复制的行。 字符选取：命令 0yw 可以复制第一个单词。这时移动光标至其他位置，按下 p 就可以在当前行、光标后的位置粘贴单词，按下 P 就可以在当前行、光标前的位置粘贴单词。 将文本存到指定的寄存器中：命令 "aY 可以将当前行复制，并存储到寄存器 a 中。这时移动光标至其他位置，通过命令 "AY 就可以把这一行的内容扩展到寄存器 a 中，而之前存储的内容也不会丢失。为了便于理解和记忆，建议大家现在就试一试上面提到的这些操作。操作过程中，你可以随时通过 :reg 来查看寄存器的变化。 有趣的是：在 Vim 中，y 是复制命令，源于单词 “yanking”。而在 Emacs 中，”yanking” 代表的是粘贴（或者说，重新插入刚才删掉的内容），而并不是复制。

范围

范围 (Ranges) 其实很好理解，但很多 Vim 用户的理解不到位。

很多命令都可以加一个数字，用于指明操作范围
范围可以是一个行号，用于指定某一行
范围也可以是一对通过 , 或 ; 分割的行号
大部分命令，默认只作用于当前行
只有 :write 和 :global 是默认作用于所有行的

范围的使用是十分直观的。以下为一些例子（其中，:d 为 :delete 的缩写）：

命令	操作的行
`:d`	当前行
`:.d`	当前行
`:1d`	第一行
`:$d`	最后一行
`:1,$d`	所有行
`:%d`	所有行（这是 `1,$` 的语法糖）
`:.,5d`	当前行至第 5 行
`:,5d`	同样是当前行至第 5 行
`:,+3d`	当前行及接下来的 3 行
`:1,+3d`	第一行至当前行再加 3 行
`:,-3d`	当前行及向上的 3 行（Vim 会弹出提示信息，因为这是一个保留的范围）
`:3,'xdelete`	第三行至标注为 x 的那一行
`:/^foo/,$delete`	当前行以下，以字符 “foo” 开头的那一行至结尾
`:/^foo/+1,$delete`	当前行以下，以字符 “foo” 开头的那一行的下一行至结尾

需要注意的是，; 也可以用于表示范围。区别在于，a,b 的 b 是以当前行作为参考的。而 a;b 的 b 是以 a 行作为参考的。举个例子，现在你的光标在第 5 行。这时 :1,+1d 会删除第 1 行至第 6 行，而 :1;+1d 会删除第 1 行和第 2 行。如果你想设置多个寻找条件，只需要在条件前加上 /，比如：

:/foo//bar//quux/d

这就会删除当前行之后的某一行。定位方式是，先在当前行之后寻找第一个包含 “foo” 字符的那一行，然后在找到的这一行之后寻找第一个包含 “bar” 字符的那一行，然后再在找到的这一行之后寻找第一个包含 “quux” 的那一行。删除的就是最后找到的这一行。有时，Vim 会在命令前自动添加范围。举个例子，如果你先通过 V 命令进入行选取模式，选中一些行后按下 : 进入命令模式，这时候你会发现 Vim 自动添加了 '<,'> 范围。这表示，接下来的命令会使用之前选取的行号作为范围。但如果后续命令不支持范围，Vim 就会报错。为了避免这样的情况发生，有些人会设置这样的按键映射：:vnoremap foo :<c-u>command，组合键 Ctrl + u 可以清除当前命令行中的内容。另一个例子是在普通模式中按下 !!，命令行中会出现 :.!。如果这时你如果输入一个外部命令，那么当前行的内容就会被这个外部命令的输出替换。你也可以通过命令 :?^$?+1,/^$/-1!ls 把当前段落的内容替换成外部命令 ls 的输出，原理是向前和向后各搜索一个空白行，删除这两个空白行之间的内容，并将外部命令 ls 的输出放到这两个空白行之间。请参阅以下两个命令来获取更多帮助：

:h cmdline-ranges
:h 10.3

标注

你可以使用标注功能来标记一个位置，也就是记录文件某行的某个位置。

标注	设置者	使用
`a`-`z`	用户	仅对当前的一个文件生效，也就意味着只可以在当前文件中跳转
`A`-`Z`	用户	全局标注，可以作用于不同文件。大写标注也称为「文件标注」。跳转时有可能会切换到另一个缓冲区
`0`-`9`	viminfo	`0` 代表 viminfo 最后一次被写入的位置。实际使用中，就代表 Vim 进程最后一次结束的位置。`1` 代表 Vim 进程倒数第二次结束的位置，以此类推

如果想跳转到指定的标注，你可以先按下 ' / g' 或者 ` / g` 然后按下标注名。如果你想定义当前文件中的标注，可以先按下 m 再按下标注名。比如，按下 mm 就可以把当前位置标注为 m。在这之后，如果你的光标切换到了文件的其他位置，只需要通过 'm 或者 `m即可回到刚才标注的行。区别在于，'m会跳转回被标记行的第一个非空字符，而`m会跳转回被标记行的被标记列。根据 viminfo 的设置，你可以在退出 Vim 的时候保留小写字符标注。请参阅:h viminfo-' 来获取更多帮助。如果你想定义全局的标注，可以先按下 m 再按下大写英文字符。比如，按下 mM 就可以把当前文件的当前位置标注为 M。在这之后，就算你切换到其他的缓冲区，依然可以通过 'M 或 `M 跳转回来。关于跳转，还有以下的方式：

按键	跳转至
`'[` 与 `[	上一次修改或复制的第一行或第一个字符
`']` 与 `]	上一次修改或复制的最后一行或最后一个字符
`'<` 与 `<	上一次在可视模式下选取的第一行或第一个字符
`'>` 与 `>	上一次在可视模式下选取的最后一行或最后一个字符
`''` 与 `'	上一次跳转之前的光标位置
`'"` 与 `"	上一次关闭当前缓冲区时的光标位置
`'^` 与 `^	上一次插入字符后的光标位置
`'.` 与 `.	上一次修改文本后的光标位置
`'(` 与 `(	当前句子的开头
`')` 与 `)	当前句子的结尾
`'{` 与 `{	当前段落的开头
`'}` 与 `}	当前段落的结尾

标注也可以搭配范围一起使用。前面提到过，如果你在可视模式下选取一些文本，然后按下 :，这时候你会发现命令行已经被填充了 :'<,'>。对照上面的表格，现在你应该明白了，这段代表的就是可视模式下选取的范围。请使用 :marks 命令来显示所有的标注，参阅 :h mark-motions 来获取关于标注的更多帮助。

补全

Vim 在插入模式中为我们提供了多种补全方案。如果有多个补全结果，Vim 会弹出一个菜单供你选择。常见的补全有标签、项目中引入的模块或库中的方法名、文件名、字典及当前缓冲区的字段。针对不同的补全方案，Vim 为我们提供了不同的按键映射。这些映射都是在插入模式中通过 Ctrl + x 来触发：

映射	类型	帮助文档
`<c-x><c-l>`	整行	`:h i^x^l`
`<c-x><c-n>`	当前缓冲区中的关键字	`:h i^x^n`
`<c-x><c-k>`	字典（请参阅 `:h 'dictionary'`）中的关键字	`:h i^x^k`
`<c-x><c-t>`	同义词字典（请参阅 `:h 'thesaurus'`）中的关键字	`:h i^x^t`
`<c-x><c-i>`	当前文件以及包含的文件中的关键字	`:h i^x^i`
`<c-x><c-]>`	标签	`:h i^x^]`
`<c-x><c-f>`	文件名	`:h i^x^f`
`<c-x><c-d>`	定义或宏定义	`:h i^x^d`
`<c-x><c-v>`	Vim 命令	`:h i^x^v`
`<c-x><c-u>`	用户自定义补全（通过 `'completefunc'` 定义）	`:h i^x^u`
`<c-x><c-o>`	Omni Completion（通过 `'omnifunc'` 定义）	`:h i^x^o`
`<c-x>s`	拼写建议	`:h i^Xs`

尽管用户自定义补全与 Omni Completion 是不同的，但他们做的事情基本一致。共同点在于，他们都是一个监听当前光标位置的函数，返回值为一系列的补全建议。用户自定义补全是由用户定义的，基于用户的个人用途，因此你可以根据自己的喜好和需求随意定制。而 Omni Completion 是针对文件类型的补全，比如在 C 语言中补全一个结构体（struct）的成员（members），或者补全一个类的方法，因而它通常都是由文件类型插件设置和调用的。如果你设置了 'complete' 选项，那么你就可以在一次操作中采用多种补全方案。这个选项默认包含了多种可能性，因此请按照自己的需求来配置。你可以通过 <c-n> 来调用下一个补全建议，或通过 <c-p> 来调用上一个补全建议。当然，这两个映射同样可以直接调用补全函数。请参阅 :h i^n 与 :h 'complete' 来获得更多帮助。如果你想配置弹出菜单的行为，请一定要看一看 :h 'completeopt' 这篇帮助文档。默认的配置已经不错了，但我个人（原作者）更倾向于把 “noselect” 加上。请参阅以下文档获取更多帮助：

:h ins-completion
:h popupmenu-keys
:h new-omni-completion

动作，操作符，文本对象

动作也就是指移动光标的操作，你肯定很熟悉 h、j、k 和 l，以及 w 和 b。但其实，/ 也是一个动作。他们都可以搭配数字使用，比如 2?the<cr> 可以将光标移动到倒数第二个 “the” 出现的位置。以下会列出一些常用的动作。你也可以通过 :h navigation 来获取更多的帮助。 操作符是对某个区域文本执行的操作。比如，d、~、gU 和 > 都是操作符。这些操作符既可以在普通模式下使用，也可以在可视模式下使用。在普通模式中，顺序是先按操作符，再按动作指令，比如 >j。在可视模式中，选中区域后直接按操作符就可以，比如 Vjd。与动作一样，操作符也可以搭配数字使用，比如 2gUw 可以将当前单词以及下一个单词转成大写。由于动作和操作符都可以搭配数字使用，因此 2gU2w 与执行两次 gU2w 效果是相同的。请参阅 :h operator 来查看所有的操作符。你也可以通过 :set tildeop 命令把 ~ 也变成一个操作符值得注意的是，动作是单向的，而文本对象是双向的。文本对象不仅作用于符号（比如括号、中括号和大括号等）标记的范围内，也作用于整个单词、整个句子等其他情况。文本对象不能用于普通模式中移动光标的操作，因为光标还没有智能到可以向两个方向同时跳转。但这个功能可以在可视模式中实现，因为在对象的一端选中的情况下，光标只需要跳转到另一端就可以了。文本对象操作一般用 i 或 a 加上对象标识符操作，其中 i 表示在对象内（英文 inner）操作，a 表示对整个对象（英文 around）操作，这时开头和结尾的空格都会被考虑进来。举个例子，diw 可以删除当前单词，ci( 可以改变括号中的内容。文本对象同样可以与数字搭配使用。比如，像 ((( ))) 这样的文本，假如光标位于最内层的括号上或最内层的括号内，那么 d2a( 将会删除从最内层开始的两对括号，以及他们之间的所有内容。其实，d2a( 这个操作等同于 2da(。在 Vim 的命令中，如果有两处都可以接收数字作为参数，那么最终结果就等同于两个数字相乘。在这里，d 与 a( 都是可以接收参数的，一个参数是 1，另一个是 2，我们可以把它们相乘然后放到最前面。请参阅 :h text-objects 来获取更多关于文本对象的帮助。

自动命令

在特定的情况下，Vim 会传出事件。如果你想针对这些事件执行回调方法，那么就需要用到自动命令这个功能。如果没有了自动命令，那你基本上是用不了 Vim 的。自动命令一直都在执行，只是很多时候你没有注意到。不信的话，可以执行命令 :au ，不要被结果吓到，这些是当前有效的所有自动命令。请使用 :h {event} 来查看 Vim 中所有事件的列表，你也可以参考 :h autocmd-events-abc 来获取关于事件的更多帮助。一个很常用的例子，就是针对文件类型执行某些设置：

autocmd FileType ruby setlocal shiftwidth=2 softtabstop=2 comments-=:#

但是缓冲区是如何知道当前的文件中包含 Ruby 代码呢？这其实是另一个自动命令检测的到的，然后把文件类型设置成为 Ruby，这样就触发了上面的 FileType 事件。在配置 vimrc 的时候，一般第一行加进去的就是 filetype on。这就意味着，Vim 启动时会读取 filetype.vim 文件，然后根据文件类型来触发相应的自动命令。如果你勇于尝试，可以查看下 :e $VIMRUNTIME/filetype.vim，然后在输出中搜索 “Ruby”。这样，你就会发现其实 Vim 只是通过文件扩展名 .rb 判断某个文件是不是 Ruby 的。注意：对于相同事件，如果有多个自动命令，那么自动命令会按照定义时的顺序执行。通过 :au 就可以查看它们的执行顺序。

au BufNewFile,BufRead *.rb,*.rbw setf ruby

BufNewFile 与 BufRead 事件是被写在 Vim 源文件中的。因此，每当你通过 :e 或者类似的命令打开文件，这两个事件都会触发。然后，就是读取 filetype.vim 文件来判断打开的文件类型。简单来说，事件和自动命令在 Vim 中的应用十分广泛。而且，Vim 为我们留出了一些易用的接口，方便用户配置适合自己的事件驱动回调。请参阅 :h autocommand 来获取更多帮助

变更历史，跳转历史

在 Vim 中，用户最近 100 次的文字改动都会被保存在变更历史中。如果在同一行有多个小改动，那么 Vim 会把它们合并成一个。尽管内容改动会合并，但作用的位置还是会只记录下最后一次改动的位置。在你移动光标或跳转的时候，每一次的移动或跳转前的位置会被记录到跳转历史中。类似地，跳转历史也可以最多保存 100 条记录。对于每个窗口，跳转记录是独立的。但当你分离窗口时（比如使用 :split 命令），跳转历史会被复制过去。 Vim 中的跳转命令，包括 '、`、G、/、?、n、N、%、(、)、[[、]]、{、}、:s、:tag、L、M、H 以及开始编辑一个新文件的命令。

列表	显示所有条目	跳转到上一个位置	跳转到下一个位置
跳转历史	`:jumps`	`[count]<c-o>`	`[count]<c-i>`
变更历史	`:changes`	`[count]g;`	`[count]g,`

如果你执行第二列的命令显示所有条目，这时 Vim 会用 > 标记来为你指示当前位置。通常这个标记位于 1 的下方，也就代表最后一次的位置。如果你希望关闭 Vim 之后还保留这些条目，请参阅 :h viminfo-' 来获取更多帮助。注意：上面提到过，最后一次跳转前的位置也会记录在标注中，也可以通过连按 \`\` 或 '' 跳转到那个位置请参阅以下两个命令来获取更多帮助：

:h changelist
:h jumplist

内容变更历史记录

Vim 会记录文本改变之前的状态。因此，你可以使用「撤销」操作 u 来取消更改，也可以通过「重做」操作 Ctrl + r 来恢复更改。值得注意的是，Vim 采用 tree 数据结构来存储内容变更的历史记录，而不是采用 queue。你的每次改动都会成为存储为树的节点。而且，除了第一次改动（根节点），之后的每次改动都可以找到一个对应的父节点。每一个节点都会记录改动的内容和时间。其中，「分支」代表从任一节点到根节点的路径。当你进行了撤销操作，然后又输入了新的内容，这时候就相当于创建了分支。这个原理和 git 中的 branch（分支）十分类似。考虑以下这一系列按键操作：

ifoo<esc>
obar<esc>
obaz<esc>
u
oquux<exc>

那么现在，Vim 中会显示三行文本，分别是 “foo”、”bar” 和 “quux”。这时候，存储的树形结构如下：

     foo(1)
       /
    bar(2)
   /      \
baz(3)   quux(4)

这个树形结构共包含四次改动，括号中的数字就代表时间顺序。现在，我们有两种方式遍历这个树结构。一种叫「按分支遍历」，一种叫「按时间遍历」。撤销 u 与重做 Ctrl + r 操作是按分支遍历。对于上面的例子，现在我们有三行字符。这时候按 u 会回退到 “bar” 节点，如果再按一次 u 则会回退到 “foo” 节点。这时，如果我们按下 Ctrl + r 就会前进至 “bar” 节点，再按一次就回前进至 “quux” 节点。在这种方式下，我们无法访问到兄弟节点（即 “baz” 节点）。与之对应的是按时间遍历，对应的按键是 g- 和 g+。对于上面的例子，按下 g- 会首先回退到 “baz” 节点。再次按下 g- 会回退到 “bar” 节点。

命令/按键	执行效果
`[count]u` 或 `:undo [count]`	回退到 `[count]` 次改动之前
`[count]<c-r>` 或 `:redo [count]`	重做 `[count]` 次改动
`U`	回退至最新的改动
`[count]g-` 或 `:earlier [count]?`	根据时间回退到 `[count]` 次改动之前。”?” 为 “s”、”m”、”h”、”d” 或 “f”之一。例如，`:earlier 2d` 会回退到两天之前。`:earlier 1f` 则会回退到最近一次文件保存时的内容
`[count]g+` 或 `:later [count]?`	类似 `g-`，但方向相反

内容变更记录会储存在内存中，当 Vim 退出时就会清空。如果需要持久化存储内容变更记录，请参阅备份文件，交换文件，撤销文件以及 viminfo 文件的处理章节的内容。如果你觉得这一部分的内容难以理解，请参阅 undotree，这是一个可视化管理内容变更历史记录的插件。类似的还有 vim-mundo。请参阅以下链接获取更多帮助：

:h undo.txt
:h usr_32

全局位置信息表，局部位置信息表

在某一个动作返回一系列「位置」的时候，我们可以利用「全局位置信息表」和「局部位置信息表」来存储这些位置信息，方便以后跳转回对应的位置。每一个存储的位置包括文件名、行号和列号。比如，编译代码是出现错误，这时候我们就可以把错误的位置直接显示在全局位置信息表，或者通过外部抓取工具使位置显示在局部位置信息表中。尽管我们也可以把这些信息显示到一个空格缓冲区中，但用这两个信息表显示的好处在于接口调用很方便，而且也便于浏览输出。 Vim 中，全局位置信息表只能有一个，但每一个窗口都可以有自己的局部位置信息表。这两个信息表的外观看上去很类似，但在操作上会稍有不同。以下为两者的操作比较：

动作	全局位置信息表	局部位置信息表
打开窗口	`:copen`	`:lopen`
关闭窗口	`:cclose`	`:lclose`
下一个条目	`:cnext`	`:lnext`
上一个条目	`:cprevious`	`:lprevious`
第一个条目	`:cfirst`	`:lfirst`
最后一个条目	`:clast`	`:llast`

请参阅 :h :cc 以及底下的内容，来获取更多命令的帮助。 应用实例：如果我们想用 grep 递归地在当前文件夹中寻找某个关键词，然后把输出结果放到全局位置信息表中，只需要这样：

:let &grepprg = 'grep -Rn $* .'
:grep! foo
<grep output - hit enter>
:copen

执行了上面的代码，你就能看到所有包含字符串 “foo” 的文件名以及匹配到的相关字段都会显示在全局位置信息表中。

宏

你可以在 Vim 中录制一系列按键，并把他们存储到寄存器中。对于一些需要临时使用多次的一系列操作，把它们作为宏保存起来会显著地提升效率。对于一些复杂的操作，建议使用 Vim 脚本来实现。

首先，按下 q，然后按下你想要保存的寄存器，任何小写字母都可以。比如我们来把它保存到 q 这个寄存器中。按下 qq，你会发现命令行里已经显示了 “recording @q”。
如果你已经录制完成，那么只需要再按一次 q 就可以结束录制。
如果你想调用刚才录制的宏，只需要 [count]@q
如果你想调用上一次使用的宏，只需要 [count]@@

实例 1：一个插入字符串 “abc” 后换行的宏，重复调用十次：

qq
iabc<cr><esc>
q
10@q

（对于上面这个功能，你同样可以通过如下的按键： oabc 然后 ESC 然后 10. 来实现）。 实例 2：一个在每行前都加上行号的宏。从第一行开始，行号为 1，后面依次递增。我们可以通过 Ctrl + a 来实现递增的行号，在定义宏的时候，它会显示成 ^A。

qq
0yf jP0^A
q
1000 @q

这里能实现功能，是因为我们假定了文件最多只有 1000 行。但更好的方式是使用「递归」宏，它会一直执行，知道不能执行为止：

qq
0yf jP0^A@q
q
@q

（对于上面这个插入行号的功能，如果你不愿意使用宏，同样可以通过这段按键操作来实现：:%s/^/\=line('.') . '. '）。这里向大家展示了如何不用宏来达到相应的效果，但要注意，这些不用宏的实现方式只适用于这些简单的示例。对于一些比较复杂的自动化操作，你确实应该考虑使用宏。请参阅以下文档获取更多帮助：

:h recording
:h 'lazyredraw'

颜色主题

颜色主题可以把你的 Vim 变得更漂亮。Vim 是由多个组件构成的，我们可以给每一个组件都设置不同的文字颜色、背景颜色以及文字加粗等等。比如，我们可以通过这个命令来设置背景颜色：

:highlight Normal ctermbg=1 guibg=red

执行后你会发现，现在背景颜色变成红色了。请参阅 :h :highlight 来获取更多帮助。其实，颜色主题就是一系列的 :highlight 命令的集合。事实上，大部分颜色主题都包含两套配置。一套适用于例如 xterm 和 iTerm 这样的终端环境（使用前缀 cterm），另一套适用于例如 gvim 和 MacVim 的图形界面环境（使用前缀 gui）。对于上面的例子，ctermbg 就是针对终端环境的，而 guibg 就是针对图形界面环境的。如果你下载了一个颜色主题，并且在终端环境中打开了 Vim，然后发现显示的颜色与主题截图中差别很大，那很可能是配置文件只设置了图形界面环境的颜色。反之同理，如果你使用的是图形界面环境，发现显示颜色有问题，那就很可能是配置文件只设置了终端环境的颜色。第二种情况（图形界面环境的显示问题）其实不难解决。如果你使用的是 Neovim 或者 Vim 7.4.1830 的后续版本，可以通过打开真彩色设置来解决显示问题。这就可以让终端环境的 Vim 使用 GUI 的颜色定义，但首先，你要确认一下你的终端环境和环境内的组件（比如 tmux）是否都支持真彩色。可以看一下这篇文档，描述的十分详细。请参阅以下文档或链接来获取更多帮助：

:h 'termguicolors'
主题列表
自定义主题中的颜色

折叠

每一部分文字（或者代码）都会有特定的结构。对于存在结构的文字和代码，也就意味着它们可以按照一定的逻辑分割成不同区域。Vim 中的折叠功能，就是按照特定的逻辑把文字和代码折叠成一行，并显示一些简短的描述。折叠功能涉及到很多操作，而且折叠功能可以嵌套使用。在 Vim 中，有以下 6 中折叠类型：

折叠方式	概述
diff	在「比较窗口」中折叠未改变的文本
expr	使用 `'foldexpr'` 来创建新的折叠逻辑
indent	基于缩进折叠
manual	使用 `zf`、`zF` 或 `:fold` 来自定义折叠
marker	根据特定的文本标记折叠（通常用于代码注释）
syntax	根据语法折叠，比如折叠 `if` 代码块

注意：折叠功能可能会显著地影响性能。如果你在使用折叠功能的时候出现了打字卡顿之类的问题，请考虑使用 FastFold 插件。这个插件可以让 Vim 按需更新折叠内容，而不是一直调用。请参阅以下文档获取更多帮助：

:h usr_28
:h folds

会话

如果你保存了当前的「视图」（请参阅 :h :mkview），那么当前窗口、配置和按键映射都会被保存下来（请参阅 :h :loadview）。「会话」就是存储所有窗口的相关设置，以及全局设置。简单来说，就是给当前的 Vim 运行实例拍个照，然后把相关信息存储到会话文件中。存储之后的改动就不会在会话文件中显示，你只需要在改动后更新一下会话文件就可以了。你可以把当前工作的「项目」存储起来，然后可以在不同的「项目」之间切换。现在就来试试吧。打开几个窗口和标签，然后执行 :mksession Foo.vim。如果你没有指定文件名，那就会默认保存为 Session.vim。这个文件会保存在当前的目录下，你可以通过 :pwd 来显示当前路径。重启 Vim 之后，你只需要执行 :source Foo.vim，就可以恢复刚才的会话了。所有的缓冲区、窗口布局、按键映射以及工作路径都会恢复到保存时的状态。其实 Vim 的会话文件就只是 Vim 命令的集合。你可以通过命令 :vs Foo.vim 来看看会话文件中究竟有什么。你可以决定 Vim 会话中究竟要保存哪些配置，只需要设置一下 'sessionoptions' 就可以了。为了方便开发，Vim 把最后一次调用或写入的会话赋值给了一个内部变量 v:this_session。请参阅以下文档来获取更多帮助：

:h Session
:h 'sessionoptions'
:h v:this_session

局部化

以上提到的很多概念，都有一个局部化（非全局）的版本：

全局	局部	作用域	帮助文档
`:set`	`:setlocal`	缓冲区或窗口	`:h local-options`
`:map`	`:map <buffer>`	缓冲区	`:h :map-local`
`:autocmd`	`:autocmd * <buffer>`	缓冲区	`:h autocmd-buflocal`
`:cd`	`:lcd`	窗口	`:h :lcd`
`:<leader>`	`:<localleader>`	缓冲区	`:h maploacalleader`

变量也有不同的作用域，详细内容请参考 Vim scripting 的文档。

用法

获取离线帮助

Vim 自带了一套很完善的帮助文档，它们是一个个有固定排版格式的文本文件，通过标签可以访问这些文件的特定位置。在开始之前先读一下这个章节：:help :help。执行这个命令以后会在新窗口打开 $VIMRUNTIME/doc/helphelp.txt 文件并跳转到这个文件中 :help 标签的位置。一些关于帮助主题的简单规则：

用单引号把文本包起来表示选项，如：:h 'textwidth'
以小括号结尾表示 VimL 函数，如：:h reverse()
以英文冒号开头表示命令，如：:h :echo

使用快捷键 <c-d> （这是 ctrl+d）来列出所有包含你当前输入的内容的帮助主题。如：:h tab<c-d> 会列出所有包含 tab 主题，从 softtabstop 到 setting-guitablabel （译者注：根据安装的插件不同列出的选项也会不同）。你想查看所有的 VimL 方法吗？很简单，只要输入：:h ()<c-d> 就可以了。你想查看所有与窗口相关的函数吗？输入 :h win*()<c-d>。相信你很快就能掌握这些技巧，但是在刚开始的时候，你可能对于该通过什么进行查找一点线索都没有。这时你可以想象一些与要查找的内容相关的关键字，再让 :helpgrep 来帮忙。

:helpgrep backwards

上面的命令会在所有的帮助文件中搜索“backwards”，然后跳转到第一个匹配的位置。所有的匹配位置都会被添加到全局位置信息表，用 :cp / :cn 可以在匹配位置之间进行切换。或者用 :copen 命令来打开全局位置信息表，将光标定位到你想要的位置，再按回车就可以跳转到该匹配项。详细说明请参考 :h quickfix。

获取离线帮助（补充）

这个列表最初发表在 vim_dev，由 @chrisbra 编辑的，他是 Vim 开发人员中最活跃的一个。经过一些微小的改动后，重新发布到了这里。

如果你知道你想要找什么，使用帮助系统的搜索会更简单一些，因为搜索出的主题都带有固定的格式。而且帮助系统中的主题包含了你当前使用的 Vim 版本的所特有特性，而网上那些已经过时或者是早期发布的话题是不会包含这些的。因此学习使用帮助系统以及它所用的语言是很有必要的。这里是一些例子（不一定全，我有可能忘了一些什么）。（译者注：下面列表中提及的都是如何指定搜索主题以便快速准确的找到你想要的帮助）

选项要用单引号引起来。用 :h 'list' 来查看列表选项帮助。只有你明确的知道你要找这么一个选项的时候才可以这么做，不然的话你可以用 :h options.txt 来打开所有选项的帮助页面，再用正则表达式进行搜索，如：/width。某些选项有它们自己的命名空间，如：:h cpo-a，:h cpo-A， :h cpo-b 等等。
普通模式的命令不能用冒号作为前缀。使用 :h gt 来转到“gt”命令的帮助页面。
正则表达式以“/”开头，所以 :h /\+ 会带你到正则表达式中量词“+”的帮助页面。
组合键经常以一个字母开头表示它们可以在哪些模式中使用。如：:h i_CTRL-X 会带你到插入模式下的 CTRL-X 命令的用法帮助页面，这是一个自动完成类的组合键。需要注意的是某些键是有固定写法的，如 Control 键写成 CTRL。还有，查找普通模式下的组合键帮助时，可以省略开头的字母“n”，如：:h CTRL-A。而 :h c_CTRL-A（译者注：原文为 :h c_CRTL-R，感觉改为 A 更符合上下文语境）会解释 CTRL-A 在命令模式下输入命令时的作用；:h v_CTRL-A 说的是在可见模式下把光标所在处的数字加 1；:h g_CTRL-A 则说的是 g 命令（你需要先按 “g” 的命令）。这里的 “g” 代表一个普通的命令，这个命令总是与其它的按键组合使用才生效，与 “z” 开始的命令相似。
寄存器是以 “quote” 开头的。如：:h quote: （译者注：原文为:h quote，感觉作者想以”:”来举例）来查看关于”:”寄存器的说明。
关于 Vim 脚本（VimL）的帮助都在 :h eval.txt 里。而某些方面的语言可以使用 :h expr-X 获取帮助，其中的 ‘X’ 是一个特定的字符，如：:h expr-! 会跳转到描述 VimL 中’!’（非）的章节。另外一个重要提示，可以使用 :h function-list 来查看所有函数的简要描述，列表中包括函数名和一句话描述。

关于映射都可以在 :h map.txt 中找到。通过 :h mapmode-i 来查找 :imap 命令的相关信息；通过 :h map-topic 来查找专门针对映射的帮助（译者注：topic 为一个占位符，正如上面的字符 ‘X’ 一样，在实际使用中需要替换成相应的单词）（如：:h :map-local 查询本地 buffer 的映射，:h map-bar 查询如何在映射中处理’ ’)。

命令定义用 “command-“ 开头，如用 :h command-bar 来查看自定义命令中’!’的作用。
窗口管理类的命令是以 “CTRL-W” 开头的，所以你可以用 :h CTRL-W_* 来查找相应的帮助（译者注：’*‘同样为占位符）（如：:h CTRL-W_p 查看切换到之前访问的窗口命令的解释）。如果你想找窗口处理的命令，还可以通过访问 :h windows.txt 并逐行向下浏览，所有窗口管理的命令都在这里了。
执行类的命令以”:”开头，即：:h :s 讲的是 “:s” 命令。
在输入某个话题时按 CTRL-D，让 Vim 列出所有的近似项辅助你输入。
用 :helpgrep 在所有的帮助页面（通常还包括了已安装的插件的帮助页面）中进行搜索。参考 :h :helpgrep 来了解如何使用。当你搜索了一个话题之后，所有的匹配结果都被保存到了全局位置信息表（或局部位置信息表）当中，可以通过 :copen 或 :lopen 打开。在打开的窗口中可能通过 / 对搜索结果进行进一步的过滤。
:h helphelp 里介绍了如何使用帮助系统。
用户手册。它采用了一种对初学者更加友好的方式来展示帮助话题。用 :h usr_toc.txt 打开目录（你可能已经猜到这个命令的用处了）。浏览用户手册能帮助你找出某些你想了解的话题，如你可以在第 24 章看到关于“复合字符”以及“输入特殊字符”的讲解（用 :h usr_24.txt 可以快速打开相关章节）。
高亮分组的帮助以 hl- 开头。如：:h hl-WarningMsg 说的是警告信息分组的高亮。
语法高亮以:syc- 开头，如：:h :syn-conceal 讲的是 :syn 命令的对于隐藏字符是如何显示的。
快速修复命令以 :c 开头，而位置列表命令以 :l 开头。
:h BufWinLeave 讲的是 BufWinLeave 自动命令。还有，:h autocommand-events （译者注：原文是 :h autocommands-events，但是没有该帮助）讲的是所有可用的事件。
启动参数都以“-”开头，如：:h -f 会告诉你 Vim 中 “-f” 参数的作用。
额外的特性都以“+”开头，如：:h +conceal 讲的是关于隐藏字符的支持。
错误代码可以在帮助系统中直接查到。:h E297 会带你到关于这一错误的详细解释。但是有时并没有转到错误描述，而是列出了经常导出这一错误的 Vim 命令，如 :h E128 （译者注：原文为:h hE128，但是并没有该帮助）会直接跳转到 :function 命令。
关于包含的语法文件的文档的帮助话题格式是 :h ft-*-syntax。如：:h ft-c-syntax 说的就是 C 语言语法文件以及它所提供的选项。有的语法文件还会带有自动完成（:h ft-php-omni）或文件类型插件（:h ft-tex-plugin）相关的章节可以查看。

另外在每个帮助页的顶端通常会包含一个用户文档链接（更多的从从用户的角度出发来主角命令的功能和用法，不涉及那么多细节）。如：:h pattern.txt 里包含了 :h 03.9 和 :h usr_27 两个章节的链接。

获取在线帮助

如果你遇到了无法解决的问题，或者需要指引的话，可以参考 Vim 使用邮件列表。 IRC 也是一个很不错的资源。 Freenode 上的 #vim 频道很庞大，并且里面有许多乐于助人的人。如果你想给 Vim 提交 Bug 的话，可以使用 vim_dev 邮件列表。

执行自动命令

你可以触发任何事件，如：:doautocmd BufRead。

用户自定义事件

对于插件而言，创建你自己的自定义事件有时非常有用。

function! Chibby()
    " A lot of stuff is happening here.
    " And at last..
    doautocmd User ChibbyExit
endfunction

现在你插件的用户可以在 Chibby 执行完成之后做任何他想做的事情：

autocmd User ChibbyExit call ChibbyCleanup()

顺便提一句，如果在使用 :autocmd 或 :doautocmd 时没有捕捉异常，那么会输出 “No matching autocommands” 信息。这也是为什么许多插件用 silent doautocmd ... 的原因。但是这也会有不足，那就是你不能再在 :autocmd 中使用 echo "foo" 了，取而代之的是你要使用 unsilent echo "foo" 来输出。这就是为什么要在触发事件之前先判断事件是否存在的原因，

if exists('#User#ChibbyExit')
  doautocmd User ChibbyExit
endif

帮助文档：:h User

事件嵌套

默认情况下，自动命令不能嵌套！如果某个自动命令执行了一个命令，这个命令再依次触发其它的事件，这是不可能的。例如你想在每次启动 Vim 的时候自动打开你的 vimrc 文件：

autocmd VimEnter * edit $MYVIMRC

当你启动 Vim 的时候，它会帮你打开你的 vimrc 文件，但是你很快会注意到这个文件没有任何的高亮，尽管平时它是正常可以高亮的。问题在于你的非嵌套自动命令 :edit 不会触发“BufRead”事件，所以并不会把文件类型设置成“vim”，进而 $VIMRUNTIME/syntax/vim.vim 永远不会被引入。详细信息请参考：:au BufRead *.vim。要想完成上面所说的需求，使用下面这个命令：

autocmd VimEnter * nested edit $MYVIMRC

帮助文档：:h autocmd-nested

剪切板

如果你想在没有 GUI 支持的 Unix 系统中使用 Vim 的 'clipboard' 选项，则需要 +clipboard 以及可选的 +xterm_clipboard 两个特性支持。帮助文档：

:h 'clipboard'
:h gui-clipboard
:h gui-selections

另外请参考：持续粘贴（为什么我每次都要设置 ‘paste’ 模式

剪贴板的使用（Windows, OSX）

Windows 自带了剪贴板，OSX 则带了一个粘贴板在这两个系统中都可以用大家习惯用的 ctrl+c / cmd+c 复制选择的文本，然后在另外一个应用中用 ctrl+v / cmd+v 进行粘贴。需要注意的是复制的文本已经被发送到了剪贴板，所以你在粘贴复制的内容之前关闭这个应用是没有任何问题的。每次复制的时候，都会向剪贴板寄存器 * 中写入数据。而在 Vim 中分别使用 "*y 和 "*p 来进行复制（yank) 和粘贴（paste)。如果你不想每次操作都要指定 * 寄存器，可以在你的 vimrc 中添加如下配置：

set clipboard=unnamed

通常情况下复制/删除/放入操作会往 " 寄存器中写入数据，而加上了上面的配置之后 * 寄存器也会被写入同样数据，因此简单的使用 y 和 p 就可以复制粘贴了。我再说一遍：使用上面的选项意味着每一次的复制/粘贴，即使在同一个 Vim 窗口里，都会修改剪贴板的内容。你自己决定上面的选项是否适合。如果你觉得输入 y 还是太麻烦的话，可以使用下面的设置把在可视模式下选择的内容发送到剪贴板：

set clipboard=unnamed,autoselect
set guioptions+=a

帮助文档：

:h clipboard-unnamed
:h autoselect
:h 'go_a'

剪贴板的使用（Linux, BSD, …）

如果你的系统使用了 X 图形界面，事情会变得有一点不同。X 图形界面实现了 X 窗口系统协议, 这个协议在 1987 年发布的主版本 11，因此 X 也通常被称为 X11。在 X10 版本中，剪贴缓冲区被用来实现像 clipboard 一样由 X 来复制文本，并且可以被所有的程序访问。现在这个机制在 X 中还存在，但是已经过时了，很多程序都不再使用这一机制。近年来数据在程序之间是通过选择进行传递的。一共有三种选择，经常用到的有两种：PRIMARY 和 CLIPBOARD。选择的工作工模大致是这样的：

Program A：<ctrl+c>
Program A：声称对 CLIPBOARD 的所有权
Program B：<ctrl+v>
Program B：发现CLIPBOARD的所有权被Program A持有
Program B：从Program A请求数据
Program A：响应这个请求并发送数据给Program B
Program B：从Program A接收数据并插入到窗口中

选择	何时使用	如何粘贴	如何在 Vim 中访问
PRIMARY	选择文本	鼠标中键, shift+insert	`*` 寄存器
CLIPBOARD	选择文本并按 `ctrl+c`	`ctrl+v`	`+`寄存器

注意：X 服务器并不会保存选择（不仅仅是 CLIPBOARD 选择）！因此在关闭了相应的程序后，你用 ctrl+c 复制的内容将丢失。使用 "*p 来贴粘 PRIMARY 选择中的内容，或者使用 "+y1G 来将整个文件的内容复制到 CLIPBOARD 选择。如果你需要经常访问这两个寄存器，可以考虑使用如下配置：

set clipboard^=unnamed          " * 寄存器
" 或者
set clipboard^=unnamedplus      " + 寄存器

（^= 用来将设置的值加到默认值之前，详见：:h :set^=）这会使得所有复制/删除/放入操作使用 * 或 + 寄存器代替默认的未命令寄存器 "。之后你就可以直接使用 y 或 p 访问你的 X 选择了。帮助文档：

:h clipboard-unnamed
:h clipboard-unnamedplus

打开文件时恢复光标位置

如果没有这个设置，每次打开文件时光标都将定位在第一行。而加入了这个设置以后，你就可以恢复到上次关闭文件时光标所在的位置了。将下面的配置添加到你的 vimrc 文件：

autocmd BufReadPost *
    \ if line("'\"") > 1 && line("'\"") <= line("$") |
    \   exe "normal! g`\"" |
    \ endif

这是通过判断之前的光标位置是否存在（文件可能被其它程序修改而导致所记录的位置已经不存在了），如果存在的话就执行 g`" （转到你离开时的光标位置但是不更改跳转列表）。这需要使用 viminfo 文件：:h viminfo-。

临时文件

根据选项的不同， Vim 最多会创建 4 种工作文件。

备份文件

你可以让 Vim 在将修改写入到文件之前先备份原文件。默认情况下， Vim 会保存一个备份文件但是当修改成功写入后会立即删除它（:set writebackup）。如果你想一直保留这个备份文件的话，可以使用 :set backup。而如果你想禁用备份功能的话，可以使用 :set nobackup nowritebackup。咱们来看一下上次我在 vimrc 中改了什么：

$ diff ~/.vim/vimrc ~/.vim/files/backup/vimrc-vimbackup
390d389
< command! -bar -nargs=* -complete=help H helpgrep <args>

帮助文档：:h backup

交换文件

假设你有一个非常棒的科幻小说的构思。在按照故事情节已经写了好几个小时几十万字的时候..忽然停电了！而那时你才想起来你上次保存 ~/来自外太空的邪恶入侵者.txt 是在.. 好吧，你从来没有保存过。但是并非没有希望了！在编辑某个文件的时候， Vim 会创建一个交换文件，里面保存的是对当前文件所有未保存的修改。自己试一下，打开任意的文件，并使用 :swapname 获得当前的交换文件的保存路径。你也可以将 :set noswapfile 加入到 vimrc 中来禁用交换文件。默认情况下，交换文件会自动保存在被编辑文件所在的目录下，文件名以 .file.swp 后缀结尾，每当你修改了超过 200 个字符或是在之前 4 秒内没有任何动作时更新它的内容，在你不再编辑这个文件的时候会被删除。你可以自己修改这些数字，详见：:h 'updatecount' 和 :h 'updatetime'。而在断电时，交换文件并不会被删除。当你再次打开 vim ~/来自外太空的邪恶入侵者.txt 时， Vim 会提示你恢复这个文件。帮助文档：:h swap-file 和 :h usr_11

撤销文件

内容变更历史记录是保存在内存中的，并且会在 Vim 退出时清空。如果你想让它持久化到磁盘中，可以设置 :set undofile。这会把文件 ~/foo.c 的撤销文件保存在 ~/foo.c.un~。帮助文档：:h 'undofile' 和 :h undo-persistence

viminfo 文件

备份文件、交换文件和撤销文件都是与文本状态相关的，而 viminfo 文件是用来保存在 Vim 退出时可能会丢失的其它的信息的。包括历史记录（命令历史、搜索历史、输入历史）、寄存器内容、标注、缓冲区列表、全局变量等等。默认情况下，viminfo 被保存在 ~/.viminfo。帮助文档：:h viminfo 和 :h 'viminfo'

临时文件管理设置示例

如果你跟我一样，也喜欢把这些文件放到一个位置（如：~/.vim/files）的话，可以使用下面的配置：

" 如果文件夹不存在，则新建文件夹
if !isdirectory($HOME.'/.vim/files') && exists('*mkdir')
  call mkdir($HOME.'/.vim/files')
endif

" 备份文件
set backup
set backupdir   =$HOME/.vim/files/backup/
set backupext   =-vimbackup
set backupskip  =
" 交换文件
set directory   =$HOME/.vim/files/swap//
set updatecount =100
" 撤销文件
set undofile
set undodir     =$HOME/.vim/files/undo/
" viminfo 文件
set viminfo     ='100,n$HOME/.vim/files/info/viminfo

注意：如果你在一个多用户系统中编辑某个文件时， Vim 提示你交换文件已经存在的话，可能是因为有其他的用户此时正在编辑这个文件。而如果将交换文件放到自己的 home 目录的话，这个功能就失效了。因此服务器非常不建议将这些文件修改到 HOME 目录，避免多人同时编辑一个文件，却没有任何警告。

编辑远程文件

Vim 自带的 netrw 插件支持对远程文件的编辑。实际上它将远程的文件通过 scp 复制到本地的临时文件中，再用那个文件打开一个缓冲区，然后在保存时把文件再复制回远程位置。下面的命令在你本地的 VIM 配置与 SSH 远程服务器上管理员想让你使用的配置有冲突时尤其有用：

:e scp://bram@awesome.site.com/.vimrc

如果你已经设置了 ~/.ssh/config，SSH 会自动读取这里的配置：

Host awesome
    HostName awesome.site.com
    Port 1234
    User bram

如果你的 ~/.ssh/config 中有以上的内容，那么下面的命令就可以正常执行了：

:e scp://awesome/.vimrc

可以用同样的方法编辑 ~/.netrc, 详见：:h netrc-netrc。确保你已经看过了 :h netrw-ssh-hack 和 :h g:netrw_ssh_cmd。另外一种编辑远程文件的方法是使用 sshfs，它会用 FUSE 来挂载远程的文件系统到你本地的系统当中。

插件管理

Pathogen是第一个比较流行的插件管理工具。实际上它只是修改了 runtimepath （:h 'rtp'）来引入所有放到该目录下的文件。你需要自己克隆插件的代码仓库到那个目录。真正的插件管理工具会在 Vim 中提供帮助你安装或更新插件的命令。以下是一些常用的插件管理工具：

多行编辑

这是一种可以同时输入多行连续文本的技术。参考这个示例。用 <c-v> 切换到可视块模式。然后向下选中几行，按 I 或 A （译者注：大写字母，即 shift+i 或 shift+a）然后开始输入你想要输入的文本。在刚开始的时候可能会有些迷惑，因为文本只出现在了当前编辑的行，只有在当前的插入动作结束后，之前选中的其它行才会出现插入的文本。举一个简单的例子：<c-v>3jItext<esc>。如果你要编辑的行长度不同，但是你想在他们后面追加相同的内容的话，可以试一下这个：<c-v>3j$Atext<esc>。有时你可能需要把光标放到当前行末尾之后，默认情况下你是不可能做到的，但是可能通过设置 virtualedit 选项达到目的：

set virtualedit=all

设置之后 $10l 或 90| 都会生效，即使超过了行尾的长度。详见 :h blockwise-examples。在开始的时候可能会觉得有些复杂，但是它很快就会成为你的第二天性的。如果你想探索更有趣的事情，可以看看多光标

使用外部程序和过滤器

免责声明：Vim 是单线程的，因此在 Vim 中以前端进程执行其它的程序时会阻止其它的一切。当然你可以使用 Vim 程序接口，如 Lua，并且使用它的多线程支持，但是在那期间， Vim 的处理还是被阻止了。Neovim 添加了任务 API 解决了此问题。（据说 Bram 正在考虑在 Vim 中也添加任务控制。如果你使用了较新版本的的 Vim ，可以看一下 :helpgrep startjob。）使用 :! 启动一个新任务。如果你想列出当前工作目录下的所有文件，可以使用 :!ls。用 | 来将结果通过管道重定向，如：:!ls -l | sort | tail -n5。没有使用范围时（译者注：范围就是 : 和 ! 之间的内容，. 表示当前行，+4 表示向下偏移 4 行，$ 表示最末行等，多行时用 , 将它们分开，如 .,$ 表示从当前行到末行），:! 会显示在一个可滚动的窗口中（译者注：在 GVim 和在终端里运行的结果稍有不同）。相反的，如果指定了范围，这些行会被过滤。这意味着它们会通过管道被重定向到过滤程序的 stdin，在处理后再通过过滤程序的 stdout 输出，用输出结果替换范围内的文本。例如：为接下来的 5 行文本添加行号，可以使用：

:.,+4!nl -ba -w1 -s' '

由于手动添加范围很麻烦， Vim 提供了一些辅助方法以方便的添加范围。如果需要经常带着范围的话，你可以在可见模式中先选择，然后再按 : （译者注：选中后再按 ! 更方便）。还可以使用 ! 来取用一个 motion 的范围，如 !ipsort （译者注：原文为 !ip!sort ，但经过实验发现该命令执行报错，可能是因为 Vim 版本的原因造成的，新版本使用 ip 选择当前段落后自动在命令后添加了 ! ，按照作者的写法来看，可能之前的版本没有自动添加 ! ）可以将当前段落的所有行按字母表顺序进行排序。一个使用过滤器比较好的案例是Go 语言。它的缩进语法非常个性，甚至还专门提供了一个名为 gofmt 的过滤器来对 Go 语言的源文件进行正确的缩进。Go 语言的插件通常会提供一个名为 :Fmt 的函数，这个函数就是执行了 :%!gofmt 来对整个文件进行缩进。人们常用 :r !prog 将 prog 程序的插入放到当前行的下面，这对于脚本来说是很不错的选择，但是在使用的过程中我发现 !!ls 更加方便，它会用输出结果替换当前行的内容。（译者注：前面命令中的 prog 只是个占位符，在实际使用中需要替换成其它的程序，如 :r !ls，这就与后面的 !!ls 相对应了，两者唯一的不同是第一个命令不会覆盖当前行内容，但是第二个命令会）帮助文档：

:h filter
:h :read!

Cscope

Cscope 的功能比 ctags 要完善，但是只支持 C（通过设置 cscope.files 后同样支持 C++以及 Java）。鉴于 Tag 文件只是知道某个符号是在哪里定义的，cscope 的数据库里的数据信息就多的多了：

符号是在哪里定义的？
符号是在哪里被使用的？
这个全局符号定义了什么？
这个变量是在哪里被赋值的？
这个函数在源文件的哪个位置？
哪些函数调用了这个函数？
这个函数调用了哪些函数？
“out of space”消息是从哪来的？
在目录结构中当前的源文件在哪个位置？
哪些文件引用了这个头文件？

1. 构建数据库

在你项目的根目录执行下面的命令：

$ cscope -bqR

这条命令会在当前目录下创建三个文件：cscope{,.in,.po}.out 。把它们想象成你的数据库。不幸的时 cscope 默认只分析 *.[c|h|y|l] 文件。如果你想在 Java 项目中使用 cscope ，需要这样做：

$ find . -name "*.java" > cscope.files
$ cscope -bq

2. 添加数据库

打开你新创建的数据库连接：

:cs add cscope.out

检查连接已经创建成功：

:cs show

（当然你可以添加多个连接。）

3. 查询数据库

:cs find <kind> <query>

如：:cs find d foo 会列出 foo(...) 调用的所有函数。

Kind	说明
s	symbol：查找使用该符号的引用
g	global：查找该全局符号的定义
c	calls：查找调用当前方法的位置
t	text：查找出现该文本的位置
e	egrep：使用 egrep 搜索当前单词
f	file：打开文件名
i	includes：查询引入了当前文件的文件
d	depends：查找当前方法调用的方法

推荐一些比较方便的映射，如：

nnoremap <buffer> <leader>cs :cscope find s  <c-r>=expand('<cword>')<cr><cr>
nnoremap <buffer> <leader>cg :cscope find g  <c-r>=expand('<cword>')<cr><cr>
nnoremap <buffer> <leader>cc :cscope find c  <c-r>=expand('<cword>')<cr><cr>
nnoremap <buffer> <leader>ct :cscope find t  <c-r>=expand('<cword>')<cr><cr>
nnoremap <buffer> <leader>ce :cscope find e  <c-r>=expand('<cword>')<cr><cr>
nnoremap <buffer> <leader>cf :cscope find f  <c-r>=expand('<cfile>')<cr><cr>
nnoremap <buffer> <leader>ci :cscope find i ^<c-r>=expand('<cfile>')<cr>$<cr>
nnoremap <buffer> <leader>cd :cscope find d  <c-r>=expand('<cword>')<cr><cr>

所以 :tag （或 <c-]>）跳转到标签定义的文件，而 :cstag 可以达到同样的目的，同时还会打开 cscope 的数据库连接。'cscopetag' 选项使得 :tag 命令自动的像 :cstag 一样工作。这在你已经使用了基于标签的映射时会非常方便。帮助文档：:h cscope

MatchIt

由于 Vim 是用 C 语言编写的，因此许多功能都假设使用类似 C 语言的语法。默认情况下，如果你的光标在 { 或 #endif , 就可以使用 % 跳转到与之匹配的 } 或 #ifdef。 Vim 自带了一个名为 matchit.vim 的插件，但是默认没有启用。启用后可以用 % 在 HTML 相匹配的标签或 VimL 的 if/else/endif 块之间进行跳转，它还带来了一些新的命令。

在 Vim 8 中安装

" vimrc
packadd! matchit

在 Vim 7 或者更早的版本中安装

"vimrc
runtime macros/matchit.vim

由于 matchit 的文档很全面，我建议安装以后执行一次下面的命令：

:!mkdir -p ~/.vim/doc
:!cp $VIMRUNTIME/macros/matchit.vim ~/.vim/doc
:helptags ~/.vim/doc

简短的介绍

至此这个插件已经可以使用了。参考 :h matchit-intro 来获得支持的命令以及 :h matchit-languages 来获得支持的语言。你可以很方便的定义自己的匹配对，如：

autocmd FileType python let b:match_words = '\<if\>:\<elif\>:\<else\>'

之后你就可以在任何的 Python 文件中使用 % （向前）或 g% （向后）在这三个片断之间跳转了。帮助文档：

:h matchit-install
:h matchit
:h b:match_words

技巧

跳至选择的区域另一端

在使用 v 或者 V 选择某段文字后，可以用 o 或者 O 按键跳至选择区域的开头或者结尾。

:h v_o
:h v_O

聪明地使用 n 和 N

n 与 N 的实际跳转方向取决于使用 / 还是 ? 来执行搜索，其中 / 是向后搜索，? 是向前搜索。一开始我（原作者）觉得这里很难理解。如果你希望 n 始终为向后搜索，N 始终为向前搜索，那么只需要这样设置：

nnoremap <expr> n  'Nn'[v:searchforward]
nnoremap <expr> N  'nN'[v:searchforward]

聪明地使用命令行历史

我（原作者）习惯用 Ctrl + p 和 Ctrl + n 来跳转到上一个/下一个条目。其实这个操作也可以用在命令行中，快速调出之前执行过的命令。不仅如此，你会发现 上 和 下 其实更智能。如果命令行中已经存在了一些文字，我们可以通过按方向键来匹配已经存在的内容。比如，命令行中现在是 :echo，这时候我们按 上，就会帮我们补全成 :echo "Vim rocks!"（前提是，之前输入过这段命令）。当然，Vim 用户都不愿意去按方向键，事实上我们也不需要去按，只需要设置这样的映射：

cnoremap <c-n> <down>
cnoremap <c-p> <up>

这个功能，我（原作者）每天都要用很多次。

智能 Ctrl-l

Ctrl + l 的默认功能是清空并「重新绘制」当前的屏幕，就和 :redraw! 的功能一样。下面的这个映射就是执行重新绘制，并且取消通过 / 和 ? 匹配字符的高亮，而且还可以修复代码高亮问题（有时候，由于多个代码高亮的脚本重叠，或者规则过于复杂，Vim 的代码高亮显示会出现问题）。不仅如此，还可以刷新「比较模式」（请参阅 :help diff-mode）的代码高亮：

nnoremap <leader>l :nohlsearch<cr>:diffupdate<cr>:syntax sync fromstart<cr><c-l>

禁用错误报警声音和图标

set noerrorbells
set novisualbell
set t_vb=

请参阅 Vim Wiki: Disable beeping。

快速移动当前行

有时，我（原作者）想要快速把当前行上移或下移一行，只需要这样设置映射：

nnoremap [e  :<c-u>execute 'move -1-'. v:count1<cr>
nnoremap ]e  :<c-u>execute 'move +'. v:count1<cr>

这个映射，同样可以搭配数字使用，比如连续按下 2 ] e 就可以把当前行向下移动两行。

快速添加空行

nnoremap [<space>  :<c-u>put! =repeat(nr2char(10), v:count1)<cr>'[
nnoremap ]<space>  :<c-u>put =repeat(nr2char(10), v:count1)<cr>

设置之后，连续按下 5 \[ 空格 在当前行上方插入 5 个空行。

运行时检测

需要的特性：+profile Vim 提供了一个内置的运行时检查功能，能够找出运行慢的代码。 :profile 命令后面跟着子命令来确定要查看什么。如果你想查看所有的：

:profile start /tmp/profile.log
:profile file *
:profile func *
<do something in Vim>
<quit Vim>

Vim 不断地在内存中检查信息，只在退出的时候输出出来。（Neovim 已经解决了这个问题用 :profile dump 命令）看一下 /tmp/profile.log 文件，检查时运行的所有代码都会被显示出来，包括每一行代码运行的频率和时间。大多数代码都是用户不熟悉的插件代码，如果你是在解决一个确切的问题，直接跳到这个日志文件的末尾，那里有 FUNCTIONS SORTED ON TOTAL TIME 和 FUNCTIONS SORTED ON SELF TIME 两个部分，如果某个 function 运行时间过长一眼就可以看到。

查看启动时间

感觉 Vim 启动的慢？到了研究几个数字的时候了：

vim --startuptime /tmp/startup.log +q && vim /tmp/startup.log

第一栏是最重要的因为它显示了绝对运行时间，如果在前后两行之间时间差有很大的跳跃，那么是第二个文件太大或者含有需要检查的错误的 VimL 代码。

NUL 符用新行表示

文件中的 NUL 符（\0），在内存中被以新行（\n）保存，在缓存空间中显示为 ^@。更多信息请参看 man 7 ascii 和 :h NL-used-for-Nul 。

快速编辑自定义宏

这个功能真的很实用！下面的映射，就是在一个新的命令行窗口中读取某一个寄存器（默认为 *）。当你设置完成后，只需要按下 回车 即可让它生效。在录制宏的时候，我经常用这个来更改拼写错误。

nnoremap <leader>m  :<c-u><c-r><c-r>='let @'. v:register .' = '. string(getreg(v:register))<cr><c-f><left>

只需要连续按下 leader m 或者 " leader m 就可以调用了。请注意，这里之所以要写成 <c-r><c-r> 是为了确保 <c-r> 执行了。请参阅 :h c_^R^R

快速跳转到源(头)文件

这个技巧可以用在多种文件类型中。当你从源文件或者头文件中切换到其他文件的时候，这个技巧可以设置「文件标记」（请参阅 :h marks），然后你就可以通过连续按下 ' C 或者 ' H 快速跳转回去（请参阅 :h 'A）。

autocmd BufLeave *.{c,cpp} mark C
autocmd BufLeave *.h       mark H

注意：由于这个标记是设置在 viminfo 文件中，因此请先确认 :set viminfo? 中包含了 :h viminfo-'。

在 GUI 中快速改变字体大小

印象中，我（原作者）记得一下代码是来自 tpope’s 的配置文件：

command! Bigger  :let &guifont = substitute(&guifont, '\d\+$', '\=submatch(0)+1', '')
command! Smaller :let &guifont = substitute(&guifont, '\d\+$', '\=submatch(0)-1', '')

根据模式改变光标类型

我（原作者）习惯在普通模式下用块状光标，在插入模式下用条状光标（形状类似英文 “I” 的样子），然后在替换模式中使用下划线形状的光标。

if empty($TMUX)
  let &t_SI = "\<Esc>]50;CursorShape=1\x7"
  let &t_EI = "\<Esc>]50;CursorShape=0\x7"
  let &t_SR = "\<Esc>]50;CursorShape=2\x7"
else
  let &t_SI = "\<Esc>Ptmux;\<Esc>\<Esc>]50;CursorShape=1\x7\<Esc>\\"
  let &t_EI = "\<Esc>Ptmux;\<Esc>\<Esc>]50;CursorShape=0\x7\<Esc>\\"
  let &t_SR = "\<Esc>Ptmux;\<Esc>\<Esc>]50;CursorShape=2\x7\<Esc>\\"
endif

原理很简单，就是让 Vim 在进入和离开插入模式的时候，输出一些序列，请参考 escape sequence。Vim 与终端之间的中间层，比如 tmux 会处理并执行上面的代码。但上面这个还是有一个缺点的。终端环境的内部原理不尽相同，对于序列的处理方式也稍有不同。因此，上面的代码可能无法在你的环境中运行。甚至，你的运行环境也有可能不支持其他光标形状，请参阅你的 Vim 运行环境的文档。好消息是，上面这个代码，可以在 iTerm2 中完美运行。

防止水平滑动的时候失去选择

如果你选中了一行或多行，那么你可以用 < 或 > 来调整他们的缩进。但在调整之后就不会保持选中状态了。你可以连续按下 g v 来重新选中他们，请参考 :h gv。因此，你可以这样来配置映射：

xnoremap <  <gv
xnoremap >  >gv

设置好之后，在可视模式中使用 >>>>> 就不会再出现上面提到的问题了。

选择当前行至结尾，排除换行符

在 Vim 里，我们可以同过 v$ 选择当前行至结尾，但此时会把最后一个换行符也选中，通常需要按额外的 h 来取消最后选中最后一个换行符号。 Vim 提供了一个 g_ 快捷键，可以移动光标至最后一个非空字符。因此，为达到次效果，可以使用 vg_。当然，如果觉得按三个键比较麻烦，可以添加一个映射：

nnoremap L g_

这样就可以通过 vL 达到一样的效果了。

重新载入保存文件

通过自动命令，你可以在保存文件的同时触发一些其他功能。比如，如果这个文件是一个配置文件，那么就重新载入；或者你还可以对这个文件进行代码风格检查。

autocmd BufWritePost $MYVIMRC source $MYVIMRC
autocmd BufWritePost ~/.Xdefaults call system('xrdb ~/.Xdefaults')

更加智能的当前行高亮

我（原作者）很喜欢「当前行高亮」（请参阅 :h cursorline）这个功能，但我只想让这个效果出现在当前窗口，而且在插入模式中关闭这个效果：

autocmd InsertLeave,WinEnter * set cursorline
autocmd InsertEnter,WinLeave * set nocursorline

更快的关键字补全

关键字补全（<c-n> 或 <c-p>）功能的工作方式是，无论 'complete' 设置中有什么，它都会尝试着去补全。这样，一些我们用不到的标签也会出现在补全列表中。而且，它会扫描很多文件，有时候运行起来非常慢。如果你不需要这些，那么完全可以像这样把它们禁用掉：

set complete-=i   " disable scanning included files
set complete-=t   " disable searching tags

改变颜色主题的默认外观

如果你想让状态栏在颜色主题更改后依然保持灰色，那么只需要这样设置：

autocmd ColorScheme * highlight StatusLine ctermbg=darkgray cterm=NONE guibg=darkgray gui=NONE

同理，如果你想让某一个颜色主题（比如 “lucius”）的状态栏为灰色（请使用 :echo color_name 来查看当前可用的所有颜色主题）：

autocmd ColorScheme lucius highlight StatusLine ctermbg=darkgray cterm=NONE guibg=darkgray gui=NONE

命令

下面的命令都比较有用，最好了解一下。用 :h :<command name> 来了解更多关于它们的信息，如：:h :global。

:global 和 :vglobal - 在所有匹配行执行命令

在所有符合条件的行上执行某个命令。如： :global /regexp/ print 会在所有包含 “regexp” 的行上执行 print 命令（译者注：regexp 有正则表达式的意思，该命令同样支持正则表达式，在所有符合正则表达式的行上执行指定的命令）。趣闻：你们可能都知道老牌的 grep 命令，一个由 Ken Thompson 编写的过滤程序。它是干什么用的呢？它会输出所有匹配指定正则表达式的行！现在猜一下 :global /regexp/ print 的简写形式是什么？没错！就是 :g/re/p 。 Ken Thompsom 在编写 grep 程序的时候是受了 vi :global 的启发。（译者注： https://robots.thoughtbot.com/how-grep-got-its-name）既然它的名字是 :global，理应仅作用在所有行上，但是它也是可以带范围限制的。假设你想使用 :delete 命令删除从当前行到下一个空行（由正则表达式 ^$ 匹配）范围内所有包含 “foo” 的行：

:,/^$/g/foo/d

如果要在所有不匹配的行上执行命令的话，可以使用 :global! 或是它的别名 :vglobal （ V 代表的是 inVerse ）。

:normal 和 :execute - 脚本梦之队

这两个命令经常在 Vim 的脚本里使用。借助于 :normal 可以在命令行里进行普通模式的映射。如：:normal! 4j 会令光标下移 4 行（由于加了”!”，所以不会使用自定义的映射 “j”）。需要注意的是 :normal 同样可以使用范围数（译者注：参考 :h range 和 :h :normal-range 了解更多），故 :%norm! Iabc 会在所有行前加上 “abc”。借助于 :execute 可以将命令和表达式混合在一起使用。假设你正在编辑一个 C 语言的文件，想切换到它的头文件：

:execute 'edit' fnamemodify(expand('%'), ':r') . '.h'

（译者注：头文件为与与源文件同名但是扩展名为 .h 的文件。上面的命令中 expand 获得当前文件的名称，fnamemodify 获取不带扩展名的文件名，再连上 ‘.h’ 就是头文件的文件名了，最后在使用 edit 命令打开这个头文件。）这两个命令经常一起使用。假设你想让光标下移 n 行：

:let n = 4
:execute 'normal!' n . 'j'

重定向消息

许多命令都会输出消息，:redir 用来重定向这些消息。它可以将消息输出到文件、寄存器或是某个变量中。

" 将消息重定向到变量 `neatvar` 中
:redir => neatvar
" 打印所有寄存器的内容
:reg
" 结束重定向
:redir END
" 输出变量
:echo neatvar
" 恶搞一下，我们把它输出到当前缓冲区
:put =neatvar

再 Vim 8 中，可以更简单的方式即位：

:put =execute('reg')

（译者注：原文最后一条命令是 :put =nicevar 但是实际会报变量未定义的错误）（实测 neovim/vim8 下没问题）帮助文档：:h :redir

调试

常规建议

如果你遇到了奇怪的行为，尝试用这个命令重现它：

vim -u NONE -N

这样会在不引用 vimrc（默认设置）的情况下重启 vim，并且在 nocompatible 模式下（使用 vim 默认设置而不是 vi 的）。（搜索 :h --noplugin 命令了解更多启动加载方式）如果仍旧能够出现该错误，那么这极有可能是 vim 本身的 bug，请给 vim_dev 发送邮件反馈错误，多数情况下问题不会立刻解决，你还需要进一步研究许多插件经常会提供新的（默认的/自动的）操作。如果在保存的时候发生了，那么请用 :verb au BufWritePost 命令检查潜在的问题如果你在使用一个插件管理工具，将插件行注释调，再进行调试。问题还没有解决？如果不是插件的问题，那么肯定是你的自定义的设置的问题，可能是你的 options 或 autocmd 等等。到了一行行代码检查的时候了，不断地排除缩小检查范围知道你找出错误，根据二分法的原理你不会花费太多时间的。在实践过程中，可能就是这样，把 :finish 放在你的 vimrc 文件中间，Vim 会跳过它之后的设置。如果问题还在，那么问题就出在:finish之前的设置中，再把:finish放到前一部分设置的中间位置。否则问题就出现在它后面的半部分设置，那么就把:finish放到后半部分的中间位置。不断的重复即可找到。

调整日志等级

Vim 现在正在使用的另一个比较有用的方法是增加 debug 信息输出详细等级。现在 Vim 支持 9 个等级，可以用:h 'verbose'命令查看。

:e /tmp/foo
:set verbose=2
:w
:set verbose=0

这可以显示出所有引用的文件、没有变化的文件或者各种各样的作用于保存的插件。如果你只是想用简单的命令来提高等级，也是用 :verbose ，放在其他命令之前，通过计数来指明等级，默认是 1.

:verb set verbose
"  verbose=1
:10verb set verbose
"  verbose=10

通常用等级 1 来显示上次从哪里设置的选项

:verb set ai?
"      Last set from ~/.vim/vimrc

一般等级越高输出信息月详细。但是不要害怕，亦可以把输出导入到文件中：

:set verbosefile=/tmp/foo | 15verbose echo "foo" | vsplit /tmp/foo

你可以一开始的时候就打开 verbosity，用 -V 选项，它默认设置调试等级为 10。例如：vim -V5

查看启动日志

查看运行时日志

Vim 脚本调试

如果你以前使用过命令行调试器的话，对于:debug命令你很快就会感到熟悉。只需要在任何其他命令之前加上:debug就会让你进入调试模式。也就是，被调试的 Vim 脚本会在第一行停止运行，同时该行会被显示出来。想了解可用的 6 个调试命令，可以查阅:h >cont和阅读下面内容。需要指出的是，类似 gdb 和其他相似调试器，调试命令可以使用它们的简短形式：c、 q、n、s、 i和 f。除了上面的之外，你还可以自由地使用任何 Vim 的命令。比如，:echo myvar，该命令会在当前的脚本代码位置和上下文上被执行。只需要简单使用:debug 1，你就获得了REPL调试特性。当然，调试模式下是可以定义断点的，不然的话每一行都去单步调试就会十分痛苦。（断点之所以被叫做断点，是因为运行到它们的时候，运行就会停止下来。因此，你可以利用断点跳过自己不感兴趣的代码区域）。请查阅:h :breakadd、 :h :breakdel和 :h :breaklist获取更多细节。假设你需要知道你每次在保存一个文件的时候有哪些代码在运行：

:au BufWritePost
" signify  BufWritePost
"     *         call sy#start()
:breakadd func *start
:w
" Breakpoint in "sy#start" line 1
" Entering Debug mode.  Type "cont" to continue.
" function sy#start
" line 1: if g:signify_locked
>s
" function sy#start
" line 3: endif
>
" function sy#start
" line 5: let sy_path = resolve(expand('%:p'))
>q
:breakdel *

正如你所见，使用<cr>命令会重复之前的调试命令，也就是在该例子中的s命令。 :debug命令可以和verbose选项一起使用。

语法文件调试

语法文件由于包含错误的或者复制的正则表达式，常常会使得 Vim 的运行较慢。如果 Vim 在编译的时候包含了+profile feature特性，就可以给用户提供一个超级好用的:syntime命令。

:syntime on
" 多次敲击<c-l>来重绘窗口，这样的话就会使得相应的语法规则被重新应用一次
:syntime off
:syntime report

输出结果包含了很多的度量维度。比如，你可以通过结果知道哪些正则表达式耗时太久需要被优化；哪些正则表达式一直在别使用但重来没有一次成功匹配。请查阅:h :syntime。

杂项

附加资源

资源名称	简介
七个高效的文本编辑习惯	作者：Bram Moolenaar（即 Vim 的作者）
七个高效的文本编辑习惯 2.0（PDF 版）	同上
IBM DeveloperWorks: 使用脚本编写 Vim 编辑器	Vim 脚本编写五辑
《漫漫 Vim 路》	使用魔抓定制 Vim 插件
《 Vim 实践 (第 2 版)》	轻取 Vim 最佳书籍
Vimcasts.org	Vim 录屏演示
为什么是个脚本都用 vi？	常见误区释疑
你不爱 vi，所以你不懂 Vim	简明,扼要,准确的干货

Vim 配置集合

目前，网上有很多流行 Vim 配置集合，对于 Vim 配置集合，个人认为有利有弊。对于维护的比较好的配置，比如 SpaceVim 还是值得尝试的，可以节省很多自行配置的时间。当然，网上还有很多其他很流行的配置，比如：

常见问题

编辑小文件时很慢

有两个因素对性能影响非常大：

过于复杂的 正则表达式 。尤其是 Ruby 的语法文件，以前会造成性能下降。（见调试语法文件）
屏幕重绘 。有一些功能会强制重绘所有行。

典型肇事者	原因	解决方案
`:set cursorline`	会导致所有行重绘	`:set nocursorline`
`:set cursorcolumn`	会导致所有行重绘	`:set nocursorcolumn`
`:set relativenumber`	会导致所有行重绘	`:set norelativenumber`
`:set foldmethod=syntax`	如果语法文件已经很慢了，这只会变得更慢	`:set foldmethod=manual`，`:set foldmethod=marker` 或者使用快速折叠插件
`:set synmaxcol=3000`	由于内部表示法，Vim 处理比较长的行时会有问题。让它高亮到 3000 列……	`:set synmaxcol=200`
matchparen.vim	Vim 默认加载的插件，用正则表达式查找配对的括号	禁用插件：`:h matchparen`

注意：只有在你真正遇到性能问题的时候才需要做上面的调整。在大多数情况下使用上面提到的选项是完全没有问题的。

编辑大文件的时候很慢

Vim 处理大文件最大的问题就是它会一次性读取整个文件。这么做是由于缓冲区的内部机理导致的（在 vim_dev 中讨论）。如果只是想查看的话，tail hugefile | vim - 是一个不错的选择。如果你能接受没有语法高亮，并且禁用所有插件和设置的话，使用：

$ vim -u NONE -N

这将会使得跳转变快很多，尤其是省去了基于很耗费资源的正则表达式的语法高亮。你还可以告诉 Vim 不要使用交换文件和 viminfo 文件，以避免由于写这些文件而造成的延时：

$ vim -n -u NONE -i NONE -N

简而言之，尽量避免使用 Vim 写过大的文件。

持续粘贴（为什么我每次都要设置 ‘paste’ 模式）

持续粘贴模式让终端模拟器可以区分输入内容与粘贴内容。你有没有遇到过往 Vim 里粘贴代码之后被搞的一团糟？这在你使用 cmd+v、shirt-insert、middle-click 等进行粘贴的时候才会发生。因为那样的话你只是向终端模拟器扔了一大堆的文本。 Vim 并不知道你刚刚是粘贴的文本，它以为你在飞速的输入。于是它想缩进这些行但是失败了。这明显不是个问题，如果你用 Vim 的寄存器粘贴，如："+p ，这时 Vim 就知道了你在粘贴，就不会导致格式错乱了。使用 :set paste 就可以解决这个问题正常进行粘贴。见 :h 'paste' 和 :h 'pastetoggle' 获取更多信息。如果你受够了每次都要设置 'paste' 的话，看看这个能帮你自动设置的插件：bracketed-paste。点此查看该作者对于这个插件的更多描述。 Neovim 尝试把这些变得更顺畅，如果终端支持的话，它会自动开启持续粘贴模式，无须再手动进行切换。

在终端中按 ESC 后有延时

如果你经常使用命令行，那么肯定要接触 终端模拟器 ，如 xterm、gnome-terminal、iTerm2 等等（与实际的终端不同）。终端模拟器与他们的祖辈一样，使用转义序列（也叫 控制序列 ）来控制光标移动、改变文本颜色等。转义序列就是以转义字符开头的 ASCII 字符串（用脱字符表示法表示成 ^[ ）。当遇到这样的字符串后，终端模拟器会从终端信息数据库中查找对应的动作。为了使用问题更加清晰，我会先来解释一下什么是映射超时。在映射存在歧义的时候就会产生映射超时：

:nnoremap ,a :echo 'foo'<cr>
:nnoremap ,ab :echo 'bar'<cr>

上面的例子中两个映射都能正常工作，但是当输入 ,a 之后，Vim 会延时 1 秒，因为它要确认用户是否还要输入那个 b。转义序列会产生同样的问题：

<esc> 作为返回普通模式或取消某个动作的按键而被大量使用
光标键使用转义序列进行的编码
Vim 期望 Alt （也叫作 Mate Key ）会发送一个正确的 8-bit 编码的高位，但是许多终端模拟器并不支持这个（也可能默认没有启用），而只是发送一个转义序列作为代替。

你可以这样测试上面所提到的事情： vim -u NONE -N 然后输入 i<c-v><left> ，你会看到一个以 ^[ 开头的字符串，表明这是一个转义序列，^[ 就是转义字符。简而言之，Vim 在区分录入的 <esc> 和转义序列的时候需要一定的时间。默认情况下，Vim 用 :set timeout timeoutlen=1000，就是说它会用 1 秒的时间来区分有歧义的映射以及按键编码。这对于映射来说是一个比较合理的值，但是你可以自行定义按键延时的长短，这是解决该问题最根本的办法：

set timeout           " for mappings
set timeoutlen=1000   " default value
set ttimeout          " for key codes
set ttimeoutlen=10    " unnoticeable small value

在 :h ttimeout 里你可以找到一个关于这些选项之间关系的小表格。而如果你在 tmux 中使用 Vim 的话，别忘了把下面的配置加入到你的 ~/.tmux.conf文件中：

set -sg escape-time 0

无法重复函数中执行的搜索

在命令中的搜索（/、:substitute 等）内容会改变“上次使用的搜索内容”。（它保存在/寄存器中，用 :echo @/ 可以输出它里面的内容）
简单的文本变化可以通过 . 重做。（它保存在 . 寄存器，用 :echo @. 可以输出它的内容）

而在你在函数中进行这些操作的时候，一切就会变得不同。因此你不能用 N/n 查找某个函数刚刚查找的内容，也不能重做函数中对文本的修改。帮助文档：:h function-search-undo。

SpaceVim 第一个版本

Wed, 18 Jan 2017 00:00:00 +0000

Like spacemacs, but for vim.

SpaceVim 放在 github 上， 3 天获取 700+ 星，该项目不仅适合 vim 以及 neovim 老用户，对于新用户来说，也是非常适合的。 @Shougo 大神以及 @mhinz 大神对此项目也很支持，另外，该项目在 Hacker News 首页也出现过。拥有 200+ points 。在 gittter #neovim 内，也有用户支持该项目。目前该项目 80% 收藏者来自国外，国内确实没有找到很好的 post 平台，现尝试在 V2EX 上发布下，希望有更多的 vim 用户支持，让 vim 中文社区更加活跃。该项目地址 github 地址是： SpaceVim/SpaceVim 官网： http://spacevim.org SpaceVim 是高度可定制的模块化 Vim 配置集合，适合开发各种语言，尤其是 Java c c++ python php 等常用语言，并且拥有非常优秀的 UI 界面，用户可以根据自己需求载入需要的模块。如果有兴趣，欢迎进群大家一起讨论。本群为非常专业的技术讨论群，请勿水！

在 Vim 中使用聊天工具

Fri, 30 Dec 2016 00:00:00 +0000

安装
微信及QQ聊天
- 依赖
- 启动

在装了 arch 之后，没有庄 gnome 等桌面，而是采用了 I3-WM 这样的平铺桌面，平时有聊天的需求，又无法忍受手机打字那么麻烦，于是做了一个 Linux 系统下借助 Vim 的聊天工具。分享给大家：

安装

call dein#add('wsdjeg/vim-chat')

安装完成之后，可以使用 call chat#chatting#OpenMsgWin()，打开聊天窗口。

微信及QQ聊天

依赖

mojo-webqq 和 mojo-weixin：用于将QQ及微信协议转换成irc协议
IRC 依赖模块: cpanm -v Mojo::IRC::Server::Chinese, 详见： irc.md
irssi: irc 聊天客户端
feh: 图片查看器，用于打开二维码
neovim： vim8 的异步存在问题，无法实现相应功能，故只能在neovim下使用
Linux: 目前仅在Linux下测试成功， Windows 下请直接使用QQ客户端

启动

首先启动 QQ 服务器 call chat#qq#start(), 然后会自动弹出一个二维码，手机扫描下就可以登录了。neovim 默认使用 Alt + x 打开/关闭聊天窗口。

为什么要写博客

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

为什么要写博客
为什么使用独立站点
为什么使用邮件评论
关于社交软件

为什么要写博客

其实关于这个问题，至今我也没有完全想明白。可能是因为上了年纪的原因，有些怀旧，但是发现过往的记忆似乎很难完全想起来了。因此，我觉得有必要日常做一些简单的记录。

我想记录一些值得记忆的人和事，也许多年以后回来看看，会很欣慰
记录日常遇到的一些问题及解决的方法
记录折腾一些有意思的小玩意的过程

为什么使用独立站点

其实早在 2004 年 QQ 出现的时候，就开始写 QQ 空间日志，再到后来的新浪博客、网易博客、百度空间、博客园、CSDN 等等，这些平台都有使用过。但是都存在各种各样的问题，包括：

页面样式定制不自由，个人网站每一个字符、每一张图片、每一个链接都应该是完全可控的。
跑路风险，备份麻烦。这些平台都有停止服务的可能，那些写在其上的文字很难备份转移。
广告满天飞，尤其是 CSDN。
登录才能阅读，像知乎、CSDN 这类网站，非登录用户都无法阅读全文。

独立站点的优势在于：

完全可控，自己个人站点中每一个字符、每一张图片、每一个链接都是可控的
使用 Git 仓库，编辑历史可以追溯，备份也方便

为什么使用邮件评论

邮件更加私密，也显得更加正式。同时，也可以避免广告、spam 等内容直接在评论区显示。

关于社交软件

之前用过的社交平台软件，各种各样问题都有。以至于有很长一段时间，很想彻底摆脱这些社交软件。 Reddit 账号已删除，留张图片纪念一下：

可爱的小天使

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

命令形式
global与substitute
global标志的[range]用法

:global 和 :substitute 命令是 Vim 最强大的命令之一，将其摸透用熟可以事半功倍，在这里我总结了一些网上的网上的经典问题，结合自己的使用和理解，通过实例详细介绍一下其用法。示例难度不一，其中有些可能并没有多少实用性，仅仅是为了展示功能。

命令形式

阅读 :help :g可知，该命令的使用形式为：

:[range]global/{pattern}/{command}

global 命令在 [range] 指定的文本范围内（缺省为整个文件）查找 {pattern}，然后对匹配到的行执行命令{command}，如果希望对没匹配上的行执行命令，则使用 global! 或 vglobal 命令。先来看 Vim 用户手册里的一个经典例子。 【例1】倒序文件行（即unix下的tac命令）

:g/^/m 0

这条命令用行首标记 ^ 匹配文件的所有行（这是查找的一个常用技巧，如果用 .则是匹配非空行，不满足本例要求），然后用 move 命令依次将每行移到第一行（第0行的下一行），从而实现了倒序功能。 global命令实际上是分成两步执行：首先扫描[range]指定范围内的所有行，给匹配{pattern}的行打上标记；然后依次对打有标记的行执行{command}命令，如果被标记的行在对之前匹配行的命令操作中被删除、移动或合并，则其标记自动消失，而不对该行执行{command}命令。标记的概念很重要，以例说明。 【例2】删除偶数行

:g/^/+1 d

这条命令也是匹配所有行，然后隔行删除（其中+1用以定位于当前行的下一行）。为什么是隔行呢？因为在对第一行执行+1 d命令时删除的是第二行，而第二行虽然也被标记了，但已不存在了，因此不会执行删除第三行的命令。本例也可以用:normal命令实现：

:%normal! jdd

% 指定整个文件，然后依次执行普通模式下的 jdd，即下移删除一行。与 global 命令不同之处在于， %normal! jdd 是按照行号顺序执行，在第一行时删除了第二行，后面的所有行号都减一，因此在第二行执行 jdd 时删除的是原来的第四行。也就是说，global 命令是通过偶数行标记的消失实现的，而 normal 命令是通过后续行的自动前移实现的。 【例3】删除奇数行

:g/^/d|m.

光是:g/^/d显然不行，这会删除所有行，我们需要用move命令把偶数行的标记去掉。当然，本例可以很简单的转换成【例2】，在此只是用来强调标记的概念。本例若想用 normal 命令实现比较有意思，%normal! dd也同样会删除整个文件，%normal! jkdd就可以，我不知道两者为什么不同，可能和normal命令内部的运行机制有关。

global与substitute

不少人觉得这两个命令差不多，的确，它们的形式很相似，都是要进行查找匹配，只不过 :substitute 执行的是替换而 :global 执行的其它命令（当然，substitute 缺省的 [range] 是当前行，这点也不同）。先看两个例子，体会一下:s和:g不同的思维方式。 【例4】double所有行

:%s/.*/&\r&/
:g/^/t.

substitue是查找任意行，然后替换为两行夹回车；global是将每一行复制（:t就是:copy）到自己下面，更加清晰明了。 【例5】把以回车排版、以空行分段的文本变成以回车分段的文本 很多txt格式的ebook，以及像vim help这样的文本，每行的字符数受限，段之间用空行分隔。若把它们拷贝到word里，那些硬回车和空行就比较讨厌了，虽然word里也有自动调整格式的功能，不过在Vim里搞定更是小菜一碟。先看看用替换如何实现。

:%s/\n\n\@!//

\n\n\@!是查找后面不跟回车的回车（关于\@!的用法请:h /\@!，在此不多说了），然后替换为空，也就是去掉用于排版的回车。注：如果等宽段之间无空行，则合并命令变为:%s/\n\%(\s\{2,}\|\n\)\@!//g global命令则完全是另一种思路。

:g/./,/^$/j

/./标记非空行，/^$/查找其后的空行，然后对二者之间的行进行合并操作。也许有人会问，段中的每一行会不会都执行了j命令？前面已经说过，在之前操作中消失掉的标记行不执行操作命令，在处理每段第一行时已经把段内的其余行都合并了，所以每段只会执行一次j命令。这条命令使用global标记做为[range]的起始行，这样的用法后面还会详述。 global经常与substitute组合使用，用前者定位满足一定条件的行，用后者在这些行中进行查找替换。如：【例6】将aaa替换成bbb，除非该行中有ccc或者ddd

:v/ccc\|ddd/s/aaa/bbb/g

【例7】将aaa替换成bbb，条件是该行中有ccc但不能有ddd 如何写出一个匹配aaa并满足行内有ccc但不能有ddd的正则表达式？我不知道。即便能写出来，也必定极其复杂。用global命令则并不困难：

:g/ccc/if getline('.') !~ 'ddd' | s/aaa/bbb/g

该命令首先标记匹配ccc的行，然后执行if命令（if也是ex命令！），getline函数取得当前行，然后判断是否匹配ddd，如果不匹配（!~的求值为true）则执行替换。要掌握这样的用法需要对ex命令、Vim函数和表达式有一定了解才行，实际上，这条命令已经是一个快捷版的脚本了。可能有人会想，把g和v连起来用不就行了么，可惜global命令不支持（恐怕也没法支持）嵌套。

global标志的[range]用法

:h range

在global命令第一步中所设的标记，可以被用来为{command}命令设定各种形式的[range]。在【例2】和【例5】中都已使用了这一技巧，灵活使用[range]，是一项重要的基本功。先看看【例2】和【例3】的一般化问题。 【例8】每n行中，删除前/后m行（例如，每10行删除前/后3行）

:g/^/,+2 d | ,+6 m -1
:g/^/,+6 m -1 | +1,+3 d

这两个命令还是利用move来清除保留行的标志，需要注意的是执行第二个命令时的当前行是第一个命令寻址并执行后的位置。再看两个更实用点的例子。

感谢 gqqnb2005 提醒，C++ preprocessor 已經是個很複雜很强大的語言了，下面的两个示例仅供参考理解 :g 命令配合 / 命令搜索确定 range, 实际上，语法级别的 range 确定，使用正则表达式是完全不够的。

【例9】提取条件编译内容。例如，在一个多平台的C程序里有大量的条件编译代码：

#ifdef WIN32
XXX1
XXX2
#endif
...
#ifdef WIN32
XXX3
XXX4
#else
YYY1
YYY2
#endif

现在用global命令把Win32平台下代码提取出来，拷贝到文件末：

:g/#ifdef WIN32/+1,/#else\|#endif/-1 t $

t命令的[range]是由逗号分隔，起始行是/#ifdef WIN32/标记行的下一行，结束行是一个查找定位，是在起始行后面出现的#endif或#else的上一行，t将二者间的内容复制到末尾。 【例10】提取上述C程序中的非Win32平台的代码（YYY部分） 首先说明一下，这个例子比前例要复杂的多，主要涉及的是[range]的操作，已经和global命令没多少关系，大可不看。加到这的目的是把问题说完，供喜欢细抠的朋友参考。本例的复杂性在于：首先，不能简单的用#else和#endif定位，因为代码中可能有其它的条件编译，我们必须要将查找范围限定在#ifdef WIN32的block中；另外，在block中可能并没有#else部分，这会给定位带来很大麻烦。解决方法是：

:try | g/#ifdef WIN32//#else/+1, /#endif/-1 t $ | endtry

先不管try和endtry，只看中间的global部分：找到WIN32，再向后找到#else，将其下一行作为[range]的起始行，然后从当前的光标（WIN32所在行，而非刚找到的#else的下一行）向下找到#endif，将其上一行作为[range]的结束行，然后执行t命令。但对于没有#else的block，如第一段代码，[range]的起始行是YYY1，而结束行是XXX2（因为查找#endif时是从第一行开始的，而不是从YYY1开始），这是一个非法的[range]，会引起exception，如果不放在try里面global命令就会立刻停止。与逗号(,)不同，如果[range]是用分号(;)分隔的，则会使得当前光标移至起始行，在查找#endif时是从#else的下一行开始，这样就产生非法[range]，用不着try，但带来的问题是：没有#else的block会错误的把后面block中的#else部分找出来。

欢迎来到 Racket

Tue, 19 Mar 2013 00:00:00 +0000

简介
S-表达式
高阶函数
Lambda 表达式
惰性求值
闭包
安装
执行 racket 脚本

Racket 是一种编程语言（programming language）—— Lisp 语言的一种方言和 Scheme 的一种派生语言；

简介

1958 年，人工智能之父 John McCarthy 发明了一种以 Lambda 演算为基础的符号处理语言， 1960 年 McCarthy 发表著名论文 Recursive Functions of Symbolic Expressions and Their Computation by Machine, 从此这种语言被命名为 LSIP (List Processor），其语法被命名为：符号表达式(S-Expression)。 LISP 构建在 7 个函数 [atom car cdr cond cons eq quote] 和 2 个特型 [lambda label] 之上。 Lisp诞生之初是为了纯粹的科学研究，代码执行像数学公式一样，以人的大脑来演算。直到麦卡锡的学生斯蒂芬·罗素将eval函数在IBM 704机器上实现后，才开启了Lisp作为一种计算机语言的历史。1962年，第一个完整的Lisp编译器在MIT诞生，从此之后Lisp以MIT为中心向全世界传播。之后十多年，出现了各种Lisp方言。 1975年，Scheme诞生。Scheme同样诞生与MIT，它的设计哲学是最小极简主义，它只提供必须的少数几个原语，所有其他的实用功能都由库来实现。在极简主义的设计思想下， Scheme趋于极致的优雅，并作为计算机教学语言在教育界广泛使用。 1984年，Common Lisp诞生。在二十世纪七八十年代，由于Lisp方言过多，社区分裂，不利于lisp整体的发展。从1981年开始，在一个Lisp黑客组织的运作下，经过三年的努力整合后，于1984年推出了Common Lisp。由于Scheme的设计理念和其他Lisp版本不同，所以尽管Common Lisp借鉴了Scheme的一些特点，但没有把Scheme整合进来。此后Lisp仅剩下两支方言： Common Lisp 和 Scheme。从二十世纪九十年代开始，由于C++、Java、C#的兴起，Lisp逐渐没落。直到2005年后，随着科学计算的升温，动态语言JavaScript、Python、Ruby的流行，Lisp又渐渐的回到人们的视线。不过在Lisp的传统阵地教育界，Python作为强有力的挑战者对Scheme发起冲锋；在2008年，MIT放弃了使用Scheme作为教学语言的SICP（计算机程序的构造和解释）课程，而启用Python进行基础教学。同时美国东北大学另立炉灶，其主导的科学计算系统PLT Scheme开始迅猛发展； 2010年，PLT Scheme改名为Racket。近几年，The Racket Language连续成为年度最活跃语言网站，并驾齐驱的还有haskell网站。

S-表达式

首先说一下S-表达式：S-表达式的基本元素是list与atom。list由括号包围，可包涵任何数量的由空格所分隔的元素，原子是其它内容。其使用前缀表示法，在Lisp中既用作代码，也用作数据。如：1+2*3 写成前缀表达式就是 (+ 1 (* 2 3)) 。

优点：容易parse，简单纯粹，不用考虑什么优先级等，也是实现代码即数据的前提；
缺点：可读性不是很强；

高阶函数

高阶函数至少满足下列一个条件：

接受一个或多个函数作为输入；
输出一个函数；

微积分中的导数就是一个例子，映射一个函数到另一个函数。在无类型 lambda 演算中，所有函数都是高阶的。在函数式编程中，返回另一个函数的高阶函数被称为Curry化的函数。 Curry化即把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。如 f(x,y)=x+y, 如果给定了 y=1，则就得到了 g(x)=x+1 这个函数。

Lambda 表达式

Racket中实用Lambda表达式来定义匿名函数，《如何设计程序》书中给出的使用原则是：如果某个非递归函数只需要当参数使用一次，使用Lambda表达式。如果想用Lambda表达式来表达递归，就需要引入Y组合子，Y 就是这样一个操作符，它作用于任何一个 (接受一个函数作为参数的) 函数 F，就会返回一个函数 X。再把 F 作用于这个函数 X，还是得到 X。所以 X 被叫做 F 的不动点(fixed point)，即 (Y F) = (F (Y F)) 。

惰性求值

惰性求值(Lazy Evaluation)，说白了就是某些中间结果不需要被求出来，求出来反而不利于后面的计算也浪费了时间。参见：惰性求值与惰性编程。惰性求值是一个计算机编程中的一个概念，它的目的是要最小化计算机要做的工作。惰性计算的最重要的好处是它可以构造一个无限的数据类型。使用惰性求值的时候，表达式不在它被绑定到变量之后就立即求值，而是在该值被取用的时候求值。语句如 x:=expression; (把一个表达式的结果赋值给一个变量)明显的调用这个表达式并把计算并把结果放置到 x 中，但是先不管实际在 x 中的是什么，直到通过后面的表达式中到 x 的引用而有了对它的值的需求的时候，而后面表达式自身的求值也可以被延迟，最终为了生成让外界看到的某个符号而计算这个快速增长的依赖树。

闭包

闭包在计算机科学中，闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。自由变量是在表达式中用于表示一个位置或一些位置的符号，比如 f(x,y) 对 x 求偏导时，y就是自由变量。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。在函数中(嵌套)定义另一个函数时，如果内部的函数引用了外部的函数的变量，则可能产生闭包。运行时，一旦外部的函数被执行，一个闭包就形成了，闭包中包含了内部函数的代码，以及所需外部函数中的变量的引用。其中所引用的变量称作上值(upvalue)。网上有很多讲 JavaScript 闭包的文章，如果你对 LISP 有系统的了解，那么这个概念自然会很清楚了。快排的Racket实现

#lang racket
(define (quick-sort array)
  (cond
    [(empty? array) empty]                            ; 快排的思想是分治+递归
    [else (append 
           (quick-sort (filter (lambda (x) (< x (first array))) array))
           ; 这里的 array 就是闭包   
           (filter (lambda (x) (= x (first array))) array)
           (quick-sort (filter (lambda (x) (> x (first array))) array)))]))
 
(quick-sort '(1 3 2 5 3 4 5 0 9 82 4))
;; 运行结果 '(0 1 2 3 3 4 4 5 5 9 82)

通过这个例子，就可以感受到基于 lambda 算子的 Racket 语言强大的表达能力了。高阶函数、lambda 表达式和闭包的使用使得 Racket 所描述的快排十分的精炼，这和基于冯诺依曼模型C语言是迥然不容的思维模式。

安装

在 Racket 官网下载对应系统的安装包，安装完成后，就可以在命令行里使用 racket 命令。

执行 racket 脚本

新建 hello.rkt 文件：

#lang lisp

(+ 1 1)

打开命令行，执行 racket -t hello.rkt, 就可以看到输出 2。

使用 Windows Live Writer 发布博客

Fri, 20 May 2011 00:00:00 +0000

很早以前，使用 wordpress 搭建博客的时候，尝试过 Windows Live Writer 这个工具。一些操作界面记忆犹新。图片来源于网络。早期的记录： https://groups.google.com/g/ircubuntu-cn/c/CkxGsARUDV8

01:57 <Kandu> wsdjeg: wsdjeg.tk
02:06 <Kandu> wsdjeg: <img src="http://127.0.0.1/wordpress/wp-content/themes/twentyten/images/headers/path.jpg"
02:07 <wsdjeg> 怎么了
02:35 <wsdjeg> 为什么不现实图片呢
02:46 <szsloss> 你的是什么服务器啊？？
02:54 <szsloss> apache or nginx??
03:12 <wsdjeg> 我自己的电脑阿
03:26 <wsdjeg> 不知道 ubuntu
03:31 <wsdjeg> 刚装的lamp
03:33 <szsloss> 要 环境的啊
03:35 <wsdjeg> 不会设置
03:37 <szsloss> 哦
03:43 <wsdjeg> 怎么杨设置阿
03:46 <szsloss> 那就是 apache 了】
03:50 <RuiZi> J :#ubuntu-cn
03:54 <myke2> Q :Read error: Connection reset by peer
04:05 <wsdjeg> 帮个忙 怎么设置 我就想做一个boog
04:20 <jiero> blog已经不流行了。
04:21 <jiero> 哈哈
04:43 <szsloss> 你 在 apache 里配置 一个 host 就可以了
04:45 <wsdjeg> 那该怎么设置下呢 有高手指点下么
04:54 <wsdjeg> 如何配置呢
Evanescence wsdjeg: you can set up Wordpress following official tutorial
Evanescence wsdjeg: and ubuntu wiki is usful too
06:27 <szsloss> wsdjeg: http://carrot.iteye.com/blog/232558
07:01 <szsloss> wsdjeg: http://clin003.com/servers/windows-configure-apache-virtualhost-1850/
07:09 <szsloss> 网上多的是啊
10:26 <wsdjeg> 还是高不明白
10:29 <shellex> ACTION 在咕噜牛奶
10:33 <bluek> sudo gedit /usr/share/gnome-session没有啊
10:48 <wsdjeg> 直接点阿 在什么地方加什么文件 内容是什么
11:48 <wsdjeg> 具体怎么弄阿 大哥
21:27 <caleb-> wsdjeg: 开了服务记得要设置防火墙
21:35 <caleb-> wsdjeg: 裸奔不是好习惯
21:48 <wsdjeg> 不懂
21:53 <wsdjeg> 怎么设置呢
22:18 <caleb-> wsdjeg: ubuntu 默认有图形介面的

感觉当年的聊天记录现在看了，都看不下去了，当时申请的 tk 域名，后期就没再用过。虽然现在无法下载原来的 Windows Live Writer，但是感谢开源社区维护了一个开源的版本：OpenLiveWriter

大学毕业了

Wed, 30 Jun 2010 00:00:00 +0000

2006年，这一年我考上了苏州大学。家里人都非常高兴，就如同2003年那会儿考上了仪征中学一样。在选择专业的时候第一志愿直接选择了生物科学专业，因为高中期间，几门课程当中生物课学的最好。依然记得，新生报道是我的父亲陪同一起来的大学。我们提前了一天来到了苏州，当时小姑姑住在白马涧那边，我们还去了白马涧公园玩了一下，河里的水清澈见底，还有桃花水母。第二天，我和父亲一起来了学校报道。报名好了整理完宿舍的时候，父亲再三叮嘱一些事情就离开了。我也不太记得具体是什么事情，没过多久父亲又回来找到了我，他的脸色不太好，有些发白。他没有说，其实我是知道的，父亲很少坐车出远门，折返回来坐车一定是晕车了。父亲的话很少，仍然是叮嘱了那几句话就回去了，然而，这次叮嘱，明显感觉声音在哽咽。从小打到，我记忆中就没见过父亲掉眼泪，他脾气其实不太好，和妈妈、爷爷奶奶经常拌嘴，是个很要强的人，这是我记忆中第一次见到父亲落泪。想来也是，以往高中、初中基本上就在家附近，哪怕是高中也是周末都回家，上了大学离家太远了。我更新这篇日志是2024年，距离大学毕业过去了整整十四年。回过头来再看，发现居然没人任何物件可以支撑这四年的记忆，回忆起来挺吃力的，感觉记忆也是零碎的，前后错乱的，似乎都没有一个时间主线。依稀就记得那么一些人和事，可能再过几年，这些记忆应该慢慢会更加的淡化。

模块化 vimrc 初体验

Wed, 01 Apr 2009 00:00:00 +0000

Vim 使用已经快有4个年头了，从最早期的只有一个 ~/.vimrc 文件，到之前一个完整的 ~/.vim 目录，期间配置文件结构也改变了很多。配置也变得越来越臃肿。体验过 eclipse 这样的工具后，回过头来在看看 Vim 的配置，似乎也可以把一些功能做成一些模块，然后根据自己实际的需求载入这些模块。在这里，我们使用 Bundle 这款工具来管理插件，大致的思路如下：

主文件结构

~/.vimrc:

" 将插件管理器加入 rtp
set rtp+=~/.vim/bundle/bundle
call bundle#begin()

" 模块逻辑
let g:modulars = ['core', 'java']

" 根据模块变量载入模块

for m in g:modulars
    exe 'so ~/.vim/modulars/' . m . '.vim' 
endfor

call bundle#end()

模块结构

我们以 Java 模块为例： ~/.vim/modulars/java.vim:

Bundle 'javautil.vim'
Bundle 'javaclass.vim'

" 插件配置

let g:java_util_foo = 'xxx'

Lua 数据库访问

Fri, 20 Jun 2008 00:00:00 +0000

Lua 面向对象

Sat, 14 Jun 2008 00:00:00 +0000

Lua 垃圾回收

Thu, 12 Jun 2008 00:00:00 +0000

Lua 采用了自动内存管理。这意味着你不用操心新创建的对象需要的内存如何分配出来，也不用考虑在对象不再被使用后怎样释放它们所占用的内存。 Lua 运行了一个垃圾收集器来收集所有死对象（即在 Lua 中不可能再访问到的对象）来完成自动内存管理的工作。 Lua 中所有用到的内存，如：字符串、表、用户数据、函数、线程、内部结构等，都服从自动管理。 Lua 实现了一个增量标记-扫描收集器。它使用这两个数字来控制垃圾收集循环：垃圾收集器间歇率和垃圾收集器步进倍率。这两个数字都使用百分数为单位（例如：值 100 在内部表示 1 ）。垃圾收集器间歇率控制着收集器需要在开启新的循环前要等待多久。增大这个值会减少收集器的积极性。当这个值比 100 小的时候，收集器在开启新的循环前不会有等待。设置这个值为 200 就会让收集器等到总内存使用量达到之前的两倍时才开始新的循环。垃圾收集器步进倍率控制着收集器运作速度相对于内存分配速度的倍率。增大这个值不仅会让收集器更加积极，还会增加每个增量步骤的长度。不要把这个值设得小于 100 ，那样的话收集器就工作的太慢了以至于永远都干不完一个循环。默认值是 200 ，这表示收集器以内存分配的”两倍”速工作。如果你把步进倍率设为一个非常大的数字（比你的程序可能用到的字节数还大 10% ），收集器的行为就像一个 stop-the-world 收集器。接着你若把间歇率设为 200 ，收集器的行为就和过去的 Lua 版本一样了：每次 Lua 使用的内存翻倍时，就做一次完整的收集。垃圾回收器函数 Lua 提供了以下函数collectgarbage ([opt [, arg]])用来控制自动内存管理:

collectgarbage("collect"): 做一次完整的垃圾收集循环。通过参数 opt 它提供了一组不同的功能：
collectgarbage("count"): 以 K 字节数为单位返回 Lua 使用的总内存数。这个值有小数部分，所以只需要乘上 1024 就能得到 Lua 使用的准确字节数（除非溢出）。
collectgarbage("restart"): 重启垃圾收集器的自动运行。
collectgarbage("setpause"): 将 arg 设为收集器的间歇率（参见 §2.5）。返回间歇率的前一个值。
collectgarbage("setstepmul"): 返回步进倍率的前一个值。
collectgarbage("step"): 单步运行垃圾收集器。步长”大小”由 arg 控制。传入 0 时，收集器步进（不可分割的）一步。传入非 0 值，收集器收集相当于 Lua 分配这些多（K 字节）内存的工作。如果收集器结束一个循环将返回 true 。
collectgarbage("stop"): 停止垃圾收集器的运行。在调用重启前，收集器只会因显式的调用运行。

以下演示了一个简单的垃圾回收实例:

mytable = {"apple", "orange", "banana"}

print(collectgarbage("count"))

mytable = nil

print(collectgarbage("count"))

print(collectgarbage("collect"))

print(collectgarbage("count"))

执行以上程序，输出结果如下(注意内存使用的变化)：

Lua 调试(Debug)

Tue, 10 Jun 2008 00:00:00 +0000

Lua 提供了 debug 库用于提供创建我们自定义调速器的功能。Lua 本身并未有内置的调速器，但很多开发者共享了他们的 Lua 调速器代码。 Lua 中 debug 库包含以下函数： sethook ([thread,] hook, mask [, count]):

debug(): 进入一个用户交互模式，运行用户输入的每个字符串。使用简单的命令以及其它调试设置，用户可以检阅全局变量和局部变量，改变变量的值，计算一些表达式，等等。输入一行仅包含 cont 的字符串将结束这个函数，这样调用者就可以继续向下运行。
getfenv(object): 返回对象的环境变量。
gethook(optional thread): 返回三个表示线程钩子设置的值：当前钩子函数，当前钩子掩码，当前钩子计数
getinfo ([thread,] f [, what]): 返回关于一个函数信息的表。你可以直接提供该函数，也可以用一个数字 f 表示该函数。数字 f 表示运行在指定线程的调用栈对应层次上的函数： 0 层表示当前函数（getinfo 自身）； 1 层表示调用 getinfo 的函数（除非是尾调用，这种情况不计入栈）；等等。如果 f 是一个比活动函数数量还大的数字， getinfo 返回 nil。
debug.getlocal ([thread,] f, local): 此函数返回在栈的 f 层处函数的索引为 local 的局部变量的名字和值。这个函数不仅用于访问显式定义的局部变量，也包括形参、临时变量等。
getmetatable(value): 把给定索引指向的值的元表压入堆栈。如果索引无效，或是这个值没有元表，函数将返回 0 并且不会向栈上压任何东西。
getregistry(): 返回注册表表，这是一个预定义出来的表，可以用来保存任何 C 代码想保存的 Lua 值。
getupvalue (f, up): 此函数返回函数 f 的第 up 个上值的名字和值。如果该函数没有那个上值，返回 nil 。以 ‘(‘ （开括号）打头的变量名表示没有名字的变量（去除了调试信息的代码块）。
将一个函数作为钩子函数设入。字符串 mask 以及数字 count 决定了钩子将在何时调用。掩码是由下列字符组合成的字符串，每个字符有其含义：
- ‘c’: 每当 Lua 调用一个函数时，调用钩子；
- ‘r’: 每当 Lua 从一个函数内返回时，调用钩子；
- ‘l’: 每当 Lua 进入新的一行时，调用钩子。
setlocal ([thread,] level, local, value): 这个函数将 value 赋给栈上第 level 层函数的第 local 个局部变量。如果没有那个变量，函数返回 nil 。如果 level 越界，抛出一个错误。
setmetatable (value, table): 将 value 的元表设为 table （可以是 nil）。返回 value。
setupvalue (f, up, value): 这个函数将 value 设为函数 f 的第 up 个上值。如果函数没有那个上值，返回 nil 否则，返回该上值的名字。
traceback ([thread,] [message [, level]]): 如果 message 有，且不是字符串或 nil，函数不做任何处理直接返回 message。否则，它返回调用栈的栈回溯信息。字符串可选项 message 被添加在栈回溯信息的开头。数字可选项 level 指明从栈的哪一层开始回溯（默认为 1 ，即调用 traceback 的那里）。

上表列出了我们常用的调试函数，接下来我们可以看些简单的例子：

function myfunction ()
print(debug.traceback("Stack trace"))
print(debug.getinfo(1))
print("Stack trace end")
    return 10
end
myfunction ()
print(debug.getinfo(1))

执行以上代码输出结果为：

Stack trace
stack traceback:
   test2.lua:2: in function 'myfunction'
   test2.lua:8: in main chunk
    [C]: ?
table: 0054C6C8
Stack trace end

在以实例中，我们使用到了 debug 库的 traceback 和 getinfo 函数， getinfo 函数用于返回函数信息的表。另一个实例我们经常需要调试函数的内的局部变量。我们可以使用 getupvalue 函数来设置这些局部变量。实例如下：

function newCounter ()
  local n = 0
  local k = 0
  return function ()
    k = n
    n = n + 1
    return n
    end
end

counter = newCounter ()
print(counter())
print(counter())

local i = 1

repeat
  name, val = debug.getupvalue(counter, i)
  if name then
    print ("index", i, name, "=", val)
    if(name == "n") then
        debug.setupvalue (counter,2,10)
   end
    i = i + 1
  end -- if
until not name

print(counter())

执行以上代码输出结果为：

1
2
index   1   k   =   1
index    2   n   =   2
11

在以上实例中，计数器在每次调用时都会自增1。实例中我们使用了 getupvalue 函数查看局部变量的当前状态。我们可以设置局部变量为新值。实例中，在设置前 n 的值为 2,使用 setupvalue 函数将其设置为 10。现在我们调用函数，执行后输出为 11 而不是 3。调试类型

命令行调试
图形界面调试

命令行调试器有：RemDebug、clidebugger、ctrace、xdbLua、LuaInterface - Debugger、Rldb、ModDebug。图形界调试器有：SciTE、Decoda、ZeroBrane Studio、akdebugger、luaedit。

Lua 异常处理

Fri, 30 May 2008 00:00:00 +0000

语法错误
运行错误
pcall 和 xpcall、debug

程序运行中错误处理是必要的，在我们进行文件操作，数据转移及web service 调用过程中都会出现不可预期的错误。如果不注重错误信息的处理，就会造成信息泄露，程序无法运行等情况。任何程序语言中，都需要错误处理。错误类型有：

语法错误
运行错误

语法错误

语法错误通常是由于对程序的组件（如运算符、表达式）使用不当引起的。一个简单的实例如下：

-- test.lua 文件
a == 2

以上代码执行结果为：

lua: test.lua:2: syntax error near '=='

正如你所看到的，以上出现了语法错误，一个 = 号跟两个 = 号是有区别的。一个 = 是赋值表达式两个 = 是比较运算。另外一个实例:

for a= 1,10
   print(a)
end

执行以上程序会出现如下错误：

lua: test2.lua:2: 'do' expected near 'print'

语法错误比程序运行错误更简单，运行错误无法定位具体错误，而语法错误我们可以很快的解决，如以上实例我们只要在for语句下添加 do 即可：

for a= 1,10
do
   print(a)
end

运行错误

运行错误是程序可以正常执行，但是会输出报错信息。如下实例由于参数输入错误，程序执行时报错：

function add(a,b)
   return a+b
end

add(10)

当我们编译运行以下代码时，编译是可以成功的，但在运行的时候会产生如下错误：

lua: test2.lua:2: attempt to perform arithmetic on local 'b' (a nil value)
stack traceback:
 test2.lua:2: in function 'add'
  test2.lua:5: in main chunk
    [C]: ?

以下报错信息是由于程序缺少 b 参数引起的。错误处理我们可以使用两个函数：assert 和 error 来处理错误。实例如下：

local function add(a,b)
   assert(type(a) == "number", "a 不是一个数字")
   assert(type(b) == "number", "b 不是一个数字")
   return a+b
end
add(10)

执行以上程序会出现如下错误：

lua: test.lua:3: b 不是一个数字
stack traceback:
	[C]: in function 'assert'
	test.lua:3: in local 'add'
	test.lua:6: in main chunk
	[C]: in ?

实例中assert首先检查第一个参数，若没问题，assert不做任何事情；否则，assert以第二个参数作为错误信息抛出。 error函数语法格式：

error (message [, level])

功能：终止正在执行的函数，并返回message的内容作为错误信息(error函数永远都不会返回) 通常情况下，error会附加一些错误位置的信息到message头部。 Level参数指示获得错误的位置:

Level=1[默认]：为调用error位置(文件+行号)
Level=2：指出哪个调用error的函数的函数
Level=0:不添加错误位置信息

pcall 和 xpcall、debug

Lua中处理错误，可以使用函数pcall（protected call）来包装需要执行的代码。 pcall接收一个函数和要传递个后者的参数，并执行，执行结果：有错误、无错误；返回值true或者或false, errorinfo。语法格式如下

if pcall(function_name, ….) then
-- 没有错误
else
-- 一些错误
end

简单实例：

> =pcall(function(i) print(i) end, 33)
33
true
   
> =pcall(function(i) print(i) error('error..') end, 33)
33
false        stdin:1: error..

> function f() return false,2 end
> if f() then print '1' else print '0' end
0

pcall以一种”保护模式”来调用第一个参数，因此pcall可以捕获函数执行中的任何错误。通常在错误发生时，希望落得更多的调试信息，而不只是发生错误的位置。但pcall返回时，它已经销毁了调用桟的部分内容。 Lua提供了xpcall函数，xpcall接收第二个参数——一个错误处理函数，当错误发生时，Lua会在调用桟展看（unwind）前调用错误处理函数，于是就可以在这个函数中使用debug库来获取关于错误的额外信息了。 debug库提供了两个通用的错误处理函数:

debug.debug：提供一个Lua提示符，让用户来价差错误的原因
debug.traceback：根据调用桟来构建一个扩展的错误消息

>=xpcall(function(i) print(i) error('error..') end, function() print(debug.traceback()) end, 33) 33 stack traceback: stdin:1: in function [C]: in function 'error' stdin:1: in function [C]: in function 'xpcall' stdin:1: in main chunk [C]: in ? false nil

xpcall 使用实例 2:

function myfunction ()
   n = n/nil
end

function myerrorhandler( err )
   print( "ERROR:", err )
end

status = xpcall( myfunction, myerrorhandler )
print( status)

执行以上程序会出现如下错误：

ERROR: test2.lua:2: attempt to perform arithmetic on global 'n' (a nil value)
false

Lua 文件 IO

Sat, 24 May 2008 00:00:00 +0000

Lua I/O 库用于读取和处理文件。分为简单模式（和C一样）、完全模式。

简单模式（simple model）拥有一个当前输入文件和一个当前输出文件，并且提供针对这些文件相关的操作。
完全模式（complete model）使用外部的文件句柄来实现。它以一种面对对象的形式，将所有的文件操作定义为文件句柄的方法

简单模式在做一些简单的文件操作时较为合适。但是在进行一些高级的文件操作的时候，简单模式就显得力不从心。例如同时读取多个文件这样的操作，使用完全模式则较为合适。打开文件操作语句如下：

file = io.open (filename [, mode])

mode 的值有：

模式	描述
r	以只读方式打开文件，该文件必须存在。
w	打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
a	以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）
r+	以可读写方式打开文件，该文件必须存在。
w+	打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
a+	与a类似，但此文件可读可写
b	二进制模式，如果文件是二进制文件，可以加上b
+	号表示对文件既可以读也可以写

简单模式简单模式使用标准的 I/O 或使用一个当前输入文件和一个当前输出文件。以下为 file.lua 文件代码，操作的文件为test.lua(如果没有你需要创建该文件)，代码如下：

-- 以只读方式打开文件
file = io.open("test.lua", "r")

-- 设置默认输入文件为 test.lua
io.input(file)

-- 输出文件第一行
print(io.read())

-- 关闭打开的文件
io.close(file)

-- 以附加的方式打开只写文件
file = io.open("test.lua", "a")

-- 设置默认输出文件为 test.lua
io.output(file)

-- 在文件最后一行添加 Lua 注释
io.write("--  test.lua 文件末尾注释")

-- 关闭打开的文件
io.close(file)

执行以上代码，你会发现，输出了 test.ua 文件的第一行信息，并在该文件最后一行添加了 lua 的注释。如我这边输出的是：

-- test.lua 文件

在以上实例中我们使用了 io.”x” 方法，其中 io.read() 中我们没有带参数，参数可以是下表中的一个：

模式	描述
`*n`	读取一个数字并返回它。例：`file.read('*n')`
`*a`	从当前位置读取整个文件。例：`file.read("*a")`
`*l`（默认）	读取下一行，在文件尾 (EOF) 处返回 nil。例：`file.read("*l")`
`number`	返回一个指定字符个数的字符串，或在 EOF 时返回 nil。例：`file.read(5)`

其他的 io 方法有：

io.tmpfile():返回一个临时文件句柄，该文件以更新模式打开，程序结束时自动删除

io.type(file): 检测obj是否一个可用的文件句柄

io.flush(): 向文件写入缓冲中的所有数据

io.lines(optional file name): 返回一个迭代函数,每次调用将获得文件中的一行内容,当到文件尾时，将返回nil,但不关闭文件

完全模式通常我们需要在同一时间处理多个文件。我们需要使用 file:function_name 来代替 io.function_name 方法。以下实例演示了如同同时处理同一个文件:

-- 以只读方式打开文件
file = io.open("test.lua", "r")

-- 输出文件第一行
print(file:read())

-- 关闭打开的文件
file:close()

-- 以附加的方式打开只写文件
file = io.open("test.lua", "a")

-- 在文件最后一行添加 Lua 注释
file:write("--test")

-- 关闭打开的文件
file:close()

执行以上代码，你会发现，输出了 test.ua 文件的第一行信息，并在该文件最后一行添加了 lua 的注释。如我这边输出的是：

-- test.lua 文件

read 的参数与简单模式一致。其他方法:

file:seek(optional whence, optional offset): 设置和获取当前文件位置,成功则返回最终的文件位置(按字节),失败则返回nil加错误信息。参数 whence 值可以是:
    "set": 从文件头开始
    "cur": 从当前位置开始[默认]
    "end": 从文件尾开始
    offset:默认为0
不带参数file:seek()则返回当前位置,file:seek("set")则定位到文件头,file:seek("end")则定位到文件尾并返回文件大小

file:flush(): 向文件写入缓冲中的所有数据

io.lines(optional file name): 打开指定的文件filename为读模式并返回一个迭代函数,每次调用将获得文件中的一行内容,当到文件尾时，将返回nil,并自动关闭文件。
若不带参数时io.lines() io.input():lines(); 读取默认输入设备的内容，但结束时不关闭文件,如

for line in io.lines("main.lua") do

　　print(line)

　　end

以下实例使用了 seek 方法，定位到文件倒数第 25 个位置并使用 read 方法的 *a 参数，即从当期位置(倒数第 25 个位置)读取整个文件。

-- 以只读方式打开文件
file = io.open("test.lua", "r")

file:seek("end",-25)
print(file:read("*a"))

-- 关闭打开的文件
file:close()

我这边输出的结果是：

st.lua 文件末尾--test

Lua 协同程序(coroutine)

Tue, 20 May 2008 00:00:00 +0000

什么是协同(coroutine)？ Lua 协同程序(coroutine)与线程比较类似：拥有独立的堆栈，独立的局部变量，独立的指令指针，同时又与其它协同程序共享全局变量和其它大部分东西。协同是非常强大的功能，但是用起来也很复杂。线程和协同程序区别线程与协同程序的主要区别在于，一个具有多个线程的程序可以同时运行几个线程，而协同程序却需要彼此协作的运行。在任一指定时刻只有一个协同程序在运行，并且这个正在运行的协同程序只有在明确的被要求挂起的时候才会被挂起。协同程序有点类似同步的多线程，在等待同一个线程锁的几个线程有点类似协同。基本语法

方法	描述
coroutine.create()	创建 coroutine，返回 coroutine，参数是一个函数，当和 resume 配合使用的时候就唤醒函数调用
coroutine.resume()	重启 coroutine，和 create 配合使用
coroutine.yield()	挂起 coroutine，将 coroutine 设置为挂起状态，这个和 resume 配合使用能有很多有用的效果
coroutine.status()	查看 coroutine 的状态注：coroutine 的状态有三种：dead，suspend，running，具体什么时候有这样的状态请参考下面的程序
coroutine.wrap（）	创建 coroutine，返回一个函数，一旦你调用这个函数，就进入 coroutine，和 create 功能重复
coroutine.running()	返回正在跑的 coroutine，一个 coroutine 就是一个线程，当使用 running 的时候，就是返回一个 corouting 的线程号

以下实例演示了以上各个方法的用法：

-- coroutine_test.lua 文件
co = coroutine.create(
    function(i)
        print(i);
    end
)

coroutine.resume(co, 1)   -- 1
print(coroutine.status(co))  -- dead

print("----------")

co = coroutine.wrap(
    function(i)
        print(i);
    end
)

co(1)

print("----------")

co2 = coroutine.create(
    function()
        for i=1,10 do
            print(i)
            if i == 3 then
                print(coroutine.status(co2))  --running
                print(coroutine.running()) --thread:XXXXXX
            end
            coroutine.yield()
        end
    end
)

coroutine.resume(co2) --1
coroutine.resume(co2) --2
coroutine.resume(co2) --3

print(coroutine.status(co2))   -- suspended
print(coroutine.running())   --nil

print("----------")

以上实例执行输出结果为：

1
dead
----------
1
----------
1
2
3
running
thread: 0x7fb801c05868    false
suspended
thread: 0x7fb801c04c88    true
----------

coroutine.running 就可以看出来,coroutine 在底层实现就是一个线程。当 create 一个 coroutine 的时候就是在新线程中注册了一个事件。当使用 resume 触发事件的时候，create 的 coroutine 函数就被执行了，当遇到 yield 的时候就代表挂起当前线程，等候再次 resume 触发事件。接下来我们分析一个更详细的实例：

function foo (a)
    print("foo 函数输出", a)
    return coroutine.yield(2 * a) -- 返回  2*a 的值
end

co = coroutine.create(function (a , b)
    print("第一次协同程序执行输出", a, b) -- co-body 1 10
    local r = foo(a + 1)

    print("第二次协同程序执行输出", r)
    local r, s = coroutine.yield(a + b, a - b)  -- a，b的值为第一次调用协同程序时传入

    print("第三次协同程序执行输出", r, s)
    return b, "结束协同程序"                   -- b的值为第二次调用协同程序时传入
end)

print("main", coroutine.resume(co, 1, 10)) -- true, 4
print("--分割线----")
print("main", coroutine.resume(co, "r")) -- true 11 -9
print("---分割线---")
print("main", coroutine.resume(co, "x", "y")) -- true 10 end
print("---分割线---")
print("main", coroutine.resume(co, "x", "y")) -- cannot resume dead coroutine
print("---分割线---")

以上实例执行输出结果为：

第一次协同程序执行输出 1   10
foo 函数输出    2
main true    4
--分割线----
第二次协同程序执行输出   r
main true    11  -9
---分割线---
第三次协同程序执行输出  x   y
main true    10  结束协同程序
---分割线---
main false   cannot resume dead coroutine
---分割线---

以上实例接下如下：

调用resume，将协同程序唤醒,resume操作成功返回true，否则返回false；
协同程序运行；
运行到yield语句；
yield挂起协同程序，第一次resume返回；（注意：此处yield返回，参数是resume的参数）
第二次resume，再次唤醒协同程序；（注意：此处resume的参数中，除了第一个参数，剩下的参数将作为yield的参数）
yield返回；
协同程序继续运行；
如果使用的协同程序继续运行完成后继续调用 resumev方法则输出：cannot resume dead coroutine

resume 和 yield 的配合强大之处在于，resume 处于主程中，它将外部状态（数据）传入到协同程序内部；而 yield 则将内部的状态（数据）返回到主程中。生产者-消费者问题现在我就使用 Lua 的协同程序来完成生产者-消费者这一经典问题。

local newProductor

function productor()
     local i = 0
     while true do
          i = i + 1
          send(i)     -- 将生产的物品发送给消费者
     end
end

function consumer()
     while true do
          local i = receive()     -- 从生产者那里得到物品
          print(i)
     end
end

function receive()
     local status, value = coroutine.resume(newProductor)
     return value
end

function send(x)
     coroutine.yield(x)     -- x表示需要发送的值，值返回以后，就挂起该协同程序
end

-- 启动程序
newProductor = coroutine.create(productor)
consumer()

以上实例执行输出结果为：

Lua 元表(Metatable)

Tue, 13 May 2008 00:00:00 +0000

__index 元方法
__newindex 元方法
__tostring 元方法

在 Lua table 中我们可以访问对应的 key 来得到 value 值，但是却无法对两个 table 进行操作。因此 Lua 提供了元表(Metatable)，允许我们改变 table 的行为，每个行为关联了对应的元方法。例如，使用元表我们可以定义 Lua 如何计算两个 table 的相加操作 a+b。当 Lua 试图对两个表进行相加时，先检查两者之一是否有元表，之后检查是否有一个叫__add的字段，若找到，则调用对应的值。__add 等即时字段，其对应的值（往往是一个函数或是 table）就是”元方法”。有两个很重要的函数来处理元表：

setmetatable(table,metatable): 对指定 table 设置元表(metatable)，如果元表(metatable)中存在__metatable键值，setmetatable 会失败。
getmetatable(table): 返回对象的元表(metatable)。

以下实例演示了如何对指定的表设置元表：

mytable = {}                          -- 普通表
mymetatable = {}                      -- 元表
setmetatable(mytable,mymetatable)     -- 把 mymetatable 设为 mytable 的元表

以上代码也可以直接写成一行：

mytable = setmetatable({},{})

以下为返回对象元表：

getmetatable(mytable)                 -- 这回返回mymetatable

`__index` 元方法

这是 metatable 最常用的键。当你通过键来访问 table 的时候，如果这个键没有值，那么 Lua 就会寻找该 table 的 metatable（假定有 metatable）中的__index 键。如果__index包含一个表格，Lua 会在表格中查找相应的键。我们可以在使用 lua 命令进入交互模式查看：

$ lua
Lua 5.3.0  Copyright (C) 1994-2015 Lua.org, PUC-Rio
> other = { foo = 3 }
> t = setmetatable({}, { __index = other })
> t.foo
3
> t.bar
nil

如果__index包含一个函数的话，Lua 就会调用那个函数，table 和键会作为参数传递给函数。 __index 元方法查看表中元素是否存在，如果不存在，返回结果为 nil；如果存在则由 __index 返回结果。

mytable = setmetatable({key1 = "value1"}, {
  __index = function(mytable, key)
    if key == "key2" then
      return "metatablevalue"
    else
      return nil
    end
  end
})

print(mytable.key1,mytable.key2)

实例输出结果为：

value1	metatablevalue

实例解析：

mytable 表赋值为 {key1 = “value1”}。
mytable 设置了元表，元方法为 __index。
在 mytable 表中查找 key1，如果找到，返回该元素，找不到则继续。
在 mytable 表中查找 key2，如果找到，返回该元素，找不到则继续。
判断元表有没有__index方法，如果__index方法是一个函数，则调用该函数。元方法中查看是否传入 “key2” 键的参数（mytable.key2 已设置），如果传入 “key2” 参数返回 “metatablevalue”，否则返回 mytable 对应的键值。

我们可以将以上代码简单写成：

mytable = setmetatable({key1 = "value1"}, { __index = { key2 = "metatablevalue" } })
print(mytable.key1,mytable.key2)

`__newindex` 元方法

__newindex 元方法用来对表更新，__index则用来对表访问。当你给表的一个缺少的索引赋值，解释器就会查找__newindex 元方法：如果存在则调用这个函数而不进行赋值操作。以下实例演示了 __newindex 元方法的应用：

mymetatable = {}
mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })

print(mytable.key1)

mytable.newkey = "新值2"
print(mytable.newkey,mymetatable.newkey)

mytable.key1 = "新值1"
print(mytable.key1,mymetatable.newkey1)

以上实例执行输出结果为：

value1
nil    新值2
新值1    nil

以上实例中表设置了元方法 __newindex，在对新索引键（newkey）赋值时（mytable.newkey = “新值 2”），会调用元方法，而不进行赋值。而如果对已存在的索引键（key1），则会进行赋值，而不调用元方法 __newindex。以下实例使用了 rawset 函数来更新表：

mytable = setmetatable({key1 = "value1"}, {
  __newindex = function(mytable, key, value)
       rawset(mytable, key, "\""..value.."\"")

  end
})

mytable.key1 = "new value"
mytable.key2 = 4

print(mytable.key1,mytable.key2)

以上实例执行输出结果为：

new value  "4"

为表添加操作符以下实例演示了两表相加操作：

-- 计算表中最大值，table.maxn在Lua5.2以上版本中已无法使用
-- 自定义计算表中最大值函数 table_maxn
function table_maxn(t)
    local mn = 0
    for k, v in pairs(t) do
        if mn < k then
            mn = k
        end
    end
    return mn
end

-- 两表相加操作
mytable = setmetatable({ 1, 2, 3 }, {
  __add = function(mytable, newtable)
    for i = 1, table_maxn(newtable) do
      table.insert(mytable, table_maxn(mytable)+1,newtable[i])
    end
    return mytable
  end
})

secondtable = {4,5,6}

mytable = mytable + secondtable
	for k,v in ipairs(mytable) do
print(k,v)
end

以上实例执行输出结果为：

__add 键包含在元表中，并进行相加操作。表中对应的操作列表如下：

模式	描述
`__add`	对应的运算符 `+`.
`__sub`	对应的运算符 `-`.
`__mul`	对应的运算符 `*`.
`__div`	对应的运算符 `/`.
`__mod`	对应的运算符 `%`.
`__unm`	对应的运算符 `-`.
`__concat`	对应的运算符 `..`.
`__eq`	对应的运算符 `==`.
`__lt`	对应的运算符 `<`.
`__le`	对应的运算符 `<=`.
`__call`	元方法

__call 元方法在 Lua 调用一个值时调用。以下实例演示了计算表中元素的和：

-- 计算表中最大值，table.maxn在Lua5.2以上版本中已无法使用
-- 自定义计算表中最大值函数 table_maxn
function table_maxn(t)
    local mn = 0
    for k, v in pairs(t) do
        if mn < k then
            mn = k
        end
    end
    return mn
end

-- 定义元方法__call
mytable = setmetatable({10}, {
  __call = function(mytable, newtable)
	sum = 0
	for i = 1, table_maxn(mytable) do
		sum = sum + mytable[i]
	end
    for i = 1, table_maxn(newtable) do
		sum = sum + newtable[i]
	end
	return sum
  end
})
newtable = {10,20,30}
print(mytable(newtable))

以上实例执行输出结果为：

`__tostring` 元方法

__tostring 元方法用于修改表的输出行为。以下实例我们自定义了表的输出内容：

mytable = setmetatable({ 10, 20, 30 }, {
  __tostring = function(mytable)
    sum = 0
    for k, v in pairs(mytable) do
        sum = sum + v
 end
    return "表所有元素的和为 " .. sum
  end
})
print(mytable)

以上实例执行输出结果为：

表所有元素的和为 60

从本文中我们可以知道元表可以很好的简化我们的代码功能，所以了解 Lua 的元表，可以让我们写出更加简单优秀的 Lua 代码。

Lua 模块和包

Sat, 10 May 2008 00:00:00 +0000

加载机制

模块类似于一个封装库，从 Lua 5.1 开始，Lua 加入了标准的模块管理机制，可以把一些公用的代码放在一个文件里，以 API 接口的形式在其他地方调用，有利于代码的重用和降低代码耦合度。 Lua 的模块是由变量、函数等已知元素组成的 table，因此创建一个模块很简单，就是创建一个 table，然后把需要导出的常量、函数放入其中，最后返回这个 table 就行。以下为创建自定义模块 module.lua，文件代码格式如下：

-- 文件名为 module.lua
-- 定义一个名为 module 的模块
module = {}

-- 定义一个常量
module.constant = "这是一个常量"

-- 定义一个函数
function module.func1()
    io.write("这是一个公有函数！\n")
end

local function func2()
    print("这是一个私有函数！")
end

function module.func3()
    func2()
end

return module

由上可知，模块的结构就是一个 table 的结构，因此可以像操作调用 table 里的元素那样来操作调用模块里的常量或函数。上面的 func2 声明为程序块的局部变量，即表示一个私有函数，因此是不能从外部访问模块里的这个私有函数，必须通过模块里的公有函数来调用. require 函数 Lua 提供了一个名为 require 的函数用来加载模块。要加载一个模块，只需要简单地调用就可以了。例如：

require("<模块名>")

或者

require "<模块名>"

执行 require 后会返回一个由模块常量或函数组成的 table，并且还会定义一个包含该 table 的全局变量。

-- test_module.php 文件
-- module 模块为上文提到到 module.lua
require("module")

print(module.constant)

module.func3()

以上代码执行结果为：

这是一个常量
这是一个私有函数！

或者给加载的模块定义一个别名变量，方便调用：

-- test_module2.php 文件
-- module 模块为上文提到到 module.lua
-- 别名变量 m
local m = require("module")

print(m.constant)

m.func3()

以上代码执行结果为：

这是一个常量
这是一个私有函数！

加载机制

对于自定义的模块，模块文件不是放在哪个文件目录都行，函数 require 有它自己的文件路径加载策略，它会尝试从 Lua 文件或 C 程序库中加载模块。 require 用于搜索 Lua 文件的路径是存放在全局变量 package.path 中，当 Lua 启动后，会以环境变量 LUA_PATH 的值来初始这个环境变量。如果没有找到该环境变量，则使用一个编译时定义的默认路径来初始化。当然，如果没有 LUA_PATH 这个环境变量，也可以自定义设置，在当前用户根目录下打开 .profile 文件（没有则创建，打开 .bashrc 文件也可以），例如把 “~/lua/” 路径加入 LUA_PATH 环境变量里：

#LUA_PATH
export LUA_PATH="~/lua/?.lua;;"

文件路径以 “;” 号分隔，最后的 2 个 “;;” 表示新加的路径后面加上原来的默认路径。接着，更新环境变量参数，使之立即生效。

source ~/.profile

这时假设 package.path 的值是：

/Users/dengjoe/lua/?.lua;./?.lua;/usr/local/share/lua/5.1/?.lua;/usr/local/share/lua/5.1/?/init.lua;/usr/local/lib/lua/5.1/?.lua;/usr/local/lib/lua/5.1/?/init.lua

那么调用 require(“module”) 时就会尝试打开以下文件目录去搜索目标。

/Users/dengjoe/lua/module.lua;
./module.lua
/usr/local/share/lua/5.1/module.lua
/usr/local/share/lua/5.1/module/init.lua
/usr/local/lib/lua/5.1/module.lua
/usr/local/lib/lua/5.1/module/init.lua

如果找过目标文件，则会调用 package.loadfile 来加载模块。否则，就会去找 C 程序库。搜索的文件路径是从全局变量 package.cpath 获取，而这个变量则是通过环境变量 LUA_CPATH 来初始。搜索的策略跟上面的一样，只不过现在换成搜索的是 so 或 dll 类型的文件。如果找得到，那么 require 就会通过 package.loadlib 来加载它。 C 包 Lua 和 C 是很容易结合的，使用 C 为 Lua 写包。与 Lua 中写包不同，C 包在使用以前必须首先加载并连接，在大多数系统中最容易的实现方式是通过动态连接库机制。 Lua 在一个叫 loadlib 的函数内提供了所有的动态连接的功能。这个函数有两个参数:库的绝对路径和初始化函数。所以典型的调用的例子如下:

local path = "/usr/local/lua/lib/libluasocket.so"
local f = loadlib(path, "luaopen_socket")

loadlib 函数加载指定的库并且连接到 Lua，然而它并不打开库（也就是说没有调用初始化函数），反之他返回初始化函数作为 Lua 的一个函数，这样我们就可以直接在 Lua 中调用他。如果加载动态库或者查找初始化函数时出错，loadlib 将返回 nil 和错误信息。我们可以修改前面一段代码，使其检测错误然后调用初始化函数：

local path = "/usr/local/lua/lib/libluasocket.so"
-- 或者 path = "C:\\windows\\luasocket.dll"，这是 Window 平台下
local f = assert(loadlib(path, "luaopen_socket"))
f()  -- 真正打开库

一般情况下我们期望二进制的发布库包含一个与前面代码段相似的 stub 文件，安装二进制库的时候可以随便放在某个目录，只需要修改 stub 文件对应二进制库的实际路径即可。将 stub 文件所在的目录加入到 LUA_PATH，这样设定后就可以使用 require 函数加载 C 库了。

Lua tables（表）

Mon, 28 Apr 2008 00:00:00 +0000

Lua 迭代器

Sun, 20 Apr 2008 00:00:00 +0000

泛型 for 迭代器
无状态的迭代器

迭代器（iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址在 Lua 中迭代器是一种支持指针类型的结构，它可以遍历集合的每一个元素。

泛型 for 迭代器

泛型 for 在自己内部保存迭代函数，实际上它保存三个值：迭代函数、状态常量、控制变量。泛型 for 迭代器提供了集合的 key/value 对，语法格式如下：

for k, v in pairs(t) do
    print(k, v)
end

上面代码中，k, v 为变量列表；pairs(t)为表达式列表。查看以下实例:

array = {"Lua", "Tutorial"}

for key,value in ipairs(array)
do
   print(key, value)
end

以上代码执行输出结果为：

1  Lua
2  Tutorial

以上实例中我们使用了 Lua 默认提供的迭代函数 ipairs。下面我们看看范性 for 的执行过程：

首先，初始化，计算 in 后面表达式的值，表达式应该返回范性 for 需要的三个值：迭代函数、状态常量、控制变量；与多值赋值一样，如果表达式返回的结果个数不足三个会自动用 nil 补足，多出部分会被忽略。
第二，将状态常量和控制变量作为参数调用迭代函数（注意：对于 for 结构来说，状态常量没有用处，仅仅在初始化时获取他的值并传递给迭代函数）。
第三，将迭代函数返回的值赋给变量列表。
第四，如果返回的第一个值为 nil 循环结束，否则执行循环体。
第五，回到第二步再次调用迭代函数

在 Lua 中我们常常使用函数来描述迭代器，每次调用该函数就返回集合的下一个元素。Lua 的迭代器包含以下两种类型：

无状态的迭代器
多状态的迭代器

无状态的迭代器

无状态的迭代器是指不保留任何状态的迭代器，因此在循环中我们可以利用无状态迭代器避免创建闭包花费额外的代价。每一次迭代，迭代函数都是用两个变量（状态常量和控制变量）的值作为参数被调用，一个无状态的迭代器只利用这两个值可以获取下一个元素。这种无状态迭代器的典型的简单的例子是 ipairs，他遍历数组的每一个元素。以下实例我们使用了一个简单的函数来实现迭代器，实现数字 n 的平方：

function square(iteratorMaxCount,currentNumber)
   if currentNumber<iteratorMaxCount
   then
      currentNumber = currentNumber+1
   return currentNumber, currentNumber*currentNumber
   end
end

for i,n in square,3,0
do
   print(i,n)
end

以上实例输出结果为：

1
4
9

迭代的状态包括被遍历的表（循环过程中不会改变的状态常量）和当前的索引下标（控制变量），ipairs 和迭代函数都很简单，我们在 Lua 中可以这样实现：

function iter (a, i)
    i = i + 1
    local v = a[i]
    if v then
       return i, v
    end
end

function ipairs (a)
    return iter, a, 0
end

当 Lua 调用 ipairs(a)开始循环时，他获取三个值：迭代函数 iter、状态常量 a、控制变量初始值 0；然后 Lua 调用 iter(a,0)返回 1,a[1]（除非 a[1]=nil）；第二次迭代调用 iter(a,1)返回 2,a[2]……直到第一个 nil 元素。多状态的迭代器很多情况下，迭代器需要保存多个状态信息而不是简单的状态常量和控制变量，最简单的方法是使用闭包，还有一种方法就是将所有的状态信息封装到 table 内，将 table 作为迭代器的状态常量，因为这种情况下可以将所有的信息存放在 table 内，所以迭代函数通常不需要第二个参数。以下实例我们创建了自己的迭代器：

array = {"Lua", "Tutorial"}

function elementIterator (collection)
   local index = 0
   local count = #collection
   -- 闭包函数
   return function ()
      index = index + 1
      if index <= count
      then
         --  返回迭代器的当前元素
         return collection[index]
      end
   end
end

for element in elementIterator(array)
do
   print(element)
end

以上实例输出结果为：

Lua
Tutorial

以上实例中我们可以看到，elementIterator 内使用了闭包函数，实现计算集合大小并输出各个元素。

Lua 数组

Mon, 14 Apr 2008 00:00:00 +0000

一维数组
多维数组

数组，就是相同数据类型的元素按一定顺序排列的集合，可以是一维数组和多维数组。 Lua 数组的索引键值可以使用整数表示，数组的大小不是固定的。

一维数组

一维数组是最简单的数组，其逻辑结构是线性表。一维数组可以用 for 循环出数组中的元素，如下实例：

array = {"Lua", "Tutorial"}

for i= 0, 2 do
   print(array[i])
end

以上代码执行输出结果为：

nil
Lua
Tutorial

正如你所看到的，我们可以使用整数索引来访问数组元素，如果知道的索引没有值则返回 nil。在 Lua 索引值是以 1 为起始，但你也可以指定 0 开始。除此外我们还可以以负数为数组索引值：

array = {}

for i= -2, 2 do
   array[i] = i *2
end

for i = -2,2 do
   print(array[i])
end

以上代码执行输出结果为：

多维数组

多维数组即数组中包含数组或一维数组的索引键对应一个数组。以下是一个三行三列的阵列多维数组：

-- 初始化数组
array = {}
for i=1,3 do
   array[i] = {}
      for j=1,3 do
         array[i][j] = i*j
      end
end

-- 访问数组
for i=1,3 do
   for j=1,3 do
      print(array[i][j])
   end
end

以上代码执行输出结果为：

不同索引键的三行三列阵列多维数组：

-- 初始化数组
array = {}
maxRows = 3
maxColumns = 3
for row=1,maxRows do
   for col=1,maxColumns do
      array[row*maxColumns +col] = row*col
   end
end

-- 访问数组
for row=1,maxRows do
   for col=1,maxColumns do
      print(array[row*maxColumns +col])
   end
end

以上代码执行输出结果为：

正如你所看到的，以上的实例中，数组设定了指定的索引值，这样可以避免出现 nil 值，有利于节省内存空间。

Lua 字符串

Tue, 08 Apr 2008 00:00:00 +0000

字符串操作
字符串操作
- string.upper

字符串或串(String)是由数字、字母、下划线组成的一串字符。 Lua 语言中字符串可以使用以下三种方式来表示：

单引号间的一串字符。
双引号间的一串字符。
[[和]]间的一串字符。

以上三种方式的字符串实例如下：

string1 = "Hello"
print("\"字符串 1 是\"", string1)
string2 = 'lua'
print("字符串 2 是", string2)


string3 = [["Lua 教程"]]
print("字符串 3 是", string3)

以上代码执行输出结果为：

"字符串 1 是"	Hello
字符串 2 是	lua
字符串 3 是	"Lua 教程"

转义字符用于表示不能直接显示的字符，比如后退键，回车键，等。如在字符串转换双引号可以使用 “"“。所有的转义字符和所对应的意义：

转义字符	意义	ASCII 码值（十进制）
\a	响铃(BEL)	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个 TAB 位置）	009
\v	垂直制表(VT)	011
\	代表一个反斜线字符’’'	092
'	代表一个单引号（撇号）字符	039
"	代表一个双引号字符	034
空字符(NULL)	000
\ddd	1 到 3 位八进制数所代表的任意字符	三位八进制
\xhh	1 到 2 位十六进制所代表的任意字符	二位十六进制

字符串操作

Lua 提供了很多的方法来支持字符串的操作：字符串大小写转换以下实例演示了如何对字符串大小写进行转换：

string1 = "Lua";
print(string.upper(string1))
print(string.lower(string1))

以上代码执行结果为：

LUA
lua

字符串查找与反转以下实例演示了如何对字符串进行查找与反转操作：

string = "Lua Tutorial"
-- 查找字符串
print(string.find(string,"Tutorial"))
reversedString = string.reverse(string)
print("新字符串为",reversedString)

以上代码执行结果为：

5    12
新字符串为   lairotuT auL

字符串格式化以下实例演示了如何对字符串进行格式化操作：

string1 = "Lua"
string2 = "Tutorial"
number1 = 10
number2 = 20
-- 基本字符串格式化
print(string.format("基本格式化 %s %s",string1,string2))
-- 日期格式化
date = 2; month = 1; year = 2014
print(string.format("日期格式化 %02d/%02d/%03d", date, month, year))
-- 十进制格式化
print(string.format("%.4f",1/3))

以上代码执行结果为：

基本格式化 Lua Tutorial
日期格式化 02/01/2014
0.3333

字符与整数相互转换以下实例演示了字符与整数相互转换：

-- 字符转换
-- 转换第一个字符
print(string.byte("Lua"))
-- 转换第三个字符
print(string.byte("Lua",3))
-- 转换末尾第一个字符
print(string.byte("Lua",-1))
-- 第二个字符
print(string.byte("Lua",2))
-- 转换末尾第二个字符
print(string.byte("Lua",-2))


-- 整数 ASCII 码转换为字符
print(string.char(97))

以上代码执行结果为：

其他常用函数以下实例演示了其他字符串操作，如计算字符串长度，字符串连接，字符串复制等：

string1 = "wsdjeg."
string2 = "spacevim"
string3 = ".org"
-- 使用 .. 进行字符串连接
print("连接字符串",string1..string2..string3)


-- 字符串长度
print("字符串长度 ",string.len(string2))


-- 字符串复制 2 次
repeatedString = string.rep(string2,2)
print(repeatedString)

以上代码执行结果为：

连接字符串	wsdjeg.spacevim.org
字符串长度 	8
spacevimspacevim

字符串操作

Lua 提供了很多的方法来支持字符串的操作：

string.upper

字符串全部转为大写字母。

string.upper(argument)

示例：

str1 = "wsdjeg"
print(string.upper(str1))

输出：

WSDJEG

Lua 运算符

Fri, 28 Mar 2008 00:00:00 +0000

算术运算符
关系运算符

运算符是一个特殊的符号，用于告诉解释器执行特定的数学或逻辑运算。Lua 提供了以下几种运算符类型：

算术运算符
关系运算符
逻辑运算符
其他运算符

算术运算符

下表列出了 Lua 语言中的常用算术运算符，设定 A 的值为 10，B 的值为 20：

操作符	描述	实例
`+`	加法	`A + B` 输出结果 30
`-`	减法	`A - B` 输出结果 -10
`*`	乘法	`A * B` 输出结果 200
`/`	除法	`B / A` 输出结果 2
`%`	取余	`B % A` 输出结果 0
`^`	乘幂	`A ^ 2` 输出结果 100
`-`	负号	`-A` 输出结果 -10

实例我们可以通过以下实例来更加透彻的理解算术运算符的应用：

a = 21
b = 10
c = a + b
print("Line 1 - c 的值为 ", c )
c = a - b
print("Line 2 - c 的值为 ", c )
c = a * b
print("Line 3 - c 的值为 ", c )
c = a / b
print("Line 4 - c 的值为 ", c )
c = a % b
print("Line 5 - c 的值为 ", c )
c = a^2
print("Line 6 - c 的值为 ", c )
c = -a
print("Line 7 - c 的值为 ", c )

以上程序执行结果为：

Line 1 - c 的值为 31
Line 2 - c 的值为 11
Line 3 - c 的值为 210
Line 4 - c 的值为 2.1
Line 5 - c 的值为 1
Line 6 - c 的值为 441
Line 7 - c 的值为 -21

关系运算符

下表列出了 Lua 语言中的常用关系运算符，设定 A 的值为 10，B 的值为 20：

操作符	描述	实例
==	等于，检测两个值是否相等，相等返回 true，否则返回 false	(A == B) 为 false。
~=	不等于，检测两个值是否相等，相等返回 false，否则返回 true	(A ~= B) 为 true。
>	大于，如果左边的值大于右边的值，返回 true，否则返回 false	(A > B) 为 false。
<	小于，如果左边的值大于右边的值，返回 false，否则返回 true	(A < B) 为 true。
>=	大于等于，如果左边的值大于等于右边的值，返回 true，否则返回 false	(A >= B) is not true.
<=	小于等于，如果左边的值小于等于右边的值，返回 true，否则返回 false	(A <= B) is true.

实例我们可以通过以下实例来更加透彻的理解关系运算符的应用：

a = 21
b = 10

if( a == b )
then
   print("Line 1 - a 等于 b" )
else
   print("Line 1 - a 不等于 b" )
end

if( a ~= b )
then
   print("Line 2 - a 不等于 b" )
else
   print("Line 2 - a 等于 b" )
end

if ( a < b )
then
   print("Line 3 - a 小于 b" )
else
   print("Line 3 - a 大于等于 b" )
end

if ( a > b )
then
   print("Line 4 - a 大于 b" )
else
   print("Line 5 - a 小于等于 b" )
end

-- 修改 a 和 b 的值
a = 5
b = 20
if ( a <= b )
then
   print("Line 5 - a 小于等于  b" )
end

if ( b >= a )
then
   print("Line 6 - b 大于等于 a" )
end

以上程序执行结果为：

Line 1 - a 不等于 b
Line 2 - a 不等于 b
Line 3 - a 大于等于 b
Line 4 - a 大于 b
Line 5 - a 小于等于 b
Line 6 - b 大于等于 a

Lua 函数

Thu, 20 Mar 2008 00:00:00 +0000

多返回值
可变参数

在 Lua 中，函数是对语句和表达式进行抽象的主要方法。既可以用来处理一些特殊的工作，也可以用来计算一些值。 Lua 提供了许多的内建函数，你可以很方便的在程序中调用它们，如 print()函数可以将传入的参数打印在控制台上。 Lua 函数主要有两种用途：

完成指定的任务，这种情况下函数作为调用语句使用；
计算并返回值，这种情况下函数作为赋值语句的表达式使用。

函数定义 Lua 编程语言函数定义格式如下：

optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
   function_body
 return result_params_comma_separated
end

解析：

optional_function_scope: 该参数是可选的制定函数是全局函数还是局部函数，未设置该参数末尾为全局函数，如果你需要设置函数为局部函数需要使用关键字 local。
function_name: 指定函数名称。
argument1, argument2, argument3..., argumentn : 函数参数，多个参数以逗号隔开，函数也可以不带参数。
function_body: 函数体，函数中需要执行的代码语句块。
result_params_comma_separated: 函数返回值，Lua 语言函数可以返回多个值，每个值以逗号隔开。

实例以下实例定义了函数 max()，参数为 num1, num2，用于比较两值的大小，并返回最大值：

--[[ 函数返回两个值的最大值 --]]
function max(num1, num2)

   if (num1 > num2) then
      result = num1;
   else
      result = num2;
   end

   return result;
end
-- 调用函数
print("两值比较最大值为 ",max(10,4))
print("两值比较最大值为 ",max(5,6))

以上代码执行结果为： Lua 中我们可以将函数作为参数传递给函数，如下实例：

myprint = function(param)
   print("这是打印函数 -   ##",param,"##")
end

function add(num1,num2,functionPrint)
   result = num1 + num2
   -- 调用传递的函数参数
   functionPrint(result)
end
myprint(10)
-- myprint 函数作为参数传递
add(2,5,myprint)

以上代码执行结果为：

多返回值

Lua 函数可以返回多个结果值，比如 string.find，其返回匹配串”开始和结束的下标”（如果不存在匹配串返回 nil）。

> s, e = string.find("www.w3cschool.cn", "w3cschool")
> print(s, e)
5	13

Lua 函数中，在 return 后列出要返回的值得列表即可返回多值，如：

function maximum (a)
    local mi = 1             -- 最大值索引
    local m = a[mi]          -- 最大值
    for i,val in ipairs(a) do
       if val > m then
           mi = i
           m = val
       end
    end
    return m, mi
end

print(maximum({8,10,23,12,5}))

以上代码执行结果为：

可变参数

Lua 函数可以接受可变数目的参数，和 C 语言类似在函数参数列表中使用三点（…) 表示函数有可变的参数。 Lua 将函数的参数放在一个叫 arg 的表中，#arg 表示传入参数的个数。例如，我们计算几个数的平均值：

function average(...)
   result = 0
   local arg={...}
   for i,v in ipairs(arg) do
      result = result + v
   end
   print("总共传入 " .. #arg .. " 个数")
   return result/#arg
end

print("平均值为",average(10,5,3,4,5,6))

以上代码执行结果为：

Lua 流程控制

Thu, 13 Mar 2008 00:00:00 +0000

if 语句
if else 语句
else if 语句
if else 嵌套

Lua 编程语言流程控制语句通过程序设定一个或多个条件语句来设定。在条件为 true 时执行指定程序代码，在条件为 false 时执行其他指定代码。控制结构的条件表达式结果可以是任何值，Lua 认为 false 和 nil 为假，true 和非 nil 为真。要注意的是 Lua 中 0 为 true：

--[ 0 为true ]
if(0)
then
    print("0 为真")
end

以上代码输出结果为：

0 为真

Lua 提供了以下控制结构语句：

语句	描述
if 语句	if 语句由一个布尔表达式作为条件判断，其后紧跟其他语句组成。
if…else 语句	if 语句可以与 else 语句搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码。
if 嵌套语句	你可以在 if 或 else if 中使用一个或多个 if 或 else if 语句。

if 语句

Lua if 语句由一个布尔表达式作为条件判断，其后紧跟其他语句组成。 Lua if 语句语法格式如下：

if(布尔表达式)
then
   --[ 在布尔表达式为 true 时执行的语句 --]
end

在布尔表达式为 true 时会 if 中的代码块会被执行，在布尔表达式为 false 时，紧跟在 if 语句 end 之后的代码会被执行。 Lua 认为 false 和 nil 为假，true 和非 nil 为真。要注意的是 Lua 中 0 为 true。实例以下实例用于判断变量 a 的值是否小于 20：

--[ 定义变量 --]
a = 10

--[ 使用 if 语句 --]
if( a < 20 )
then
   --[ if 条件为 true 时打印以下信息 --]
   print("a 小于 20" )
end
print("a 的值为:", a)

以上代码执行结果如下：

if else 语句

Lua if 语句可以与 else 语句搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码块。 Lua if…else 语句语法格式如下：

if(布尔表达式)
then
   --[ 布尔表达式为 true 时执行该语句块 --]
else
   --[ 布尔表达式为 false 时执行该语句块 --]
end

在布尔表达式为 true 时会 if 中的代码块会被执行，在布尔表达式为 false 时，else 的代码块会被执行。 Lua 认为 false 和 nil 为假，true 和非 nil 为真。要注意的是 Lua 中 0 为 true。实例以下实例用于判断变量 a 的值：

--[ 定义变量 --]
a = 100;
--[ 检查条件 --]
if( a < 20 )
then
   --[ if 条件为 true 时执行该语句块 --]
   print("a 小于 20" )
else
   --[ if 条件为 false 时执行该语句块 --]
   print("a 大于 20" )
end
print("a 的值为 :", a)

以上代码执行结果如下：

else if 语句

Lua if 语句可以与 else if…else 语句搭配使用, 在 if 条件表达式为 false 时执行 else if…else 语句代码块，用于检测多个条件语句。 Lua if…else if…else 语句语法格式如下：

if( 布尔表达式 1)
then
   --[ 在布尔表达式 1 为 true 时执行该语句块 --]

else if( 布尔表达式 2)
   --[ 在布尔表达式 2 为 true 时执行该语句块 --]

else if( 布尔表达式 3)
   --[ 在布尔表达式 3 为 true 时执行该语句块 --]
else
   --[ 如果以上布尔表达式都不为 true 则执行该语句块 --]
end

示例代码，以下示例代码对变量 a 值进行判断：

--[ 定义变量 --]
a = 100

--[ 检查布尔条件 --]
if( a == 10 )
then
   --[ 如果条件为 true 打印以下信息 --]
   print("a 的值为 10" )
elseif( a == 20 )
then
   --[ if else if 条件为 true 时打印以下信息 --]
   print("a 的值为 20" )
elseif( a == 30 )
then
   --[ if else if condition 条件为 true 时打印以下信息 --]
   print("a 的值为 30" )
else
   --[ 以上条件语句没有一个为 true 时打印以下信息 --]
   print("没有匹配 a 的值" )
end
print("a 的真实值为: ", a )

运行结果如下：

if else 嵌套

Lua if 语句允许嵌套, 这就意味着你可以在一个 if 或 else if 语句中插入其他的 if 或 else if 语句。 Lua if 嵌套语句语法格式如下：

if( 布尔表达式 1)
then
   --[ 布尔表达式 1 为 true 时执行该语句块 --]
   if(布尔表达式 2)
   then
      --[ 布尔表达式 2 为 true 时执行该语句块 --]
   end
end

你可以用同样的方式嵌套 else if…else 语句。实例以下实例用于判断变量 a 和 b 的值：

--[ 定义变量 --]
a = 100;
b = 200;

--[ 检查条件 --]
if( a == 100 )
then
   --[ if 条件为 true 时执行以下 if 条件判断 --]
   if( b == 200 )
   then
      --[ if 条件为 true 时执行该语句块 --]
      print("a 的值为 100 b 的值为 200" );
   end
end
print("a 的值为 :", a );
print("b 的值为 :", b );

以上代码执行结果如下：

Lua 循环

Sun, 09 Mar 2008 00:00:00 +0000

while 循环
for 循环
- 数值 for 循环
  - 泛型 for 循环
repeat until 循环
嵌套循环
循环控制语句

很多情况下我们需要做一些有规律性的重复操作，因此在程序中就需要重复执行某些语句。一组被重复执行的语句称之为循环体，能否继续重复，决定循环的终止条件。循环结构是在一定条件下反复执行某段程序的流程结构，被反复执行的程序被称为循环体。循环语句是由循环体及循环的终止条件两部分组成的。 Lua 语言提供了以下几种循环处理方式：

循环类型	描述
while 循环	在条件为 true 时，让程序重复地执行某些语句。执行语句前会先检查条件是否为 true。
for 循环	重复执行指定语句，重复次数可在 for 语句中控制。
Lua repeat…until	重复执行循环，直到指定的条件为真时为止
循环嵌套	可以在循环内嵌套一个或多个循环语句（while、for、do..while）

while 循环

while(condition)
do
   statements
end

statements(循环体语句) 可以是一条或多条语句，condition(条件) 可以是任意表达式，在 condition(条件) 为 true 时执行循环体语句。示例：

a = 15
while ( a < 20 )
do
   print("a 的值为:", a)
   a = a + 1
end

for 循环

Lua 编程语言中 for 循环语句可以重复执行指定语句，重复次数可在 for 语句中控制。 Lua 编程语言中 for 语句有两大类：：

数值 for 循环
泛型 for 循环

数值 for 循环

基本语法：

for var=exp1,exp2,exp3 do
    <执行体>
end

var 从 exp1 变化到 exp2，每次变化以 exp3 为步长递增 var，并执行一次”执行体”。exp3 是可选的，如果不指定，默认为 1。实例：

for i=1,f(x) do
    print(i)
end

for i=10,1,-1 do
    print(i)
end

for 的三个表达式在循环开始前一次性求值，以后不再进行求值。比如上面的 f(x)只会在循环开始前执行一次，其结果用在后面的循环中。验证如下:

function f(x)
    print("方法被执行")
    return x*2
end
for i=1,f(5) do print(i)
end

泛型 for 循环

泛型 for 循环通过一个迭代器函数来遍历所有值，类似 java 中的 foreach 语句。 Lua 编程语言中泛型 for 循环语法格式:

--打印数组a的所有值
for i,v in ipairs(a)
    do print(v)
end

示例：

days = {"Suanday","Monday","Tuesday"}
for i,v in ipairs(days) do  print(v) end

repeat until 循环

Lua 编程语言中 repeat…until 循环语句不同于 for 和 while 循环，for 和 while 循环的条件语句在当前循环执行开始时判断，而 repeat…until 循环的条件语句在当前循环结束后判断。基本语法格式：

repeat
   statements
until( condition )

我们注意到循环条件判断语句（condition）在循环体末尾部分，所以在条件进行判断前循环体都会执行一次。如果条件判断语句（condition）为 false，循环会重新开始执行，直到条件判断语句（condition）为 true 才会停止执行。示例代码：

--[ 变量定义 --]
a = 10
--[ 执行循环 --]
repeat
   print("a的值为:", a)
   a = a + 1
until( a > 13 )

允许结果如下：

嵌套循环

Lua 编程语言中允许循环中嵌入循环。以下实例演示了 Lua 循环嵌套的应用。语法 Lua 编程语言中 for 循环嵌套语法格式:

for init,max/min value, increment
do
   for init,max/min value, increment
   do
      statements
   end
   statements
end

Lua 编程语言中 while 循环嵌套语法格式:

while(condition)
do
   while(condition)
   do
      statements
   end
   statements
end

Lua 编程语言中 repeat…until 循环嵌套语法格式:

repeat
   statements
   repeat
      statements
   until( condition )
until( condition )

除了以上同类型循环嵌套外，我们还可以使用不同的循环类型来嵌套，如 for 循环体中嵌套 while 循环。实例以下实例使用了 for 循环嵌套:

j =2
for i=2,10 do
   for j=2,(i/j) , 2 do
      if(not(i%j))
      then
         break
      end
      if(j > (i/j))then
         print("i 的值为：",i)
      end
   end
end

运行结果如下：

循环控制语句

lua 支持 break 语句，退出当前循环或语句，并开始脚本执行紧接着的语句:

--[ 定义变量 --]
a = 10

--[ while 循环 --]
while ( a < 20 )
do
   print("a 的值为:", a)
   a = a + 1
   if ( a > 13)
   then
      --[ 使用 break 语句终止循环 --]
      break
   end
end

Lua 数据类型

Wed, 13 Feb 2008 00:00:00 +0000

nil（空）
boolean（布尔）
number（数字）
string（字符串）
table（表）
function（函数）
thread（线程）
userdata（自定义类型）

Lua 是动态类型语言，变量不要类型定义,只需要为变量赋值。值可以存储在变量中，作为参数传递或结果返回。 Lua 中有 8 个基本类型分别为：nil、boolean、number、string、userdata、function、thread 和 table。

数据类型	描述
nil	这个最简单，只有值 nil 属于该类，表示一个无效值（在条件表达式中相当于 false）。
boolean	包含两个值：false 和 true。
number	表示双精度类型的实浮点数
string	字符串由一对双引号或单引号来表示
function	由 C 或 Lua 编写的函数
userdata	表示任意存储在变量中的 C 数据结构
thread	表示执行的独立线路，用于执行协同程序
table	Lua 中的表（table）其实是一个”关联数组”（associative arrays），数组的索引可以是数字或者是字符串。在 Lua 里，table 的创建是通过”构造表达式”来完成，最简单构造表达式是{}，用来创建一个空表。

我们可以使用 type 函数测试给定变量或者值的类型

print(type("Hello world"))      --> string
print(type(10.4*3))             --> number
print(type(print))              --> function
print(type(type))               --> function
print(type(true))               --> boolean
print(type(nil))                --> nil
print(type(type(X)))            --> string

nil（空）

nil 类型表示一种没有任何有效值，它只有一个值 – nil，例如打印一个没有赋值的变量，便会输出一个 nil 值：

> print(type(a))
nil
>

对于全局变量和 table，nil 还有一个”删除”作用，给全局变量或者 table 表里的变量赋一个 nil 值，等同于把它们删掉，执行下面代码就知：

tab1 = { key1 = "val1", key2 = "val2", "val3" }
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end

tab1.key1 = nil
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end

boolean（布尔）

boolean 类型只有两个可选值：true（真）和 false（假），Lua 把 false 和 nil 看作是”假”，其他的都为”真”:

print(type(true))
print(type(false))
print(type(nil))

if type(false) or type(nil) then
    print("false and nil are false!")
else
    print("other is true!")
end

number（数字）

Lua 默认只有一种 number 类型 – double（双精度）类型（默认类型可以修改 luaconf.h 里的定义），以下几种写法都被看作是 number 类型：

print(type(2))
print(type(2.2))
print(type(0.2))
print(type(2e+1))
print(type(0.2e-1))
print(type(7.8263692594256e-06))

string（字符串）

字符串由一对双引号或单引号来表示。

string1 = "this is string1"
string2 = 'this is string2'

也可以用 2 个方括号 “[[]]” 来表示”一块”字符串。

html = [[
<html>
<head></head>
<body>
    <a href="//www.w3cschool.cn/">w3cschoolW3Cschool教程</a>
</body>
</html>
]]
print(html)

在对一个数字字符串上进行算术操作时，Lua 会尝试将这个数字字符串转成一个数字:

> print("2" + 6)
8.0
> print("2" + "6")
8.0
> print("2 + 6")
2 + 6
> print("-2e2" * "6")
-1200.0
> print("error" + 1)
stdin:1: attempt to perform arithmetic on a string value
stack traceback:
 stdin:1: in main chunk
    [C]: in ?
>

以上代码中”error” + 1 执行报错了，字符串连接使用的是 .. ，如：

> print("a" .. 'b')
ab
> print(157 .. 428)
157428
>

使用 # 来计算字符串的长度，放在字符串前面，如下实例：

> len = "www.w3cschool.cn"
> print(#len)
16
> print(#"www.w3cschool.cn")
16
>

table（表）

在 Lua 里，table 的创建是通过”构造表达式”来完成，最简单构造表达式是{}，用来创建一个空表。也可以在表里添加一些数据，直接初始化表:

-- 创建一个空的 table
local tbl1 = {}

-- 直接初始表
local tbl2 = {"apple", "pear", "orange", "grape"}

Lua 中的表（table）其实是一个”关联数组”（associative arrays），数组的索引可以是数字或者是字符串。

-- table_test.lua 脚本文件
a = {}
a["key"] = "value"
key = 10
a[key] = 22
a[key] = a[key] + 11
for k, v in pairs(a) do
    print(k .. " : " .. v)
end

脚本执行结果为：不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始。

-- table_test2.lua 脚本文件
local tbl = {"apple", "pear", "orange", "grape"}
for key, val in pairs(tbl) do
    print("Key", key)
end

脚本执行结果为： table 不会固定长度大小，有新数据添加时 table 长度会自动增长，没初始的 table 都是 nil。

-- table_test3.lua 脚本文件
a3 = {}
for i = 1, 10 do
    a3[i] = i
end
a3["key"] = "val"
print(a3["key"])
print(a3["none"])

脚本执行结果为：

function（函数）

在 Lua 中，函数是被看作是”第一类值（First-Class Value）”，函数可以存在变量里:

-- function_test.lua 脚本文件
function factorial1(n)
    if n == 0 then
        return 1
    else
        return n * factorial1(n - 1)
    end
end
print(factorial1(5))
factorial2 = factorial1
print(factorial2(5))

脚本执行结果为： function 可以以匿名函数（anonymous function）的方式通过参数传递:

-- function_test2.lua 脚本文件
function anonymous(tab, fun)
    for k, v in pairs(tab) do
        print(fun(k, v))
    end
end
tab = { key1 = "val1", key2 = "val2" }
anonymous(tab, function(key, val)
    return key .. " = " .. val
end)

脚本执行结果为：

thread（线程）

在 Lua 里，最主要的线程是协同程序（coroutine）。它跟线程（thread）差不多，拥有自己独立的栈、局部变量和指令指针，可以跟其他协同程序共享全局变量和其他大部分东西。线程跟协程的区别：线程可以同时多个运行，而协程任意时刻只能运行一个，并且处于运行状态的协程只有被挂起（suspend）时才会暂停。

userdata（自定义类型）

userdata 是一种用户自定义数据，用于表示一种由应用程序或 C/C++ 语言库所创建的类型，可以将任意 C/C++ 的任意数据类型的数据（通常是 struct 和指针）存储到 Lua 变量中调用。

Lua 基本语法

Sat, 09 Feb 2008 00:00:00 +0000

注释
标识符
关键词
全局变量

Lua 提供了交互式编程模式和脚本式编程模式，交互式编程模式可以在命令行中直接输入代码并查看结果。 Lua 的交互式编程可通过 lua -i 或者 lua 命令开启。

F:\languages>lua
Lua 5.1.5  Copyright (C) 1994-2012 Lua.org, PUC-Rio
>

在命令行中，输入以下命令:

> print("hello world!")

按下回车后可以看到执行结果如下：

> print("hello world!")
hello world!
>

脚本式编程，指的是，将代码写入文件后并执行，比如新建 hello.lua 文件，并写入以下内容：

print("hello world!")

使用 lua 执行以上脚本，输出结果为：

F:\languages\lua>lua hello.lua
hello world!

我们也可以在 lua 文件顶部添加执行命令，比如，添加

#!/usr/local/bin/lua
print("hello world!")

然后通过 ./hello.lua 的方式来执行。

注释

Lua 的注释分单行注释和多行注释，单行注释以两个减号开头

-- 这是一个单行注释
print("hello world!")

多行注释在段落前后分别有 --[[ 和 --]]。

--[[
这是一个多行注释
这是一个多行注释
--]]
print("hello world!")

标识符

Lua 标识符用于定义一个变量、函数的名称。标示符以一个字母 A 到 Z 或 a 到 z 或下划线 _ 开头后加上 0 个或多个字母，下划线，数字（0 到 9）。最好不要使用下划线加大写字母的标示符，因为 Lua 的保留字也是这样的。 Lua 不允许使用特殊字符如 @, $, 和 % 来定义标示符。 Lua 是一个区分大小写的编程语言。因此在 Lua 中 W3c 与 w3c 是两个不同的标示符。以下列出了一些正确的标示符：

mohd         zara      abc     move_name    a_123
myname50     _temp     j       a23b9        retVal

关键词

Lua 本身一些保留的关键字是不可以使用的，比如循环用到的 for while 等。以下列出了 Lua 的保留关键字。保留关键字不能作为常量或变量或其他用户自定义标示符：

| and      | break | do    | else   |
| elseif   | end   | false | for    |
| function | if    | in    | local  |
| nil      | not   | or    | repeat |
| return   | then  | true  | until  |
| while    |

全局变量

Lua 的默认情况下变量总是全局变量，全局变量也不需要声明，直接赋值即可，访问一个未赋值即不存在的全局变量，也不会报错，只不过得到的是：nil

> print(b)
nil
> b=10
> print(b)
10
>

如果你想删除一个全局变量，只需要将变量赋值为 nil。

> b = nil
> print(b)
nil

这样变量 b 就好像从没被使用过一样。换句话说, 当且仅当一个变量不等于 nil 时，这个变量即存在。

学习 Lua 脚本语言

Sun, 03 Feb 2008 00:00:00 +0000

起因

大学期间，和朋友一起玩过一段时间《魔兽世界》，这款游戏的插件都是使用 lua 来写的。当时折腾插件时经常莫名其妙报错。于是，就想着要不自己也学习下 lua，然后也可以自己写一些插件。

开始学习

最初的时候，其实并没有太多的在线教程，只能硬着头皮看官方的手册。好在 lua 算是比较简单的语言。电脑上是 Ubuntu 7.04 LTS 版本，装上 lua 和 Vim 这两个工具后，就开始学着写一些简单的脚本了。

大学选修课《Java 编程》

Wed, 11 Oct 2006 00:00:00 +0000

大学的专业是生物科学，本以为选修课会选一个实验相关的课程。科室不知道为什么鬼使神差的选了一个 Java 的。这个似乎和生物没有一丁点关系。感觉可能是因为以前接触过 C 语言，多多少少对编程还有一点了解，以前的兴趣死灰复燃。 C 语言更多的是面向过程编程，经常是把一个过程分离成多个函数来写。但是 Java 完全不一样，面向对象编程这个思想，也是第一次听说。在 Java 里，一切都是对象，做任何事情之前，得先有对象，然后通过对象来执行某件事。第一节课上的似乎非常无趣，第一个程序是死记硬背下来的。

class People {
    public static void main(String args[]){
        System.out.println("hello world!");
    }
}

进入苏州大学的第一天

Mon, 21 Aug 2006 00:00:00 +0000

都说上有天堂，下有苏杭。第一次来到苏州，市区的环境真的没有想像中的那么好。 21 号报到，提前 1 天来到了苏州，正好姑姑在苏州这边工作，去玩了一天。恰逢啤酒节，白马涧公园晚上也很热闹。第二天早晨，免费进园玩了一会。早晨的空气非常好，小溪里的桃花水母晶莹剔透。办好报到，收拾好宿舍，父亲就回去了。临走是分明看到父亲的眼睛是红的，也许是因为第一次长时间出远门，自己心里也非常堵，似乎一点没有入学的开心氛围。

高中毕业了

Fri, 30 Jun 2006 00:00:00 +0000

转眼间，高中毕业了。这三年来对我来说起伏还是很大的。刚进高中的时候，成绩还是中等偏上，上课也非常认真。可惜高一的化学、历史太枯燥无味，完全是死记硬背东西，一点兴趣也没有。那时地理跟政治两门课学的挺轻松。以至于后来上课打瞌睡，政治老师都不叫我了。也不记得是什么时候开始迷上玩游戏的，03年那会，检查还不严，随随便便都可以去上网，后来04年就严了，未成年基本上肯定不让上网了。那时候玩的最多的是大话西游跟梦幻西游，这两游戏账号到现在还在呢。什么样的通宵经历都有了，中午去上网的也有，下午下课后直接去的也有，晚自习下课去的也有。连续通宵一周的也有了。甚至有一次通宵完了回来第二天是考试的也有。高一高二两年，真的把各种玩游戏的方式都体验了个遍。高二期末考试结束，班上阿连问我考多少，结果我是倒数第二，他倒数第一，还被他笑了一通。也就是那一次让我彻底破防了，怎么说也是初中班里第二名靠近来的，这回去没法交差啦。于是，在学校后面租了一个房间，彻底戒掉网游，高考前再也不去上网了。暑假前后两个月，埋头苦学，恶补。60天结束第一次月考，考了班上第一名，班主任差点觉得我是作弊的😂，往后基本上就是前三来来去去就再也没什么大的变动了。高考结束了哪天，晚上我又去上网啦，上了一夜回来被老爸骂了一通，不过想来，似乎也完全没瘾了。

不要轻言放弃

Thu, 01 Sep 2005 00:00:00 +0000

高中2年时间过去了，这两年时间玩了太多时间，学习完全是荒废了，期末考试成绩非常差，差到自己已经完全不相信了。甚至有一种想自暴自弃的感觉。但是，看到家人期许的眼神，看到父亲忙碌的背影，觉得自己错的太离谱了。是的，这个暑假，学校有补习课，一个人住在学校后面的小屋子里，早起晚睡，没日没夜的看书，写模拟试卷，总算感觉稍微充实一点了。

分班选生物还是化学

Wed, 01 Sep 2004 00:00:00 +0000

高一这一年过的很快，这一年没有用心学习，玩的太多了，到了高二分班的时候了。记得初中升高中的时候，化学考的比物理都高，以为以后会一直喜欢化学这门课的。可是完全没有想到的是，目前政治这门课成绩最好，然后是地理课，再然后是物理。总结下来，高一的历史和化学死背的东西太多，逻辑性的东西太少，所以不喜欢，成绩自然也就落下了。难不成要学文科？！！不行，坚决不学文科，选一个物理吧，这个目前还算跟得上。再选一个新的课程，生物。

Vim 环视和固化分组

Sun, 01 Aug 2004 00:00:00 +0000

vim	Perl	意义
`\@=`	`(?=`	顺序环视
`\@!`	`(?!`	顺序否定环视
`\@<=`	`(?<=`	逆序环视
`\@<!`	`(?<!`	逆序否定环视
`\@>`	`(?>`	固化分组
`\%(atom\)`	`(?:`	非捕获型括号

和 perl 稍有不同的是，vim 中的环视和固化分组的模式的位置与 perl 不同。例如，查找紧跟在 foo 之后的 bar，perl 将模式写在环视的括号内，而 vim 将模式写在环视的元字符之前。 Perl 的写法

/(?<=foo)bar/

vim 的写法

/\(foo\)\@<=bar

Vim 使用示例

顺序环视查找后面是 sql 的 my： /my$sql$\@=
顺序否定环视查找后面不是 sql 的 my：/my$sql$\@!
逆序环视查找前面是 my 的 sql： /$my$\@<=sql
逆序否定环视查找前面不是 my 的 sql： /$my$\@<!sql
固化分组
非捕获型括号意思是，此分组不捕获，可以理解为不算在分组信息中

:%s/\%(my\)sql\(ok\)/\1

上面的命令会将 mysqlok 替换为 ok ，由于 my 为捕获在分组中，故组中 \1 为 ok。

最后一封信

Wed, 30 Jun 2004 00:00:00 +0000

今天收到一份来自刘雅月信，非常的意外。记得高一刚开始的时候，一次在操场上，看到一个女孩子摔倒了，鬼使神差地跑过去递了纸巾。想到马上要分班了，也挺失落的。

Lisp 编程语言相关知识

Tue, 01 Jul 2003 00:00:00 +0000

利用暑假的时间，简单学习了解了下 Lisp 这一编程语言，也可以说这一类编程语言。

初识 Lisp

Lisp 是一种历史悠久的、函数式编程语言举个简单的例子：

(+ 1 7 9 11)

安装 Scheme

从 Scheme 官网下载安装包： https://groups.csail.mit.edu/mac/ftpdir/scheme-7.5/#Download 下周安装完成后，可以使用 mit-scheme 命令调用。

运行 scm 文件

在 MIT-Scheme 中输入 code 非常麻烦，光标不能回退和上下移动，所以比较简单的方法就是运行已经写完的文件：

mit-scheme -load yourfile.scm

过往的记忆

Mon, 30 Jun 2003 00:00:00 +0000

社交软件
小学毕业照
初中毕业照

这篇文字算是一些零碎旧时光记忆的合集吧，没有主题，纯粹是想到什么写什么，零碎记忆拼凑而成，算是给旧时光画一个句号。

社交软件

微信应该是14年左右火起来的，我还是到了第二段职业生涯才开始使用微信，大约是16-18年样子。早期都是使用 QQ，还记得传美版QQ么，很喜欢那个蓝色星月版本，以及通知的提示音。记得以前看到一个 QQ 签名，我使用了很久，“此去经年，感叹那两个少年，一个温柔了岁月，一个惊艳了流年···”

小学毕业照

还有一些小伙伴：

命令	描述
`/\(a\+\)[^a]\+\1`	查找开头和结尾处a的个数相同的字符串，如 aabbbaa，aaacccaaa，但是不匹配 abbbaa
`:s/\(http:\/\/[-a-z\._~\+%\/]\+\)/<a href="\1">\1<\/a>/`	将 url 替换为 http://url的格式
`:s/\(\w\+\)\s\+\(\w\+\)/\2\t\1`	将 data1 data2 修改为 data2 data1