内置

Nvim :help 页面,生成来源 使用 tree-sitter-vimdoc 解析器。


内置函数 builtin-functions
对于按用途分组的函数,请参阅 function-list.

1. 详细信息 builtin-function-details

abs({expr}) abs()
返回{expr}的绝对值。当{expr} 评估为 Float 时,abs() 返回 Float。当{expr} 可以转换为 Number 时,abs() 返回 Number。否则 abs() 给出错误消息并返回 -1。示例
echo abs(1.456)
1.456
echo abs(-5.456)
5.456
echo abs(-4)
4
参数
{expr} (number)
返回值
(number)
acos({expr}) acos()
返回{expr}以弧度为单位的反正弦,以范围为 [0, pi] 的 Float 表示。{expr} 必须评估为范围为 [-1, 1] 的 FloatNumber。如果{expr} 超出范围 [-1, 1],则返回 NaN。如果{expr} 不是 FloatNumber,则返回 0.0。示例
echo acos(0)
1.570796
echo acos(-0.5)
2.094395
参数
{expr} (number)
返回值
(number)
add({object}, {expr}) add()
将项目{expr} 附加到 ListBlob {object}。返回结果 ListBlob。示例
let alist = add([1, 2, 3], item)
call add(mylist, "woodstock")
请注意,当{expr}List 时,它将作为一个单独的项目附加。使用 extend() 连接 Lists。当{object}Blob 时,{expr} 必须是一个数字。使用 insert() 在另一个位置添加项目。如果{object} 不是 ListBlob,则返回 1。
参数
{object} (any)
{expr} (any)
返回值
(any) 结果 ListBlob,或者如果{object} 不是 ListBlob,则为 1。
and({expr}, {expr}) and()
对两个参数进行按位与运算。参数将转换为数字。List、Dict 或 Float 参数会导致错误。另见 or()xor()。示例
let flag = and(bits, 0x80)
参数
{expr} (number)
{expr1} (number)
返回值
(integer)
api_info() api_info()
返回 api-metadata 的字典。
以一种易于理解的格式查看它
lua vim.print(vim.fn.api_info())
返回值
(table)
append({lnum}, {text}) append()
{text}List 时:将 List 的每个项目作为文本行附加到当前缓冲区中的行{lnum} 下面。否则将{text} 作为一行文本附加到当前缓冲区中的行{lnum} 下面。接受任何类型的项目并将其转换为字符串。{lnum} 可以为零,以便在第一行之前插入一行。{lnum} 的用法与 getline() 相同。如果失败({lnum} 超出范围或内存不足),则返回 1;如果成功,则返回 0。当{text} 是一个空列表时,无论{lnum} 的值如何,都将返回零。
let failed = append(line('$'), "# THE END")
let failed = append(0, ["Chapter 1", "the beginning"])
参数
{lnum} (integer)
{text} (string|string[])
返回值
(0|1)
appendbufline({buf}, {lnum}, {text}) appendbufline()
append() 相同,但将文本附加到缓冲区{expr} 中。
此函数仅适用于已加载的缓冲区。如有必要,请首先调用 bufload()
有关{buf} 的用法,请参阅 bufname().
{lnum} 是要附加在其下方的行号。请注意,使用 line() 将使用当前缓冲区,而不是正在附加到的缓冲区。使用 "$" 在缓冲区末尾附加。不支持其他字符串值。
如果成功,则返回 0;如果失败,则返回 1。
如果{buf} 不是有效缓冲区,或者{lnum} 无效,则会显示错误消息。示例
let failed = appendbufline(13, 0, "# THE START")
但是,当{text} 是一个空列表时,对于无效的{lnum} 不会显示错误消息,因为{lnum} 实际上没有被使用。
参数
{buf} (integer|string)
{lnum} (integer)
{text} (string)
返回值
(0|1)
argc([{winid}]) argc()
结果是参数列表中文件数量。参阅 arglist。如果没有提供{winid},则使用当前窗口的参数列表。如果{winid} 为 -1,则使用全局参数列表。否则,{winid} 指定使用其参数列表的窗口:窗口号或窗口 ID。如果{winid} 参数无效,则返回 -1。
参数
{winid} (integer?)
返回值
(integer)
argidx() argidx()
结果是参数列表中的当前索引。0 是第一个文件。argc() - 1 是最后一个。参阅 arglist.
返回值
(integer)
arglistid([{winnr} [, {tabnr}]]) arglistid()
返回参数列表 ID。这是一个用于标识正在使用的参数列表的数字。零用于全局参数列表。参阅 arglist。如果参数无效,则返回 -1。
如果没有任何参数,则使用当前窗口。如果提供{winnr},则仅使用当前选项卡页中的此窗口。如果提供{winnr}{tabnr},则使用指定选项卡页中的窗口。{winnr} 可以是窗口号或 window-ID.
参数
{winnr} (integer?)
{tabnr} (integer?)
返回值
(integer)
argv([{nr} [, {winid}]]) argv()
结果是参数列表中的第{nr}个文件。参阅 arglist。 "argv(0)" 是第一个。示例
let i = 0
while i < argc()
  let f = escape(fnameescape(argv(i)), '.')
  exe 'amenu Arg.' .. f .. ' :e ' .. f .. '<CR>'
  let i = i + 1
endwhile
如果没有{nr} 参数,或者{nr} 为 -1,则返回包含整个 arglistList
{winid} 参数指定窗口 ID,参阅 argc()。有关 Vim 命令行参数,请参阅 v:argv.
如果参数列表中没有第{nr}个参数,则返回一个空字符串。如果{winid} 参数无效,则返回一个空列表。
参数
{nr} (integer?)
{winid} (integer?)
返回值
(string|string[])
asin({expr}) asin()
返回{expr}以弧度为单位的反正弦,以范围为 [-pi/2, pi/2] 的 Float 表示。{expr} 必须评估为范围为 [-1, 1] 的 FloatNumber。如果{expr} 超出范围 [-1, 1],则返回 NaN。如果{expr} 不是 FloatNumber,则返回 0.0。示例
echo asin(0.8)
0.927295
echo asin(-0.5)
-0.523599
参数
{expr} (any)
返回值
(number)
assert_beeps({cmd}) assert_beeps()
运行{cmd},如果它不产生蜂鸣声或视觉响铃,则将错误消息添加到 v:errors 中。另见 assert_fails()assert_nobeep()assert-return.
参数
{cmd} (string)
返回值
(0|1)
assert_equal({expected}, {actual} [, {msg}]) assert_equal()
{expected}{actual} 不相等时,将错误消息添加到 v:errors 中,并返回 1。否则返回零。 assert-return 错误的格式为 "Expected {expected} but got {actual}"。当{msg} 存在时,它将与错误消息的开头一起添加,以及运行脚本时的断言位置。
没有自动转换,字符串 "4" 与数字 4 不同。数字 4 与浮点数 4.0 也不同。 'ignorecase' 的值在此处不适用,大小写始终很重要。示例
call assert_equal('foo', 'bar', 'baz')
将以下内容添加到 v:errors
test.vim line 12: baz: Expectedfoo but gotbar
参数
{expected} (any)
{actual} (any)
{msg} (any?)
返回值
(0|1)
assert_equalfile({fname_one}, {fname_two}) assert_equalfile()
当文件{fname_one}{fname_two} 不包含完全相同的文本时,将错误消息添加到 v:errors 中。另见 assert-return。当{fname_one}{fname_two} 不存在时,错误消息会说明这一点。
参数
{fname_one} (string)
{fname_two} (string)
返回值
(0|1)
assert_exception({error} [, {msg}]) assert_exception()
当 v:exception 不包含字符串{error} 时,将错误消息添加到 v:errors 中。另见 assert-return。这可以用来断言命令抛出异常。使用错误号,后跟冒号,可以避免与翻译相关的問題
try
  commandthatfails
  call assert_false(1, 'command should have failed')
catch
  call assert_exception('E492:')
endtry
参数
{error} (any)
{msg} (any?)
返回值
(0|1)
assert_fails()
assert_fails({cmd} [, {error} [, {msg} [, {lnum} [, {context}]]]]) 运行{cmd},如果它不产生错误,或者当{error} 未在错误消息中找到时,则将错误消息添加到 v:errors 中。另见 assert-return.
{error} 是一个字符串时,它必须在第一个报告的错误中逐字找到。通常情况下,这将是错误代码,包括冒号,例如 "E123:"。
call assert_fails('bad cmd', 'E987:')
{error} 是包含一个或两个字符串的 List 时,它们将用作模式。第一个模式与第一个报告的错误匹配
call assert_fails('cmd', ['E987:.*expected bool'])
如果存在第二个模式,则与最后一个报告的错误匹配。要仅匹配最后一个错误,请对第一个错误使用空字符串
call assert_fails('cmd', ['', 'E987:'])
如果{msg} 为空,则不使用它。执行此操作是为了在传递{lnum} 参数时获取默认消息。 E1115
{lnum} 存在且不为负数,并且{error} 参数存在且匹配时,它将与报告错误时的行号进行比较。这可能是函数或脚本中的行号。 E1116
{context} 存在时,它将用作模式,并与{lnum} 所在的上下文(脚本名称或函数名称)进行匹配。
请注意,蜂鸣声不被视为错误,并且某些失败的命令只会发出蜂鸣声。对于这些命令,请使用 assert_beeps()
参数
{cmd} (string)
{error} (任何类型?)
{msg} (any?)
{lnum} (整数?)
{context} (任何类型?)
返回值
(0|1)
assert_false({actual} [, {msg}]) assert_false()
{actual} 不是假时,一个错误信息将被添加到 v:errors 中,与 assert_equal() 相同。错误信息格式为 "Expected False but got {actual}"。当 {msg} 存在时,它将被添加到错误信息的最前面,连同断言在脚本中运行的位置。另请参阅 assert-return.
当一个值等于 0 时,它就是假。当 {actual} 不是一个数字时,断言失败。
参数
{actual} (any)
{msg} (any?)
返回值
(0|1)
assert_inrange({lower}, {upper}, {actual} [, {msg}]) assert_inrange()
这断言数字和 Float 值。当 {actual} 小于 {lower} 或大于 {upper} 时,一个错误信息将被添加到 v:errors 中。另请参阅 assert-return。错误信息格式为 "Expected range {lower} - {upper}, but got {actual}"。当 {msg} 存在时,它将被添加到错误信息的最前面。
参数
{lower} (数字)
{upper} (数字)
{actual} (数字)
{msg} (字符串?)
返回值
(0|1)
assert_match({pattern}, {actual} [, {msg}]) assert_match()
{pattern}{actual} 不匹配时,一个错误信息将被添加到 v:errors 中。另请参阅 assert-return。错误信息格式为 "Pattern {pattern} does not match {actual}"。当 {msg} 存在时,它将被添加到错误信息的最前面,连同断言在脚本中运行的位置。
{pattern} 用于与 expr-=~ 相同:匹配始终与 'magic' 设置且 'cpoptions' 为空相同,无论 'magic''cpoptions' 的实际值是什么。
{actual} 用作字符串,应用自动转换。使用 "^" 和 "$" 与文本的开头和结尾匹配。同时使用两者以匹配整个文本。
示例
call assert_match('^f.*o$', 'foobar')
将导致一个字符串被添加到 v:errors
test.vim line 12: Pattern '^f.*o$' does not matchfoobar
参数
{pattern} (字符串)
{actual} (字符串)
{msg} (字符串?)
返回值
(0|1)
assert_nobeep({cmd}) assert_nobeep()
运行 {cmd} 并将一个错误信息添加到 v:errors 中,如果它产生了蜂鸣声或视觉铃声。另请参阅 assert_beeps().
参数
{cmd} (string)
返回值
(0|1)
assert_notequal({expected}, {actual} [, {msg}]) assert_notequal()
assert_equal() 的反面:当 {expected}{actual} 相等时,将一个错误信息添加到 v:errors 中。另请参阅 assert-return.
参数
{expected} (any)
{actual} (any)
{msg} (any?)
返回值
(0|1)
assert_notmatch({pattern}, {actual} [, {msg}]) assert_notmatch()
assert_match() 的反面:当 {pattern}{actual} 匹配时,将一个错误信息添加到 v:errors 中。另请参阅 assert-return.
参数
{pattern} (字符串)
{actual} (字符串)
{msg} (字符串?)
返回值
(0|1)
assert_report({msg}) assert_report()
直接报告测试失败,使用字符串 {msg}。始终返回 1。
参数
{msg} (字符串)
返回值
(0|1)
assert_true({actual} [, {msg}]) assert_true()
{actual} 不是真时,一个错误信息将被添加到 v:errors 中,与 assert_equal() 相同。另请参阅 assert-return。当一个值是一个非零数字或 v:true 时,它就是 TRUE。当 {actual} 不是一个数字或 v:true 时,断言失败。当 {msg} 被给出时,它将被添加到默认信息的前面,连同断言在脚本中运行的位置。
参数
{actual} (any)
{msg} (字符串?)
返回值
(0|1)
atan({expr}) atan()
返回 {expr} 的反正切函数的主值,以弧度表示,范围在 [-pi/2, +pi/2] 之间,作为 Float{expr} 必须求值为 FloatNumber。如果 {expr} 不是 FloatNumber,则返回 0.0。示例
echo atan(100)
1.560797
echo atan(-4.01)
-1.326405
参数
{expr} (number)
返回值
(number)
atan2({expr1}, {expr2}) atan2()
返回 {expr1} / {expr2} 的反正切函数,以弧度表示,作为 Float,范围在 [-pi, pi] 之间。{expr1}{expr2} 必须求值为 FloatNumber。如果 {expr1}{expr2} 不是 FloatNumber,则返回 0.0。示例
echo atan2(-1, 1)
-0.785398
echo atan2(1, -1)
2.356194
参数
{expr1} (number)
{expr2} (数字)
返回值
(number)
blob2list({blob}) blob2list()
返回一个 List,包含 Blob {blob} 中每个字节的数字值。示例
blob2list(0z0102.0304)        " returns [1, 2, 3, 4]
blob2list(0z)                " returns []
在错误情况下返回一个空的 List。 list2blob() 执行相反的操作。
参数
{blob} (任何类型)
返回值
(任何类型[])
browse({save}, {title}, {initdir}, {default}) browse()
显示一个文件选择器。这仅在 "has("browse")" 返回 TRUE 时有效(仅在某些 GUI 版本中)。输入字段为:{save} 当为 TRUE 时,选择要写入的文件 {title} 文件选择器的标题 {initdir} 开始浏览的目录 {default} 默认文件名 当点击“取消”按钮、出现错误或无法浏览时,将返回一个空字符串。
参数
{save} (任何类型)
{title} (字符串)
{initdir} (字符串)
{default} (字符串)
返回值
(0|1)
browsedir({title}, {initdir}) browsedir()
显示一个目录选择器。这仅在 "has("browse")" 返回 TRUE 时有效(仅在某些 GUI 版本中)。在不支持目录浏览器的系统上,将使用文件浏览器。在这种情况下:选择要使用的目录中的一个文件。输入字段为:{title} 文件选择器的标题 {initdir} 开始浏览的目录 当点击“取消”按钮、出现错误或无法浏览时,将返回一个空字符串。
参数
{title} (字符串)
{initdir} (字符串)
返回值
(0|1)
bufadd({name}) bufadd()
向缓冲区列表添加一个缓冲区,名称为 {name}(必须是字符串)。如果文件 {name} 的缓冲区已经存在,则返回该缓冲区编号。否则,返回新创建缓冲区的缓冲区编号。当 {name} 为空字符串时,将始终创建一个新缓冲区。缓冲区将没有设置 'buflisted',并且尚未加载。要向缓冲区添加一些文本,请使用以下方法
let bufnr = bufadd('someName')
call bufload(bufnr)
call setbufline(bufnr, 1, ['some', 'text'])
在错误情况下返回 0。
参数
{name} (字符串)
返回值
(integer)
bufexists({buf}) bufexists()
结果是一个数字,如果名为 {buf} 的缓冲区存在,则为 TRUE。如果 {buf} 参数是一个数字,则使用缓冲区编号。数字 0 是当前窗口的备用缓冲区。
如果 {buf} 参数是一个字符串,它必须与缓冲区名称完全匹配。名称可以是
相对于当前目录。
完整的路径。
具有 'buftype' 设置为 "nofile" 的缓冲区的名称。
一个 URL 名称。将找到未列出的缓冲区。请注意,帮助文件在 :buffers 的输出中按其短名称列出,但 bufexists() 需要使用其长名称才能找到它们。bufexists() 可能会报告缓冲区存在,但要在 :buffer 命令中使用该名称,您可能需要使用 expand()。尤其是在 MS-Windows 中,使用 8.3 名称,例如 "c:\DOCUME~1"。使用 "bufexists(0)" 测试备用文件名是否存在。
参数
{buf} (任何类型)
返回值
(0|1)
buflisted({buf}) buflisted()
结果是一个数字,如果名为 {buf} 的缓冲区存在并且已列出(已设置 'buflisted' 选项),则为 TRUE{buf} 参数的使用方式与 bufexists() 相同。
参数
{buf} (任何类型)
返回值
(0|1)
bufload({buf}) bufload()
确保缓冲区 {buf} 已加载。如果缓冲区名称引用一个现有文件,则读取该文件。否则,缓冲区将为空。如果缓冲区已经加载,则不会有任何变化。如果缓冲区与文件无关,则不会读取任何文件(例如,当 'buftype' 为 "nofile" 时)。如果缓冲区文件存在现有交换文件,则不会有任何对话框,缓冲区将照常加载。{buf} 参数的使用方式与 bufexists() 相同。
参数
{buf} (任何类型)
bufloaded({buf}) bufloaded()
结果是一个数字,如果名为 {buf} 的缓冲区存在并且已加载(在窗口中显示或隐藏),则为 TRUE{buf} 参数的使用方式与 bufexists() 相同。
参数
{buf} (任何类型)
返回值
(0|1)
bufname([{buf}]) bufname()
结果是一个缓冲区的名称。它与 :ls 命令显示的名称基本相同,但不使用特殊名称,例如 "[No Name]"。如果省略 {buf},则使用当前缓冲区。如果 {buf} 是一个数字,则给出该缓冲区编号的名称。数字 0 是当前窗口的备用缓冲区。如果 {buf} 是一个字符串,则将其用作 file-pattern 与缓冲区名称匹配。这始终与 'magic' 设置且 'cpoptions' 为空相同。当有多个匹配项时,将返回一个空字符串。"" 或 "%" 可用于当前缓冲区,"#" 可用于备用缓冲区。优先考虑完全匹配,否则接受缓冲区名称开头、结尾或中间的匹配项。如果您只想要完全匹配,则在模式的开头添加 "^",在结尾添加 "$"。首先找到已列出的缓冲区。如果存在与已列出的缓冲区匹配的单个匹配项,则返回该匹配项。接下来,搜索未列出的缓冲区。如果 {buf} 是一个字符串,但您想将其用作缓冲区编号,则通过向其添加零将其强制转换为数字
echo bufname("3" + 0)
如果缓冲区不存在或没有名称,则返回一个空字符串。
echo bufname("#")        " alternate buffer name
echo bufname(3)                " name of buffer 3
echo bufname("%")        " name of current buffer
echo bufname("file2")        " name of buffer where "file2" matches.
参数
{buf} (整数|字符串?)
返回值
(字符串)
bufnr([{buf} [, {create}]]) bufnr()
结果是一个缓冲区的编号,与 :ls 命令显示的编号相同。有关 {buf} 的使用,请参阅上面的 bufname()。如果缓冲区不存在,则返回 -1。或者,如果 {create} 参数存在且为 TRUE,则创建一个新的、未列出的缓冲区,并返回其编号。bufnr("$") 是最后一个缓冲区
let last_buffer = bufnr("$")
结果是一个数字,它是现有缓冲区的最高缓冲区编号。请注意,并非所有编号较小的缓冲区都一定存在,因为 ":bwipeout" 可能已删除它们。使用 bufexists() 测试缓冲区是否存在。
参数
{buf} (整数|字符串?)
{create} (任何类型?)
返回值
(integer)
bufwinid({buf}) bufwinid()
结果是一个数字,它是与缓冲区{buf}关联的第一个窗口的窗口 ID。关于{buf}的使用,请参见上面的bufname()。如果缓冲区{buf}不存在或没有这样的窗口,则返回 -1。示例
echo "A window containing buffer 1 is " .. (bufwinid(1))
仅处理当前选项卡页。有关查找更多内容,请参见win_findbuf()
参数
{buf} (任何类型)
返回值
(integer)
bufwinnr({buf}) bufwinnr()
类似于bufwinid(),但返回窗口编号而不是窗口 ID。如果缓冲区{buf}不存在或没有这样的窗口,则返回 -1。示例
echo "A window containing buffer 1 is " .. (bufwinnr(1))
该编号可与CTRL-W_w 和 ":wincmd w" :wincmd 一起使用。
参数
{buf} (任何类型)
返回值
(integer)
byte2line({byte}) byte2line()
返回当前缓冲区中包含字节计数{byte}处字符的行号。这包括行尾字符,具体取决于当前缓冲区的'fileformat' 选项。第一个字符的字节计数为 1。另请参见line2byte()go:goto
如果{byte} 值无效,则返回 -1。
参数
{byte} (任何)
返回值
(integer)
byteidx({expr}, {nr} [, {utf16}]) byteidx()
返回字符串{expr} 中第{nr} 个字符的字节索引。对于第一个字符,使用零,然后返回零。如果没有多字节字符,则返回值等于{nr}。合成字符不单独计数,其字节长度将添加到前面的基本字符中。有关单独计数合成字符,请参见下面的byteidxcomp()。当{utf16} 存在且为 TRUE 时,{nr} 用作字符串{expr} 中的 UTF-16 索引,而不是字符索引。UTF-16 索引是字符串以 16 位字编码时的索引。如果指定的 UTF-16 索引位于字符的中间(例如,在 4 字节字符中),则返回该字符中第一个字节的字节索引。有关更多信息,请参阅string-offset-encoding。示例
echo matchstr(str, ".", byteidx(str, 3))
将显示第四个字符。另一种执行相同操作的方法是
let s = strpart(str, byteidx(str, 3))
echo strpart(s, 0, byteidx(s, 1))
另请参见strgetchar()strcharpart()
如果字符少于{nr} 个,则返回 -1。如果正好有{nr} 个字符,则返回字符串的字节长度。有关从字节索引获取字符和 UTF-16 索引,请分别参见charidx()utf16idx()。示例
echo byteidx('a😊😊', 2)        " returns 5
echo byteidx('a😊😊', 2, 1)        " returns 1
echo byteidx('a😊😊', 3, 1)        " returns 5
参数
{expr} (any)
{nr} (整数)
{utf16} (任何?)
返回值
(integer)
byteidxcomp({expr}, {nr} [, {utf16}]) byteidxcomp()
与 byteidx() 相似,但合成字符将作为单独的字符进行计数。示例
let s = 'e' .. nr2char(0x301)
echo byteidx(s, 1)
echo byteidxcomp(s, 1)
echo byteidxcomp(s, 2)
第一个和第三个 echo 结果为 3('e' 加合成字符为 3 个字节),第二个 echo 结果为 1('e' 为 1 个字节)。
参数
{expr} (any)
{nr} (整数)
{utf16} (任何?)
返回值
(integer)
call({func}, {arglist} [, {dict}]) call() E699 使用列表 {arglist} 中的项作为参数来调用函数{func}{func} 可以是Funcref 也可以是函数的名称。a:firstline 和 a:lastline 设置为光标行。返回被调用函数的返回值。{dict} 用于具有“dict”属性的函数。它将用于设置局部变量“self”。字典函数
参数
{func} (任何)
{arglist} (任何)
{dict} (任何?)
返回值
(任何)
ceil({expr}) ceil()
返回大于或等于{expr} 的最小整数值,作为一个浮点数(向上取整)。{expr} 必须计算为浮点数数字。示例
echo ceil(1.456)
2.0
echo ceil(-5.456)
-5.0
echo ceil(4.0)
4.0
如果{expr} 不是浮点数数字,则返回 0.0。
参数
{expr} (number)
返回值
(number)
chanclose({id} [, {stream}]) chanclose()
关闭与之关联的通道或特定流。对于作业,{stream} 可以是“stdin”、“stdout”、“stderr” 或“rpc”(为使用"rpc":v:true 启动的作业关闭 stdin/stdout)。如果省略{stream},则所有流都将关闭。如果通道是 pty,则这将关闭 pty 主机,向作业进程发送 SIGHUP。对于套接字,只有一个流,并且应省略{stream}
参数
{id} (整数)
{stream} (字符串?)
返回值
(0|1)
changenr() changenr()
返回最近一次更改的编号。这与:undolist 显示的编号相同,并且可与:undo 命令一起使用。当进行更改时,它是该更改的编号。重做后,它是重做更改的编号。撤消后,它比撤消更改的编号少 1。如果撤消列表为空,则返回 0。
返回值
(integer)
chansend({id}, {data}) chansend()
将数据发送到通道{id}。对于作业,它将数据写入进程的 stdin。对于 stdio 通道channel-stdio,它将写入 Nvim 的 stdout。如果写入成功,则返回写入的字节数,否则返回 0。有关更多信息,请参见channel-bytes
{data} 可以是字符串、字符串可转换、Blob 或列表。如果{data} 是列表,则其项将用换行符连接;项中的任何换行符都将作为 NUL 发送。要发送最后的换行符,请包含最后的空字符串。示例
call chansend(id, ["abc", "123\n456", ""])
将发送“abc<NL>123<NUL>456<NL>”。
chansend() 写入原始数据,而不是 RPC 消息。如果通道是使用"rpc":v:true 创建的,则通道将期望 RPC 消息,请使用rpcnotify()rpcrequest()
参数
{id} (数字)
{data} (字符串|字符串[])
返回值
(0|1)
char2nr({string} [, {utf8}]) char2nr()
返回{string} 中第一个字符的数字值。示例
echo char2nr(" ")        " returns 32
echo char2nr("ABC")        " returns 65
echo char2nr("á")        " returns 225
echo char2nr("á"[0])        " returns 195
echo char2nr("\<M-x>")        " returns 128
非 ASCII 字符始终被视为 UTF-8 字符。{utf8} 被忽略,它仅存在于向后兼容性方面。组合字符是单独的字符。 nr2char() 执行相反的操作。
如果{string} 不是字符串,则返回 0。
参数
{string} (字符串)
{utf8} (任何?)
返回值
(0|1)
charclass({string}) charclass()
返回{string} 中第一个字符的字符类别。字符类别为以下之一:0 空格 1 标点符号 2 字词字符(取决于'iskeyword')3 表情符号 其他特定 Unicode 类别 该类别用于模式和字词移动。如果{string} 不是字符串,则返回 0。
参数
{string} (字符串)
返回值
(0|1|2|3|'other')
charcol({expr} [, {winid}]) charcol()
col() 相同,但返回使用{expr} 给出的列位置的字符索引,而不是字节位置。
示例:当光标位于第 5 行中的“세”上,文本为“여보세요”时
echo charcol('.')        " returns 3
echo col('.')                " returns 7
参数
{expr} (字符串|整数[])
{winid} (integer?)
返回值
(integer)
charidx({string}, {idx} [, {countcc} [, {utf16}]]) charidx()
返回{string} 中位于{idx} 处的字节的字符索引。第一个字符的索引为零。如果没有多字节字符,则返回值等于{idx}
当省略{countcc} 或为FALSE 时,合成字符不单独计数,其字节长度将添加到前面的基本字符中。当{countcc}TRUE 时,合成字符将作为单独的字符进行计数。
{utf16} 存在且为 TRUE 时,{idx} 用作字符串{expr} 中的 UTF-16 索引,而不是字节索引。
如果参数无效或字节少于{idx} 个,则返回 -1。如果正好有{idx} 个字节,则返回字符串的字符长度。
如果第一个参数不是字符串,第二个参数不是数字,或者当第三个参数存在且不是零或一时,则会显示错误并返回 -1。
有关从字符索引获取字节索引,请参见byteidx()byteidxcomp(),有关从字符索引获取 UTF-16 索引,请参见utf16idx()。有关更多信息,请参阅string-offset-encoding。示例
echo charidx('áb́ć', 3)                " returns 1
echo charidx('áb́ć', 6, 1)        " returns 4
echo charidx('áb́ć', 16)                " returns -1
echo charidx('a😊😊', 4, 0, 1)        " returns 2
参数
{string} (字符串)
{idx} (整数)
{countcc} (布尔值?)
{utf16} (布尔值?)
返回值
(integer)
chdir({dir}) chdir()
将当前工作目录更改为{dir}。目录更改的范围取决于当前窗口的目录
如果当前窗口具有窗口本地目录(:lcd),则更改窗口本地目录。
否则,如果当前选项卡页具有本地目录(:tcd),则更改选项卡页本地目录。
否则,更改全局目录。{dir} 必须是字符串。如果成功,则返回上一个工作目录。将其传递给另一个 chdir() 以恢复目录。失败时,返回空字符串。
示例
let save_dir = chdir(newdir)
if save_dir != ""
   " ... do some work
   call chdir(save_dir)
endif
参数
{dir} (字符串)
返回值
(字符串)
cindent({lnum}) cindent()
根据 C 缩进规则获取第{lnum} 行的缩进量,就像'cindent' 一样。缩进量以空格计算,'tabstop' 的值很重要。{lnum} 的用法与getline() 中的用法相同。当{lnum} 无效时,返回 -1。参见C 缩进
参数
{lnum} (integer)
返回值
(integer)
clearmatches([{win}]) clearmatches()
清除先前由matchadd():match 命令为当前窗口定义的所有匹配项。如果指定了{win},则使用此编号或窗口 ID 的窗口,而不是当前窗口。
参数
{win} (整数?)
col({expr} [, {winid}]) col()
结果是一个数字,它是使用{expr} 给出的列位置的字节索引。有关接受的位置,请参见getpos()。当{expr} 为“$”时,表示光标行的结尾,因此结果是光标行中的字节数加 1。此外,{expr} 可以是 [lnum, col]:包含行号和列号的列表。当列为“$”时最有用,用于获取特定行的最后一列。当“lnum”或“col”超出范围时,col() 返回零。
使用可选的{winid} 参数,将为该窗口而不是当前窗口获取值。
要获取行号,请使用line()。要获取两者,请使用getpos()
要获取屏幕列位置,请使用 virtcol()。要获取字符位置,请使用 charcol()
请注意,只能使用当前文件中的标记。
示例
echo col(".")                        " column of cursor
echo col("$")                        " length of cursor line plus one
echo col("'t")                        " column of mark t
echo col("'" .. markname)        " column of mark markname
第一列为 1。如果 {expr} 无效或找不到 ID 为 {winid} 的窗口,则返回 0。对于大写标记,列实际上可能位于另一个缓冲区中。对于光标位置,当 'virtualedit' 处于活动状态时,如果光标位于行尾之后,则列会高一位。此外,当使用 <Cmd> 映射时,光标不会移动,这可以用来在插入模式下获取列。
imap <F2> <Cmd>echo col(".").."\n"<CR>
参数
{expr} (字符串|整数[])
{winid} (integer?)
返回值
(integer)
complete({startcol}, {matches}) complete() E785 设置插入模式补全的匹配项。只能在插入模式下使用。您需要使用带 CTRL-R 的映射(参见 i_CTRL-R)。在 CTRL-O 之后或使用表达式映射时,它不起作用。{startcol} 是完成文本开始的行的字节偏移量。直到光标的文本是将被匹配项替换的原始文本。对于空字符串,请使用 col('.')。"col('.') - 1" 将用匹配项替换一个字符。{matches} 必须是 List。每个 List 项目都是一个匹配项。有关可能的项目类型,请参见 complete-items。"longest" in 'completeopt' 被忽略。请注意,在调用此函数后,您需要避免插入任何会导致补全停止的内容。匹配项可以使用 CTRL-NCTRL-P 如常使用插入模式补全选择。弹出菜单将显示(如果指定),请参见 ins-completion-menu。示例
inoremap <F5> <C-R>=ListMonths()<CR>
func ListMonths()
  call complete(col('.'), ['January', 'February', 'March',
    \ 'April', 'May', 'June', 'July', 'August', 'September',
    \ 'October', 'November', 'December'])
  return ''
endfunc
这没什么用,但它展示了它是如何工作的。请注意,返回空字符串以避免插入零。
参数
{startcol} (整数)
{matches} (any[])
complete_add({expr}) complete_add()
{expr} 添加到匹配项列表。仅供使用 'completefunc' 选项指定的函数使用。如果失败(空字符串或内存不足),则返回 0;如果匹配项已添加,则返回 1;如果匹配项已存在于列表中,则返回 2。有关 {expr} 的解释,请参见 complete-functions。它与 'omnifunc' 返回的列表中的一个项目相同。
参数
{expr} (any)
返回值
(0|1|2)
complete_check() complete_check()
检查在查找补全匹配项时键入的键。这在查找匹配项需要一些时间时使用。如果要中止查找匹配项,则返回 TRUE,否则返回零。仅供使用 'completefunc' 选项指定的函数使用。
返回值
(0|1)
complete_info([{what}]) complete_info()
返回一个包含插入模式补全信息的 Dictionary。参见 ins-completion。项目包括:mode 当前补全模式名称字符串。有关值,请参见 complete_info_mode。pum_visible 如果弹出菜单可见,则为 TRUE。参见 pumvisible()。items 补全匹配项列表。每个项目都是一个字典,包含条目 "word"、"abbr"、"menu"、"kind"、"info" 和 "user_data"。参见 complete-items。selected 选定项目的索引。第一个索引为零。如果未选择任何项目(仅显示键入的文本,或者在使用 <Up><Down> 键时,最后一个补全在未选择任何项目后),则索引为 -1。inserted 插入的字符串。[尚未实现] preview_winid 信息浮动预览窗口 ID。preview_bufnr 信息浮动预览缓冲区 ID。
complete_info_mode
mode 值为:"" 未处于补全模式 "keyword" 关键字补全 i_CTRL-X_CTRL-N "ctrl_x" 刚刚按下 CTRL-X i_CTRL-X "scroll" 使用 i_CTRL-X_CTRL-Ei_CTRL-X_CTRL-Y 滚动 "whole_line" 整行 i_CTRL-X_CTRL-L "files" 文件名 i_CTRL-X_CTRL-F "tags" 标记 i_CTRL-X_CTRL-] "path_defines" 定义补全 i_CTRL-X_CTRL-D "path_patterns" 包含补全 i_CTRL-X_CTRL-I "dictionary" 字典 i_CTRL-X_CTRL-K "thesaurus" 同义词库 i_CTRL-X_CTRL-T "cmdline" Vim 命令行 i_CTRL-X_CTRL-V "function" 用户定义的补全 i_CTRL-X_CTRL-U "omni" 全能补全 i_CTRL-X_CTRL-O "spell" 拼写建议 i_CTRL-X_s "eval" complete() 补全 "unknown" 其他内部模式
如果提供了可选的 {what} 列表参数,则仅返回 {what} 中列出的项目。{what} 中不受支持的项目将被静默忽略。
要获取弹出菜单的位置和大小,请参见 pum_getpos()。它也可以在 v:event 中使用,在 CompleteChanged 事件期间。
如果发生错误,则返回一个空的 Dictionary
示例
" Get all items
call complete_info()
" Get only 'mode'
call complete_info(['mode'])
" Get only 'mode' and 'pum_visible'
call complete_info(['mode', 'pum_visible'])
参数
{what} (any[]?)
返回值
(table)
confirm({msg} [, {choices} [, {default} [, {type}]]]) confirm()
confirm() 为用户提供一个对话框,用户可以在其中进行选择。它返回选择的数字。对于第一个选择,此值为 1。
{msg} 在一个带有 {choices} 作为备选方案的对话框中显示。当 {choices} 缺失或为空时,将使用 "&OK"(并进行翻译)。{msg} 是一个 String,使用 '\n' 来包含换行符。仅在某些系统中,当字符串不适合时,才会换行。
{choices} 是一个 String,其中各个选择以 '\n' 分隔,例如:
confirm("Save changes?", "&Yes\n&No\n&Cancel")
'&' 后的字母是该选择的快捷键。因此,您可以键入 'c' 来选择 "Cancel"。快捷键不必是第一个字母。
confirm("file has been modified", "&Save\nSave &All")
对于控制台,每个选择的第一个字母将用作默认快捷键。不区分大小写。
可选的 {type} String 参数提供对话框的类型。它可以是以下值之一:"Error"、"Question"、"Info"、"Warning" 或 "Generic"。仅第一个字符是相关的。如果省略 {type},则使用 "Generic"。
可选的 {type} 参数提供对话框的类型。这仅用于 Win32 GUI 的图标。它可以是以下值之一:"Error"、"Question"、"Info"、"Warning" 或 "Generic"。仅第一个字符是相关的。如果省略 {type},则使用 "Generic"。
如果用户通过按下 <Esc>CTRL-C 或其他有效的中断键来中止对话框,则 confirm() 返回 0。
一个示例
let choice = confirm("What do you want?",
                     \ "&Apples\n&Oranges\n&Bananas", 2)
if choice == 0
     echo "make up your mind!"
elseif choice == 3
     echo "tasteful"
else
     echo "I prefer bananas myself."
endif
在 GUI 对话框中,使用按钮。按钮的布局取决于 'guioptions' 中的 'v' 标志。如果它被包含,则按钮始终垂直放置。否则,confirm() 尝试将按钮放在一条水平线上。如果它们不适合,则无论如何都会使用垂直布局。对于某些系统,始终使用水平布局。
参数
{msg} (字符串)
{choices} (string?)
{default} (integer?)
{type} (string?)
返回值
(integer)
copy({expr}) copy()
复制 {expr}。对于 Numbers 和 Strings,这与直接使用 {expr} 没有区别。当 {expr}List 时,将创建一个浅拷贝。这意味着可以更改原始 List 而不更改副本,反之亦然。但项目是相同的,因此更改一个项目会更改两个 Lists 的内容。一个 Dictionary 的复制方式与 List 相似。另请参见 deepcopy()
参数
{expr} (any)
返回值
(任何)
cos({expr}) cos()
返回 {expr} 的余弦值,以弧度为单位,作为 Float{expr} 必须计算为 FloatNumber。如果 {expr} 不是 FloatNumber,则返回 0.0。示例
echo cos(100)
0.862319
echo cos(-4.01)
-0.646043
参数
{expr} (number)
返回值
(number)
cosh({expr}) cosh()
返回 {expr} 的双曲余弦值,作为 [1, inf] 范围内的 Float{expr} 必须计算为 FloatNumber。如果 {expr} 不是 FloatNumber,则返回 0.0。示例
echo cosh(0.5)
1.127626
echo cosh(-0.5)
-1.127626
参数
{expr} (number)
返回值
(number)
count({comp}, {expr} [, {ic} [, {start}]]) count() E706 返回值 {expr} 的项目在 StringListDictionary {comp} 中出现的次数。
如果提供了 {start},则从具有此索引的项目开始。{start} 只能与 List 一起使用。
如果提供了 {ic} 并且它是 TRUE,则不区分大小写。
{comp} 是字符串时,将返回 {expr} 的非重叠出现的次数。如果 {expr} 是空字符串,则返回零。
参数
{comp} (string|table|any[])
{expr} (any)
{ic} (boolean?)
{start} (integer?)
返回值
(integer)
ctxget([{index}]) ctxget()
返回一个表示 contextDictionary,该 context 来自 context-stack 的顶部(参见 context-dict)。如果未提供 {index},则假定为 0(即:顶部)。
参数
{index} (integer?)
返回值
(table)
ctxpop() ctxpop()
弹出并恢复 context-stack 顶部的 context
返回值
(任何)
ctxpush([{types}]) ctxpush()
将当前编辑器状态 (context) 推送到 context-stack 上。如果提供了 {types} 并且它是一个 List,其中包含 String,则它指定要包含在推送的 context 中的 context-types。否则,将包含所有 context 类型。
参数
{types} (string[]?)
返回值
(任何)
ctxset({context} [, {index}]) ctxset()
context-stack 上的 {index} 处的 context 设置为 {context} 所表示的 context。{context} 是一个包含 context 数据的 Dictionary(参见 context-dict)。如果未提供 {index},则假定为 0(即:顶部)。
参数
{context} (table)
{index} (integer?)
返回值
(任何)
ctxsize() ctxsize()
返回 context-stack 的大小。
返回值
(任何)
cursor({lnum}, {col} [, {off}]) cursor()
cursor({list}) 将光标定位在行 {lnum} 中的列(字节数){col} 处。第一列为一。
当有一个参数 {list} 时,它将用作一个包含两个、三个或四个项目的 List:[{lnum}, {col}] [{lnum}, {col}, {off}] [{lnum}, {col}, {off}, {curswant}] 这类似于 getpos()getcurpos() 的返回值,但没有第一个项目。
要使用{col}作为字符计数来定位光标,请使用setcursorcharpos()
不会改变跳转列表。{lnum}的使用方式与getline()相同,但如果{lnum}为零,光标将保持在当前行。如果{lnum}大于缓冲区中的行数,光标将定位在缓冲区中的最后一行。如果{col}大于行中的字节数,光标将定位在行中的最后一个字符。如果{col}为零,光标将保持在当前列。如果给出{curswant},则将其用于设置垂直移动的首选列。否则使用{col}
当使用'virtualedit'时,{off}指定从字符开头到屏幕列的偏移量。例如,<Tab>内的位置或最后一个字符之后的位置。如果可以设置位置,则返回 0,否则返回 -1。
参数
{list} (integer[])
返回值
(任何)
debugbreak({pid}) debugbreak()
专门用于中断正在调试的程序。它将导致进程{pid}收到 SIGTRAP 信号。对于其他进程的行为未定义。参见 terminal-debug。(向非 MS-Windows 的进程{pid}发送 SIGINT 信号)
如果成功中断程序,则返回 TRUE。否则返回 FALSE
参数
{pid} (integer)
返回值
(任何)
deepcopy({expr} [, {noref}]) deepcopy() E698 复制{expr}。对于数字和字符串,这与直接使用{expr}没有区别。当{expr}是一个List时,将创建一个完整副本。这意味着可以更改原始的List而不改变副本,反之亦然。当一个项目是一个List时,会递归地为它创建一个副本。因此,更改副本中的一个项目不会更改原始List的内容。
当省略或{noref}为零时,包含的ListDictionary只复制一次。所有引用都指向这个单一副本。当{noref}设置为 1 时,ListDictionary的每次出现都会产生一个新的副本。这也意味着循环引用会导致 deepcopy() 失败。E724
嵌套可以达到 100 层。当有一个项目引用回更高层时,使用{noref}设置为 1 进行深层复制将失败。另请参见 copy()
参数
{expr} (any)
{noref} (boolean?)
返回值
(任何)
delete({fname} [, {flags}]) delete()
如果没有{flags},或者{flags}为空:删除名为{fname}的文件。
{fname}是符号链接时,这也适用。符号链接本身将被删除,而不是它指向的内容。
{flags}为“d”时:删除名为{fname}的目录。如果目录{fname}不为空,则此操作将失败。
{flags}为“rf”时:递归地删除名为{fname}的目录及其所有内容。请小心! 注意:在 MS-Windows 上,无法删除正在使用的目录。
结果是一个数字,如果删除操作成功,则为 0/false;如果删除失败或部分失败,则为 -1/true。
参数
{fname} (string)
{flags} (string?)
返回值
(integer)
deletebufline({buf}, {first} [, {last}]) deletebufline()
从缓冲区{buf}中删除第{first}行到第{last}行(包含)的所有行。如果省略了{last},则仅删除第{first}行。成功则返回 0,失败则返回 1。
此函数仅适用于已加载的缓冲区。如有必要,请首先调用 bufload()
有关{buf}的使用,请参见上面的 bufname()
{first}{last}的使用方式与getline()相同。请注意,当使用line()时,它指的是当前缓冲区。使用“$”来引用缓冲区{buf}中的最后一行。
参数
{buf} (integer|string)
{first} (integer|string)
{last} (integer|string?)
返回值
(任何)
dictwatcheradd({dict}, {pattern}, {callback}) dictwatcheradd()
向字典添加一个观察者。字典观察者由三个部分组成
一个字典 ({dict});
一个键模式 ({pattern})。
一个函数 ({callback})。
调用此函数后,{dict}以及与{pattern}匹配的键的每次更改都会导致调用{callback}
例如,要观察所有全局变量
silent! call dictwatcherdel(g:, '*', 'OnDictChanged')
function! OnDictChanged(d,k,z)
  echomsg string(a:k) string(a:z)
endfunction
call dictwatcheradd(g:, '*', 'OnDictChanged')
目前,{pattern}只接受非常简单的模式,这些模式可以在字符串末尾包含一个“*”,在这种情况下,它将匹配以“*”之前子字符串开头的每个键。这意味着如果“*”不是{pattern}的最后一个字符,则只会匹配与{pattern}完全相同的键。
{callback}接收三个参数
正在观察的字典。
发生更改的键。
一个包含键的新旧值的字典。
可以通过检查第三个参数中的键来确定更改类型
如果同时包含oldnew,则表示更新了键。
如果只包含new,则表示添加了键。
如果只包含old,则表示删除了键。
插件可以使用此函数来实现具有验证和解析逻辑的选项。
参数
{dict} (table)
{pattern} (字符串)
{callback} (function)
返回值
(任何)
dictwatcherdel({dict}, {pattern}, {callback}) dictwatcherdel()
删除使用dictwatcheradd()添加的观察者。所有三个参数都必须与传递给dictwatcheradd()的参数匹配,才能成功删除观察者。
参数
{dict} (any)
{pattern} (字符串)
{callback} (function)
返回值
(任何)
did_filetype() did_filetype()
当执行自动命令并且至少触发过一次 FileType 事件时,返回 TRUE。可用于避免在检测文件类型的脚本中再次触发 FileType 事件。FileType 当使用:setf FALLBACK时,返回 FALSE。当编辑另一个文件时,计数器将重置,因此这实际上检查了当前缓冲区是否触发过 FileType 事件。这允许在开始编辑另一个缓冲区的自动命令中设置'filetype'并加载语法文件。
返回值
(任何)
diff_filler({lnum}) diff_filler()
返回第{lnum}行上方的填充行数。这些是另一个差异窗口中在此处插入的行。这些填充行在显示中显示,但不存在于缓冲区中。{lnum}的使用方式与getline()相同。因此,“.”是当前行,“'m”是标记 m,等等。如果当前窗口不在差异模式下,则返回 0。
参数
{lnum} (integer)
返回值
(任何)
diff_hlID({lnum}, {col}) diff_hlID()
返回第{lnum}行第{col}列(字节索引)处差异模式的突出显示 ID。如果当前行没有差异更改,则返回零。{lnum}的使用方式与getline()相同。因此,“.”是当前行,“'m”是标记 m,等等。{col}对于最左边的列为 1,{lnum}对于第一行为 1。突出显示 ID 可以与synIDattr()一起使用,以获取有关突出显示的语法信息。
参数
{lnum} (integer)
{col} (integer)
返回值
(任何)
digraph_get({chars}) digraph_get() E1214 返回{chars}的双字符。这应该是一个恰好包含两个字符的字符串。如果{chars}不仅仅是两个字符,或者{chars}的双字符不存在,则会给出错误并返回一个空字符串。
另请参见 digraph_getlist()
示例
" Get a built-in digraph
echo digraph_get('00')                " Returns '∞'
" Get a user-defined digraph
call digraph_set('aa', 'あ')
echo digraph_get('aa')                " Returns 'あ'
参数
{chars} (string)
返回值
(任何)
digraph_getlist([{listall}]) digraph_getlist()
返回一个双字符列表。如果给出{listall}参数并且它为 TRUE,则返回所有双字符,包括默认双字符。否则,只返回用户定义的双字符。
另请参见 digraph_get()
示例
" Get user-defined digraphs
echo digraph_getlist()
" Get all the digraphs, including default digraphs
echo digraph_getlist(1)
参数
{listall} (boolean?)
返回值
(任何)
digraph_set({chars}, {digraph}) digraph_set()
将双字符{chars}添加到列表中。{chars}必须是一个包含两个字符的字符串。{digraph}是一个包含一个 UTF-8 编码字符的字符串。E1215 请注意,合成字符不会被忽略。此函数类似于:digraphs命令,但对于添加以空格开头的双字符很有用。
如果注册了digraph,则函数结果为 v:true。如果失败,则会给出错误消息并返回 v:false。
如果要一次定义多个双字符,可以使用digraph_setlist()
示例
call digraph_set('  ', 'あ')
参数
{chars} (string)
{digraph} (string)
返回值
(任何)
digraph_setlist({digraphlist}) digraph_setlist()
类似于digraph_set(),但此函数可以一次添加多个双字符。{digraphlist}是一个由列表组成的列表,其中每个列表包含两个字符串,分别为{chars}{digraph},与digraph_set()中的相同。E1216 示例
call digraph_setlist([['aa', 'あ'], ['ii', 'い']])
它类似于以下内容
for [chars, digraph] in [['aa', 'あ'], ['ii', 'い']]
      call digraph_set(chars, digraph)
endfor
但函数在第一个错误后返回,后续双字符不会被添加。
参数
{digraphlist} (table<integer,string[]>)
返回值
(任何)
empty({expr}) empty()
如果{expr}为空,则返回数字 1,否则返回零。
ListDictionary在没有项目时为空。
String在长度为零时为空。
NumberFloat在值为零时为空。
v:falsev:null为空,v:true不为空。
Blob在长度为零时为空。
参数
{expr} (any)
返回值
(任何)
environ() environ()
将所有环境变量作为字典返回。您可以像这样检查环境变量是否存在
echo has_key(environ(), 'HOME')
请注意,变量名称可能是驼峰式命名法;要忽略大小写,请使用
echo index(keys(environ()), 'HOME', 0, 1) != -1
返回值
(任何)
escape({string}, {chars}) escape()
使用反斜杠转义{string}中出现的{chars}中的字符。例如
echo escape('c:\program files\vim', ' \')
结果为
c:\\program\ files\\vim
另请参阅 shellescape()fnameescape()
参数
{string} (字符串)
{chars} (string)
返回值
(任何)
eval({string}) eval()
计算 {string} 并返回结果。特别适用于将 string() 的结果转换为原始值。这适用于数字、浮点数、字符串、Blob 以及它们的组合。也适用于引用现有函数的 Funcref
参数
{string} (字符串)
返回值
(任何)
eventhandler() eventhandler()
在事件处理程序内返回 1。即 Vim 在等待用户输入字符时被中断,例如,在将文件拖放到 Vim 上时。这意味着无法使用交互式命令。否则返回零。
返回值
(任何)
executable({expr}) executable()
此函数检查是否存在名为 {expr} 的可执行文件。{expr} 必须是程序名称,不包含任何参数。
executable() 使用 $PATH 的值和/或程序的正常搜索路径。 PATHEXT
在 MS-Windows 上,可以选择包含 ".exe"、".bat" 等。然后尝试 $PATHEXT 中的扩展名。因此,如果 "foo.exe" 不存在,则可以找到 "foo.exe.bat"。如果未设置 $PATHEXT,则使用 ".com;.exe;.bat;.cmd"。$PATHEXT 中的点本身可用于尝试在不添加扩展名的情况下使用名称。当 'shell' 看起来像一个 Unix shell 时,也会尝试在不添加扩展名的情况下使用名称。在 MS-Windows 上,它只检查文件是否存在且不是目录,而不是检查它是否真的可执行。在 MS-Windows 上,始终可以找到与 Vim 可执行文件位于同一目录中的可执行文件(它在 启动 时添加到 $PATH 中)。 NoDefaultCurrentDirectoryInExePath
在 MS-Windows 上,通常也会找到 Vim 的当前工作目录中的可执行文件,但可以通过设置 $NoDefaultCurrentDirectoryInExePath 环境变量来禁用此功能。
结果是一个数字:1 表示存在,0 表示不存在。可以使用 exepath() 获取可执行文件的完整路径。
参数
{expr} (string)
返回值
(0|1)
execute({command} [, {silent}]) execute()
执行 {command} 并捕获其输出。如果 {command} 是一个 String,则返回 {command} 输出。如果 {command} 是一个 List,则返回连接的输出。{command} 中的行延续不被识别。示例
echo execute('echon "foo"')
foo
echo execute(['echon "foo"', 'echon "bar"'])
foobar
可选的 {silent} 参数可以具有以下值:" " 不使用 :silent "silent" 使用 :silent "silent!" 使用 :silent! 默认值为 "silent"。请注意,与 :redir 不同,使用 "silent!" 时,错误消息会被丢弃。
要获取行列表,请对结果使用 split()
execute('args')->split("\n")
此函数在 沙箱 中不可用。注意:如果嵌套,外部 execute() 不会观察内部调用的输出。注意:文本属性(高亮显示)不会被捕获。要在除当前窗口之外的另一个窗口中执行命令,请使用 win_execute()
参数
{command} (string|string[])
{silent} (''|'silent'|'silent!'?)
返回值
(字符串)
exepath({expr}) exepath()
如果 {expr} 是一个可执行文件,并且作为(部分或完整)路径给出或在 $PATH 中找到,则返回 {expr} 的完整路径。否则返回空字符串。如果 {expr} 以 "./" 开头,则使用 当前目录
参数
{expr} (string)
返回值
(字符串)
exists({expr}) exists()
结果是一个数字,如果 {expr} 已定义,则为 TRUE,否则为零。
要检查支持的功能,请使用 has()。要检查文件是否存在,请使用 filereadable()
{expr} 参数是一个字符串,它包含以下内容之一:varname 内部变量(参见 dict.key 内部变量)。也适用于 花括号名称 的 list[i]、字典 条目、列表 项目等。注意,评估索引可能会对无效表达式导致错误消息。例如
let l = [1, 2, 3]
echo exists("l[5]")
0
echo exists("l[xx]")
E121: Undefined variable: xx 0 &option-name Vim 选项(仅检查是否存在,不检查是否真正有效) +option-name 可用的 Vim 选项。 $ENVNAME 环境变量(也可以通过与空字符串比较来实现) *funcname 内置函数(参见 函数)或用户定义函数(参见 用户函数)。也适用于 Funcref 的变量。 :cmdname Ex 命令:内置命令、用户命令或命令修饰符 :command。返回:1 表示与命令的开头匹配 2 表示与命令完全匹配 3 表示与多个用户命令匹配 要检查支持的命令,请始终检查返回值是否为 2。 :2match :2match 命令。 :3match :3match 命令(但你可能不应该使用它,它保留供内部使用) #event 为此事件定义的自动命令 #event#pattern 为此事件和模式定义的自动命令(模式按字面意义理解并逐个字符与自动命令模式进行比较) #group 自动命令组存在 #group#event 为此组和事件定义的自动命令。 #group#event#pattern 为此组、事件和模式定义的自动命令。 ##event 支持此事件的自动命令。
示例
echo exists("&mouse")
echo exists("$HOSTNAME")
echo exists("*strftime")
echo exists("*s:MyFunc")
echo exists("*MyFunc")
echo exists("*v:lua.Func")
echo exists("bufcount")
echo exists(":Make")
echo exists("#CursorHold")
echo exists("#BufReadPre#*.gz")
echo exists("#filetypeindent")
echo exists("#filetypeindent#FileType")
echo exists("#filetypeindent#FileType#*")
echo exists("##ColorScheme")
符号 (&/$/*/#) 和名称之间不能有空格。名称后面不能有额外的字符,尽管在某些情况下会忽略。这将来可能会变得更加严格,因此不要依赖它!工作示例
echo exists(":make")
不工作的示例
echo exists(":make install")
注意,参数必须是一个字符串,而不是变量本身的名称。例如
echo exists(bufcount)
这不会检查 "bufcount" 变量是否存在,而是获取 "bufcount" 的值,并检查它是否存在。
参数
{expr} (string)
返回值
(0|1)
exp({expr}) exp()
Float 的形式返回 {expr} 的指数,范围为 [0, inf]。{expr} 必须计算为 FloatNumber。如果 {expr} 不是 FloatNumber,则返回 0.0。示例
echo exp(2)
7.389056
echo exp(-1)
0.367879
参数
{expr} (number)
返回值
(任何)
expand({string} [, {nosuf} [, {list}]]) expand()
{string} 中展开通配符和以下特殊关键字。 'wildignorecase' 适用。
如果给出了 {list} 并且它为 TRUE,则将返回一个列表。否则结果为一个字符串,当有多个匹配项时,它们之间用 <NL> 字符分隔。
如果扩展失败,则结果为空字符串。除非 {string} 不以 '%'、'#' 或 '<' 开头,否则不会包含不存在文件的名称,请参见下文。
{string} 以 '%'、'#' 或 '<' 开头时,扩展就像对带有其关联修饰符的 命令行特殊 变量进行扩展一样。以下是一个简要概述
% 当前文件名 # 备用文件名 #n 备用文件名 n <cfile> 光标下的文件名 <afile> 自动命令文件名 <abuf> 自动命令缓冲区号(作为字符串!) <amatch> 自动命令匹配的名称 <cexpr> 光标下的 C 表达式 <sfile> 源脚本文件或函数名 <slnum> 源脚本行号或函数行号 <sflnum> 脚本文件行号,在函数中也一样 <SID> "<SNR>123_" 其中 "123" 是当前脚本 ID <SID> <script> 源脚本文件,或定义当前函数的脚本文件 <stack> 调用堆栈 <cword> 光标下的单词 <cWORD> 光标下的单词 <client> 最后一个接收到的消息的 {clientid} 修饰符::p 展开为完整路径 :h 头部(删除最后一个路径组件) :t 尾部(仅最后一个路径组件) :r 根(删除一个扩展名) :e 仅扩展名
示例
let &tags = expand("%:p:h") .. "/tags"
注意,当扩展以 '%'、'#' 或 '<' 开头的字符串时,任何后续文本都会被忽略。这不起作用
let doesntwork = expand("%:h.bak")
使用此
let doeswork = expand("%:h") .. ".bak"
还要注意,扩展 "<cfile>" 和其他项只会返回引用的文件名,而不会进行进一步扩展。如果 "<cfile>" 是 "~/.cshrc",则需要再次进行 expand() 以将 "~/" 扩展为主目录的路径
echo expand(expand("<cfile>"))
变量和后续修饰符之间不能有空格。可以使用 fnamemodify() 函数来修改普通文件名。
当使用 '%' 或 '#' 时,如果当前或备用文件名未定义,则使用空字符串。在没有名称的缓冲区中使用 "%:p" 将导致当前目录,并添加一个 '/'。当 'verbose' 设置时,如果参数无法扩展,则扩展 '%'、'#' 和 <> 项将导致错误消息。
{string} 不以 '%'、'#' 或 '<' 开头时,它就像在命令行上展开文件名一样进行扩展。将使用 'suffixes''wildignore',除非给出了可选的 {nosuf} 参数并且它为 TRUE。包含不存在文件的名称。"**" 项可用于在目录树中搜索。例如,要查找当前目录及其子目录中的所有 "README" 文件
echo expand("**/README")
expand() 也可用于扩展仅在 shell 中已知的变量和环境变量。但这可能很慢,因为可能会使用 shell 来进行扩展。参见 expr-env-expand。扩展的变量仍然像文件名列表一样进行处理。如果无法扩展环境变量,则保持不变。因此 ":echo expand('$FOOBAR')" 将导致 "$FOOBAR"。
参见 glob(),用于查找现有文件。参见 system(),用于获取外部命令的原始输出。
参数
{string} (字符串)
{nosuf} (boolean?)
{list} (nil|false?)
返回值
(字符串)
expandcmd({string} [, {options}]) expandcmd()
在字符串 {string} 中展开特殊项,就像对 Ex 命令(如 :edit)所做的那样。这将展开特殊关键字(就像使用 expand() 一样)和环境变量,在 {string} 中的任何位置。仅在开头展开 "~user" 和 "~/path"。
{options} Dict 参数中支持以下项:errmsg 如果设置为 TRUE,则在扩展过程中遇到错误时将显示错误消息。默认情况下,不会显示错误消息。
返回扩展的字符串。如果在扩展过程中遇到错误,则返回未修改的 {string}
示例
echo expandcmd('make %<.o')
make /path/runtime/doc/builtin.o
echo expandcmd('make %<.o', {'errmsg': v:true})
参数
{string} (字符串)
{options} (table?)
返回值
(任何)
extend({expr1}, {expr2} [, {expr3}]) extend()
{expr1}{expr2} 必须都是 列表 或者都是 字典
如果它们是 列表:将 {expr2} 附加到 {expr1}。如果给出了 {expr3},则在 {expr1} 中索引为 {expr3} 的项之前插入 {expr2} 的项。当 {expr3} 为零时,在第一个项之前插入。当 {expr3} 等于 len({expr1}) 时,{expr2} 将被附加。示例
echo sort(extend(mylist, [7, 5]))
call extend(mylist, [2, 3], 1)
{expr1}{expr2} 是同一个列表时,复制的项数等于列表的原始长度。例如,当 {expr3} 为 1 时,你将获得 N 个第一个项的新副本(其中 N 是列表的原始长度)。使用 add() 将一个项连接到列表中。要将两个列表连接成一个新的列表,请使用 + 运算符
let newlist = [1, 2, 3] + [4, 5]
如果它们是 字典:将来自 {expr2} 的所有条目添加到 {expr1} 中。如果一个键同时存在于 {expr1}{expr2} 中,则使用 {expr3} 来决定该怎么做:{expr3} = "keep":保留 {expr1} 的值 {expr3} = "force":使用 {expr2} 的值 {expr3} = "error":给出错误消息 E737
当省略 {expr3} 时,假设为 "force"。
{expr2} 不为空时,{expr1} 会发生改变。如有必要,请先制作 {expr1} 的副本。{expr2} 保持不变。当 {expr1} 被锁定且 {expr2} 不为空时,操作将失败。返回 {expr1}。错误时返回 0。
参数
{expr1} (table)
{expr2} (table)
{expr3} (table?)
返回值
(任何)
extendnew({expr1}, {expr2} [, {expr3}]) extendnew()
类似于 extend(),但它不是将项目添加到 {expr1} 中,而是创建一个新的列表或字典并返回。{expr1} 保持不变。
参数
{expr1} (table)
{expr2} (table)
{expr3} (table?)
返回值
(任何)
feedkeys({string} [, {mode}]) feedkeys()
{string} 中的字符被排队,等待处理,就好像它们来自映射或由用户键入一样。
默认情况下,字符串被添加到键入缓冲区的末尾,因此,如果映射仍在执行,字符将在它们之后出现。使用 'i' 标记在其他字符之前插入,它们将首先执行,在映射中的任何字符之前执行。
该函数不会等待处理 {string} 中包含的键。
要将特殊键包含在 {string} 中,请使用双引号和 "\..." 符号 expr-quote。例如,feedkeys("\<CR>") 模拟按下 <Enter> 键。但 feedkeys('\<CR>') 推送了 5 个字符。 <Ignore> 键码可用于退出等待字符而无需执行任何操作。
{mode} 是一个字符串,它可以包含以下字符标记:'m' 重新映射键。这是默认设置。如果 {mode} 不存在,则键会被重新映射。'n' 不要重新映射键。't' 将键作为键入处理;否则,它们将被视为来自映射处理。这对撤销、打开折叠等很重要。'L' 低级输入。其他标志不使用。'i' 插入字符串而不是追加(见上文)。'x' 执行命令,直到键入缓冲区为空。这类似于使用 ":normal!"。你可以多次调用 feedkeys() 而不使用 'x',然后使用 'x'(可能使用空 {string})调用一次,以执行所有键入缓冲区。请注意,当 Vim 以插入模式结束时,它将表现得好像键入了 <Esc>,以避免卡住,等待键入字符,然后脚本才继续。请注意,如果你设法在执行命令时调用 feedkeys(),从而递归地调用它,那么所有键入缓冲区将被最后一次调用消耗。'!' 当与 'x' 一起使用时,不会结束插入模式。可以在测试中使用,当计时器设置为稍后退出插入模式时。这对测试 CursorHoldI 有用。
返回值始终为 0。
参数
{string} (字符串)
{mode} (string?)
返回值
(任何)
filecopy({from}, {to}) filecopy()
{from} 指向的文件复制到 {to} 中。结果是一个数字,如果文件复制成功,则为 TRUE,如果复制失败,则为 FALSE。如果名为 {to} 的文件已存在,则会失败。请注意,它不处理目录(目前)。
此函数在 沙盒 中不可用。
参数
{from} (string)
{to} (string)
返回值
(0|1)
filereadable({file}) filereadable()
结果是一个数字,如果名为 {file} 的文件存在,并且可以读取,则为 TRUE。如果 {file} 不存在,或者是一个目录,则结果为 FALSE{file} 是任何表达式,用作字符串。如果你不关心文件是否可读,可以使用 glob(){file} 按原样使用,你可能需要先扩展通配符
echo filereadable('~/.vimrc')
0
echo filereadable(expand('~/.vimrc'))
1
参数
{file} (string)
返回值
(0|1)
filewritable({file}) filewritable()
结果是一个数字,如果名为 {file} 的文件存在,并且可以写入,则为 1。如果 {file} 不存在,或者不可写,则结果为 0。如果 {file} 是一个目录,并且可以写入,则结果为 2。
参数
{file} (string)
返回值
(0|1)
filter({expr1}, {expr2}) filter()
{expr1} 必须是 列表字符串Blob字典。对于 {expr1} 中的每个项目,评估 {expr2},当结果为零或假时,从 列表字典 中删除该项目。类似地,对于 Blob 中的每个字节和 字符串 中的每个字符。
{expr2} 必须是 字符串Funcref
如果 {expr2} 是一个 字符串,则在 {expr2} 内部 v:val 具有当前项目的价值。对于 字典 v:key 具有当前项目的键,对于 列表 v:key 具有当前项目的索引。对于 Blob v:key 具有当前字节的索引。对于 字符串 v:key 具有当前字符的索引。示例
call filter(mylist, 'v:val !~ "OLD"')
删除包含 "OLD" 的项目。
call filter(mydict, 'v:key >= 8')
删除键低于 8 的项目。
call filter(var, 0)
删除所有项目,从而清除 列表字典
请注意,{expr2} 是表达式的结果,然后再次用作表达式。通常,使用 字面字符串 是一个好主意,以避免不得不双重转义反斜杠。
如果 {expr2} 是一个 Funcref,它必须接受两个参数:1. 当前项目的键或索引。2. 当前项目的价值。该函数必须返回 TRUE,如果该项目应被保留。保留列表奇数项目的示例
func Odd(idx, val)
  return a:idx % 2 == 1
endfunc
call filter(mylist, function('Odd'))
使用 lambda 时更短
call filter(myList, {idx, val -> idx * val <= 42})
如果你不使用 "val",你可以省略它
call filter(myList, {idx -> idx % 2 == 1})
对于 列表字典,操作是在原地完成的。如果你希望它保持不变,请先制作一个副本
let l = filter(copy(mylist), 'v:val =~ "KEEP"')
返回 {expr1},即被过滤的 列表字典,或一个新的 Blob字符串。当在评估 {expr2} 时遇到错误时,不会处理 {expr1} 中的任何其他项目。当 {expr2} 是一个 Funcref 时,函数内部的错误会被忽略,除非它是用 "abort" 标记定义的。
参数
{expr1} (string|table)
{expr2} (string|function)
返回值
(任何)
finddir({name} [, {path} [, {count}]]) finddir()
{path} 中查找目录 {name}。支持向下和向上递归目录搜索。有关 {path} 的语法,请参见 文件搜索
返回第一个找到的匹配项的路径。当找到的目录位于当前目录下方时,将返回相对路径。否则,将返回完整路径。如果省略或为空 {path},则使用 'path'
如果提供了可选的 {count},则在 {path} 中查找 {name} 的第 {count} 个匹配项,而不是第一个匹配项。当 {count} 为负数时,在 列表 中返回所有匹配项。
如果找不到目录,则返回空字符串。
这与 ex 命令 :find 非常相似。
参数
{name} (字符串)
{path} (string?)
{count} (integer?)
返回值
(任何)
findfile({name} [, {path} [, {count}]]) findfile()
finddir() 相同,但查找文件而不是目录。使用 'suffixesadd'。示例
echo findfile("tags.vim", ".;")
从当前文件的目录向上搜索,直到找到文件 "tags.vim"。
参数
{name} (字符串)
{path} (string?)
{count} (any?)
返回值
(任何)
flatten({list} [, {maxdepth}]) flatten()
{list} 展平到 {maxdepth} 级。如果没有 {maxdepth},则结果是 列表,没有嵌套,就好像 {maxdepth} 是一个非常大的数字。{list} 在原地被修改,如果你不想要这样,请使用 flattennew()E900
{maxdepth} 表示嵌套列表中发生更改的深度。当 {maxdepth} 为 0 时,{list} 不会被修改。{maxdepth} 必须是正数。
如果发生错误,则返回数字零。
示例
echo flatten([1, [2, [3, 4]], 5])
[1, 2, 3, 4, 5]
echo flatten([1, [2, [3, 4]], 5], 1)
[1, 2, [3, 4], 5]
参数
{list} (any[])
{maxdepth} (integer?)
返回值
(any[]|0)
flattennew({list} [, {maxdepth}]) flattennew()
flatten() 相同,但首先制作 {list} 的副本。
参数
{list} (any[])
{maxdepth} (integer?)
返回值
(any[]|0)
float2nr({expr}) float2nr()
通过省略小数点后的部分将 {expr} 转换为数字。{expr} 必须评估为 FloatNumber。如果 {expr} 不是 FloatNumber,则返回 0。当 {expr} 的值超出 Number 的范围时,结果将被截断为 0x7fffffff 或 -0x7fffffff(或当启用 64 位 Number 支持时,为 0x7fffffffffffffff 或 -0x7fffffffffffffff)。NaN 导致 -0x80000000(或当启用 64 位 Number 支持时,为 -0x8000000000000000)。示例
echo float2nr(3.95)
3
echo float2nr(-23.45)
-23
echo float2nr(1.0e100)
2147483647 (或 9223372036854775807)
echo float2nr(-1.0e150)
-2147483647 (或 -9223372036854775807)
echo float2nr(1.0e-100)
0
参数
{expr} (number)
返回值
(任何)
floor({expr}) floor()
返回小于或等于 {expr} 的最大整数,作为 Float(向下取整)。{expr} 必须评估为 FloatNumber。如果 {expr} 不是 FloatNumber,则返回 0.0。示例
echo floor(1.856)
1.0
echo floor(-5.456)
-6.0
echo floor(4.0)
4.0
参数
{expr} (number)
返回值
(任何)
fmod({expr1}, {expr2}) fmod()
返回 {expr1} / {expr2} 的余数,即使除法不可表示。返回 {expr1} - i * {expr2},其中 i 是一个整数,使得如果 {expr2} 非零,则结果与 {expr1} 符号相同,且大小小于 {expr2} 的大小。如果 {expr2} 为零,则返回的值为零。返回值为一个 Float{expr1}{expr2} 必须计算为一个 FloatNumber。如果 {expr1}{expr2} 不是 FloatNumber,则返回 0.0。示例
echo fmod(12.33, 1.22)
0.13
echo fmod(-12.33, 1.22)
-0.13
参数
{expr1} (number)
{expr2} (数字)
返回值
(任何)
fnameescape({string}) fnameescape()
{string} 转义为文件名命令参数。所有具有特殊含义的字符,如 '%''|',都使用反斜杠转义。对于大多数系统,转义的字符是 " \t\n*?[{`$\\%#'\"|!<".} 对于系统中文件名中出现反斜杠的情况,它取决于 'isfname' 的值。开头的 '+' 和 '>' 也被转义(在 :edit:write 之后是特殊的)。还有一个单独的 "-"(在 :cd 之后是特殊的)。在发生错误时返回空字符串。示例
let fname = '+some str%nge|name'
exe "edit " .. fnameescape(fname)
导致执行
edit \+some\ str\%nge\|name
参数
{string} (字符串)
返回值
(字符串)
fnamemodify({fname}, {mods}) fnamemodify()
根据 {mods} 修改文件名 {fname}{mods} 是一个字符字符串,与在命令行上使用文件名的方式类似。参见 filename-modifiers。示例
echo fnamemodify("main.c", ":p:h")
结果为
/home/user/vim/vim/src
如果 {mods} 为空或使用了不支持的修饰符,则返回 {fname}。当 {fname} 为空时,使用 {mods} ":h" 返回 ".",以便 :cd 可以使用它。这与没有缓冲区名称的 expand('%:h') 不同,后者返回空字符串。 注意: 环境变量在 {fname} 中不起作用,请先使用 expand()
参数
{fname} (string)
{mods} (string)
返回值
(字符串)
foldclosed({lnum}) foldclosed()
结果是一个 Number。如果行 {lnum} 位于一个封闭的折叠中,则结果是该折叠中第一行的行号。如果行 {lnum} 不在封闭的折叠中,则返回 -1。{lnum} 的使用方式与 getline() 相同。因此 "." 是当前行,"'m" 是标记 m,等等。
参数
{lnum} (integer)
返回值
(integer)
foldclosedend({lnum}) foldclosedend()
结果是一个 Number。如果行 {lnum} 位于一个封闭的折叠中,则结果是该折叠中最后一行行号。如果行 {lnum} 不在封闭的折叠中,则返回 -1。{lnum} 的使用方式与 getline() 相同。因此 "." 是当前行,"'m" 是标记 m,等等。
参数
{lnum} (integer)
返回值
(integer)
foldlevel({lnum}) foldlevel()
结果是一个 Number,表示当前缓冲区中行 {lnum} 的折叠级别。对于嵌套折叠,将返回最深级别。如果行 {lnum} 没有折叠,则返回零。无论折叠是打开还是关闭,都无关紧要。在更新折叠时使用(来自 'foldexpr')-1 会返回给行,其中折叠仍有待更新,并且折叠级别未知。作为特例,通常可以使用上一行的级别。{lnum} 的使用方式与 getline() 相同。因此 "." 是当前行,"'m" 是标记 m,等等。
参数
{lnum} (integer)
返回值
(integer)
foldtext() foldtext()
返回一个 String,用于显示封闭的折叠。这是用于 'foldtext' 选项的默认函数,应该只在评估 'foldtext' 时调用它。它使用 v:foldstartv:foldendv:folddashes 变量。返回的字符串如下所示
+-- 45 lines: abcdef
前导破折号的数量取决于折叠级别。"45" 是折叠中的行数。"abcdef" 是折叠中第一个非空行的文本。前导空格、"//" 或 "/*" 以及来自 'foldmarker''commentstring' 选项的文本将被移除。当用于绘制实际的折叠文本时,行的其余部分将使用来自 'fillchars' 设置的折叠字符填充。当没有折叠时返回空字符串。
返回值
(字符串)
foldtextresult({lnum}) foldtextresult()
返回在行 {lnum} 处显示的封闭折叠的文本。在适当的上下文中评估 'foldtext'。当行 {lnum} 处没有封闭折叠时,将返回空字符串。{lnum} 的使用方式与 getline() 相同。因此 "." 是当前行,"'m" 是标记 m,等等。在导出折叠文本时很有用,例如导出到 HTML。
参数
{lnum} (integer)
返回值
(字符串)
foreach({expr1}, {expr2}) foreach()
{expr1} 必须是一个 ListStringBlobDictionary。对于 {expr1} 中的每个项目,执行 {expr2}{expr1} 不会被修改;其值可能会被修改,就像使用 :lockvar 1 一样。 E741 参见 map()filter() 以修改 {expr1}
{expr2} 必须是 字符串Funcref
如果 {expr2} 是一个 字符串,则在 {expr2} 内部 v:val 具有当前项目的价值。对于 字典 v:key 具有当前项目的键,对于 列表 v:key 具有当前项目的索引。对于 Blob v:key 具有当前字节的索引。对于 字符串 v:key 具有当前字符的索引。示例
call foreach(mylist, 'let used[v:val] = v:true')
这记录了 {expr1} 列表中的项目。
注意,{expr2} 是表达式的结果,然后用作命令。通常,使用 literal-string 可以避免重复使用反斜杠。
如果 {expr2} 是一个 Funcref,则它必须接受两个参数:1. 当前项目的键或索引。2. 当前项目的值。对于 lambda,如果它只接受一个参数,则不会出现错误。如果函数返回一个值,则会忽略该值。
在所有情况下都返回 {expr1}。当在执行 {expr2} 时遇到错误时,将不再处理 {expr1} 中的任何其他项目。当 {expr2} 是 Funcref 时,函数内部的错误将被忽略,除非它是在使用 "abort" 标志定义的。
参数
{expr1} (string|table)
{expr2} (string|function)
返回值
(任何)
fullcommand({name}) fullcommand()
从简短的缩写命令名称中获取完整的命令名称;有关命令缩写的详细信息,请参见 20.2
字符串参数 {name} 可以以 : 开头,并且可以包含 [范围],这些都会被跳过,不会被返回。如果命令不存在或存在歧义(对于用户定义的命令),则返回空字符串。
例如 fullcommand('s')fullcommand('sub')fullcommand(':%substitute') 都返回 "substitute"。
参数
{name} (字符串)
返回值
(字符串)
funcref({name} [, {arglist}] [, {dict}]) funcref()
function() 相同,但返回的 Funcref 将通过引用查找函数,而不是通过名称。这在函数 {name} 之后被重新定义时很重要。
function() 不同,{name} 必须是已存在的用户函数。它仅适用于已加载的自动加载函数(为了避免在仅打算使用函数名称时错误地加载自动加载脚本,请使用 function() )。{name} 不能是内置函数。发生错误时返回 0。
参数
{name} (字符串)
{arglist} (any?)
{dict} (任何?)
返回值
(任何)
function({name} [, {arglist}] [, {dict}]) function() partial E700 E923 返回一个引用函数 {name}Funcref 变量。{name} 可以是用户定义函数的名称,也可以是内部函数的名称。
{name} 也可以是 Funcref 或 partial。当它是 partial 时,将使用其中存储的 dict,并且不允许 {dict} 参数。例如
let FuncWithArg = function(dict.Func, [arg])
let Broken = function(dict.Func, [arg], dict)
当使用 Funcref 时,即使它之后被重新定义,函数也会通过 {name} 找到。使用 funcref() 来保持相同的函数。
{arglist}{dict} 存在时,这会创建一个 partial。这意味着参数列表和/或字典存储在 Funcref 中,并在调用 Funcref 时使用。
参数被传递给函数,位于其他参数之前,但在来自 method 的任何参数之后。示例
func Callback(arg1, arg2, name)
"...
endfunc
let Partial = function('Callback', ['one', 'two'])
"...
call Partial('name')
以与以下方式相同的方式调用函数
call Callback('one', 'two', 'name')
使用 method
func Callback(one, two, three)
"...
endfunc
let Partial = function('Callback', ['two'])
"...
eval 'one'->Partial('three')
以与以下方式相同的方式调用函数
call Callback('one', 'two', 'three')
function() 调用可以嵌套以向 Funcref 添加更多参数。额外的参数将附加到参数列表的末尾。示例
func Callback(arg1, arg2, name)
"...
endfunc
let Func = function('Callback', ['one'])
let Func2 = function(Func, ['two'])
"...
call Func2('name')
以与以下方式相同的方式调用函数
call Callback('one', 'two', 'name')
Dictionary 仅在调用 "dict" 函数时有用。在这种情况下,{dict} 将作为 "self" 传递。示例
function Callback() dict
   echo "called for " .. self.name
endfunction
"...
let context = {"name": "example"}
let Func = function('Callback', context)
"...
call Func()        " will echo: called for example
当没有额外的参数时,不需要使用 function(),这两个是等效的,如果 Callback() 被定义为 context.Callback()
let Func = function('Callback', context)
let Func = context.Callback
参数列表和 Dictionary 可以组合起来
function Callback(arg1, count) dict
"...
endfunction
let context = {"name": "example"}
let Func = function('Callback', ['one'], context)
"...
call Func(500)
以与以下方式相同的方式调用函数
call context.Callback('one', 500)
在错误情况下返回 0。
参数
{name} (字符串)
{arglist} (any?)
{dict} (任何?)
返回值
(任何)
garbagecollect([{atexit}]) garbagecollect()
清理没有使用的 ListsDictionaries,这些列表和字典具有循环引用。
几乎没有必要调用此函数,因为它在 Vim 耗尽内存或在 'updatetime' 之后等待用户按下键时会自动完成。没有循环引用的项目在变为未使用时会始终被释放。这在您在一个运行了很长时间的脚本中删除了非常大的 List 和/或 Dictionary 时非常有用,这些列表和字典具有循环引用。
当可选的 {atexit} 参数为 1 时,如果之前没有完成垃圾回收,则在退出 Vim 时也会执行垃圾回收。这在检查内存泄漏时非常有用。
垃圾回收不会立即完成,而是在安全执行时完成。当等待用户输入字符时就会进行。
参数
{atexit} (boolean?)
返回值
(任何)
get({list}, {idx} [, {default}]) get() get()-listList {list} 中获取项目 {idx}。当该项目不可用时,返回 {default}。当省略 {default} 时,返回零。
参数
{list} (any[])
{idx} (整数)
{default} (any?)
返回值
(任何)
get({blob}, {idx} [, {default}]) get()-blob
Blob {blob} 中获取字节 {idx}。当该字节不可用时,返回 {default}。当省略 {default} 时,返回 -1。
参数
{blob} (string)
{idx} (整数)
{default} (any?)
返回值
(任何)
get({dict}, {key} [, {default}]) get()-dict
Dictionary {dict} 中获取具有键 {key} 的项目。当该项目不可用时,返回 {default}。当省略 {default} 时,返回零。有用的示例
let val = get(g:, 'var_name', 'default')
如果 g:var_name 存在,则获取其值,如果不存在,则使用 "default"。
参数
{dict} (table<string,any>)
{key} (string)
{default} (any?)
返回值
(任何)
get({func}, {what}) get()-func
Funcref {func} 中获取项目 {what}{what} 的可能值是:"name" 函数名称 "func" 函数 "dict" 字典 "args" 包含参数的列表 "arity" 一个字典,包含有关函数接受的参数数量(减去 {arglist})的信息,具有以下字段:required 位置参数的数量 optional 可选参数的数量,除了必需的参数之外 varargs 如果函数接受可变数量的参数,则为 TRUE ...
注意: 如果 Funcref 的 {arglist} 包含的参数数量超过 Funcref 预期的数量,则不会出现错误,它不会被验证。
发生错误时返回零。
参数
{func} (function)
{what} (string)
返回值
(任何)
getbufinfo([{buf}]) getbufinfo()
getbufinfo([{dict}]) 获取缓冲区信息作为字典列表。
没有参数时,返回所有缓冲区的信息。
当参数为 字典 时,只返回与指定条件匹配的缓冲区。{dict} 中可以指定以下键:buflisted 只包含列出的缓冲区。bufloaded 只包含加载的缓冲区。bufmodified 只包含修改过的缓冲区。
否则,{buf} 指定要返回信息的特定缓冲区。有关 {buf} 的用法,请参见上面的 bufname()。如果找到缓冲区,则返回的列表包含一个项。否则,结果为空列表。
每个返回的列表项都是一个包含以下条目的字典:bufnr 缓冲区编号。changed 如果缓冲区已修改,则为 TRUE。changedtick 对缓冲区进行的更改次数。command 如果缓冲区属于命令行窗口 cmdwin,则为 TRUE。hidden 如果缓冲区隐藏,则为 TRUE。lastused 时间戳(以秒为单位,如 localtime()),表示缓冲区最后一次使用的时间。listed 如果缓冲区已列出,则为 TRUE。lnum 在当前窗口中打开缓冲区时使用的行号。仅在缓冲区过去已在窗口中显示时有效。如果要获取给定窗口中最后一个已知光标位置的行号,请使用 line()
echo line('.', {winid})
linecount 缓冲区中的行数(仅在加载时有效)loaded 如果缓冲区已加载,则为 TRUE。name 缓冲区中文件的完整路径。signs 放在缓冲区中的标记列表。每个列表项都是一个包含以下字段的字典:id 标记标识符 lnum 行号 name 标记名称 variables 对包含缓冲区局部变量的字典的引用。windows 显示此缓冲区的 窗口 ID 列表
示例
for buf in getbufinfo()
    echo buf.name
endfor
for buf in getbufinfo({'buflisted':1})
    if buf.changed
        " ....
    endif
endfor
要获取缓冲区局部选项,请使用
getbufvar({bufnr}, '&option_name')
参数
{dict} (vim.fn.getbufinfo.dict?)
返回值
(vim.fn.getbufinfo.ret.item[])
getbufline({buf}, {lnum} [, {end}]) getbufline()
返回一个包含从 {lnum}{end}(包含)的行的 列表,这些行位于缓冲区 {buf} 中。如果省略 {end},则返回一个仅包含行 {lnum}列表。有关仅获取行的信息,请参见 getbufoneline()
有关{buf}的使用,请参见上面的 bufname()
对于 {lnum}{end},可以使用 "$" 来表示缓冲区的最后一行。否则,必须使用数字。
{lnum} 小于 1 或大于缓冲区中的行数时,将返回一个空的 列表
{end} 大于缓冲区中的行数时,它将被视为 {end} 设置为缓冲区中的行数。当 {end}{lnum} 之前时,将返回一个空的 列表
此函数仅适用于已加载的缓冲区。对于未加载和不存在的缓冲区,将返回一个空的 列表
示例
let lines = getbufline(bufnr("myfile"), 1, "$")
参数
{buf} (integer|string)
{lnum} (integer)
{end_} (integer?)
返回值
(任何)
getbufoneline({buf}, {lnum}) getbufoneline()
getbufline() 相同,但仅获取一行并将其作为字符串返回。
参数
{buf} (integer|string)
{lnum} (integer)
返回值
(字符串)
getbufvar({buf}, {varname} [, {def}]) getbufvar()
结果是缓冲区 {buf} 中选项或局部缓冲区变量 {varname} 的值。请注意,必须使用没有 "b:" 的名称。{varname} 参数是字符串。当 {varname} 为空时,返回一个包含所有缓冲区局部变量的 字典。当 {varname} 等于 "&" 时,返回一个包含所有缓冲区局部选项的 字典。否则,当 {varname} 以 "&" 开头时,返回缓冲区局部选项的值。这也适用于全局或缓冲区局部选项,但不适用于全局变量、窗口局部变量或窗口局部选项。有关 {buf} 的用法,请参见上面的 bufname()。当缓冲区或变量不存在时,将返回 {def} 或空字符串,不会出现错误消息。示例
        let bufmodified = getbufvar(1, "&mod")
        echo "todo myvar = " .. getbufvar("todo", "myvar")
Parameters: ~
  • {buf} (`integer|string`)
  • {varname} (`string`)
  • {def} (`any?`)
Return: ~
  (`any`)
getcellwidths() getcellwidths()
返回一个包含由 setcellwidths() 覆盖的字符范围的单元格宽度 列表。格式与 setcellwidths() 的参数相同。如果没有任何字符范围的单元格宽度被覆盖,则返回一个空的列表。
返回值
(任何)
getchangelist([{buf}]) getchangelist()
返回缓冲区 {buf}changelist。有关 {buf} 的用法,请参见上面的 bufname()。如果缓冲区 {buf} 不存在,则返回一个空的列表。
返回的列表包含两个条目:一个包含更改位置的列表和列表中的当前位置。更改列表中的每个条目都是一个包含以下条目的字典:col 列号 coladd 'virtualedit' 的列偏移量 lnum 行号 如果缓冲区 {buf} 是当前缓冲区,则当前位置指的是列表中的位置。对于其他缓冲区,它设置为列表的长度。
参数
{buf} (整数|字符串?)
返回值
(table[])
getchar([{expr}]) getchar()
从用户或输入流中获取单个字符。如果省略 {expr},则等待直到有字符可用。如果 {expr} 为 0,则仅在有字符可用时获取字符。否则,返回 0。如果 {expr} 为 1,则仅检查是否有字符可用,但不会使用它。如果字符不可用,则返回 0。如果您希望始终获取字符串,请使用 getcharstr()
在没有 {expr}{expr} 为 0 时,将返回整个字符或特殊键。如果它是一个单字符,则结果是一个数字。使用 nr2char() 将其转换为字符串。否则,将返回包含编码字符的字符串。对于特殊键,它是一个包含以 0x80(十进制:128)开头的字节序列的字符串。这与字符串 "\<Key>" 相同,例如,"\<Left>"。当使用未包含在字符本身中的修饰符(Shift、Control、Alt)时,返回的值也是字符串。
{expr} 为 0 且按下 Esc 时,Vim 将等待一小段时间以查看这是否是一个转义序列的开始。
{expr} 为 1 时,只返回第一个字节。对于一个字节的字符,它是字符本身作为数字。使用 nr2char() 将其转换为字符串。
使用 getcharmod() 获取任何其他修饰符。
当用户单击鼠标按钮时,将返回鼠标事件。然后可以在 v:mouse_colv:mouse_lnumv:mouse_winidv:mouse_win 中找到位置。getmousepos() 也可以使用。鼠标移动事件将被忽略。以下示例将鼠标定位在通常发生的位置
let c = getchar()
if c == "\<LeftMouse>" && v:mouse_win > 0
  exe v:mouse_win .. "wincmd w"
  exe v:mouse_lnum
  exe "normal " .. v:mouse_col .. "|"
endif
没有提示,您必须以某种方式向用户说明需要输入一个字符。屏幕不会重绘,例如在调整窗口大小时。
没有映射用于字符。键码被替换,因此当用户按下 <Del> 键时,您将获得 <Del> 键的代码,而不是原始字符序列。示例
getchar() == "\<Del>"
getchar() == "\<S-Left>"
此示例将 "f" 重定义为忽略大小写
nmap f :call FindChar()<CR>
function FindChar()
  let c = nr2char(getchar())
  while col('.') < col('$') - 1
    normal l
    if getline('.')[col('.') - 1] ==? c
      break
    endif
  endwhile
endfunction
参数
{expr} (0|1?)
返回值
(integer)
getcharmod() getcharmod()
结果是一个数字,表示使用 getchar() 或其他方式获取的最后一个字符的修饰符状态。这些值将被加在一起:2 shift 4 control 8 alt (meta) 16 meta (当它与 ALT 不同时) 32 鼠标双击 64 鼠标三击 96 鼠标四击 (== 32 + 64) 128 command (Mac) 或 super 只有未包含在字符本身中的修饰符才会被获取。因此,Shift-a 会产生 "A",没有任何修饰符。如果没有使用修饰符,则返回 0。
返回值
(integer)
getcharpos({expr}) getcharpos()
获取字符串 {expr} 的位置。与 getpos() 相同,但返回的列表中的列号是字符索引而不是字节索引。如果 getpos() 返回一个非常大的列号,等于 v:maxcol,则 getcharpos() 将返回最后一个字符的字符索引。
示例:当光标位于第 5 行中的“세”上,文本为“여보세요”时
getcharpos('.')                returns [0, 5, 3, 0]
getpos('.')                returns [0, 5, 7, 0]
参数
{expr} (string)
返回值
(integer[])
getcharsearch() getcharsearch()
{dict} 的形式返回当前字符搜索信息,其中包含以下条目
char 用于字符搜索的先前字符 (tfTF);如果未执行字符搜索,则为空字符串 forward 字符搜索的方向;1 表示向前,0 表示向后 until 用于字符搜索的类型;1 表示 tT 字符搜索,0 表示 fF 字符搜索
这有助于始终使 ;, 向前/向后搜索,而与先前字符搜索的方向无关
nnoremap <expr> ; getcharsearch().forward ? ';' : ','
nnoremap <expr> , getcharsearch().forward ? ',' : ';'
另请参见 setcharsearch()
返回值
(table)
getcharstr([{expr}]) getcharstr()
从用户或输入流中获取单个字符,作为字符串。如果省略 {expr},则等待直到有字符可用。如果 {expr} 为 0 或 false,则仅在有字符可用时获取字符。否则,返回空字符串。如果 {expr} 为 1 或 true,则仅检查是否有字符可用,但不会使用它。如果字符不可用,则返回空字符串。否则,其工作方式类似于 getchar(),只是数字结果将被转换为字符串。
参数
{expr} (0|1?)
返回值
(字符串)
getcmdcomplpat() getcmdcomplpat()
返回当前命令行的补全模式。仅在编辑命令行时有效,因此需要使用 c_CTRL-\_ec_CTRL-R_=。另请参见 getcmdtype()setcmdpos()getcmdline()getcmdprompt()getcmdcompltype()setcmdline()。当补全未定义时,返回空字符串。
返回值
(字符串)
getcmdcompltype() getcmdcompltype()
返回当前命令行补全的类型。仅在编辑命令行时有效,因此需要使用 c_CTRL-\_ec_CTRL-R_=。有关返回字符串的信息,请参见 :command-completion。另请参见 getcmdtype()setcmdpos()getcmdline()getcmdprompt()getcmdcomplpat()setcmdline()。当补全未定义时,返回空字符串。
返回值
(字符串)
getcmdline() getcmdline()
返回当前命令行输入。仅在编辑命令行时有效,因此需要使用 c_CTRL-\_ec_CTRL-R_=。示例
cmap <F7> <C-\>eescape(getcmdline(), ' \')<CR>
另请参见 getcmdtype()getcmdpos()setcmdpos()getcmdprompt()setcmdline()。在输入密码或使用 inputsecret() 时,返回空字符串。
返回值
(字符串)
getcmdpos() getcmdpos()
返回命令行中光标位置的字节数。第一列为 1。仅在编辑命令行时有效,因此需要使用 c_CTRL-\_ec_CTRL-R_= 或表达式映射。否则返回 0。另请参见 getcmdtype()setcmdpos()getcmdline()getcmdprompt()setcmdline()
返回值
(integer)
getcmdprompt() getcmdprompt()
在使用 input()confirm() 等函数时返回当前的命令行提示符。仅在编辑命令行时有效,因此需要使用 c_CTRL-\_ec_CTRL-R_=。另请参见 getcmdtype()getcmdline()getcmdpos()setcmdpos()setcmdline()
返回值
(字符串)
getcmdscreenpos() getcmdscreenpos()
返回命令行中光标的屏幕位置的字节数。第一列为 1。它不是使用 getcmdpos(),而是添加了提示符位置。仅在编辑命令行时有效,因此需要使用 c_CTRL-\_ec_CTRL-R_= 或表达式映射。否则返回 0。另请参见 getcmdpos()setcmdpos()getcmdline()setcmdline()
返回值
(任何)
getcmdtype() getcmdtype()
返回当前的命令行类型。可能的返回值为:: 正常 Ex 命令 > 调试模式命令 debug-mode / 向前搜索命令 ? 向后搜索命令 @ input() 命令 - :insert:append 命令 = i_CTRL-R_= 仅在编辑命令行时有效,因此需要使用 c_CTRL-\_ec_CTRL-R_= 或表达式映射。否则返回空字符串。另请参见 getcmdpos()setcmdpos()getcmdline()
返回值
(':'|'>'|'/'|'?'|'@'|'-'|'=')
getcmdwintype() getcmdwintype()
返回当前 command-line-window 类型。可能的返回值与 getcmdtype() 相同。不在命令行窗口中时返回空字符串。
返回值
(':'|'>'|'/'|'?'|'@'|'-'|'=')
getcompletion({pat}, {type} [, {filtered}]) getcompletion()
返回命令行补全匹配项列表。String {type} 参数指定补全类型。支持以下补全类型
arglist 参数列表中的文件名 augroup autocmd 组 buffer 缓冲区名称 breakpoint :breakadd:breakdel 子选项 cmdline cmdline-completion 结果 color 颜色方案 command Ex 命令 compiler 编译器 compilers 自定义,{func} 自定义补全,通过 {func} 定义 customlist,{func} 自定义补全,通过 {func} 定义 diff_buffer :diffget:diffput 补全 dir 目录名称 dir_in_path 'cdpath' 中的目录名称 environment 环境变量名称 event autocommand 事件 expression Vim 表达式 file 文件和目录名称 file_in_path 'path' 中的文件和目录名称 filetype 文件类型名称 'filetype' function 函数名称 help 帮助主题 highlight 高亮组 history :history 子选项 keymap 键盘映射 locale 本地化名称(作为 locale -a 的输出) mapclear 缓冲区参数映射映射名称 menu 菜单 messages :messages 子选项 option 选项 packadd 可选包 pack-add 名称 runtime :runtime 补全 scriptnames 源代码脚本名称 :scriptnames shellcmd Shell 命令 shellcmdline 带文件名参数的 Shell 命令行 sign :sign 子选项 syntax 语法文件名称 'syntax' syntime :syntime 子选项 tag 标签 tag_listfiles 标签,文件名 user 用户名 var 用户变量
如果 {pat} 为空字符串,则返回所有匹配项。否则,仅返回与 {pat} 匹配的项。有关 {pat} 中特殊字符的使用,请参见 wildcards
如果可选的 {filtered} 标志设置为 1,则将应用 'wildignore' 来过滤结果。否则,将返回所有匹配项。'wildignorecase' 选项始终适用。
如果 'wildoptions' 选项包含 "fuzzy",则使用模糊匹配来获取补全匹配项。否则,将使用正则表达式匹配。因此,此函数遵循用户偏好,这在命令行上会发生。如果您不想要这样,可以在调用 getcompletion() 之前将 'wildoptions' 设置为空,并在之后恢复它。
如果 {type} 为 "cmdline",则返回 cmdline-completion 结果。例如,要补全 ":call" 命令后的可能值
echo getcompletion('call ', 'cmdline')
如果没有匹配项,则返回空列表。{type} 的无效值会导致错误。
参数
{pat} (string)
{type} (string)
{filtered} (boolean?)
返回值
(string[])
getcurpos([{winid}]) getcurpos()
获取光标的位置。这与 getpos('.') 相似,但在列表中包含额外的 "curswant" 项
[0, lnum, col, off, curswant]
"curswant" 数字是垂直移动光标时首选的列。在 $ 命令之后,它将是一个非常大的数字,等于 v:maxcol。另请参见 getcursorcharpos()getpos()。第一个 "bufnum" 项始终为零。光标的字节位置在 "col" 中返回。要获取字符位置,请使用 getcursorcharpos()
可选的 {winid} 参数可以指定窗口。它可以是窗口编号或 window-ID。返回最后已知的光标位置,如果它不是当前窗口,则可能与缓冲区的当前值无效。如果 {winid} 无效,则返回一个包含零的列表。
这可用于保存和恢复光标位置
let save_cursor = getcurpos()
MoveTheCursorAround
call setpos('.', save_cursor)
请注意,这仅在窗口内有效。有关恢复更多状态,请参见 winrestview()
参数
{winid} (integer?)
返回值
(任何)
getcursorcharpos([{winid}]) getcursorcharpos()
getcurpos() 相同,但返回的 List 中的列编号是字符索引,而不是字节索引。
示例:光标位于第 3 行的 "보" 上,文本为 "여보세요"
getcursorcharpos()        " returns [0, 3, 2, 0, 3]
getcurpos()                " returns [0, 3, 4, 0, 3]
参数
{winid} (integer?)
返回值
(任何)
getcwd([{winnr} [, {tabnr}]]) getcwd()
没有参数时,返回有效 current-directory 的名称。使用 {winnr}{tabnr} 时,将返回该范围内的工作目录,并将忽略 'autochdir'。选项卡和窗口由各自的编号标识,0 表示当前选项卡或窗口。缺少选项卡编号意味着 0。因此,以下等效
getcwd(0)
getcwd(0, 0)
如果 {winnr} 为 -1,则将其忽略,仅解析选项卡。{winnr} 可以是窗口编号或 window-ID。如果 {winnr}{tabnr} 均为 -1,则返回全局工作目录。如果参数无效,则抛出错误。 E5000 E5001 E5002
参数
{winnr} (integer?)
{tabnr} (integer?)
返回值
(字符串)
getenv({name}) getenv()
返回环境变量 {name} 的值。{name} 参数是字符串,没有前导 "$"。示例
myHome = getenv('HOME')
当变量不存在时,将返回 v:null。这与设置为空字符串的变量不同。另请参见 expr-env
参数
{name} (字符串)
返回值
(字符串)
getfontname([{name}]) getfontname()
没有参数时,返回正在使用的正常字体的名称。就像用于 Normal 高亮组 hl-Normal 的字体一样。如果有参数,则会检查 String {name} 是否为有效的字体名称。如果不是,则返回空字符串。否则,将返回实际的字体名称,或者如果 GUI 不支持获取实际名称,则返回 {name}。仅在 GUI 运行时有效,因此不在您的 vimrc 或 gvimrc 文件中。使用 GUIEnter autocommand 在 GUI 启动后立即使用此函数。
参数
{name} (string?)
返回值
(字符串)
getfperm({fname}) getfperm()
结果为 String,它是给定文件 {fname} 的读、写和执行权限。如果 {fname} 不存在或其目录不可读,则返回空字符串。结果格式为 "rwxrwxrwx",其中每组 "rwx" 标志分别表示文件所有者、文件所属组和其它用户的权限。如果用户没有给定的权限,则该标志将被替换为字符串 "-"。示例
echo getfperm("/etc/passwd")
echo getfperm(expand("~/.config/nvim/init.vim"))
希望(从安全性的角度来看)这将显示字符串 "rw-r--r--" 甚至 "rw-------"。
有关设置权限,请使用 setfperm()
参数
{fname} (string)
返回值
(字符串)
getfsize({fname}) getfsize()
结果为 Number,它是给定文件 {fname} 的大小(以字节为单位)。如果 {fname} 是目录,则返回 0。如果找不到文件 {fname},则返回 -1。如果 {fname} 的大小太大而无法放入 Number 中,则返回 -2。
参数
{fname} (string)
返回值
(integer)
getftime({fname}) getftime()
结果为 Number,它是给定文件 {fname} 的最后修改时间。该值以 1970 年 1 月 1 日以来的秒数为单位,可以传递给 strftime()。另请参见 localtime()strftime()。如果找不到文件 {fname},则返回 -1。
参数
{fname} (string)
返回值
(integer)
getftype({fname}) getftype()
结果为 String,它是对给定文件 {fname} 的文件类型的描述。如果 {fname} 不存在,则返回空字符串。以下是一个表格,列出了不同类型的文件及其结果:正常文件 "file" 目录 "dir" 符号链接 "link" 块设备 "bdev" 字符设备 "cdev" 套接字 "socket" FIFO "fifo" 所有其他 "other" 示例
getftype("/home")
请注意,诸如 "link" 之类的类型仅在支持它的系统上返回。在某些系统上,仅返回 "dir" 和 "file"。
参数
{fname} (string)
返回值
('file'|'dir'|'link'|'bdev'|'cdev'|'socket'|'fifo'|'other')
getjumplist([{winnr} [, {tabnr}]]) getjumplist()
返回指定窗口的 jumplist
没有参数时,使用当前窗口。使用 {winnr} 时,仅在当前选项卡页中使用此窗口。{winnr} 也可以是 window-ID。使用 {winnr}{tabnr} 时,在指定的选项卡页中使用窗口。如果 {winnr}{tabnr} 无效,则返回空列表。
返回的列表包含两个条目:一个包含跳转位置的列表和列表中最后使用的跳转位置编号。跳转位置列表中的每个条目都是一个字典,包含以下条目:bufnr 缓冲区编号 col 列编号 coladd 'virtualedit' 的列偏移量 filename 如果可用,则为文件名 lnum 行号
参数
{winnr} (integer?)
{tabnr} (integer?)
返回值
(vim.fn.getjumplist.ret)
getline({lnum} [, {end}]) getline()
如果没有 {end},则结果是一个字符串,该字符串是当前缓冲区的第 {lnum} 行。例如
getline(1)
{lnum} 是一个不以数字开头的字符串时,会调用 line() 将字符串转换为数字。要获取光标下的行
getline(".")
{lnum} 是一个小于 1 或大于缓冲区行数的数字时,将返回一个空字符串。
当给出 {end} 时,结果是一个 List,其中每个项目都是当前缓冲区中从 {lnum}{end}(包括第 {end} 行)范围内的行。{end} 的使用方式与 {lnum} 相同。非存在的行将被静默地省略。当 {end}{lnum} 之前时,将返回一个空 List。例如
let start = line('.')
let end = search("^$") - 1
let lines = getline(start, end)
要获取其他缓冲区的行,请参见 getbufline()getbufoneline()
参数
{lnum} (integer|string)
{end_} (nil|false?)
返回值
(字符串)
getloclist({nr} [, {what}]) getloclist()
返回一个包含窗口 {nr} 位置列表中所有条目的 List{nr} 可以是窗口编号或 window-ID。当 {nr} 为零时,将使用当前窗口。
对于位置列表窗口,将返回显示的位置列表。对于无效的窗口编号 {nr},将返回一个空列表。否则,与 getqflist() 相同。
如果提供可选的 {what} 字典参数,则返回 {what} 中列出的项目,作为字典。有关 {what} 中支持的项目,请参阅 getqflist()
除了 getqflist(){what} 中支持的项目外,getloclist() 还支持以下项目
filewinid 用于显示位置列表中文件的窗口的 ID。此字段仅在从位置列表窗口调用时适用。有关更多详细信息,请参见 location-list-file-window
如果窗口 {nr} 没有位置列表,则返回一个具有默认值的 Dictionary。如果窗口 {nr} 不存在,则返回一个空字典。
示例(另请参见 getqflist-examples
echo getloclist(3, {'all': 0})
echo getloclist(5, {'filewinid': 0})
参数
{nr} (整数)
{what} (table?)
返回值
(任何)
getmarklist([{buf}]) getmarklist()
如果没有 {buf} 参数,则返回一个包含所有全局标记信息的 Listmark
如果指定了可选的 {buf} 参数,则返回在缓冲区 {buf} 中定义的局部标记。有关 {buf} 的使用,请参见 bufname()。如果 {buf} 无效,则返回一个空列表。
返回的 List 中的每个项目都是一个 Dict,包含以下内容:mark 标记名称,以 "'" 为前缀 pos 一个包含标记位置的 List:[bufnum, lnum, col, off] 有关更多信息,请参阅 getpos()。file 文件名
有关获取特定标记信息的详细信息,请参阅 getpos()
参数
{buf} (integer??)
返回值
(vim.fn.getmarklist.ret.item[])
getmatches([{win}]) getmatches()
返回一个包含之前使用 matchadd():match 命令为当前窗口定义的所有匹配项的 Listgetmatches() 可与 setmatches() 结合使用,因为 setmatches() 可以恢复使用 getmatches() 保存的匹配项列表。如果指定了 {win},则使用具有此编号或窗口 ID 的窗口,而不是当前窗口。如果 {win} 无效,则返回一个空列表。例如
echo getmatches()
[{"group": "MyGroup1", "pattern": "TODO",
"priority": 10, "id": 1}, {"group": "MyGroup2",
"pattern": "FIXME", "priority": 10, "id": 2}]
let m = getmatches()
call clearmatches()
echo getmatches()
[]
call setmatches(m)
echo getmatches()
[{"group": "MyGroup1", "pattern": "TODO",
"priority": 10, "id": 1}, {"group": "MyGroup2",
"pattern": "FIXME", "priority": 10, "id": 2}]
unlet m
参数
{win} (整数?)
返回值
(任何)
getmousepos() getmousepos()
返回一个包含鼠标最后已知位置的 Dictionary。这可以在映射中用于鼠标点击。项目包括:screenrow 屏幕行 screencol 屏幕列 winid 点击的窗口 ID winrow "winid" 内的行 wincol "winid" 内的列 line "winid" 内的文本行 column "winid" 内的文本列 coladd 从点击字符的开头(以屏幕列为单位)的偏移量 所有数字都是从 1 开始的。
如果不在窗口上,例如在命令行中,则只有 "screenrow" 和 "screencol" 有效,其他都为零。
当在窗口下方的状态行或窗口右侧的垂直分隔符上时,"line" 和 "column" 值为零。
当位置在文本之后时,"column" 为文本的字节长度加一。
如果鼠标在可聚焦的浮动窗口上,则将使用该窗口。
使用 getchar() 时,Vim 变量 v:mouse_lnumv:mouse_colv:mouse_winid 也会提供这些值。
返回值
(vim.fn.getmousepos.ret)
getpid() getpid()
返回一个数字,表示 Vim 进程的进程 ID。这是一个唯一的数字,直到 Vim 退出。
返回值
(integer)
getpos({expr}) getpos()
获取字符串 {expr} 的位置。{expr} 接受的值为:. 光标位置。$ 当前缓冲区的最后一行。'x 标记 x 的位置(如果未设置标记,则所有值都返回 0)。w0 当前窗口中可见的第一行(如果显示未更新,例如在静默 Ex 模式下,则为 1)。w$ 当前窗口中可见的最后一行(如果不可见任何行,则比 "w0" 小 1)。v 如果不在 Visual 模式,则返回光标位置。在 Visual 模式中,返回 Visual 区域的另一端。一种比较好的理解方式是在 Visual 模式中,"v" 和 "." 互补。虽然 "." 指的是光标位置,但 "v" 指的是 v_o 将移动光标的位置。因此,可以使用 "v" 和 "." 共同处理字符级 Visual 模式中的所有选择。如果光标位于字符级 Visual 区域的末尾,则 "v" 指的是同一 Visual 区域的开头。如果光标位于字符级 Visual 区域的开头,则 "v" 指的是同一 Visual 区域的末尾。"v" 与 '<'> 不同,因为它会立即更新。注意,可以使用另一个文件中的标记。然后,行号将应用于另一个缓冲区。
结果是一个包含四个数字的 List:[bufnum, lnum, col, off] "bufnum" 为零,除非使用像 '0 或 'A 这样的标记,在这种情况下,它将是标记的缓冲区编号。"lnum" 和 "col" 是缓冲区中的位置。第一列为 1。"off" 数字为零,除非使用 'virtualedit'。在这种情况下,它将是屏幕列中从字符开头起的偏移量。例如,<Tab> 内的位置或最后一个字符之后的位置。
有关获取光标位置的信息,请参见 getcurpos()。返回的 List 中的列号是行内的字节位置。要获取行内的字符位置,请使用 getcharpos()
注意,对于 '< 和 '>,Visual 模式很重要:当它是 "V"(可视行模式)时,'< 的列为零,'> 的列是一个很大的数字,等于 v:maxcol。可能返回一个很大的列号,等于 v:maxcol,在这种情况下,它表示“行尾之后”。如果 {expr} 无效,则返回一个包含全零的列表。
这可用于保存和恢复标记的位置
let save_a_mark = getpos("'a")
" ...
call setpos("'a", save_a_mark)
另请参见 getcharpos()getcurpos()setpos()
参数
{expr} (string)
返回值
(integer[])
getqflist([{what}]) getqflist()
返回一个包含所有当前快速修复错误的 List。每个列表项目都是一个字典,包含以下条目:bufnr 包含文件名的缓冲区的编号,使用 bufname() 获取名称 module 模块名称 lnum 缓冲区中的行号(第一行为 1)end_lnum 如果项目是多行,则为行号的结尾 col 列号(第一列为 1)end_col 如果项目具有范围,则为列号的结尾 vcol TRUE:"col" 是可视列 FALSE:"col" 是字节索引 nr 错误编号 pattern 用于查找错误的搜索模式 text 错误的描述 type 错误的类型,'E'、'1' 等 valid TRUE:已识别的错误消息 user_data 与项目关联的自定义数据,可以是任何类型。
如果没有错误列表或列表为空,则返回一个空列表。具有不存在的缓冲区编号的快速修复列表条目将返回 "bufnr" 设置为零(注意:一些函数接受缓冲区编号零以用于备用缓冲区,您可能需要显式检查零)。
实用程序:在多个文件中查找模式匹配,并对其执行某些操作
vimgrep /theword/jg *.c
for d in getqflist()
   echo bufname(d.bufnr) ':' d.lnum '=' d.text
endfor
如果提供可选的 {what} 字典参数,则仅返回 {what} 中列出的项目,作为字典。{what} 中支持以下字符串项目:changedtick 获取对列表进行的所有更改的总次数 quickfix-changedtick context 获取 quickfix-context efm 用于解析 "lines" 的 errorformat。如果不存在,则使用 'errorformat' 选项值。id 获取具有 quickfix-ID 的快速修复列表的信息;零表示当前列表或 "nr" 指定的列表的 ID idx 获取快速修复列表中此索引的快速修复条目的信息,该列表由 "id" 或 "nr" 指定。如果设置为零,则使用当前条目。请参见 quickfix-index items 快速修复列表条目 lines 使用 'efm' 解析行列表,并返回生成的条目。仅接受 List 类型。不会修改当前快速修复列表。请参见 quickfix-parse。nr 获取此快速修复列表的信息;零表示当前快速修复列表,"$" 表示最后一个快速修复列表 qfbufnr 快速修复窗口中显示的缓冲区的编号。如果快速修复缓冲区不存在,则返回 0。请参见 quickfix-buffer。size 快速修复列表中的条目数 title 获取列表标题 quickfix-title winid 获取快速修复 window-ID all 以上所有快速修复属性 {what} 中的非字符串项目将被忽略。要获取特定项目的 value,请将其设置为零。如果 "nr" 不存在,则使用当前快速修复列表。如果同时指定了 "nr" 和非零 "id",则使用 "id" 指定的列表。要在快速修复堆栈中获取列表数量,请在 {what} 中将 "nr" 设置为 "$"。返回的字典中的 "nr" 值包含快速修复堆栈大小。当指定 "lines" 时,将忽略所有其他项目("efm" 除外)。返回的字典包含 "items" 条目,其中包含条目列表。
返回的字典包含以下条目: changedtick 对列表所做的更改总数 quickfix-changedtick context quickfix 列表上下文。参见 quickfix-context 如果不存在,则设置为 ""。 id quickfix 列表 ID quickfix-ID。如果不存在,则设置为 0。 idx quickfix 列表中 quickfix 条目的索引。如果不存在,则设置为 0。 items quickfix 列表条目。如果不存在,则设置为一个空列表。 nr quickfix 列表编号。如果不存在,则设置为 0。 qfbufnr quickfix 窗口中显示的缓冲区编号。如果不存在,则设置为 0。 size quickfix 列表中的条目数。如果不存在,则设置为 0。 title quickfix 列表标题文本。如果不存在,则设置为 ""。 winid quickfix 窗口 ID。如果不存在,则设置为 0
示例(另请参见 getqflist-examples
echo getqflist({'all': 1})
echo getqflist({'nr': 2, 'title': 1})
echo getqflist({'lines' : ["F1:10:L10"]})
参数
{what} (table?)
返回值
(任何)
getreg([{regname} [, 1 [, {list}]]]) getreg()
结果是一个字符串,它就是寄存器 {regname} 的内容。示例
let cliptext = getreg('*')
当寄存器 {regname} 未设置时,结果为空字符串。{regname} 参数必须是一个字符串。
getreg('=') 返回表达式的最后一个评估值寄存器。 (用于映射。) getreg('=', 1) 返回表达式本身,以便可以使用 setreg() 恢复。对于其他寄存器,额外的参数被忽略,因此你可以始终提供它。
如果 {list} 存在并且为 TRUE,则结果类型将更改为 List。每个列表项都是一行文本。如果你关心寄存器中可能存在的零字节,请使用它:如果没有第三个参数,则 NL 和零字节都被表示为 NL (参见 NL-used-for-Nul)。当寄存器未设置时,将返回一个空列表。
如果未指定 {regname},则使用 v:register
参数
{regname} (string?)
{list} (nil|false?)
返回值
(字符串)
getreginfo([{regname}]) getreginfo()
以字典的形式返回有关寄存器 {regname} 的详细信息,其中包含以下条目: regcontents 寄存器 {regname} 中包含的行列表,与 getreg({regname}, 1, 1) 相同。 regtype 寄存器 {regname} 的类型,如 getregtype() 中所述。 isunnamed 布尔标志,如果当前寄存器由未命名寄存器指向,则为 v:true。 points_to 对于未命名寄存器,给出当前指向的寄存器的单字母名称 (参见 quotequote)。例如,在使用 dd 删除一行后,此字段将为 "1",即获取已删除文本的寄存器。
{regname} 参数是一个字符串。如果 {regname} 无效或未设置,则将返回一个空字典。如果未指定 {regname},则使用 v:register。返回的字典可以传递给 setreg()
参数
{regname} (string?)
返回值
(table)
getregion({pos1}, {pos2} [, {opts}]) getregion()
返回缓冲区中从 {pos1}{pos2} 的字符串列表。
{pos1}{pos2} 都必须是包含四个数字的 List。有关列表格式,请参见 getpos()。可以指定来自不同缓冲区的位置,但请注意 getregion-notes 中的限制。
可选参数 {opts} 是一个 Dict,并支持以下项目
type 指定区域的选择类型。有关可能的取值,请参见 getregtype(),但可以省略宽度,并且不能使用空字符串。 (默认值:"v")
exclusive 如果为 TRUE,则对结束位置使用排他性选择。 (默认值:遵循 'selection')
你可以通过 visualmode() 获取最后的选择类型。如果 Visual 模式处于活动状态,请使用 mode() 获取 Visual 模式 (例如,在 :vmap 中)。此函数对于获取在不同列中开始和结束的文本很有用,例如 charwise-visual 选择。
getregion-notes
注意
{pos1}{pos2} 的顺序无关紧要,它始终会返回从左上角位置到右下角位置的内容。
如果启用了 'virtualedit' 并且区域超出了行的结尾,则生成的线将用空格填充。
如果区域是块状的,并且它在多单元格字符的中间开始或结束,则它不会被包含,但其选定部分将被空格替换。
如果 {pos1}{pos2} 不在同一个缓冲区中,则将返回一个空列表。
{pos1}{pos2} 必须属于一个 bufloaded() 缓冲区。
它在当前窗口上下文中进行评估,如果缓冲区在具有不同 'virtualedit''list' 值的窗口中显示,则会产生影响。
示例
xnoremap <CR>
\ <Cmd>echom getregion(
\ getpos('v'), getpos('.'), #{ type: mode() })<CR>
参数
{pos1} (table)
{pos2} (table)
{opts} (table?)
返回值
(string[])
getregionpos({pos1}, {pos2} [, {opts}]) getregionpos()
getregion() 相同,但返回一个位置列表,描述由 {pos1}{pos2} 绑定的缓冲区文本段。每个段都是每行的两个位置对
[[{start_pos}, {end_pos}], ...]
位置是一个包含四个数字的 List:[bufnum, lnum, col, off] "bufnum" 是缓冲区编号。 "lnum" 和 "col" 是缓冲区中的位置。第一列为 1。如果起始位置的 "off" 编号非零,则它是从字符开始处的屏幕列偏移量。例如,在 <Tab> 内或最后一个字符之后的位置。如果结束位置的 "off" 编号非零,则它是字符的第一个单元格的偏移量,该单元格未包含在选择中,否则其所有单元格都包含在选择中。
除了 getregion() 支持的选项外,{opts} 还支持以下选项
eol 如果为 TRUE,则使用 "col" 值大于行长度的值来指示超出行结尾的位置。如果为 FALSE,则位置限制在行内,如果行为空或选择完全超出行的结尾,则两个位置的 "col" 值都使用 0。 (默认值:FALSE)
参数
{pos1} (table)
{pos2} (table)
{opts} (table?)
返回值
(integer[][][])
getregtype([{regname}]) getregtype()
结果是一个字符串,它就是寄存器 {regname} 的类型。该值将是以下之一:"v" 表示 字符级 文本 "V" 表示 行级 文本 "<CTRL-V>{width}" 表示 块级视觉 文本 "" 表示空寄存器或未知寄存器 <CTRL-V> 是值为 0x16 的一个字符。{regname} 参数是一个字符串。如果未指定 {regname},则使用 v:register
参数
{regname} (string?)
返回值
(字符串)
getscriptinfo([{opts}]) getscriptinfo()
返回一个 List,其中包含有关所有已源代码的 Vim 脚本的信息,按源代码顺序排列,就像 :scriptnames 所显示的那样。
可选的 Dict 参数 {opts} 支持以下可选项目: name 脚本名称匹配模式。如果指定,并且未指定 "sid",则返回有关名称与模式 "name" 匹配的脚本的信息。 sid 脚本 ID <SID>。如果指定,则仅返回有关 ID 为 "sid" 的脚本的信息,并忽略 "name"。
返回的 List 中的每个项目都是一个包含以下项目的 Dict: autoload 始终设置为 FALSE。 functions 在脚本中定义的脚本局部函数名称列表。仅在使用 {opts} 中的 "sid" 项目指定特定脚本时才出现。 name Vim 脚本文件名。 sid 脚本 ID <SID>。 variables 包含脚本局部变量的字典。仅在使用 {opts} 中的 "sid" 项目指定特定脚本时才出现。请注意,这是一个副本,无法使用此字典更改脚本局部变量的值。 version Vim 脚本版本,始终为 1
示例
echo getscriptinfo({'name': 'myscript'})
echo getscriptinfo({'sid': 15})[0].variables
参数
{opts} (table?)
返回值
(vim.fn.getscriptinfo.ret[])
gettabinfo([{tabnr}]) gettabinfo()
如果未指定 {tabnr},则返回有关所有选项卡页面的信息,作为 List。每个 List 项目都是一个 Dictionary。否则,{tabnr} 指定选项卡页面的编号,并返回有关该页面的信息。如果选项卡页面不存在,则返回一个空 List。
每个 List 项目都是一个包含以下条目的 Dictionary: tabnr 选项卡页面的编号。 variables 对包含选项卡页面局部变量的字典的引用。 windows 选项卡页面中的 窗口 ID 列表。
参数
{tabnr} (integer?)
返回值
(任何)
gettabvar({tabnr}, {varname} [, {def}]) gettabvar()
获取选项卡页面 {tabnr} 中的选项卡局部变量 {varname} 的值。 t:var 选项卡的编号从 1 开始。{varname} 参数是一个字符串。当 {varname} 为空时,将返回一个包含所有选项卡局部变量的字典。请注意,必须使用不带 "t:" 的名称。当选项卡或变量不存在时,将返回 {def} 或空字符串,不会出现错误消息。
参数
{tabnr} (integer)
{varname} (string)
{def} (any?)
返回值
(任何)
gettabwinvar({tabnr}, {winnr}, {varname} [, {def}]) gettabwinvar()
获取选项卡页面 {tabnr} 中窗口 {winnr} 的窗口局部变量 {varname} 的值。{varname} 参数是一个字符串。当 {varname} 为空时,将返回一个包含所有窗口局部变量的字典。当 {varname} 等于 "&" 时,以 Dictionary 的形式获取所有窗口局部选项的值。否则,当 {varname} 以 "&" 开头时,获取窗口局部选项的值。请注意,{varname} 必须是不带 "w:" 的名称。选项卡的编号从 1 开始。对于当前选项卡页面,请使用 getwinvar(){winnr} 可以是窗口编号或 窗口 ID。当 {winnr} 为零时,将使用当前窗口。这也适用于全局选项、缓冲区局部选项和窗口局部选项,但不适用于全局变量或缓冲区局部变量。当选项卡、窗口或变量不存在时,将返回 {def} 或空字符串,不会出现错误消息。示例
let list_is_on = gettabwinvar(1, 2, '&list')
echo "myvar = " .. gettabwinvar(3, 1, 'myvar')
要获取所有窗口局部变量,请使用
gettabwinvar({tabnr}, {winnr}, '&')
参数
{tabnr} (integer)
{winnr} (integer)
{varname} (string)
{def} (any?)
返回值
(任何)
gettagstack([{winnr}]) gettagstack()
结果是一个 Dict,它是窗口 {winnr} 的标记栈。{winnr} 可以是窗口编号或 窗口 ID。当未指定 {winnr} 时,将使用当前窗口。当窗口 {winnr} 不存在时,将返回一个空 Dict。
返回的字典包含以下条目: curidx 栈中的当前索引。当位于栈顶时,设置为 (长度 + 1)。栈底的索引为 1。 items 栈中的项目列表。每个项目都是一个包含以下描述的条目的字典。 length 栈中的条目数。
堆栈中的每个项目都是一个字典,包含以下条目:bufnr 标记跳转之前从光标位置开始的当前跳转的缓冲区编号。有关返回列表的格式,请参见 getpos()。matchnr 当前匹配的标记编号。当为一个名称找到多个匹配标记时使用。tagname 标记的名称
有关标记堆栈的更多信息,请参见 tagstack
参数
{winnr} (integer?)
返回值
(任何)
gettext({text}) gettext()
如果可能,翻译字符串 {text}。这主要用于分布式 Vim 脚本。生成消息翻译时,{text} 由 xgettext 提取,翻译人员可以在 .po 文件中添加翻译后的消息,Vim 会在调用 gettext() 时查找翻译。对于 {text},首选双引号字符串,因为 xgettext 不理解单引号字符串中的转义。
参数
{text} (string)
返回值
(任何)
getwininfo([{winid}]) getwininfo()
List 和字典的形式返回有关窗口的信息。
如果给出了 {winid},则返回有关具有该 ID 的窗口的信息,以 List 和一个项目的形式。如果窗口不存在,则结果为空列表。
如果没有 {winid},则返回有关所有选项卡页中的所有窗口的信息。
每个列表项目都是一个 Dictionary,包含以下条目:botline 最后一个完整的显示缓冲区行 bufnr 窗口中缓冲区的编号 height 窗口高度(不包括 winbar) loclist 如果显示位置列表,则为 1 quickfix 如果是 quickfix 或位置列表窗口,则为 1 terminal 如果是终端窗口,则为 1 tabnr 选项卡页编号 topline 第一个显示的缓冲区行 variables 对包含窗口局部变量的字典的引用 width 窗口宽度 winbar 如果窗口有工具栏,则为 1,否则为 0 wincol 窗口的最左侧屏幕列;win_screenpos() 中的 "col" textoff 任何 'foldcolumn''signcolumn' 和文本前方的行号所占用的列数 winid window-ID winnr 窗口编号 winrow 窗口的最顶端屏幕行;win_screenpos() 中的 "row"
参数
{winid} (integer?)
返回值
(vim.fn.getwininfo.ret.item[])
getwinpos([{timeout}]) getwinpos()
结果是一个 List,其中包含两个数字,它们是 getwinposx()getwinposy() 的结果组合: [x-pos, y-pos] {timeout} 可用于指定等待终端响应的时间(以毫秒为单位)。如果省略,则使用 100 毫秒。
对于远程终端,请使用更长的时间。当使用小于 10 的值并且在该时间内没有收到响应时,如果可用,则会返回先前报告的位置。这可用于轮询位置并在同时执行一些工作。
while 1
  let res = getwinpos(1)
  if res[0] >= 0
    break
  endif
  " Do some work here
endwhile
参数
{timeout} (integer?)
返回值
(任何)
getwinposx() getwinposx()
结果是一个数字,它表示 GUI Vim 窗口左侧的 X 坐标(以像素为单位)。如果信息不可用,则结果为 -1。该值可与 :winpos 一起使用。
返回值
(integer)
getwinposy() getwinposy()
结果是一个数字,它表示 GUI Vim 窗口顶部的 Y 坐标(以像素为单位)。如果信息不可用,则结果为 -1。该值可与 :winpos 一起使用。
返回值
(integer)
getwinvar({winnr}, {varname} [, {def}]) getwinvar()
类似于当前选项卡页的 gettabwinvar()。示例
        let list_is_on = getwinvar(2, '&list')
        echo "myvar = " .. getwinvar(1, 'myvar')
Parameters: ~
  • {winnr} (`integer`)
  • {varname} (`string`)
  • {def} (`any?`)
Return: ~
  (`any`)
glob({expr} [, {nosuf} [, {list} [, {alllinks}]]]) glob()
展开 {expr} 中的文件通配符。有关特殊字符的使用,请参见 通配符
除非给出可选的 {nosuf} 参数并且它为 TRUE,否则 'suffixes''wildignore' 选项适用:与 'wildignore' 中的某个模式匹配的名称将被跳过,而 'suffixes' 会影响匹配项的排序。 'wildignorecase' 始终适用。
{list} 存在并且它为 TRUE 时,结果是一个 List,其中包含所有匹配的文件。使用列表的优点是,您还可以正确地获取包含换行符的文件名。否则,结果是一个字符串,当有多个匹配项时,它们由 <NL> 字符分隔。
如果扩展失败,则结果为空字符串或列表。
如果需要执行复杂的操作,例如限制匹配项的数量,还可以使用 readdir()
不包含不存在文件的文件名。符号链接仅在指向现有文件时才包含。但是,当 {alllinks} 参数存在并且它为 TRUE 时,将包含所有符号链接。
对于大多数系统,可以使用反引号从任何外部命令获取文件名称。示例
let tagfiles = glob("`find . -name tags -print`")
let &tags = substitute(tagfiles, "\n", ",", "g")
反引号内的程序结果应为每行一个项目。项目内部允许空格。
有关扩展特殊 Vim 变量,请参见 expand()。有关获取外部命令的原始输出,请参见 system()
参数
{expr} (string)
{nosuf} (boolean?)
{list} (boolean?)
{alllinks} (boolean?)
返回值
(任何)
glob2regpat({string}) glob2regpat()
将 glob() 使用的文件模式转换为搜索模式。结果可用于与作为文件名的字符串匹配。例如
if filename =~ glob2regpat('Make*.mak')
  " ...
endif
这等效于
if filename =~ '^Make.*\.mak$'
  " ...
endif
{string} 为空字符串时,结果为 "^$",匹配空字符串。请注意,结果取决于系统。在 MS-Windows 上,反斜杠通常表示路径分隔符。
参数
{string} (字符串)
返回值
(任何)
globpath({path}, {expr} [, {nosuf} [, {list} [, {allinks}]]]) globpath(){path} 中的所有目录执行 glob() 并连接结果。示例
echo globpath(&rtp, "syntax/c.vim")
{path} 是一个用逗号分隔的目录名称列表。每个目录名称都将附加到 {expr} 并像 glob() 一样进行扩展。必要时会插入路径分隔符。要在目录名称内部添加逗号,请使用反斜杠进行转义。请注意,在 MS-Windows 上,目录可能包含尾随的反斜杠,如果在目录名称后面放置逗号,请将其删除。如果对某个目录的扩展失败,则不会显示错误消息。
除非给出可选的 {nosuf} 参数并且它为 TRUE,否则 'suffixes''wildignore' 选项适用:与 'wildignore' 中的某个模式匹配的名称将被跳过,而 'suffixes' 会影响匹配项的排序。
{list} 存在并且它为 TRUE 时,结果是一个 List,其中包含所有匹配的文件。使用列表的优点是,您还可以正确地获取包含换行符的文件名。否则,结果是一个字符串,当有多个匹配项时,它们由 <NL> 字符分隔。示例
echo globpath(&rtp, "syntax/c.vim", 0, 1)
{allinks} 的使用方式与 glob() 相同。
"**" 项目可用于在目录树中搜索。例如,要查找 'runtimepath' 中的目录及其以下所有 "README.txt" 文件,请执行以下操作
echo globpath(&rtp, "**/README.txt")
不支持向上搜索和限制 "**" 的深度,因此使用 'path' 并不总是能正常工作。
参数
{path} (string)
{expr} (string)
{nosuf} (boolean?)
{list} (boolean?)
{allinks} (boolean?)
返回值
(任何)
has({feature}) has()
如果支持 {feature},则返回 1,否则返回 0。{feature} 参数是一个特性名称,例如 "nvim-0.2.1" 或 "win32",见下文。另请参见 exists()
要获取系统名称,请在 Lua 中使用 vim.uv.os_uname()
print(vim.uv.os_uname().sysname)
如果代码有语法错误,则 Vimscript 可能会跳过该行的其余部分。将 :if:endif 放置在单独的行上,以避免语法错误
if has('feature')
  let x = this_breaks_without_the_feature()
endif
Vim 的编译时特性名称(以 "+" 为前缀)不被识别,因为 Nvim 始终使用所有可能的特性进行编译。 feature-compile
特性名称可以是:1. Nvim 版本。例如,"nvim-0.2.1" 特性表示 Nvim 的版本为 0.2.1 或更高
if has("nvim-0.2.1")
  " ...
endif
2. 运行时条件或其他伪特性。例如,"win32" 特性检查当前系统是否为 Windows
if has("win32")
  " ...
endif
feature-list
支持的伪特性名称列表:acl ACL 支持。bsd BSD 系统(不是 macOS,请使用 "mac" 代替)。clipboard 剪贴板 提供程序可用。fname_case 文件名中的大小写区分(对于 Darwin 和 MS-Windows,此特性不存在)。gui_running Nvim 具有 GUI。iconv 可使用 iconv() 进行转换。linux Linux 系统。mac MacOS 系统。nvim 这是 Nvim。python3 遗留 Vim python3 接口。 has-python pythonx 遗留 Vim python_x 接口。 has-pythonx sun SunOS 系统。ttyin 输入是终端 (tty)。ttyout 输出是终端 (tty)。unix Unix 系统。 vim_starting启动 期间为 True。win32 Windows 系统(32 位或 64 位)。win64 Windows 系统(64 位)。wsl WSL(Windows Subsystem for Linux)系统。
has-patch
3. Vim 修补程序。例如,"patch123" 特性表示当前 v:version 中包含了 Vim 修补程序 123
if v:version > 602 || v:version == 602 && has("patch148")
  " ...
endif
4. Vim 版本。例如,"patch-7.4.237" 特性表示 Nvim 与版本 7.4.237 或更高版本的 Vim 兼容。
if has("patch-7.4.237")
  " ...
endif
参数
{feature} (string)
返回值
(0|1)
has_key({dict}, {key}) has_key()
结果是一个数字,如果 Dictionary {dict} 具有键为 {key} 的条目,则该数字为 TRUE。否则为 FALSE。{key} 参数是一个字符串。
参数
{dict} (table)
{key} (string)
返回值
(0|1)
haslocaldir([{winnr} [, {tabnr}]]) haslocaldir()
结果是一个数字,当窗口通过 :lcd 设置了本地路径或当 {winnr} 为 -1 且选项卡页通过 :tcd 设置了本地路径时,该数字为 1,否则为 0。
选项卡和窗口由它们各自的编号标识,0 表示当前选项卡或窗口。缺失的参数表示 0。因此,以下等效
echo haslocaldir()
echo haslocaldir(0)
echo haslocaldir(0, 0)
使用 {winnr} 在当前选项卡页中使用该窗口。使用 {winnr}{tabnr} 在该选项卡页中使用该窗口。{winnr} 可以是窗口编号或 window-ID。如果 {winnr} 为 -1,则会忽略它,仅解析选项卡。如果参数无效,则抛出错误。 E5000 E5001 E5002
参数
{winnr} (integer?)
{tabnr} (integer?)
返回值
(0|1)
hasmapto({what} [, {mode} [, {abbr}]]) hasmapto()
结果是一个数字,如果存在一个映射,其右侧(映射到的内容)包含 {what},并且此映射存在于 {mode} 指示的模式之一中,则结果为 TRUE。参数 {what}{mode} 为字符串。当 {abbr} 存在且为 TRUE 时,使用缩写而不是映射。不要忘记指定插入模式和/或命令行模式。全局映射和当前缓冲区局部映射都会检查匹配项。如果没有找到匹配映射,则返回 FALSE。{mode} 中识别以下字符:n 正常模式 v 可视模式和选择模式 x 可视模式 s 选择模式 o 运算符待定模式 i 插入模式 l 语言参数(“r”,“f”,“t” 等)c 命令行模式 当 {mode} 被省略时,使用“nvo”。
此函数用于检查映射是否已存在于 Vim 脚本中的函数。示例
if !hasmapto('\ABCdoit')
   map <Leader>d \ABCdoit
endif
仅当不存在映射到“\ABCdoit”的映射时,才安装此映射。
参数
{what} (any)
{mode} (string?)
{abbr} (boolean?)
返回值
(0|1)
histadd({history}, {item}) histadd()
将字符串 {item} 添加到历史记录 {history} 中,它可以是以下之一:hist-names
"cmd" 或 ":" 命令行历史记录 "search" 或 "/" 搜索模式历史记录 "expr" 或 "=" 输入表达式历史记录 "input" 或 "@" 输入行历史记录 "debug" 或 ">" 调试命令历史记录 空表示当前或最后使用的历史记录 {history} 字符串不需要是整个名称,一个字符就足够了。如果 {item} 已经存在于历史记录中,它将被移到最新条目。结果是一个数字:如果操作成功,则为 TRUE,否则返回 FALSE。
示例
call histadd("input", strftime("%Y %b %d"))
let date=input("Enter date: ")
此函数在 沙盒 中不可用。
参数
{history} (string)
{item} (any)
返回值
(0|1)
histdel({history} [, {item}]) histdel()
清除 {history},即删除其所有条目。有关 {history} 的可能值,请参见 hist-names
如果参数 {item} 的值为字符串,则将其用作正则表达式。所有匹配该表达式的条目将从历史记录中删除(如果有)。除非使用“\c”,否则大小写必须匹配 /\c。如果 {item} 的值为数字,则将其解释为索引,请参见 :history-indexing。如果该条目存在,则将其删除。
对于成功操作,结果为 TRUE,否则返回 FALSE。
示例:清除表达式寄存器历史记录
call histdel("expr")
从搜索历史记录中删除所有以“*”开头的条目
call histdel("/", '^\*')
以下三个是等价的
call histdel("search", histnr("search"))
call histdel("search", -1)
call histdel("search", '^' .. histget("search", -1) .. '$')
要删除最后一个搜索模式并使用倒数第二个模式作为“n”命令和 'hlsearch' 的模式
call histdel("search", -1)
let @/ = histget("search", -1)
参数
{history} (string)
{item} (any?)
返回值
(0|1)
histget({history} [, {index}]) histget()
结果是一个字符串,即来自 {history} 的编号为 {index} 的条目。有关 {history} 的可能值,请参见 hist-names,有关 {index},请参见 :history-indexing。如果不存在此条目,则返回一个空字符串。当 {index} 被省略时,将使用历史记录中的最新条目。
示例:从历史记录中重新执行倒数第二个搜索。
execute '/' .. histget("search", -2)
定义一个 Ex 命令“:H {num}”,它支持重新执行来自 :history 输出的第 {num} 个条目。
command -nargs=1 H execute histget("cmd", 0+<args>)
参数
{history} (string)
{index} (integer|string?)
返回值
(字符串)
histnr({history}) histnr()
结果是 {history} 中当前条目的编号。有关 {history} 的可能值,请参见 hist-names。如果发生错误,则返回 -1。
示例
let inp_index = histnr("expr")
参数
{history} (string)
返回值
(integer)
hlID({name}) hlID()
结果是一个数字,即名为 {name} 的高亮组的 ID。如果高亮组不存在,则返回零。这可用于检索有关高亮组的信息。例如,要获取“Comment”组的背景颜色
echo synIDattr(synIDtrans(hlID("Comment")), "bg")
参数
{name} (字符串)
返回值
(integer)
hlexists({name}) hlexists()
结果是一个数字,如果名为 {name} 的高亮组存在,则为 TRUE。如果该组以某种方式定义过,则说明存在。不一定是为其定义了高亮,也可以是为语法项使用过。
参数
{name} (字符串)
返回值
(0|1)
hostname() hostname()
结果是一个字符串,即当前运行 Vim 的机器的名称。长度超过 256 个字符的机器名称将被截断。
返回值
(字符串)
iconv({string}, {from}, {to}) iconv()
结果是一个字符串,即以编码 {from} 到编码 {to} 转换后的文本 {string}。如果转换完全失败,则返回空字符串。如果某些字符无法转换,则用“?”替换。编码名称是 iconv() 库函数可以接受的任何名称,请参见“:!man 3 iconv”。请注意,Vim 对所有 Unicode 编码使用 UTF-8,从/到 UCS-2 的转换会自动更改为使用 UTF-8。由于 NUL 字节的原因,您无法在字符串中使用 UCS-2。
参数
{string} (字符串)
{from} (string)
{to} (string)
返回值
(任何)
id({expr}) id()
返回一个 字符串,它是容器类型(列表字典Blob部分)的唯一标识符。对于提到的类型,保证 id(v1) ==# id(v2) 返回 true,当且仅当 type(v1) == type(v2) && v1 is v2 时。请注意,v:_null_stringv:_null_listv:_null_dictv:_null_blob 具有相同的 id(),但类型不同,因为它们在内部表示为 NULL 指针。id() 返回容器指针的十六进制表示形式(例如,像 0x994a40),与 asprintf("%p", {expr}) 相同,但建议不要依赖返回值的具体格式。
不保证 id(no_longer_existing_container) 不会等于其他 id():新容器可能会重用已垃圾回收的容器的标识符。
参数
{expr} (any)
返回值
(任何)
indent({lnum}) indent()
结果是一个数字,即当前缓冲区中第 {lnum} 行的缩进。缩进以空格计算,'tabstop' 的值相关。{lnum} 的用法与 getline() 中相同。当 {lnum} 无效时,返回 -1。
参数
{lnum} (integer|string)
返回值
(integer)
index({object}, {expr} [, {start} [, {ic}]]) index()
{object} 中查找 {expr} 并返回其索引。有关使用 lambda 选择项目的说明,请参见 indexof()
如果 {object} 是一个 列表,则返回项目值等于 {expr} 的最低索引。没有自动转换,因此字符串“4”与数字 4 不同。数字 4 与浮点数 4.0 也不同。'ignorecase' 的值在此处不用,大小写与 {ic} 参数指示的一致。
如果 {object} 是一个 Blob,则返回字节值等于 {expr} 的最低索引。
如果提供了 {start},则从索引为 {start} 的项目开始查找(对于相对于结尾的项目,可能为负数)。
如果提供了 {ic} 且其值为 TRUE,则忽略大小写。否则,大小写必须一致。
{expr} 未在 {object} 中找到时,返回 -1。示例
let idx = index(words, "the")
if index(numbers, 123) >= 0
  " ...
endif
参数
{object} (any)
{expr} (any)
{start} (integer?)
{ic} (boolean?)
返回值
(任何)
indexof({object}, {expr} [, {opts}]) indexof()
返回 {object}{expr} 为 v:true 的项目的索引。{object} 必须是 列表Blob
如果 {object} 是一个 列表,则对列表中的每个项目评估 {expr},直到表达式为 v:true,然后返回该项目的索引。
如果 {object} 是一个 Blob,则对 Blob 中的每个字节评估 {expr},直到表达式为 v:true,然后返回该字节的索引。
{expr} 必须是 字符串函数引用
如果 {expr} 是一个 字符串:如果 {object} 是一个 列表,则在 {expr} 内,v:key 具有当前列表项目的索引,而 v:val 具有该项目的 value。如果 {object} 是一个 Blob,则在 {expr} 内,v:key 具有当前字节的索引,而 v:val 具有该字节的值。
如果 {expr} 是一个 函数引用,则它必须接受两个参数:1. 当前项目的键或索引。2. 当前项目的值。如果找到该项目并且应该停止搜索,则该函数必须返回 TRUE
可选参数 {opts} 是一个字典,支持以下项:startidx 从具有此索引的项目开始评估 {expr};对于相对于结尾的项目,可能为负数 当 {expr} 对所有项目都评估为 v:false 时,返回 -1。示例
let l = [#{n: 10}, #{n: 20}, #{n: 30}]
echo indexof(l, "v:val.n == 20")
echo indexof(l, {i, v -> v.n == 30})
echo indexof(l, "v:val.n == 20", #{startidx: 1})
参数
{object} (any)
{expr} (any)
{opts} (table?)
返回值
(任何)
input({prompt} [, {text} [, {completion}]]) input()
参数
{prompt} (string)
{text} (string?)
{completion} (string?)
返回值
(任何)
input({opts}) 结果是一个字符串,即用户在命令行上键入的任何内容。{prompt} 参数可以是提示字符串,也可以是空字符串(无提示)。提示符中可以使用“\n”来开始新行。
在第二种形式中,它接受一个包含以下键的单个字典,其中任何键都可以省略
键 默认值 描述
prompt "" 与第一种形式中的 {prompt} 相同。 default "" 与第一种形式中的 {text} 相同。 completion nothing 与第一种形式中的 {completion} 相同。 cancelreturn "" 取消对话框时返回的值。 highlight nothing 高亮处理程序:函数引用
使用 :echohl 设置的高亮用于提示。输入就像命令行一样输入,使用相同的编辑命令和映射。输入() 键入的行有单独的历史记录。示例
if input("Coffee or beer? ") == "beer"
  echo "Cheers!"
endif
如果存在可选的 {text} 参数且不为空,则将其用作默认回复,就像用户键入了该内容一样。示例
let color = input("Color? ", "white")
可选的 {completion} 参数指定对输入支持的完成类型。如果没有它,则不会执行完成。支持的完成类型与可以使用“ -complete=”参数提供给用户定义命令的类型相同。有关更多信息,请参见 :command-completion。示例
let fname = input("File: ", "", "file")
input()-highlight E5400 E5402 可选的 highlight 键允许指定用于突出显示用户输入的函数。此函数以用户输入作为其唯一参数,并且必须返回一个 3 元组列表 [hl_start_col, hl_end_col + 1, hl_group],其中 hl_start_col 是第一个突出显示的列,hl_end_col 是最后一个突出显示的列 (+ 1!),hl_group 是 :hi 用于突出显示的组。 E5403 E5404 E5405 E5406 hl_start_col 和 hl_end_col + 1 必须指向多字节字符的开头(突出显示不得破坏多字节字符),hl_end_col + 1 可以等于输入长度。起始列必须在 [0, len(input)) 范围内,结束列必须在 (hl_start_col, len(input)) 范围内,部分必须按顺序排列,以便下一个 hl_start_col 大于或等于前一个 hl_end_col。
示例(尝试带括号的一些输入)
highlight RBP1 guibg=Red ctermbg=red
highlight RBP2 guibg=Yellow ctermbg=yellow
highlight RBP3 guibg=Green ctermbg=green
highlight RBP4 guibg=Blue ctermbg=blue
let g:rainbow_levels = 4
function! RainbowParens(cmdline)
  let ret = []
  let i = 0
  let lvl = 0
  while i < len(a:cmdline)
    if a:cmdline[i] is# '('
      call add(ret, [i, i + 1, 'RBP' .. ((lvl % g:rainbow_levels) + 1)])
      let lvl += 1
    elseif a:cmdline[i] is# ')'
      let lvl -= 1
      call add(ret, [i, i + 1, 'RBP' .. ((lvl % g:rainbow_levels) + 1)])
    endif
    let i += 1
  endwhile
  return ret
endfunction
call input({'prompt':'>','highlight':'RainbowParens'})
每次显示新输入字符串时,至少调用一次突出显示函数,在重绘命令行之前。预期函数在一次 input() 调用期间是纯函数,即它对相同输入产生相同的输出,因此输出可以被记忆。函数在 :silent 修饰符下运行。如果函数导致任何错误,它将在当前 input() 调用期间被跳过。
如果命令行包含阿拉伯字符,则突出显示将被禁用。
注意: 此函数不得在启动文件中使用,用于仅在 GUI 模式下运行的版本(例如,Win32 GUI)。 注意: 当从映射中调用 input() 时,它将消耗该映射中剩余的字符,因为映射被视为键入的字符。在 input() 之前使用 inputsave() 并在 input() 之后使用 inputrestore() 来避免这种情况。另一个解决方案是避免映射中存在更多字符,例如,通过使用 :execute:normal
带映射的示例
nmap \x :call GetFoo()<CR>:exe "/" .. Foo<CR>
function GetFoo()
  call inputsave()
  let g:Foo = input("enter search pattern: ")
  call inputrestore()
endfunction
参数
{opts} (table)
返回值
(任何)
inputlist({textlist}) inputlist()
{textlist} 必须是 List 字符串。此 List 将被显示,每行一个字符串。系统将提示用户输入一个数字,该数字将被返回。如果命令行中启用了鼠标,用户也可以通过用鼠标点击来选择一个项目('mouse' 为 "a" 或包含 "c")。对于第一个字符串,将返回 0。当点击第一个项目上方时,将返回一个负数。当点击提示时,将返回 {textlist} 长度加 1。确保 {textlist} 的条目少于 'lines',否则它将无法正常工作。将条目号放在字符串的开头是一个好主意。并在第一个条目中添加一个提示。示例
        let color = inputlist(['Select color:', '1. red',
                \ '2. green', '3. blue'])
Parameters: ~
  • {textlist} (`string[]`)
Return: ~
  (`any`)
inputrestore() inputrestore()
恢复使用之前的 inputsave() 保存的自动补全。应该调用与 inputsave() 调用次数相同的次数。更频繁地调用它无害。当没有要恢复的内容时返回 TRUE,否则返回 FALSE。
返回值
(任何)
inputsave() inputsave()
保留自动补全(也来自映射)并清除它,以便后续的提示从用户那里获取输入。应该在提示之后跟随一个匹配的 inputrestore()。可以多次使用,在这种情况下,必须有同样多的 inputrestore() 调用。当内存不足时返回 TRUE,否则返回 FALSE。
返回值
(任何)
inputsecret({prompt} [, {text}]) inputsecret()
此函数的行为与 input() 函数非常相似,但有两个例外:a) 用户的响应将显示为一系列星号("*"),从而保持输入的秘密,b) 用户的响应将不会记录在输入 history 堆栈上。结果是一个 String,即用户在命令行上对发出的提示的实际输入。 注意: 不支持命令行补全。
参数
{prompt} (string)
{text} (string?)
返回值
(任何)
insert({object}, {item} [, {idx}]) insert()
{object} 是一个 List 或一个 Blob 时,在它的开头插入 {item}
如果指定了 {idx},则在索引为 {idx} 的项目之前插入 {item}。如果 {idx} 为零,它将位于第一个项目之前,就像省略 {idx} 一样。负 {idx} 也是可能的,参见 list-index。-1 在最后一个项目之前插入。
返回结果 ListBlob。示例
let mylist = insert([2, 3, 5], 1)
call insert(mylist, 4, -1)
call insert(mylist, 6, len(mylist))
最后一个示例可以用 add() 更简单地完成。请注意,当 {item} 是一个 List 时,它将作为一个单独的项目插入。使用 extend() 来连接 Lists
参数
{object} (any)
{item} (any)
{idx} (integer?)
返回值
(任何)
interrupt() interrupt()
中断脚本执行。它的作用与用户键入 CTRL-C 相似,大多数命令不会执行,控制权将返回给用户。这对于从更低层级中断执行非常有用,例如,在自动命令中。示例
function s:check_typoname(file)
   if fnamemodify(a:file, ':t') == '['
       echomsg 'Maybe typo'
       call interrupt()
   endif
endfunction
au BufWritePre * call s:check_typoname(expand('<amatch>'))
返回值
(任何)
invert({expr}) invert()
按位取反。参数将被转换为数字。List、Dict 或 Float 参数会导致错误。示例
let bits = invert(bits)
参数
{expr} (number)
返回值
(任何)
isabsolutepath({path}) isabsolutepath()
结果是一个 Number,当 {path} 是一个绝对路径时,它是 TRUE。在 Unix 上,当路径以 '/' 开头时,它被认为是绝对路径。在 MS-Windows 上,当它以可选的驱动器前缀开头,后跟 '\' 或 '/' 时,它被认为是绝对路径。UNC 路径始终是绝对路径。示例
echo isabsolutepath('/usr/share/')        " 1
echo isabsolutepath('./foobar')                " 0
echo isabsolutepath('C:\Windows')        " 1
echo isabsolutepath('foobar')                " 0
echo isabsolutepath('\\remote\file')        " 1
参数
{path} (string)
返回值
(0|1)
isdirectory({directory}) isdirectory()
结果是一个 Number,当存在名为 {directory} 的目录时,它是 TRUE。如果 {directory} 不存在,或者不是目录,则结果为 FALSE{directory} 是任何表达式,用作 String。
参数
{directory} (string)
返回值
(0|1)
isinf({expr}) isinf()
如果 {expr} 是正无穷大,则返回 1,如果 {expr} 是负无穷大,则返回 -1,否则返回 0。
echo isinf(1.0 / 0.0)
1
echo isinf(-1.0 / 0.0)
-1
参数
{expr} (number)
返回值
(1|0|-1)
islocked({expr}) islocked() E786 结果是一个 Number,当 {expr} 是一个锁定的变量的名称时,它是 TRUE。字符串参数 {expr} 必须是变量、List 项目或 Dictionary 条目的名称,而不是变量本身!示例
let alist = [0, ['a', 'b'], 2, 3]
lockvar 1 alist
echo islocked('alist')                " 1
echo islocked('alist[1]')        " 0
{expr} 是一个不存在的变量时,你会收到一条错误消息。使用 exists() 来检查是否存在。
参数
{expr} (any)
返回值
(0|1)
isnan({expr}) isnan()
如果 {expr} 是一个值为 NaN 的浮点数,则返回 TRUE
echo isnan(0.0 / 0.0)
1
参数
{expr} (number)
返回值
(0|1)
items({dict}) items()
返回一个包含 {dict} 中所有键值对的 List。每个 List 项目都是一个包含两个项目的列表:{dict} 条目的键和此条目的值。此 List 是按任意顺序排列的。另请参见 keys()values()。示例
for [key, value] in items(mydict)
   echo key .. ': ' .. value
endfor
List 或 String 参数也受支持。在这些情况下,items() 返回一个包含索引和索引处值的 List。
参数
{dict} (any)
返回值
(任何)
jobpid({job}) jobpid()
返回 job-id {job} 的 PID(进程 ID)。
参数
{job} (integer)
返回值
(integer)
jobresize({job}, {width}, {height}) jobresize()
job-id {job} 的伪终端窗口调整大小为 {width} 列和 {height} 行。如果作业不是使用 "pty":v:true 启动的,则会失败。
参数
{job} (integer)
{width} (integer)
{height} (integer)
返回值
(任何)
jobstart({cmd} [, {opts}]) jobstart()
注意: 在 Lua 中,最好使用 vim.system()(除非使用 pty 选项)。
{cmd} 作为作业启动。如果 {cmd} 是一个 List,它将直接运行(没有 'shell')。如果 {cmd} 是一个 String,它将在 'shell' 中运行,如下所示
call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}'])
(有关详细信息,请参见 shell-unquoting
示例
call jobstart('nvim -h', {'on_stdout':{j,d,e->append(line('.'),d)}})
在成功时返回 job-id,在无效参数(或作业表已满)时返回 0,如果 {cmd}[0] 或 'shell' 不可执行,则返回 -1。返回的 job-id 是一个有效的 channel-id,表示作业的 stdio 流。使用 chansend()(或 rpcnotify()rpcrequest(),如果启用了 "rpc")向 stdin 发送数据,并使用 chanclose() 关闭流,而不停止作业。
参见 job-controlRPC
注意: 在 Windows 上,如果 {cmd} 是一个 List
cmd[0] 必须是一个可执行文件(而不是 "内置")。如果它在 $PATH 中,它可以通过名称调用,不带扩展名
call jobstart(['ping', 'neovim.io'])
如果它是一个完整或部分路径,则需要扩展名
call jobstart(['System32\ping.exe', 'neovim.io'])
{cmd} 将被折叠为一个包含引号引起来的参数的字符串,正如 CommandLineToArgvW 所预期的那样 https://msdn.microsoft.com/bb776391,除非 cmd[0] 是某种形式的 "cmd.exe"。
jobstart-env
作业环境将按如下方式初始化:$NVIM 被设置为父 Nvim 的 v:servername $NVIM_LISTEN_ADDRESS 被取消设置 $NVIM_LOG_FILE 被取消设置 $VIM 被取消设置 $VIMRUNTIME 被取消设置 你可以使用 env 选项来设置它们。
jobstart-options
{opts} 是一个包含以下键的字典: clear_env: (布尔值) env 精确定义作业环境,而不是与当前环境合并。 cwd: (字符串,默认值=|当前目录|) 作业的工作目录。 detach: (布尔值) 将作业进程分离:它不会在 Nvim 退出时被杀死。如果进程在 Nvim 之前退出,on_exit 将被调用。 env: (字典) 环境变量名:值对的映射,扩展(或用 "clear_env" 替换)当前环境。 jobstart-env height: (数字) pty 终端的高度。 on_exit: (函数) 当作业退出时调用的回调函数。 on_stdout: (函数) 当作业发出 stdout 数据时调用的回调函数。 on_stderr: (函数) 当作业发出 stderr 数据时调用的回调函数。 overlapped: (布尔值) 为传递给子进程的 stdio 设置 FILE_FLAG_OVERLAPPED。仅在 MS-Windows 上;在其他平台上被忽略。 pty: (布尔值) 将作业连接到一个新的伪终端,以及其流到主文件描述符。on_stdout 接收所有输出,on_stderr 被忽略。 terminal-start rpc: (布尔值) 使用 msgpack-rpc 通过 stdio 与作业进行通信。然后 on_stdout 被忽略,但 on_stderr 仍然可以使用。 stderr_buffered: (布尔值) 在调用 on_stderr 之前收集数据直到 EOF(流关闭)。 channel-buffered stdout_buffered: (布尔值) 在调用 on_stdout 之前收集数据直到 EOF(流关闭)。 channel-buffered stdin: (字符串) "pipe"(默认)将作业的 stdin 连接到一个通道,或 "null" 断开 stdin 连接。 width: (数字) pty 终端的宽度。
{opts} 作为 self 字典传递给回调函数;调用者可以设置其他键以传递应用程序特定的数据。
返回值
成功时返回 channel-id
无效参数时返回 0
-1 如果 {cmd}[0] 不可执行。另请参见 job-controlchannelmsgpack-rpc
参数
{cmd} (string|string[])
{opts} (table?)
返回值
(任何)
jobstop({id}) jobstop()
通过向作业进程发送 SIGTERM 停止 job-id {id}。如果进程在超时后没有终止,则将发送 SIGKILL。当作业终止时,将调用其 on_exit 处理程序(如果有)。参见 job-control
对于有效的作业 ID 返回 1,对于无效 ID 返回 0,包括已退出或停止的作业。
参数
{id} (整数)
返回值
(任何)
jobwait({jobs} [, {timeout}]) jobwait()
等待作业及其 on_exit 处理程序完成。
{jobs} 是要等待的 job-id 的列表。{timeout} 是以毫秒为单位的最大等待时间。如果省略或为 -1,则无限期等待。
0 的超时可用于检查作业的状态
let running = jobwait([{job-id}], 0)[0] == -1
在 jobwait() 期间,可能调用不在 {jobs} 列表中的作业的回调函数。除非回调函数调用 :redraw,否则屏幕不会重新绘制。
返回一个长度为 len({jobs}) 的整数列表,其中每个整数都是对应作业的状态:如果作业退出,则为退出代码,如果超时,则为 -1,如果作业被中断(通过 CTRL-C),则为 -2,如果作业 ID 无效,则为 -3
参数
{jobs} (integer[])
{timeout} (integer?)
返回值
(任何)
join({list} [, {sep}]) join()
{list} 中的项目连接成一个字符串。当指定 {sep} 时,它被放在项目之间。如果省略 {sep},则使用单个空格。请注意,{sep} 不会添加到末尾。您可能希望也将其添加到末尾
let lines = join(mylist, "\n") .. "\n"
字符串项目按原样使用。 列表字典 会像 string() 一样转换为字符串。相反的函数是 split()
参数
{list} (any[])
{sep} (string?)
返回值
(任何)
json_decode({expr}) json_decode()
{expr} 从 JSON 对象转换为 Vim 值。接受 readfile() 风格的列表作为输入,以及常规字符串。可以输出任何 Vim 值。在以下情况下,它将输出 msgpack-special-dict:1. 字典包含重复键。2. 字符串包含 NUL 字节。如果包含 NUL 字节的字符串是字典键,则将发出两个特殊字典:用于字典和字符串。
注意: 函数始终将输入视为 UTF-8。JSON 标准只允许少数编码,其中 UTF-8 是推荐的,也是唯一需要支持的编码。非 UTF-8 字符是错误。
参数
{expr} (any)
返回值
(任何)
json_encode({expr}) json_encode()
{expr} 转换为 JSON 字符串。接受 msgpack-special-dict 作为输入。不会转换 Funcref、具有非字符串键的映射(可以创建为 msgpack-special-dict)、具有自引用容器的值、包含非 UTF-8 字符的字符串、包含为代理对保留的代码点的伪 UTF-8 字符串(此类字符串不是有效的 UTF-8 字符串)。不可打印字符将转换为 "\u1234" 转义符或特殊转义符(如 "\t"),其他将按原样转储。 Blob 将转换为单个字节的数组。
参数
{expr} (any)
返回值
(任何)
keys({dict}) keys()
返回一个包含 {dict} 中所有键的 列表列表 的顺序是任意的。另请参见 items()values()
参数
{dict} (table)
返回值
(任何)
keytrans({string}) keytrans()
将键的内部字节表示形式转换为可用于 :map 的形式。例如
let xx = "\<C-Home>"
echo keytrans(xx)
<C-Home>
参数
{string} (字符串)
返回值
(任何)
len({expr}) len() E701 结果是一个数字,它是参数的长度。当 {expr} 是一个字符串或一个数字时,使用字节长度,就像 strlen() 一样。当 {expr} 是一个 列表 时,返回 列表 中的项目数。当 {expr} 是一个 Blob 时,返回字节数。当 {expr} 是一个 字典 时,返回 字典 中的条目数。否则,将给出错误并返回零。
参数
{expr} (any)
返回值
(任何)
libcall({libname}, {funcname}, {argument}) libcall() E364 E368 使用单个参数 {argument} 调用运行时库 {libname} 中的函数 {funcname}。这对于调用专门用于 Vim 的库中的函数很有用。由于只可能使用一个参数,所以调用标准库函数相当有限。结果是函数返回的字符串。如果函数返回 NULL,则 Vim 将将其显示为一个空字符串 ""。如果函数返回一个数字,请使用 libcallnr()!如果 {argument} 是一个数字,则将其作为 int 传递给函数;如果 {argument} 是一个字符串,则将其作为以 null 结尾的字符串传递。
libcall() 允许您编写自己的 '插件' 扩展到 Vim,而无需重新编译程序。它不是调用系统函数的方法!如果您尝试这样做,Vim 很可能会崩溃。
对于 Win32,您编写的函数必须放在 DLL 中并使用正常的 C 调用约定(而不是 Windows 系统 DLL 中使用的 Pascal)。该函数必须接受一个参数,一个字符指针或一个长整数,并且必须返回一个字符指针或 NULL。返回的字符指针必须指向在函数返回后仍然有效的内存(例如,在 DLL 中的静态数据中)。如果它指向已分配的内存,则该内存将泄漏。在函数中使用静态缓冲区应该可以工作,它将在 DLL 被卸载时释放。
警告: 如果函数返回一个非有效指针,Vim 可能会崩溃!如果函数返回一个数字,也会发生这种情况,因为 Vim 认为它是一个指针。对于 Win32 系统,{libname} 应该是 DLL 的文件名,不包括 ".DLL" 后缀。只有当 DLL 不在通常位置时,才需要完整路径。对于 Unix:在编译您自己的插件时,请记住,目标代码必须编译为位置无关('PIC')。示例
        echo libcall("libc.so", "getenv", "HOME")
Parameters: ~
  • {libname} (`string`)
  • {funcname} (`string`)
  • {argument} (`any`)
Return: ~
  (`any`)
libcallnr({libname}, {funcname}, {argument}) libcallnr()
就像 libcall() 一样,但用于返回 int 而不是字符串的函数。示例
echo libcallnr("/usr/lib/libc.so", "getpid", "")
call libcallnr("libc.so", "printf", "Hello World!\n")
call libcallnr("libc.so", "sleep", 10)
参数
{libname} (string)
{funcname} (string)
{argument} (any)
返回值
(任何)
line({expr} [, {winid}]) line()
参见 getpos() 以了解可接受的位置。
要获取列号,请使用 col()。要同时获取两者,请使用 getpos()
使用可选的{winid} 参数,将为该窗口而不是当前窗口获取值。
对于 {expr}{winid} 的无效值返回 0。
示例
echo line(".")                        " line number of the cursor
echo line(".", winid)                " idem, in window "winid"
echo line("'t")                        " line number of mark t
echo line("'" .. marker)        " line number of mark marker
要跳到打开文件时的最后一个已知位置,请参见 last-position-jump
参数
{expr} (字符串|整数[])
{winid} (integer?)
返回值
(integer)
line2byte({lnum}) line2byte()
返回缓冲区开始处到第 {lnum} 行的字节数。这包括行尾字符,取决于当前缓冲区的 'fileformat' 选项。第一行返回 1。使用 UTF-8 编码,'fileencoding' 被忽略。这也可用于获取最后一行下方行的字节数
echo line2byte(line("$") + 1)
这是缓冲区大小加一。如果 'fileencoding' 为空,则为文件大小加一。{lnum} 的使用方式与 getline() 相同。当 {lnum} 无效时,返回 -1。另请参见 byte2line()go:goto
参数
{lnum} (integer)
返回值
(integer)
lispindent({lnum}) lispindent()
根据 Lisp 缩进规则获取第 {lnum} 行的缩进量,就像 'lisp' 一样。缩进量以空格计算,'tabstop' 的值是相关的。{lnum} 的使用方式与 getline() 相同。当 {lnum} 无效时,返回 -1。
参数
{lnum} (integer)
返回值
(任何)
list2blob({list}) list2blob()
返回一个 Blob,将 {list} 中的所有数字值连接起来。示例
echo list2blob([1, 2, 3, 4])        " returns 0z01020304
echo list2blob([])                " returns 0z
在错误时返回一个空 Blob。如果数字之一为负或大于 255,则会给出错误 E1239
blob2list() 做相反的事情。
参数
{list} (any[])
返回值
(任何)
list2str({list} [, {utf8}]) list2str()
{list} 中的每个数字转换为一个字符字符串,并将它们连接起来。示例
echo list2str([32])                " returns " "
echo list2str([65, 66, 67])        " returns "ABC"
也可以使用以下方法(速度较慢):
echo join(map(list, {nr, val -> nr2char(val)}), '')
str2list() 做相反的事情。
始终使用 UTF-8 编码,{utf8} 选项无效,仅出于向后兼容性而存在。使用 UTF-8 组成字符按预期工作。
echo list2str([97, 769])        " returns "á"
错误时返回空字符串。
参数
{list} (any[])
{utf8} (boolean?)
返回值
(任何)
localtime() localtime()
返回当前时间,以 1970 年 1 月 1 日以来的秒数衡量。另请参见 strftime()strptime()getftime()
返回值
(任何)
log({expr}) log()
返回{expr}的自然对数(以 e 为底)作为 Float{expr} 必须计算为范围为 (0, inf] 的 FloatNumber。如果{expr}不是 FloatNumber,则返回 0.0。示例
echo log(10)
2.302585
echo log(exp(5))
5.0
参数
{expr} (number)
返回值
(任何)
log10({expr}) log10()
将 Float {expr} 的以 10 为底的对数返回为 Float{expr} 必须计算为 FloatNumber。如果{expr}不是 FloatNumber,则返回 0.0。示例
echo log10(1000)
3.0
echo log10(0.01)
-2.0
参数
{expr} (number)
返回值
(任何)
luaeval({expr} [, {expr}]) luaeval()
计算 Lua 表达式{expr}并返回其结果,该结果已转换为 Vim 数据结构。有关更多详细信息,请参阅 lua-eval
参数
{expr} (string)
{expr1} (any[]?)
返回值
(任何)
map({expr1}, {expr2}) map()
{expr1} 必须是 ListStringBlobDictionary。当{expr1}ListDictionary 时,使用计算{expr2}的结果替换{expr1}中的每个项目。对于 Blob,替换每个字节。对于 String,替换每个字符,包括组成字符。如果项目类型发生更改,您可能希望使用 mapnew() 创建新的 List 或 Dictionary。
{expr2} 必须是 StringFuncref
如果{expr2}String,则在{expr2}中,v:val 具有当前项目的 value。对于 Dictionaryv:key 具有当前项目的键,而对于 Listv:key 具有当前项目的索引。对于 Blobv:key 具有当前字节的索引。对于 Stringv:key 具有当前字符的索引。示例
call map(mylist, '"> " .. v:val .. " <"')
这会在 "mylist" 中的每个项目之前添加 "> ",并在每个项目之后添加 " <"。
请注意,{expr2} 是表达式的结果,然后再次用作表达式。通常,使用 literal-string 可以避免使用双反斜杠。您仍然需要对 ' 引号进行双重转义。
如果{expr2}Funcref,则使用两个参数调用它:1. 当前项目的键或索引。2. 当前项目的 value。该函数必须返回项目的 newValue。更改每个 value 为 "key-value" 的示例
func KeyValue(key, val)
  return a:key .. '-' .. a:val
endfunc
call map(myDict, function('KeyValue'))
使用 lambda 时更短
call map(myDict, {key, val -> key .. '-' .. val})
如果你不使用 "val",你可以省略它
call map(myDict, {key -> 'item: ' .. key})
如果您不使用 "key",则可以使用简短名称
call map(myDict, {_, val -> 'item: ' .. val})
该操作对于 ListDictionary 是就地进行的。如果您希望它保持不变,请先进行复制。
let tlist = map(copy(mylist), ' v:val .. "\t"')
返回 {expr1},即被过滤的 列表字典,或一个新的 Blob字符串。当在评估 {expr2} 时遇到错误时,不会处理 {expr1} 中的任何其他项目。当 {expr2} 是一个 Funcref 时,函数内部的错误会被忽略,除非它是用 "abort" 标记定义的。
参数
{expr1} (string|table|any[])
{expr2} (string|function)
返回值
(任何)
maparg({name} [, {mode} [, {abbr} [, {dict}]]]) maparg()
{dict}省略或为零时:返回模式{mode}中映射{name}的右侧。返回的 String 具有像在 ":map" 命令列表的输出中一样翻译的特殊字符。当{dict}为 TRUE 时,将返回一个字典,请参阅下文。要获取所有映射的列表,请参阅 maplist()
{name}没有映射时,如果{dict}为 FALSE,则返回空 String,否则返回空 Dict。当{name}的映射为空时,则返回 "<Nop>"。
{name} 可以具有特殊键名,就像在 ":map" 命令中一样。
{mode} 可以是以下字符串之一:"n" Normal "v" Visual(包括 Select)"o" Operator-pending "i" Insert "c" Cmd-line "s" Select "x" Visual "l" langmap language-mapping "t" Terminal "" Normal、Visual 和 Operator-pending 当{mode}省略时,将使用 "" 的模式。
{abbr}存在且为 TRUE 时,使用缩写而不是映射。
{dict}存在且为 TRUE 时,返回一个字典,其中包含映射的所有信息,以及以下项目: mapping-dict
"lhs" 映射的{lhs},就像键入一样 "lhsraw" 映射的{lhs},作为原始字节 "lhsrawalt" 映射的{lhs},作为原始字节,备用形式,仅在它与 "lhsraw" 不同时存在 "rhs" 映射的{rhs},就像键入一样。 "callback" Lua 函数,如果 RHS 是这样定义的。 "silent" 对于 :map-silent 映射为 1,否则为 0。 "noremap" 如果映射的{rhs}不可重新映射,则为 1。 "script" 如果使用<script>定义映射,则为 1。 "expr" 对于表达式映射 (:map-<expr>) 为 1。 "buffer" 对于缓冲区本地映射 (:map-local) 为 1。 "mode" 定义映射的模式。除了上面提到的模式外,还将使用以下字符:" " Normal、Visual 和 Operator-pending "!" Insert 和 Commandline 模式 (mapmode-ic) "sid" 脚本本地 ID,用于<sid> 映射 (<SID>)。负数表示特殊上下文。 "scriptversion" 脚本版本,始终为 1。 "lnum" "sid" 中的行号,如果未知则为零。 "nowait" 不要等待其他更长的映射。 (:map-<nowait>)。 "abbr" 如果这是 abbreviation,则为 True。 "mode_bits" Nvim 的内部二进制表示形式 "mode"。 mapset() 忽略此项;仅使用 "mode"。有关使用示例,请参阅 maplist()。这些值来自 src/nvim/state_defs.h,将来可能会更改。
可以使用该字典通过 mapset() 恢复映射。
首先检查当前缓冲区的本地映射,然后检查全局映射。此函数可用于映射键,即使它已映射,并让它也执行原始映射。草图
exe 'nnoremap <Tab> ==' .. maparg('<Tab>', 'n')
参数
{name} (字符串)
{mode} (string?)
{abbr} (boolean?)
{dict} (false?)
返回值
(字符串)
mapcheck({name} [, {mode} [, {abbr}]]) mapcheck()
检查是否存在与模式{mode}中的{name}匹配的映射。有关{mode}{name}中的特殊名称,请参阅 maparg()。当{abbr}存在且非零时,使用缩写而不是映射。与以{name}开头的映射以及与{name}的开头相等的映射匹配。
匹配映射 "a" "ab" "abc"
mapcheck("a") 是 是 是 mapcheck("abc") 是 是 是 mapcheck("ax") 是 否 否 mapcheck("b") 否 否 否
与 maparg() 的区别在于,mapcheck() 查找与{name}匹配的映射,而 maparg() 仅查找完全匹配{name}的映射。当没有以{name}开头的映射时,将返回空 String。如果存在,则返回该映射的 RHS。如果存在多个以{name}开头的映射,则返回其中一个的 RHS。如果 RHS 为空,则这将是 "<Nop>"。首先检查当前缓冲区的本地映射,然后检查全局映射。此函数可用于检查是否可以在不产生歧义的情况下添加映射。示例
if mapcheck("_vv") == ""
   map _vv :set guifont=7x13<CR>
endif
这避免了在已经存在 "_v" 或 "_vvv" 的映射时添加 "_vv" 映射。
参数
{name} (字符串)
{mode} (string?)
{abbr} (boolean?)
返回值
(任何)
maplist([{abbr}]) maplist()
返回所有映射的 List。每个 List 项目都是一个 Dict,与 maparg() 返回的值相同,请参阅 mapping-dict。当{abbr}存在且为 TRUE 时,使用缩写而不是映射。
示例显示所有在 rhs 中包含 "MultiMatch" 的映射
echo maplist()->filter({_, m ->
        \ match(get(m, 'rhs', ''), 'MultiMatch') >= 0
        \ })
找到特定 :map-modes 的映射可能很棘手。 mapping-dict 的 "mode_bits" 可以简化此操作。例如,Normal、Insert 或 Command-line 模式的 mode_bits 为 0x19。要查找这些模式下可用的所有映射,您可以执行以下操作
let saved_maps = []
for m in maplist()
    if and(m.mode_bits, 0x19) != 0
        eval saved_maps->add(m)
    endif
endfor
echo saved_maps->mapnew({_, m -> m.lhs})
mode_bits 的值在 Nvim 的 src/nvim/state_defs.h 文件中定义,可以使用 :map-commands 和 "maplist()" 在运行时发现它们。示例
omap xyzzy <Nop>
let op_bit = maplist()->filter(
    \ {_, m -> m.lhs == 'xyzzy'})[0].mode_bits
ounmap xyzzy
echo printf("Operator-pending mode bit: 0x%x", op_bit)
参数
{abbr} (0|1?)
返回值
(table[])
mapnew({expr1}, {expr2}) mapnew()
map() 相似,但不是替换{expr1}中的项目,而是创建一个新的 List 或 Dictionary 并返回它。{expr1}保持不变。{expr2} 仍然可以更改项目,如果您不希望这样做,请先使用 deepcopy()
参数
{expr1} (any)
{expr2} (any)
返回值
(任何)
mapset({mode}, {abbr}, {dict}) mapset()
mapset({dict}) 从字典中恢复映射,该字典可能由 maparg()maplist() 返回。当 dict.buffer 为 true 时,缓冲区映射将在当前缓冲区上设置;调用者有责任确保目标缓冲区是当前缓冲区。此功能允许将映射从一个缓冲区复制到另一个缓冲区。dict.mode value 可以恢复涵盖多个模式的单个映射,例如使用 '!'、' '、"nox" 或 'v' 的模式值。 E1276
在第一种形式中,{mode}{abbr} 应与调用 maparg() 时相同。 E460 {mode} 用于定义设置映射的模式,而不是{dict}中的 "mode" 条目。保存和恢复映射的示例
let save_map = maparg('K', 'n', 0, 1)
nnoremap K somethingelse
" ...
call mapset('n', 0, save_map)
请注意,如果您要在多个模式下替换映射,例如使用:map!,则需要保存/恢复所有模式下的映射,因为它们可能不同。
在第二种形式中,仅使用{dict}作为参数,模式和 abbr 从字典中获取。示例
let save_maps = maplist()->filter(
                        \ {_, m -> m.lhs == 'K'})
nnoremap K somethingelse
cnoremap K somethingelse2
" ...
unmap K
for d in save_maps
    call mapset(d)
endfor
参数
{dict} (boolean)
返回值
(任何)
match({expr}, {pat} [, {start} [, {count}]]) match()
{expr} 是一个 列表 时,这将返回第一个匹配 {pat} 的项目的索引。每个项目都作为字符串使用,列表字典 则作为回声使用。
否则,{expr} 将用作字符串。结果是一个数字,它给出 {pat}{expr} 中匹配的索引(字节偏移量)。
在第一个字符或 列表 项目处匹配返回零。如果不存在匹配项,则返回 -1。
要获取子匹配项,请参见 matchlist()。示例
echo match("testing", "ing")        " results in 4
echo match([1, 'x'], '\a')        " results in 1
有关如何使用 {pat},请参见 string-matchstrpbrk()
Vim 没有 strpbrk() 函数。但您可以执行以下操作
let sepidx = match(line, '[.,;: \t]')
strcasestr()
Vim 没有 strcasestr() 函数。但您可以将 "\c" 添加到模式中以忽略大小写
let idx = match(haystack, '\cneedle')
如果给定了 {start},则搜索将从字符串中的字节索引 {start}列表 中的项目 {start} 开始。但是,结果仍然是从第一个字符/项目开始计算的索引。示例
echo match("testing", "ing", 2)
结果再次是 "4"。
echo match("testing", "ing", 4)
结果再次是 "4"。
echo match("testing", "t", 2)
结果是 "3"。对于字符串,如果 {start} > 0,则它就像字符串从 {start} 个字节后开始一样,因此 "^" 将在 {start} 处匹配。除非给定了 {count},否则它就像在 {start} 字节之前的匹配项被忽略一样(为了保持向后兼容,这有点复杂)。对于字符串,如果 {start} < 0,它将被设置为 0。对于列表,索引是从末尾开始计算的。如果 {start} 超出范围(对于字符串,{start} > strlen({expr}) 或对于 列表{start} > len({expr})),则返回 -1。
当给定 {count} 时,使用第 {count} 个匹配项。当在字符串中找到匹配项时,对下一个匹配项的搜索将从下一个字符开始。因此,此示例的结果为 1
echo match("testing", "..", 0, 2)
列表 中,搜索将在下一项中继续。请注意,当添加 {count} 时,{start} 的工作方式会发生变化,请参见上文。
match-pattern
有关可接受的模式,请参见 模式'ignorecase' 选项用于设置模式的忽略大小写属性。 'smartcase' 不被使用。匹配始终像设置了 'magic' 并且 'cpoptions' 为空一样进行。请注意,优先选择在开头匹配,因此当模式使用 "*"(任意数量的匹配项)时,它往往会在开头找到零个匹配项,而不是在文本中更后面的位置找到多个匹配项。
参数
{expr} (string|any[])
{pat} (string)
{start} (integer?)
{count} (integer?)
返回值
(任何)
matchadd() E798 E799 E801 E957 matchadd({group}, {pattern} [, {priority} [, {id} [, {dict}]]]) 定义要突出显示在当前窗口中的模式(“匹配”)。它将使用 {group} 进行突出显示。返回一个识别号(ID),该识别号可用于使用 matchdelete() 删除匹配项。该 ID 与窗口绑定。匹配区分大小写且为 magic,除非在 {pattern} 中显式覆盖大小写敏感性或 magic 属性。 'magic''smartcase''ignorecase' 选项不被使用。“Conceal” 值是特殊的,它会导致匹配项被隐藏。
可选的 {priority} 参数为匹配项分配一个优先级。具有较高优先级的匹配项的突出显示将覆盖具有较低优先级的匹配项。优先级指定为整数(负数也不例外)。如果未指定 {priority} 参数,则默认优先级为 10。 'hlsearch' 的优先级为零,因此所有优先级大于零的匹配项都将覆盖它。语法高亮(请参见 'syntax')是一种单独的机制,并且无论选择哪个优先级,匹配项都将始终覆盖语法高亮。
可选的 {id} 参数允许请求特定匹配项 ID。如果指定的 ID 已经被占用,则会显示错误消息,并且不会添加匹配项。ID 指定为正整数(不包括零)。ID 1、2 和 3 分别保留用于 :match:2match:3match。3 保留供 matchparen 插件使用。如果未指定 {id} 参数或为 -1,则 matchadd() 会自动选择一个空闲的 ID,该 ID 至少为 1000。
可选的 {dict} 参数允许进一步的自定义值。目前,它用于指定与匹配项相关的隐藏字符,该字符将显示在 hl-Conceal 突出显示的匹配项中。该字典可以包含以下成员
conceal 特殊字符,用于显示匹配项的替代字符(仅适用于 hl-Conceal 突出显示的匹配项,请参见 :syn-cchar)window 不使用当前窗口,而是使用此编号或窗口 ID 的窗口。
匹配项的数量不受限制,与 :match 命令不同。
如果发生错误,则返回 -1。
示例
highlight MyGroup ctermbg=green guibg=green
let m = matchadd("MyGroup", "TODO")
模式的删除
call matchdelete(m)
可以通过 getmatches() 获取由 matchadd():match 定义的匹配项列表。可以使用 clearmatches() 一次删除所有匹配项。
参数
{group} (integer|string)
{pattern} (字符串)
{priority} (integer?)
{id} (integer?)
{dict} (string?)
返回值
(任何)
matchaddpos({group}, {pos} [, {priority} [, {id} [, {dict}]]]) matchaddpos()matchadd() 相同,但需要一个位置列表 {pos} 而不是模式。此命令比 matchadd() 更快,因为它不处理正则表达式,并且它设置缓冲区行边界以重新绘制屏幕。它应该在需要快速添加和删除匹配项的情况下使用,例如突出显示匹配的括号。 E5030 E5031 {pos} 是一个位置列表。每个位置可以是以下之一
一个数字。整行将被突出显示。第一行编号为 1。
包含一个数字的列表,例如 [23]。具有此编号的整行将被突出显示。
包含两个数字的列表,例如 [23, 11]。第一个数字是行号,第二个数字是列号(第一列为 1,该值必须与 col() 所返回的字节索引相对应)。此位置的字符将被突出显示。
包含三个数字的列表,例如 [23, 11, 3]。如上所示,但第三个数字给出以字节为单位的突出显示长度。
行号为零和负数的条目以及列号和长度为负数的条目将被静默忽略。
如果发生错误,则返回 -1。
示例
highlight MyGroup ctermbg=green guibg=green
let m = matchaddpos("MyGroup", [[23, 24], 34])
模式的删除
call matchdelete(m)
matchaddpos() 添加的匹配项将由 getmatches() 返回。
参数
{group} (integer|string)
{pos} (any[])
{priority} (integer?)
{id} (integer?)
{dict} (string?)
返回值
(任何)
matcharg({nr}) matcharg()
选择第 {nr} 个匹配项,如使用 :match:2match:3match 命令设置的那样。返回一个包含两个元素的 列表:使用的突出显示组的名称,使用的模式。当 {nr} 不为 1、2 或 3 时,返回一个空的 列表。当没有设置匹配项时,返回 ['', '' ]。这对于保存和恢复 :match 很有用。使用 :match 命令突出显示的匹配项最多只能有三个匹配项。 matchadd() 没有这个限制。
参数
{nr} (整数)
返回值
(任何)
matchbufline({buf}, {pat}, {lnum}, {end}, [, {dict}]) matchbufline()
返回缓冲区 {buf} 中从 {lnum}{end} 行中匹配 {pat} 的匹配项的 列表
{lnum}{end} 可以是行号,也可以是字符串 "$",表示 {buf} 中的最后一行。
{dict} 参数支持以下项目:submatches 包含子匹配信息 (/\()
对于每个匹配项,将返回一个包含以下项目的 字典:byteidx 匹配项的起始字节索引 lnum 存在匹配项的行号 text 匹配的字符串请注意,在一行中可能存在多个匹配项。
此函数仅适用于已加载的缓冲区。如有必要,请首先调用 bufload()
有关某些选项设置对模式的影响的信息,请参见 match-pattern
{buf} 不是有效的缓冲区、缓冲区未加载或 {lnum}{end} 无效时,将给出错误,并返回一个空的 列表
示例
" Assuming line 3 in buffer 5 contains "a"
echo matchbufline(5, '\<\k\+\>', 3, 3)
[{'lnum': 3, 'byteidx': 0, 'text': 'a'}]
" Assuming line 4 in buffer 10 contains "tik tok"
echo matchbufline(10, '\<\k\+\>', 1, 4)
[{'lnum': 4, 'byteidx': 0, 'text': 'tik'}, {'lnum': 4, 'byteidx': 4, 'text': 'tok'}]
如果存在 {submatch} 并且为 v:true,则还会返回子匹配项,如 "\1"、"\2" 等。示例
" Assuming line 2 in buffer 2 contains "acd"
echo matchbufline(2, '\(a\)\?\(b\)\?\(c\)\?\(.*\)', 2, 2
                            \ {'submatches': v:true})
[{'lnum': 2, 'byteidx': 0, 'text': 'acd', 'submatches': ['a', '', 'c', 'd', '', '', '', '', '']}] "submatches" 列表始终包含 9 个项目。如果未找到子匹配项,则对于该子匹配项将返回一个空字符串。
参数
{buf} (string|integer)
{pat} (string)
{lnum} (string|integer)
{end_} (string|integer)
{dict} (table?)
返回值
(任何)
matchdelete({id} [, {win}]) matchdelete() E802 E803 删除先前由 matchadd() 或其中一个 :match 命令定义的 ID 为 {id} 的匹配项。如果成功,则返回 0,否则返回 -1。请参见 matchadd() 的示例。可以使用 clearmatches() 一次删除所有匹配项。如果指定了 {win},则使用此编号或窗口 ID 的窗口,而不是当前窗口。
参数
{id} (整数)
{win} (整数?)
返回值
(任何)
matchend({expr}, {pat} [, {start} [, {count}]]) matchend()
match() 相同,但返回匹配项后第一个字符的索引。示例
echo matchend("testing", "ing")
结果为 "7"。 strspn() strcspn() Vim 没有 strspn() 或 strcspn() 函数,但您可以使用 matchend() 来实现
let span = matchend(line, '[a-zA-Z]')
let span = matchend(line, '[^a-zA-Z]')
不同之处在于,当不存在匹配项时,将返回 -1。
如果给定了 {start},则它与 match() 中的含义相同。
echo matchend("testing", "ing", 2)
结果为 "7"。
echo matchend("testing", "ing", 5)
结果为 "-1"。当 {expr} 是一个 列表 时,结果将等于 match()
参数
{expr} (any)
{pat} (string)
{start} (integer?)
{count} (integer?)
返回值
(任何)
matchfuzzy({list}, {str} [, {dict}]) matchfuzzy()
如果 {list} 是一个字符串列表,则返回一个包含所有与 {str} 模糊匹配的字符串的 List。 返回列表中的字符串根据匹配分数排序。
可选的 {dict} 参数始终支持以下项目: matchseq 当此项目存在时,仅返回包含 {str} 中字符的匹配项,这些字符以给定顺序排列。 limit 返回的 {list} 中的最大匹配数。 零表示无限制。
如果 {list} 是一个字典列表,则可选的 {dict} 参数支持以下附加项目: key 与 {str} 模糊匹配的项目的键。 此项目的 value 应为字符串。 text_cb Funcref,它将为 {list} 中的每个项目调用以获取用于模糊匹配的文本。 此函数应接受一个字典项目作为参数并返回用于模糊匹配的该项目的文本。
{str} 被视为字面字符串,不支持正则表达式匹配。 支持的最大 {str} 长度为 256。
{str} 包含多个单词,每个单词之间用空格隔开时,将返回包含所有单词的字符串列表。
如果没有匹配的字符串或出现错误,则返回一个空列表。 如果 {str} 的长度大于 256,则返回一个空列表。
当给出 {limit} 时,matchfuzzy() 将在 {list} 中找到最多此数量的匹配项,并按排序顺序返回它们。
有关模糊匹配字符串的更多信息,请参考 fuzzy-matching
示例
echo matchfuzzy(["clay", "crow"], "cay")
结果为 ["clay"]。
echo getbufinfo()->map({_, v -> v.name})->matchfuzzy("ndl")
结果为一个包含与 "ndl" 模糊匹配的缓冲区名称的列表。
echo getbufinfo()->matchfuzzy("ndl", {'key' : 'name'})
结果为一个包含缓冲区信息字典的列表,其中缓冲区名称与 "ndl" 模糊匹配。
echo getbufinfo()->matchfuzzy("spl",
                             \ {'text_cb' : {v -> v.name}})
结果为一个包含缓冲区信息字典的列表,其中缓冲区名称与 "spl" 模糊匹配。
echo v:oldfiles->matchfuzzy("test")
结果为一个包含与 "test" 模糊匹配的文件名的列表。
let l = readfile("buffer.c")->matchfuzzy("str")
结果为 "buffer.c" 中与 "str" 模糊匹配的行列表。
echo ['one two', 'two one']->matchfuzzy('two one')
结果为 ['two one', 'one two']
echo ['one two', 'two one']->matchfuzzy('two one',
                             \ {'matchseq': 1})
结果为 ['two one']
参数
{list} (any[])
{str} (string)
{dict} (string?)
返回值
(任何)
matchfuzzypos({list}, {str} [, {dict}]) matchfuzzypos()
matchfuzzy() 相同,但返回匹配字符串的列表、{str} 中字符匹配的字符位置列表以及匹配分数列表。 您可以使用 byteidx() 将字符位置转换为字节位置。
如果 {str} 在一个字符串中多次匹配,则仅返回最佳匹配的位置。
如果没有匹配的字符串或出现错误,则返回一个包含三个空列表项的列表。
示例
echo matchfuzzypos(['testing'], 'tsg')
结果为 [["testing"], [[0, 2, 6]], [99]]
echo matchfuzzypos(['clay', 'lacy'], 'la')
结果为 [["lacy", "clay"], [[0, 1], [1, 2]], [153, 133]]
echo [{'text': 'hello', 'id' : 10}]
        \ ->matchfuzzypos('ll', {'key' : 'text'})
结果为 [[{"id": 10, "text": "hello"}], [[2, 3]], [127]]
参数
{list} (any[])
{str} (string)
{dict} (string?)
返回值
(任何)
matchlist({expr}, {pat} [, {start} [, {count}]]) matchlist()
match() 相同,但返回一个 List。 列表中的第一个项目是匹配的字符串,与 matchstr() 返回的相同。 以下项目是子匹配,例如 :substitute 中的 "\1"、"\2" 等。 当可选子匹配未匹配时,将使用空字符串。 例如
echo matchlist('acd', '\(a\)\?\(b\)\?\(c\)\?\(.*\)')
结果为:['acd', 'a', '', 'c', 'd', '', '', '', '', ''] 当没有匹配项时,将返回一个空列表。
您可以传入一个 List,但这并不十分有用。
参数
{expr} (any)
{pat} (string)
{start} (integer?)
{count} (integer?)
返回值
(任何)
matchstr({expr}, {pat} [, {start} [, {count}]]) matchstr()
match() 相同,但返回匹配的字符串。 例如
echo matchstr("testing", "ing")
结果为 "ing"。 当没有匹配项时,将返回 ""。 如果给出 {start},则其含义与 match() 中的相同。
echo matchstr("testing", "ing", 2)
结果为 "ing"。
echo matchstr("testing", "ing", 5)
结果为空字符串。 当 {expr} 是一个 List 时,将返回匹配的项目。 类型不会改变,它不一定是字符串。
参数
{expr} (any)
{pat} (string)
{start} (integer?)
{count} (integer?)
返回值
(任何)
matchstrlist({list}, {pat} [, {dict}]) matchstrlist()
返回 {list} 中匹配项的 List,其中 {pat} 匹配。 {list} 是一个字符串的 List{pat}{list} 中的每个字符串匹配。
{dict} 参数支持以下项目:submatches 包含子匹配信息 (/\()
对于每个匹配项,将返回一个包含以下项目的 Dict: byteidx 匹配项的起始字节索引。 idx {list} 中匹配项的索引。 text 匹配的字符串 submatches 子匹配的 List。 仅当 {dict} 中将 "submatches" 设置为 v:true 时存在。
有关某些选项设置对模式的影响的信息,请参见 match-pattern
示例
echo matchstrlist(['tik tok'], '\<\k\+\>')
[{'idx': 0, 'byteidx': 0, 'text': 'tik'}, {'idx': 0, 'byteidx': 4, 'text': 'tok'}]
echo matchstrlist(['a', 'b'], '\<\k\+\>')
[{'idx': 0, 'byteidx': 0, 'text': 'a'}, {'idx': 1, 'byteidx': 0, 'text': 'b'}]
如果 "submatches" 存在且为 v:true,则还将返回诸如 "\1"、"\2" 等子匹配。 例如
echo matchstrlist(['acd'], '\(a\)\?\(b\)\?\(c\)\?\(.*\)',
                            \ #{submatches: v:true})
[{'idx': 0, 'byteidx': 0, 'text': 'acd', 'submatches': ['a', '', 'c', 'd', '', '', '', '', '']}] "submatches" List 始终包含 9 个项目。 如果未找到子匹配,则将返回一个空字符串以表示该子匹配。
参数
{list} (string[])
{pat} (string)
{dict} (table?)
返回值
(任何)
matchstrpos({expr}, {pat} [, {start} [, {count}]]) matchstrpos()
matchstr() 相同,但返回匹配的字符串、匹配项的起始位置和结束位置。 例如
echo matchstrpos("testing", "ing")
结果为 ["ing", 4, 7]。 当没有匹配项时,将返回 ["", -1, -1]。 如果给出 {start},则其含义与 match() 中的相同。
echo matchstrpos("testing", "ing", 2)
结果为 ["ing", 4, 7]。
echo matchstrpos("testing", "ing", 5)
结果为空字符串。 当 {expr} 是一个 List 时,将返回匹配的项目、{pat} 匹配的第一个项目的索引、匹配项的起始位置和结束位置。
echo matchstrpos([1, '__x'], '\a')
结果为 ["x", 1, 2, 3]。 类型不会改变,它不一定是字符串。
参数
{expr} (any)
{pat} (string)
{start} (integer?)
{count} (integer?)
返回值
(任何)
max({expr}) max()
返回 {expr} 中所有项目的最大值。 例如
echo max([apples, pears, oranges])
{expr} 可以是 ListDictionary。 对于 Dictionary,它返回 Dictionary 中所有值的最高值。 如果 {expr} 既不是 List 也不是 Dictionary,或者 {expr} 中的某个项目无法用作 Number,则会导致错误。 一个空的 ListDictionary 将返回零。
参数
{expr} (any)
返回值
(任何)
menu_get({path} [, {modes}]) menu_get()
返回一个 List,其中包含描述 menus(由 :menu:amenu 等定义,包括 hidden-menus)的 Dictionaries
{path} 按名称匹配菜单,如果 {path} 为空字符串,则匹配所有菜单。 例如
echo menu_get('File','')
echo menu_get('')
{modes} 是一个包含零个或多个模式的字符串(有关模式列表,请参阅 maparg()creating-menus)。 "a" 表示 "all"。
示例
nnoremenu &Test.Test inormal
inoremenu Test.Test insert
vnoremenu Test.Test x
echo menu_get("")
返回类似于以下内容:
[ {
  "hidden": 0,
  "name": "Test",
  "priority": 500,
  "shortcut": 84,
  "submenus": [ {
    "hidden": 0,
    "mappings": {
      i": {
        "enabled": 1,
        "noremap": 1,
        "rhs": "insert",
        "sid": 1,
        "silent": 0
      },
      n": { ... },
      s": { ... },
      v": { ... }
    },
    "name": "Test",
    "priority": 500,
    "shortcut": 0
  } ]
} ]
参数
{path} (string)
{modes} (string?)
返回值
(任何)
menu_info({name} [, {mode}]) menu_info()
返回有关指定菜单 {name} 在模式 {mode} 中的信息。 菜单名称应在不包含快捷键字符('&')的情况下指定。 如果 {name} 为 "",则返回顶级菜单名称。
{mode} 可以是以下字符串之一: "n" Normal "v" Visual(包括 Select) "o" Operator-pending "i" Insert "c" Cmd-line "s" Select "x" Visual "t" Terminal-Job "" Normal、Visual 和 Operator-pending "!" Insert 和 Cmd-line 当省略 {mode} 时,将使用 "" 的模式。
返回一个包含以下项目的 Dictionary: accel 菜单项加速器文本 menu-text display 显示名称(不包含 '&' 的名称) enabled 如果此菜单项已启用,则为 v:true。 请参考 :menu-enable icon 图标文件(用于工具栏)的名称 toolbar-icon iconidx 内置图标的索引 modes 定义菜单的模式。 除了上面提到的模式外,还将使用以下字符: " " Normal、Visual 和 Operator-pending name 菜单项名称。 noremenu 如果菜单项的 {rhs} 不可重新映射,则为 v:true,否则为 v:false。 priority 菜单顺序优先级 menu-priority rhs 菜单项的右侧。 返回的字符串包含特殊字符,这些字符已像 ":menu" 命令列表的输出中一样被翻译。 当菜单项的 {rhs} 为空时,将返回 "<Nop>"。 script 如果允许对 {rhs} 进行脚本本地重新映射,则为 v:true,否则为 v:false。 请参阅 :menu-script。 shortcut 快捷键(菜单名称中 '&' 后的字符) menu-shortcut silent 如果菜单项使用 <silent> 参数创建,则为 v:true :menu-silent submenus 包含所有子菜单名称的 List。 仅当菜单项具有子菜单时存在。
如果未找到菜单项,则返回一个空字典。
示例
echo menu_info('Edit.Cut')
echo menu_info('File.Save', 'n')
" Display the entire menu hierarchy in a buffer
func ShowMenu(name, pfx)
  let m = menu_info(a:name)
  call append(line('$'), a:pfx .. m.display)
  for child in m->get('submenus', [])
    call ShowMenu(a:name .. '.' .. escape(child, '.'),
                                \ a:pfx .. '    ')
  endfor
endfunc
new
for topmenu in menu_info('').submenus
  call ShowMenu(topmenu, '')
endfor
参数
{name} (字符串)
{mode} (string?)
返回值
(任何)
min({expr}) min()
返回 {expr} 中所有项目的最小值。 例如
echo min([apples, pears, oranges])
{expr} 可以是 ListDictionary。 对于 Dictionary,它返回 Dictionary 中所有值的最小值。 如果 {expr} 既不是 List 也不是 Dictionary,或者 {expr} 中的某个项目无法用作 Number,则会导致错误。 一个空的 ListDictionary 将返回零。
参数
{expr} (any)
返回值
(任何)
mkdir({name} [, {flags} [, {prot}]]) mkdir() E739 创建目录 {name}
如果存在 {flags},则它必须是一个字符串。 空字符串无效。
{flags} 可以包含以下字符标志: "p" 将根据需要创建中间目录 "D" {name} 将在当前函数结束时删除,但不会递归删除 :defer "R" {name} 将在当前函数结束时递归删除 :defer
请注意,当 {name} 包含多个部分并且使用 "p" 时,某些目录可能已经存在。 仅创建的第一个目录及其包含的内容将安排删除。 例如,当使用
call mkdir('subdir/tmp/autoload', 'pR')
并且 "subdir" 已经存在,则 "subdir/tmp" 将安排删除,就像使用
defer delete('subdir/tmp', 'rf')
如果给出 {prot},则它将用于设置新目录的保护位。 默认值为 0o755(rwxr-xr-x:对用户具有 r/w 权限,对其他人具有可读权限)。 使用 0o700 使其对其他人不可读。
{prot} 将应用于 {name} 的所有部分。 因此,如果您创建 /tmp/foo/bar,则 /tmp/foo 将使用 0o700 创建。 例如
call mkdir($HOME .. "/tmp/foo/bar", "p", 0o700)
此函数在 沙盒 中不可用。
如果您尝试使用 {flags} 设置为 "p" 的 mkdir() 创建一个现有目录,则 mkdir() 将静默退出。
函数结果是一个 Number,如果调用成功,则为 TRUE,如果目录创建失败或部分失败,则为 FALSE。
参数
{name} (字符串)
{flags} (string?)
{prot} (string?)
返回值
(任何)
mode([{expr}]) mode()
返回一个表示当前模式的字符串。 如果提供 {expr} 并且它计算为一个非零 Number 或一个非空字符串 (non-zero-arg),则返回完整模式,否则仅返回第一个字母。 另请参阅 state()
n 正常无操作符待定 nov 操作符待定(强制字符级 o_v) noV 操作符待定(强制行级 o_V) noCTRL-V 操作符待定(强制块级 o_CTRL-VCTRL-V 是一个字符 niI 正常使用 i_CTRL-O插入模式 niR 正常使用 i_CTRL-O替换模式 niV 正常使用 i_CTRL-O虚拟替换模式 nt 正常在 终端模拟器 中(插入进入终端模式) ntT 正常使用 t_CTRL-\_CTRL-O终端模式 v 可视化按字符 vs 可视化按字符使用 v_CTRL-O 在选择模式 V 可视化按行 Vs 可视化按行使用 v_CTRL-O 在选择模式 CTRL-V 可视化块级 CTRL-Vs 可视化块级使用 v_CTRL-O 在选择模式 s 选择按字符 S 选择按行 CTRL-S 选择块级 i 插入 ic 插入模式补全 compl-generic ix 插入模式 i_CTRL-X 补全 R 替换 R Rc 替换模式补全 compl-generic Rx 替换模式 i_CTRL-X 补全 Rv 虚拟替换 gR Rvc 虚拟替换模式补全 compl-generic Rvx 虚拟替换模式 i_CTRL-X 补全 c 命令行编辑 cr 命令行编辑覆盖模式 c_<Insert> cv Vim Ex 模式 gQ cvr Vim Ex 模式在覆盖模式下 c_<Insert> r 击键-回车提示 rm -- 更多 -- 提示 r? 一些 :confirm 查询 ! shell 或外部命令正在执行 t 终端模式:键进入作业
这在 'statusline' 选项或 RPC 调用中很有用。在大多数其他地方,它总是返回“c”或“n”。请注意,将来可能会添加更多模式和更具体的模式。最好不要比较整个字符串,而只比较前导字符。另见 visualmode().
参数
{expr} (any?)
返回值
(任何)
msgpackdump({list} [, {type}]) msgpackdump()
将 Vimscript 对象列表转换为 msgpack。返回值是 readfile() 风格的列表。当 {type} 包含“B”时,将返回一个 Blob。示例
call writefile(msgpackdump([{}]), 'fname.mpack', 'b')
或者,使用一个 Blob
call writefile(msgpackdump([{}], 'B'), 'fname.mpack')
这将把单个 0x80 字节写入 fname.mpack 文件(包含零个项目的字典在 messagepack 中由 0x80 字节表示)。
限制: E5004 E5005 1. Funcref 不能被转储。 2. 引用自身的容器不能被转储。 3. 字典键始终以 STR 字符串形式转储。 4. 其他字符串和 Blob 始终以 BIN 字符串形式转储。 5. 第 3 和 4 点不适用于 msgpack-special-dict
参数
{list} (any)
{type} (any?)
返回值
(任何)
msgpackparse({data}) msgpackparse()
readfile() 风格的列表或 Blob 转换为 Vimscript 对象列表。示例
let fname = expand('~/.config/nvim/shada/main.shada')
let mpack = readfile(fname, 'b')
let shada_objects = msgpackparse(mpack)
这将读取 ~/.config/nvim/shada/main.shada 文件到 shada_objects 列表。
限制: 1. 除非使用通用映射(msgpack-special-map)转储 msgpack 映射,否则映射顺序不会被保留。 2. 由于解析器旨在保持所有数据不变(除了 1.),因此某些字符串被解析为 msgpack-special-dict 格式,这使用起来并不方便。 msgpack-special-dict
某些 messagepack 字符串可能会被解析为特殊字典。特殊字典是具有以下特征的字典
1. 恰好包含两个键:_TYPE_VAL。 2. _TYPE 键是 v:msgpack_types 变量中找到的类型之一。 3. _VAL 的值具有以下格式(键列包含 v:msgpack_types 中的键名)
键 值
nil 零,转储时忽略。不被 msgpackparse() 返回,因为引入了 v:null。 boolean 一或零。转储时只检查值是否为 Number。不被 msgpackparse() 返回,因为引入了 v:truev:false。 integer 包含四个数字的 List:符号(-1 或 1),最高两位,从第 62 位到第 31 位的数字,最低 31 位。也就是说,要获得实际数字,需要使用类似以下的代码
_VAL[0] * ((_VAL[1] << 62)
           & (_VAL[2] << 31)
           & _VAL[3])
具有此类型的特殊字典将在以下情况下出现在 msgpackparse() 输出中: 1. Number 为 32 位,且值高于 INT32_MAX 或低于 INT32_MIN。 2. Number 为 64 位,且值高于 INT64_MAX。它不可能低于 INT64_MIN,因为 msgpack C 解析器不支持这样的值。 float Float。此值不可能出现在 msgpackparse() 输出中。 string String,或如果二进制字符串包含零字节,则为 Blob。此值不会出现在 msgpackparse() 输出中,因为引入了 blob。 array List。此值不会出现在 msgpackparse() 输出中。 msgpack-special-map
map 包含两个项目(键和值)的 ListList。如果解析的映射包含以下键之一,则此值将出现在 msgpackparse() 输出中: 1. 任何不是字符串的键(包括二进制字符串键)。 2. 包含 NUL 字节的字符串。 3. 重复键。 ext 包含两个值的 List:第一个是表示扩展类型的带符号整数。第二个是字符串的 readfile() 风格列表。
参数
{data} (any)
返回值
(任何)
nextnonblank({lnum}) nextnonblank()
返回第一个非空白行的行号,该行位于 {lnum} 或其下方。示例
if getline(nextnonblank(1)) =~ "Java" | endif
{lnum} 无效或其下方没有非空白行时,返回零。{lnum} 用法与 getline() 相同。另见 prevnonblank().
参数
{lnum} (integer)
返回值
(任何)
nr2char({expr} [, {utf8}]) nr2char()
返回包含单个字符的字符串,该字符具有数字值 {expr}。示例
echo nr2char(64)                " returns '@'
echo nr2char(32)                " returns ' '
"utf-8" 示例
echo nr2char(300)                " returns I with bow character
始终使用 UTF-8 编码,{utf8} 选项无效,仅出于向后兼容性而存在。请注意,文件中 NUL 字符由 nr2char(10) 指定,因为 NUL 由换行符表示。nr2char(0) 是一个真正的 NUL 并终止字符串,因此会导致空字符串。
参数
{expr} (integer)
{utf8} (boolean?)
返回值
(任何)
nvim_...({...}) nvim_...() E5555 eval-api 调用 nvim api 函数。参数类型检查将比大多数其他内置函数更严格。例如,如果期望 Integer,则必须传入一个 NumberString 不会自动转换。缓冲区编号(由 bufnr() 返回)可以用作 nvim_buf_... 函数的第一个参数。所有期望对象的函数(缓冲区、窗口或标签页)也可以采用数字值 0 来指示当前(聚焦)对象。
参数
{...} (any)
返回值
(任何)
or({expr}, {expr}) or()
对两个参数进行按位或运算。参数将被转换为数字。List、Dict 或 Float 参数会导致错误。另见 and()xor()。示例
let bits = or(bits, 0x80)
基本原理:这是函数而不是使用“|”字符的原因是,Vi 一直使用“|”来分隔命令。在许多地方,不清楚“|”是运算符还是命令分隔符。
参数
{expr} (number)
{expr1} (number)
返回值
(任何)
pathshorten({path} [, {len}]) pathshorten()
缩短路径 {path} 中的目录名并返回结果。尾部(文件名)保持不变。路径中的其他组件将缩短到 {len} 个字母。如果 {len} 被省略或小于 1,则使用 1(单个字母)。保留前导的“~”和“.”字符。示例
echo pathshorten('~/.config/nvim/autoload/file1.vim')
~/.c/n/a/file1.vim
echo pathshorten('~/.config/nvim/autoload/file2.vim', 2)
~/.co/nv/au/file2.vim
路径是否存在并不重要。在错误时返回空字符串。
参数
{path} (string)
{len} (integer?)
返回值
(任何)
perleval({expr}) perleval()
计算 perl 表达式 {expr} 并返回其结果,转换为 Vim 数据结构。数字和字符串按原样返回(字符串被复制)。列表用 Vim List 类型表示。字典用 Vim Dictionary 类型表示,非字符串键会导致错误。
注意: 如果需要数组或哈希,则 {expr} 必须返回对其的引用。示例
echo perleval('[1 .. 4]')
[1, 2, 3, 4]
参数
{expr} (any)
返回值
(任何)
pow({x}, {y}) pow()
返回 {x}{y} 次方,以 Float 类型表示。{x}{y} 必须计算为 FloatNumber。如果 {x}{y} 不是 FloatNumber,则返回 0.0。示例
echo pow(3, 3)
27.0
echo pow(2, 16)
65536.0
echo pow(32, 0.20)
2.0
参数
{x} (number)
{y} (number)
返回值
(任何)
prevnonblank({lnum}) prevnonblank()
返回第一个非空白行的行号,该行位于 {lnum} 或其上方。示例
let ind = indent(prevnonblank(v:lnum - 1))
{lnum} 无效或其上方没有非空白行时,返回零。{lnum} 用法与 getline() 相同。另见 nextnonblank().
参数
{lnum} (integer)
返回值
(任何)
printf({fmt}, {expr1} ...) printf()
返回带有 {fmt} 的 String,其中“%”项被其各自参数的格式化形式替换。示例
echo printf("%4d: E%d %.30s", lnum, errno, msg)
可能会导致
" 99: E42 asdfasdfasdfasdfasdfasdfasdfas"
当用作 method 时,基数将作为第二个参数传递
Compute()->printf("result: %d")
可以使用 call() 将项目作为列表传递。
常用项包括: %s 字符串 %6S 字符串在 6 个显示单元中右对齐 %6s 字符串在 6 个字节中右对齐 %.9s 字符串截断为 9 个字节 %c 单字节 %d 十进制数 %5d 十进制数用空格填充至 5 个字符 %b 二进制数 %08b 二进制数用零填充至至少 8 个字符 %B 二进制数使用大写字母 %x 十六进制数 %04x 十六进制数用零填充至至少 4 个字符 %X 十六进制数使用大写字母 %o 八进制数 %f 浮点数,如 12.23、inf、-inf 或 nan %F 浮点数,如 12.23、INF、-INF 或 NAN %e 浮点数,如 1.23e3、inf、-inf 或 nan %E 浮点数,如 1.23E3、INF、-INF 或 NAN %g 浮点数,根据值使用 %f 或 %e %G 浮点数,根据值使用 %F 或 %E %% 百分号字符本身 %p 容器指针的表示形式
转换规范以“%”开头,以转换类型结尾。所有其他字符都将原样复制到结果中。
“%”开始转换规范。以下参数按顺序出现
% [pos-argument] [flags] [field-width] [.precision] type
pos-argument 最多只能有一个位置参数说明符。它们的形式为 {n$},其中 n >= 1。
flags 零个或多个以下标志
# 该值应转换为“备用形式”。对于 c、d 和 s 转换,此选项无效。对于 o 转换,数字的精度会增加,以强制输出字符串的第一个字符为零(除非以显式的零精度打印零值)。对于 x 和 X 转换,非零结果会在其前面加上字符串“0x”(对于 X 转换,则为“0X”)。
0 (零) 零填充。对于所有转换,转换后的值将用零而不是空格从左侧填充。如果数字转换 (d、o、x 和 X) 同时使用精度,则忽略 0 标志。
- 负字段宽度标志;转换后的值将左对齐在字段边界上。转换后的值将用空格从右侧填充,而不是用空格或零从左侧填充。如果同时使用 - 和 0,则 - 会覆盖 0。
' ' (空格) 在有符号转换 (d) 生成的正数之前应留一个空格。
+ 必须始终在有符号转换生成的数字之前放置一个符号。如果同时使用 + 和空格,则 + 会覆盖空格。
field-width 一个可选的十进制数字字符串,用于指定最小字段宽度。如果转换后的值字节数少于字段宽度,则它将用空格从左侧填充(或如果使用了左对齐标志,则用空格从右侧填充),以填补字段宽度。对于 S 转换,计数以单元格为单位。
.precision 一个可选的精度,形式为一个句点 '.' 后跟一个可选的数字字符串。如果省略数字字符串,则精度取为零。这指定了 d、o、x 和 X 转换必须出现的最小数字位数,s 转换从字符串中打印的最大字节数,或 S 转换从字符串中打印的最大单元格数。对于浮点数,它是小数点后的位数。
type 一个字符,用于指定要应用的转换类型,见下文。
字段宽度或精度(或两者)可以使用星号 "*" 而不是数字字符串来指示。在这种情况下,Number 参数提供字段宽度或精度。负字段宽度被视为左对齐标志后跟一个正字段宽度;负精度被视为缺失。示例
echo printf("%d: %.*s", nr, width, line)
这会将从“line”中使用的文本长度限制为“width”个字节。
如果要格式化的参数使用位置参数说明符指定,并且使用 '*' 来指示要使用数字参数来指定宽度或精度,则要使用的参数也必须使用 {n$} 位置参数说明符指定。参见 printf-$
转换说明符及其含义如下
printf-d printf-b printf-B printf-o printf-x printf-X dbBoxX Number 参数被转换为带符号十进制 (d)、无符号二进制 (b 和 B)、无符号八进制 (o) 或无符号十六进制 (x 和 X) 表示法。字母“abcdef”用于 x 转换;字母“ABCDEF”用于 X 转换。精度(如果有)指定必须出现的最小数字位数;如果转换后的值需要的数字位数更少,则它将用零从左侧填充。在任何情况下,不存在或过小的字段宽度都不会导致数值字段被截断;如果转换的结果比字段宽度更宽,则字段将被扩展以包含转换结果。'h' 修饰符表示参数为 16 位。'l' 修饰符表示参数为长整型。大小将根据您的平台为 32 位或 64 位。 "ll" 修饰符表示参数为 64 位。b 和 B 转换说明符从不接受宽度修饰符,并且始终假定其参数为 64 位整数。通常,这些修饰符没有用。当类型从参数中已知时,它们会被忽略。
i d 的别名 D ld 的别名 U lu 的别名 O lo 的别名
printf-c
c Number 参数被转换为一个字节,并写入结果字符。
printf-s
s 使用 String 参数的文本。如果指定了精度,则不会使用超过指定数量的字节。如果参数不是 String 类型,它会自动转换为与“:echo”相同的格式的文本。 printf-S
S 使用 String 参数的文本。如果指定了精度,则不会使用超过指定数量的显示单元格。
printf-f E807 f F Float 参数被转换为形如 123.456 的字符串。精度指定小数点后的位数。当精度为零时,小数点被省略。当未指定精度时,使用 6。非常大的数字(超出范围或除以零)使用 %f 导致“inf”或“-inf”(使用 %F 导致 INF 或 -INF)。“0.0 / 0.0”使用 %f 导致“nan”(使用 %F 导致 NAN)。示例
echo printf("%.2f", 12.115)
12.12 请注意,舍入取决于系统库。如有疑问,请使用 round()
printf-e printf-E e E Float 参数被转换为形如 1.234e+03 或 1.234E+03(使用 'E')的字符串。精度指定小数点后的位数,与 'f' 相同。
printf-g printf-G g G 如果值介于 0.001(包含)和 10000000.0(不包含)之间,则 Float 参数将像使用 'f' 一样进行转换。否则,对于 'g' 使用 'e',对于 'G' 使用 'E'。当未指定精度时,将删除多余的零和 '+' 符号,除了小数点后的零以外。因此,10000000.0 将导致 1.0e7。
printf-%
% 将写入一个 '%'。不转换任何参数。完整的转换说明符为“%%”。
当需要 Number 参数时,也接受 String 参数并自动转换为 Number。当需要 Float 或 String 参数时,也接受 Number 参数并自动转换为 Float 或 String。任何其他参数类型都会导致错误消息。
E766 E767 {exprN} 参数的数量必须与 '%' 项的数量完全匹配。如果参数不足或过多,则会给出错误。最多可以使用 18 个参数。
printf-$
在某些语言中,当单词顺序与相应的英语消息不同时,错误和信息消息更易读。为了适应具有不同单词顺序的翻译,可以使用位置参数来指示这一点。例如
#, c-format
msgid "%s returning %s"
msgstr "waarde %2$s komt terug van %1$s"
在此示例中,句子的 2 个字符串参数在输出中被反转。
echo printf(
    "In The Netherlands, vim's creator's name is: %1$s %2$s",
    "Bram", "Moolenaar")
在荷兰,vim 的创建者的名字是:Bram Moolenaar
echo printf(
    "In Belgium, vim's creator's name is: %2$s %1$s",
    "Bram", "Moolenaar")
在比利时,vim 的创建者的名字是:Moolenaar Bram
可以使用 '*' 说明符来指定宽度(和精度)。在这种情况下,您必须在参数列表中指定字段宽度位置。
echo printf("%1$*2$.*3$d", 1, 2, 3)
001
echo printf("%2$*3$.*1$d", 1, 2, 3)
2
echo printf("%3$*1$.*2$d", 1, 2, 3)
03
echo printf("%1$*2$.*3$g", 1.4142, 2, 3)
1.414
您可以混合直接和通过位置参数指定宽度和/或精度
echo printf("%1$4.*2$f", 1.4142135, 6)
1.414214
echo printf("%1$*2$.4f", 1.4142135, 6)
1.4142
echo printf("%1$*2$.*3$f", 1.4142135, 6, 2)
1.41
如果字段宽度或精度导致字符串长度超过 6400 个字符,您将遇到溢出错误 E1510
E1500
您不能混合位置参数和非位置参数
echo printf("%s%1$s", "One", "Two")
E1500: 不能混合位置参数和非位置参数: %s%1$s
E1501
您不能在格式字符串中跳过位置参数
echo printf("%3$s%1$s", "One", "Two", "Three")
E1501: $-style 格式中格式参数 2 未使用: %3$s%1$s
E1502
您可以重复使用 [field-width](或 [precision])参数
echo printf("%1$d at width %2$d is: %01$*2$d", 1, 2)
宽度为 2 的 1 是:01
但是,您不能将其用作不同的类型
echo printf("%1$d at width %2$ld is: %01$*2$d", 1, 2)
E1502: 位置参数 2 用作字段宽度,重复用作不同的类型: long int/int
E1503
当使用位置参数,但未提供正确数量的参数时,会引发错误
echo printf("%1$d at width %2$d is: %01$*2$.*3$d", 1, 2)
E1503: 位置参数 3 超出范围: 宽度为 %2$d 的 %1$d 是:%01$*2$.*3$d
只报告第一个错误
echo printf("%01$*2$.*3$d %4$d", 1, 2)
E1503: 位置参数 3 超出范围: %01$*2$.*3$d %4$d
E1504
位置参数可以多次使用
echo printf("%1$s %2$s %1$s", "One", "Two")
One Two One
但是,您不能第二次使用不同的类型
echo printf("%1$s %2$s %1$d", "One", "Two")
E1504: 位置参数 1 类型使用不一致: int/string
E1505
导致格式字符串格式错误的各种其他错误会导致
echo printf("%1$d at width %2$d is: %01$*2$.3$d", 1, 2)
E1505: 无效的格式说明符: 宽度为 %2$d 的 %1$d 是:%01$*2$.3$d
E1507
此内部错误表示解析位置格式参数的逻辑遇到了无法通过其他方式报告的问题。如果您遇到此问题,请向 Vim 报告错误,并复制使用的确切格式字符串和参数。
参数
{fmt} (string)
{expr1} (any?)
返回值
(字符串)
prompt_getprompt({buf}) prompt_getprompt()
返回缓冲区 {buf} 的有效提示文本。{buf} 可以是缓冲区名称或编号。参见 prompt-buffer
如果缓冲区不存在或不是提示缓冲区,则返回空字符串。
参数
{buf} (integer|string)
返回值
(任何)
prompt_setcallback({buf}, {expr}) prompt_setcallback()
将缓冲区 {buf} 的提示回调设置为 {expr}。当 {expr} 为空字符串时,回调将被删除。这只有在 {buf}'buftype' 设置为“prompt”时才有效。
在按下 Enter 时调用回调。当前缓冲区始终为提示缓冲区。在调用回调之前,将为提示添加一个新行,因此调用回调的提示将在倒数第二行。如果回调要向缓冲区添加文本,它必须将文本插入到最后一行之前,因为那里是当前提示所在的位置。这也可以异步完成。回调使用一个参数调用,该参数是用户在提示处输入的文本。如果用户只键入了 Enter,则这可以是空字符串。示例
   func s:TextEntered(text)
     if a:text == 'exit' || a:text == 'quit'
       stopinsert
       " Reset 'modified' to allow the buffer to be closed.
       " We assume there is nothing useful to be saved.
       set nomodified
       close
     else
       " Do something useful with "a:text".  In this example
       " we just repeat it.
       call append(line('$') - 1, 'Entered: "' .. a:text .. '"')
     endif
   endfunc
   call prompt_setcallback(bufnr(), function('s:TextEntered'))
Parameters: ~
  • {buf} (`integer|string`)
  • {expr} (`string|function`)
Return: ~
  (`any`)
prompt_setinterrupt({buf}, {expr}) prompt_setinterrupt()
为缓冲区 {buf} 设置一个回调为 {expr}。当 {expr} 为空字符串时,回调将被删除。这只有在 {buf}'buftype' 设置为“prompt”时才有效。
在插入模式下按下 CTRL-C 时,将调用此回调。如果不设置回调,Vim 会退出插入模式,就像在任何缓冲区中一样。
参数
{buf} (integer|string)
{expr} (string|function)
返回值
(任何)
prompt_setprompt({buf}, {text}) prompt_setprompt()
将缓冲区 {buf} 的提示设置为 {text}。您可能希望 {text} 以空格结尾。结果只有在 {buf}'buftype' 设置为 "prompt" 时才可见。示例
call prompt_setprompt(bufnr(''), 'command: ')
参数
{buf} (integer|string)
{text} (string)
返回值
(任何)
pum_getpos() pum_getpos()
如果弹出菜单(参见 ins-completion-menu)不可见,则返回一个空的 Dictionary,否则,返回一个带有以下键的 Dictionary:高度 可见项目数 宽度 屏幕单元格 行 顶部的屏幕行(0 为第一行) 列 最左侧的屏幕列(0 为第一列) 大小 项目总数 滚动条 TRUE 如果滚动条可见
这些值与 CompleteChanged 期间的 v:event 中的值相同。
返回值
(任何)
pumvisible() pumvisible()
当弹出菜单可见时返回非零值,否则返回零。参见 ins-completion-menu。这可以用来避免一些会删除弹出菜单的操作。
返回值
(任何)
py3eval({expr}) py3eval()
评估 Python 表达式 {expr} 并返回其结果,该结果已转换为 Vim 数据结构。数字和字符串按原样返回(字符串被复制,Unicode 字符串被额外转换为 UTF-8)。列表以 Vim List 类型表示。字典以 Vim Dictionary 类型表示,键被转换为字符串。
参数
{expr} (any)
返回值
(任何)
pyeval({expr}) pyeval() E858 E859 评估 Python 表达式 {expr} 并返回其结果,该结果已转换为 Vim 数据结构。数字和字符串按原样返回(字符串被复制)。列表以 Vim List 类型表示。字典以 Vim Dictionary 类型表示,非字符串键会导致错误。
参数
{expr} (any)
返回值
(任何)
pyxeval({expr}) pyxeval()
评估 Python 表达式 {expr} 并返回其结果,该结果已转换为 Vim 数据结构。使用 Python 2 或 3,参见 python_x'pyxversion'。另见:pyeval()py3eval()
参数
{expr} (any)
返回值
(任何)
rand([{expr}]) rand()
使用种子 {expr} 返回使用 xoshiro128** 算法生成的伪随机数。返回的数字为 32 位,即使在 64 位系统上也是如此,为了保持一致性。{expr} 可以通过 srand() 初始化,并将被 rand() 更新。如果省略 {expr},则使用内部种子值并进行更新。如果 {expr} 无效,则返回 -1。
示例
echo rand()
let seed = srand()
echo rand(seed)
echo rand(seed) % 16  " random number 0 - 15
参数
{expr} (number?)
返回值
(任何)
range({expr} [, {max} [, {stride}]]) range() E726 E727 返回一个包含数字的 List
如果只指定 {expr}: [0, 1, ..., {expr} - 1]
如果指定了 {max}: [{expr}, {expr} + 1, ..., {max}]
如果指定了 {stride}: [{expr}, {expr} + {stride}, ..., {max}](每次用 {stride} 增加 {expr},不会生成超过 {max} 的值)。当最大值为开始值的前一个值时,结果为空列表。当最大值超过开始值的前一个值时,这是一个错误。示例
echo range(4)                " [0, 1, 2, 3]
echo range(2, 4)        " [2, 3, 4]
echo range(2, 9, 3)        " [2, 5, 8]
echo range(2, -2, -1)        " [2, 1, 0, -1, -2]
echo range(0)                " []
echo range(2, 0)        " error!
参数
{expr} (any)
{max} (integer?)
{stride} (integer?)
返回值
(任何)
readblob({fname} [, {offset} [, {size}]]) readblob()
以二进制模式读取文件 {fname} 并返回一个 Blob。如果指定了 {offset},则从指定偏移量读取文件。如果它是一个负值,则用作文件末尾的偏移量。例如,要读取最后 12 个字节
echo readblob('file.bin', -12)
如果指定了 {size},则只读取指定的大小。例如,要读取文件的前 100 个字节
echo readblob('file.bin', 0, 100)
如果 {size} 为 -1 或省略,则将读取从 {offset} 开始的所有数据。这也可用于在 Unix 上读取来自字符设备的数据,此时 {size} 应明确设置。只有当设备支持寻址时才能使用 {offset}。否则,它应该为零。例如,要从串行控制台读取 10 个字节
echo readblob('/dev/ttyS0', 0, 10)
如果文件无法打开,则会显示错误消息,结果为空 Blob。如果偏移量超出文件末尾,则结果为空 blob。如果尝试读取的数据字节数超过可用字节数,则结果将被截断。另见 readfile()writefile()
参数
{fname} (string)
{offset} (integer?)
{size} (integer?)
返回值
(任何)
readdir({directory} [, {expr}]) readdir()
返回一个包含 {directory} 中的文件和目录名称的列表。如果不需要执行复杂的操作,例如限制匹配项的数量,也可以使用 glob()
当省略 {expr} 时,将包含所有条目。如果给出 {expr},则对其进行评估以检查要执行的操作:如果 {expr} 的结果为 -1,则将不再处理进一步的条目。如果 {expr} 的结果为 0,则不会将此条目添加到列表中。如果 {expr} 的结果为 1,则将此条目添加到列表中。每次评估 {expr} 时,v:val 都将设置为条目名称。如果 {expr} 是一个函数,则将名称作为参数传递。例如,要获取以 ".txt" 结尾的文件列表
echo readdir(dirname, {n -> n =~ '.txt$'})
要跳过隐藏文件和备份文件
echo readdir(dirname, {n -> n !~ '^\.\|\~$'})
如果你想获得目录树
function! s:tree(dir)
    return {a:dir : map(readdir(a:dir),
    \ {_, x -> isdirectory(x) ?
    \          {x : s:tree(a:dir .. '/' .. x)} : x})}
endfunction
echo s:tree(".")
在出错时返回一个空列表。
参数
{directory} (string)
{expr} (integer?)
返回值
(任何)
readfile({fname} [, {type} [, {max}]]) readfile()
读取文件 {fname} 并返回一个 List,文件的每一行作为一个项目。行在 NL 字符处断开。以 CR 分隔的 Macintosh 文件将导致单行长行(除非在某处出现 NL)。所有 NUL 字符将被替换为 NL 字符。如果 {type} 包含 "b",则使用二进制模式
如果最后一行以 NL 结尾,则会添加一个额外的空列表项。
不会删除任何 CR 字符。否则
在 NL 之前出现的 CR 字符将被删除。
最后一行是否以 NL 结尾无关紧要。
从文本中删除任何 UTF-8 字节顺序标记。如果给出 {max},则指定要读取的最大行数。这在您只想检查文件的前十行时很有用
for line in readfile(fname, '', 10)
  if line =~ 'Date' | echo line | endif
endfor
如果 {max} 为负数,则返回文件末尾的 -{max} 行,或尽可能多的行。如果 {max} 为零,则结果为空列表。请注意,如果未指定 {max},则整个文件将被读入内存。还要注意,没有对编码进行识别。如果需要,将文件读入缓冲区。已弃用(使用 readblob() 代替):如果 {type} 包含 "B",则返回一个 Blob,其中包含文件的二进制数据,未经修改。如果文件无法打开,则会显示错误消息,结果为空列表。另见 writefile()
参数
{fname} (string)
{type} (string?)
{max} (integer?)
返回值
(任何)
reduce({object}, {func} [, {initial}]) reduce() E998 {func} 将为 {object} 中的每个项目调用,{object} 可以是 StringListBlob{func} 将被调用两次参数:到目前为止的结果和当前项目。处理完所有项目后,将返回结果。
{initial} 是初始结果。如果省略,则使用 {object} 中的第一个项目,并且 {func} 首先针对第二个项目调用。如果未给出 {initial}{object} 为空,则无法计算结果,将给出 E998 错误。
示例
echo reduce([1, 3, 5], { acc, val -> acc + val })
echo reduce(['x', 'y'], { acc, val -> acc .. val }, 'a')
echo reduce(0z1122, { acc, val -> 2 * acc + val })
echo reduce('xyz', { acc, val -> acc .. ',' .. val })
参数
{object} (any)
{func} (function)
{initial} (any?)
返回值
(任何)
reg_executing() reg_executing()
返回正在执行的寄存器的单字母名称。如果未执行任何寄存器,则返回空字符串。参见 @
返回值
(任何)
reg_recorded() reg_recorded()
返回最后记录的寄存器的单字母名称。如果尚未记录任何内容,则返回空字符串。参见 qQ
返回值
(任何)
reg_recording() reg_recording()
返回正在记录的寄存器的单字母名称。如果未进行记录,则返回空字符串。参见 q
返回值
(任何)
reltime() reltime()
reltime({start}) reltime({start}, {end}) 返回一个表示时间值的项目。该项目是一个列表,其项目取决于系统。该项目可以传递给 reltimestr() 以将其转换为字符串,或者传递给 reltimefloat() 以将其转换为浮点数。
如果没有参数,它将返回当前的“相对时间”,这是一个仅在用作 reltime()reltimestr()reltimefloat() 的参数时才有意义的实现定义值。
如果有一个参数,它将返回自参数中指定的时间以来的经过时间。如果有两个参数,它将返回 {start}{end} 之间的经过时间。
{start}{end} 参数必须是 reltime() 返回的值。在出错时返回零。
注意:localtime() 返回当前(非相对)时间。
参数
{start} (any?)
{end_} (any?)
返回值
(任何)
reltimefloat({time}) reltimefloat()
返回一个表示 {time} 时间值的浮点数。时间单位为秒。示例:让 start = reltime() 调用 MyFunction() 让 seconds = reltimefloat(reltime(start)) 参见 reltimestr() 关于开销的说明。另见 profiling。如果出现错误,则返回空字符串
参数
{time} (any)
返回值
(任何)
reltimestr({time}) reltimestr()
返回一个表示 {time} 时间值的字符串。这是秒数、一个点以及微秒数。示例
let start = reltime()
call MyFunction()
echo reltimestr(reltime(start))
请注意,命令的开销将被添加到时间中。前导空格用于使字符串对齐良好。可以使用 split() 删除它。
echo split(reltimestr(reltime(start)))[0]
另见 profiling。如果出现错误,则返回空字符串
参数
{time} (any)
返回值
(任何)
remove({list}, {idx}) remove()
remove({list}, {idx}, {end}) 不使用 {end} 时:从 List {list} 中删除 {idx} 处的项目并返回该项目。使用 {end} 时:删除从 {idx}{end}(包括)的项目并返回包含这些项目的 List。当 {idx} 指向与 {end} 相同的项目时,将返回包含一个项目的列表。当 {end} 指向 {idx} 之前的项目时,这将是一个错误。有关 {idx}{end} 的可能值,请参见 list-index。发生错误时返回零。示例
echo "last item: " .. remove(mylist, -1)
call remove(mylist, 0, 9)
使用 delete() 删除文件。
参数
{list} (any[])
{idx} (整数)
{end_} (integer?)
返回值
(任何)
remove({blob}, {idx}) remove({blob}, {idx}, {end}) 不使用 {end} 时:从 Blob {blob} 中删除 {idx} 处的字节并返回该字节。使用 {end} 时:删除从 {idx}{end}(包括)的字节并返回包含这些字节的 Blob。当 {idx} 指向与 {end} 相同的字节时,将返回包含一个字节的 Blob。当 {end} 指向 {idx} 之前的字节时,这将是一个错误。发生错误时返回零。示例
echo "last byte: " .. remove(myblob, -1)
call remove(mylist, 0, 9)
参数
{blob} (任何类型)
{idx} (整数)
{end_} (integer?)
返回值
(任何)
remove({dict}, {key}) 从 {dict} 中删除键为 {key} 的条目并返回它。示例
echo "removed " .. remove(dict, "one")
如果 {dict} 中没有 {key},则这是一个错误。发生错误时返回零。
参数
{dict} (any)
{key} (string)
返回值
(任何)
rename({from}, {to}) rename()
将名为 {from} 的文件重命名为名为 {to} 的文件。这也可以用于跨文件系统移动文件。结果是一个数字,如果文件成功重命名,则为 0,如果重命名失败,则为非零。 注意:如果 {to} 存在,它将被覆盖,不会发出警告。此函数在 sandbox 中不可用。
参数
{from} (string)
{to} (string)
返回值
(任何)
repeat({expr}, {count}) repeat()
重复 {expr} {count} 次并返回连接的结果。示例
let separator = repeat('-', 80)
{count} 为零或负数时,结果为空。当 {expr}ListBlob 时,结果是 {expr} 连接 {count} 次。示例
let longlist = repeat(['a', 'b'], 3)
结果为 ['a', 'b', 'a', 'b', 'a', 'b']。
参数
{expr} (any)
{count} (integer)
返回值
(任何)
resolve({filename}) resolve() E655 在 MS-Windows 上,当 {filename} 是快捷方式(.lnk 文件)时,以简化的形式返回快捷方式指向的路径。在 Unix 上,在 {filename} 的所有路径组件中重复解析符号链接并返回简化的结果。为了应对链接循环,解析符号链接将在 100 次迭代后停止。在其他系统上,返回简化的 {filename}。简化步骤与 simplify() 相同。resolve() 保持一个指定当前目录的领先路径组件(前提是结果仍然是相对路径名),并且还保留一个尾随路径分隔符。
参数
{filename} (string)
返回值
(任何)
reverse({object}) reverse()
反转 {object} 中项目的顺序。{object} 可以是 ListBlobString。对于 List 和 Blob,项目将被就地反转,并返回 {object}。对于 String,将返回一个新的 String。如果 {object} 不是 List、Blob 或 String,则返回零。如果您希望 List 或 Blob 保持不变,请先制作一份副本
let revlist = reverse(copy(mylist))
参数
{object} (any)
返回值
(任何)
round({expr}) round()
{expr} 四舍五入到最接近的整数值,并将其作为 Float 返回。如果 {expr} 位于两个整数值之间,则使用较大的那个(远离零)。{expr} 必须计算为 FloatNumber。如果 {expr} 不是 FloatNumber,则返回 0.0。示例
echo round(0.456)
0.0
echo round(4.5)
5.0
echo round(-4.5)
-5.0
参数
{expr} (number)
返回值
(任何)
rpcnotify({channel}, {event} [, {args}...]) rpcnotify()
通过 RPC{event} 发送到 {channel} 并立即返回。如果 {channel} 为 0,则该事件将广播到所有通道。示例
au VimLeave call rpcnotify(0, "leaving")
参数
{channel} (integer)
{event} (string)
{args} (any?)
返回值
(任何)
rpcrequest({channel}, {method} [, {args}...]) rpcrequest()
{channel} 发送请求以通过 RPC 调用 {method},并在收到响应之前阻塞。示例
let result = rpcrequest(rpc_chan, "func", 1, 2, 3)
参数
{channel} (integer)
{method} (string)
{args} (any?)
返回值
(任何)
rubyeval({expr}) rubyeval()
计算 Ruby 表达式 {expr} 并返回将其结果转换为 Vim 数据结构。数字、浮点数和字符串按原样返回(字符串被复制)。数组表示为 Vim List 类型。哈希表示为 Vim Dictionary 类型。其他对象表示为其 "Object#to_s" 方法返回的字符串。
参数
{expr} (any)
返回值
(任何)
screenattr({row}, {col}) screenattr()
screenchar() 相似,但返回属性。这是一个相当任意的数字,只能用于与其他位置的属性进行比较。当行或列超出范围时返回 -1。
参数
{row} (integer)
{col} (integer)
返回值
(任何)
screenchar({row}, {col}) screenchar()
结果是一个数字,它是屏幕上位置 [row, col] 处的字符。这适用于所有可能的屏幕位置,包括状态行、窗口分隔符和命令行。左上角位置是第一行,第一列。字符不包含组合字符。对于双字节编码,它可能只是第一个字节。这主要用于测试。当行或列超出范围时返回 -1。
参数
{row} (integer)
{col} (integer)
返回值
(任何)
screenchars({row}, {col}) screenchars()
结果是 List 的数字。第一个数字与 screenchar() 返回的数字相同。后面的数字是基础字符上的组合字符。这主要用于测试。当行或列超出范围时返回空列表。
参数
{row} (integer)
{col} (integer)
返回值
(任何)
screencol() screencol()
结果是一个数字,它是光标的当前屏幕列。最左边的列编号为 1。此函数主要用于测试。
注意:始终返回当前屏幕列,因此如果在命令中使用(例如:“:echo screencol()”),它将返回命令行内的列,当命令执行时为 1。要获取文件中光标的位置,请使用以下映射之一
nnoremap <expr> GG ":echom " .. screencol() .. "\n"
nnoremap <silent> GG :echom screencol()<CR>
noremap GG <Cmd>echom screencol()<CR>
返回值
(任何)
screenpos({winid}, {lnum}, {col}) screenpos()
结果是一个 Dict,包含窗口 {winid} 中缓冲区行 {lnum} 和列 {col} 处文本字符的屏幕位置。{col} 是一个以 1 为基的字节索引。Dict 具有以下成员:row 屏幕行 col 第一个屏幕列 endcol 最后一个屏幕列 curscol 光标屏幕列 如果指定的位置不可见,则所有值都为零。当字符占用多个屏幕单元格时,"endcol" 值与 "col" 不同。例如,对于 Tab,"col" 可以为 1,而 "endcol" 可以为 8。对于双宽度字符,"curscol" 值是光标将放置的位置。对于 Tab,它将与 "endcol" 相同,而对于双宽度字符,它将与 "col" 相同。conceal 功能在此处被忽略,列号与 'conceallevel' 为零时相同。您可以将光标设置为正确的位置,并使用 screencol() 来获取 conceal 考虑在内的值。如果位置位于关闭的折叠中,则返回第一个字符的屏幕位置,{col} 不使用。如果 {winid} 无效,则返回空 Dict。
参数
{winid} (integer)
{lnum} (integer)
{col} (integer)
返回值
(任何)
screenrow() screenrow()
结果是一个数字,它是光标的当前屏幕行。顶行编号为 1。此函数主要用于测试。或者,您可以使用 winline()
注意:screencol() 相同的限制。
返回值
(任何)
screenstring({row}, {col}) screenstring()
结果是一个 String,其中包含屏幕上位置 [row, col] 处的基础字符和任何组合字符。这类似于 screenchars(),但返回包含字符的 String。这主要用于测试。当行或列超出范围时返回空字符串。
参数
{row} (integer)
{col} (integer)
返回值
(任何)
search({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]]) search() 搜索正则表达式模式 {pattern}。搜索从光标位置开始(您可以使用 cursor() 设置它)。
当找到匹配项时,将返回其行号。如果没有匹配项,则返回 0 并且光标不会移动。不会显示任何错误消息。要获取匹配的字符串,请使用 matchbufline()
{flags} 是一个 String,它可以包含以下字符标志:'b' 向后搜索而不是向前搜索 'c' 接受光标位置的匹配 'e' 移动到匹配的末尾 'n' 不要移动光标 'p' 返回匹配子模式的编号(见下文)'s' 在光标的前一个位置设置 ' 标记 'w' 在文件末尾环绕 'W' 不要在文件末尾环绕 'z' 从光标列而不是零开始搜索 如果没有给出 'w' 或 'W',则 'wrapscan' 选项适用。
如果提供 's' 标志,则仅当光标移动时才设置 ' 标记。's' 标志不能与 'n' 标志组合使用。
'ignorecase''smartcase''magic' 将被使用。
当没有给出 'z' 标志时,向前搜索始终从第零列开始,然后跳过光标之前的匹配项。当 'c' 标志存在于 'cpo' 中时,下次搜索将从匹配项之后开始。如果没有 'c' 标志,下次搜索将从匹配项开始处之后的一列开始。这对于重叠匹配很重要。见 cpo-c。您也可以插入 "\ze" 来更改匹配结束的位置,见 /\ze
当向后搜索并且给出 'z' 标志时,搜索将从第零列开始,因此当前行中不会找到任何匹配项(除非环绕文件末尾)。
当给出 {stopline} 参数时,搜索将在搜索该行后停止。这对于将搜索限制在一系列行很有用。示例
let match = search('(', 'b', line("w0"))
let end = search('END', '', line("w$"))
当使用{stopline}且其不为零时,这也意味着搜索不会绕过文件末尾。零值等于不提供参数。
当给出{timeout}参数时,搜索将在超过此毫秒数后停止。因此,当{timeout}为500时,搜索将在半秒后停止。该值必须不为负。零值就像不提供参数一样。
注意: 仅在搜索时才考虑超时,而在评估{skip}表达式时不考虑。
如果给出{skip}表达式,则在光标位于匹配项的开头时对其进行评估。如果评估结果为非零,则跳过此匹配项。例如,这可用于跳过注释或字符串中的匹配项。{skip}可以是字符串(作为表达式评估)、函数引用或lambda。当{skip}被省略或为空时,将接受每个匹配项。当评估{skip}导致错误时,搜索将中止并返回-1。 search()-sub-match
使用“p”标志时,返回值比\(\)中的第一个子匹配项多一个。如果它们都没有匹配,但整个模式匹配,则为1。要获取列号,请使用searchpos()
光标将定位在匹配项处,除非使用“n”标志。
示例(遍历参数列表中的所有文件)
let n = 1
while n <= argc()            " loop over all files in arglist
  exe "argument " .. n
  " start at the last char in the file and wrap for the
  " first search to find match at start of file
  normal G$
  let flags = "w"
  while search("foo", flags) > 0
    s/foo/bar/g
    let flags = "W"
  endwhile
  update                    " write the file if modified
  let n = n + 1
endwhile
使用一些标志的示例
echo search('\<if\|\(else\)\|\(endif\)', 'ncpe')
这将在光标下或光标后搜索关键字“if”、“else”和“endif”。由于“p”标志,它将根据找到的关键字返回1、2或3,或者如果搜索失败则返回0。光标位于行首第一个单词上
if (foo == 0) | let foo = foo + 1 | endif
该函数将返回1。如果没有“c”标志,该函数将找到“endif”并返回3。如果没有“e”标志,如果光标位于“if”的“f”上,也会发生相同的情况。“n”标志告诉函数不要移动光标。
参数
{pattern} (字符串)
{flags} (string?)
{stopline} (integer?)
{timeout} (integer?)
{skip} (string|function?)
返回值
(任何)
searchcount([{options}]) searchcount()
获取或更新上次搜索计数,例如在'shortmess'中没有“S”标志时显示的内容。即使'shortmess'包含“S”标志,这也适用。
这将返回一个Dictionary。如果先前模式未设置且未指定“pattern”,则字典为空。
键类型含义
current Number 匹配项的当前位置;如果光标位置在第一个匹配项之前,则为0 exact_match Boolean 如果“current”与“pos”匹配,则为1,否则为0 total Number 找到的匹配项总数 incomplete Number 0:搜索已完全完成 1:重新计算超时 2:超过最大计数
有关{options},请参阅下面的内容。
要获取上次搜索计数,当按下nN时,请使用recompute: 0调用此函数。这有时会返回错误信息,因为nN的最大计数为99。如果超过99,结果必须为最大计数加1(100)。如果要获取正确的信息,请指定recompute: 1
" result == maxcount + 1 (100) when many matches
let result = searchcount(#{recompute: 0})
" Below returns correct result (recompute defaults
" to 1)
let result = searchcount()
此函数可用于将计数添加到'statusline'
function! LastSearchCount() abort
  let result = searchcount(#{recompute: 0})
  if empty(result)
    return ''
  endif
  if result.incomplete ==# 1     " timed out
    return printf(' /%s [?/??]', @/)
  elseif result.incomplete ==# 2 " max count exceeded
    if result.total > result.maxcount &&
    \  result.current > result.maxcount
      return printf(' /%s [>%d/>%d]', @/,
      \             result.current, result.total)
    elseif result.total > result.maxcount
      return printf(' /%s [%d/>%d]', @/,
      \             result.current, result.total)
    endif
  endif
  return printf(' /%s [%d/%d]', @/,
  \             result.current, result.total)
endfunction
let &statusline ..= '%{LastSearchCount()}'
" Or if you want to show the count only when
" 'hlsearch' was on
" let &statusline ..=
" \   '%{v:hlsearch ? LastSearchCount() : ""}'
您还可以更新搜索计数,这在CursorMovedCursorMovedI自动命令中很有用
autocmd CursorMoved,CursorMovedI *
  \ let s:searchcount_timer = timer_start(
  \   200, function('s:update_searchcount'))
function! s:update_searchcount(timer) abort
  if a:timer ==# s:searchcount_timer
    call searchcount(#{
    \ recompute: 1, maxcount: 0, timeout: 100})
    redrawstatus
  endif
endfunction
这也可以用于使用“pattern”在当前缓冲区中统计匹配的文本。
" Count '\<foo\>' in this buffer
" (Note that it also updates search count)
let result = searchcount(#{pattern: '\<foo\>'})
" To restore old search count by old pattern,
" search again
call searchcount()
{options}必须是一个Dictionary。它可以包含
键类型含义
recompute Boolean 如果为TRUE,则重新计算计数,就像执行了nN一样。否则返回最后计算的结果(当nN'shortmess'中没有“S”时使用,或者调用此函数)。(默认:TRUE) pattern String 如果给出且与@/不同,则重新计算。这与在调用此函数之前执行以下命令的效果相同
let @/ = pattern
(默认:@/) timeout Number 0或负数表示没有超时。重新计算结果的超时毫秒数(默认:0) maxcount Number 0或负数表示没有限制。重新计算结果时匹配文本的最大计数。如果搜索超过总计数,“total”值将变为maxcount + 1(默认:0) pos List [lnum, col, off] 重新计算结果时的值。这将更改“current”结果值。请参见cursor()getpos()(默认:光标位置)
参数
{options} (table?)
返回值
(任何)
searchdecl({name} [, {global} [, {thisblock}]]) searchdecl()
搜索{name}的声明。
使用非零{global}参数,它就像gD一样,在文件中找到第一个匹配项。否则,它就像gd一样,在函数中找到第一个匹配项。
使用非零{thisblock}参数,将忽略在光标位置之前结束的{}块中的匹配项。避免只在另一个范围内找到变量声明。
将光标移动到找到的匹配项。成功返回零,失败返回非零。例如
if searchdecl('myvar') == 0
   echo getline('.')
endif
参数
{name} (字符串)
{global} (boolean?)
{thisblock} (boolean?)
返回值
(任何)
searchpair()
searchpair({start}, {middle}, {end} [, {flags} [, {skip} [, {stopline} [, {timeout}]]]]) 搜索嵌套的开始-结束对的匹配项。这可用于查找与“if”匹配的“endif”,同时忽略中间的其他if/endif对。搜索从光标开始。默认情况下,搜索向前,在{flags}中包含“b”表示向后搜索。如果找到匹配项,则光标将定位在该匹配项处,并返回行号。如果未找到匹配项,则返回0或-1,并且光标不会移动。不会显示错误消息。
{start}{middle}{end}是模式,请参见pattern。它们不能包含\( \)对。允许使用%( \)。当{middle}不为空时,它将在从任一方向搜索时被找到,但仅当不在嵌套的开始-结束对中时。典型用法是
echo searchpair('\<if\>', '\<else\>', '\<endif\>')
通过将{middle}留空,将跳过“else”。
{flags} 'b'、'c'、'n'、's'、'w'和'W'的使用方式与search()相同。此外:'r' 重复直到没有更多匹配项找到;将找到最外层的对。意味着“W”标志。'm' 返回匹配项的匹配项数量,而不是行号;当使用“r”时,将大于1。 注意: 通常最好使用“W”标志,以避免绕过文件末尾。
当找到{start}{middle}{end}的匹配项时,{skip}表达式将在光标定位在匹配项的开头时进行评估。如果要跳过此匹配项,则应返回非零。例如,因为它在注释或字符串中。当{skip}被省略或为空时,将接受每个匹配项。当评估{skip}导致错误时,搜索将中止并返回-1。{skip}可以是字符串、lambda、funcref或partial。其他任何内容都将使函数失败。
有关{stopline}{timeout},请参见search()
使用'ignorecase'的值。'magic'被忽略,模式的使用方式就像它已打开一样。
搜索从光标处精确开始。在搜索方向上,下一个字符处的{start}{middle}{end}的匹配项是找到的第一个匹配项。例如
if 1
  if 2
  endif 2
endif 1
从“if 2”开始,光标位于“i”上,并向前搜索,将找到“endif 2”。从“if 2”之前的字符开始,将找到“endif 1”。这是因为“if 2”将首先被找到,然后将其视为从“if 2”到“endif 2”的嵌套if/endif。当向后搜索并且{end}超过一个字符时,在模式末尾添加“\zs”可能会有用,这样,当光标位于带有结束的匹配项中时,它将找到匹配的开始。
例如,要在Vim脚本中查找“endif”命令
echo searchpair('\<if\>', '\<el\%[seif]\>', '\<en\%[dif]\>', 'W',
\ 'getline(".") =~ "^\\s*\""')
光标必须位于要找到匹配项的“if”处或之后。请注意,使用单引号字符串以避免必须双重转义反斜杠。跳过表达式仅捕获行首的注释,而不是命令后的注释。此外,行中间的“en”或“if”单词也被视为匹配项。另一个示例,用于搜索“}”的匹配“{”
echo searchpair('{', '', '}', 'bW')
当光标位于要找到匹配项的“}”处或之前时,这将起作用。要拒绝语法突出显示识别为字符串的匹配项
echo searchpair('{', '', '}', 'bW',
     \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"')
参数
{start} (string)
{middle} (string)
{end_} (string)
{flags} (string?)
{skip} (string|function?)
{stopline} (integer?)
{timeout} (integer?)
返回值
(integer)
searchpairpos()
searchpairpos({start}, {middle}, {end} [, {flags} [, {skip} [, {stopline} [, {timeout}]]]]) 与searchpair()相同,但返回一个带有匹配项的行和列位置的ListList的第一个元素是行号,第二个元素是匹配项列位置的字节索引。如果未找到匹配项,则返回[0, 0]。
let [lnum,col] = searchpairpos('{', '', '}', 'n')
有关更大的、更有用的示例,请参见match-parens
参数
{start} (string)
{middle} (string)
{end_} (string)
{flags} (string?)
{skip} (string|function?)
{stopline} (integer?)
{timeout} (integer?)
返回值
([integer, integer])
searchpos()
searchpos({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]]) 与search()相同,但返回一个带有匹配项的行和列位置的ListList的第一个元素是行号,第二个元素是匹配项列位置的字节索引。如果未找到匹配项,则返回[0, 0]。例如
let [lnum, col] = searchpos('mypattern', 'n')
当给出“p”标志时,将有一个额外的项目,其中包含子模式匹配编号search()-sub-match。例如
let [lnum, col, submatch] = searchpos('\(\l\)\|\(\u\)', 'np')
在此示例中,当找到小写字母/\l时,“submatch”为2,当找到大写字母/\u时,“submatch”为3。
参数
{pattern} (字符串)
{flags} (string?)
{stopline} (integer?)
{timeout} (integer?)
{skip} (string|function?)
返回值
(任何)
serverlist() serverlist()
返回服务器地址列表,如果所有服务器都已停止,则返回空。 serverstart() serverstop() 例如
echo serverlist()
返回值
(任何)
serverstart([{address}]) serverstart()
{address}处打开套接字或命名管道,并侦听RPC消息。客户端可以将API命令发送到返回的地址以控制Nvim。
返回地址字符串(可能与{address}参数不同,请参见下文)。
如果{address}包含冒号(“:”),则它是TCP/IPv4/IPv6地址,其中最后一个“:”分隔主机和端口(空或零分配随机端口)。
否则,{address}是命名管道的路径(Windows 除外)。
如果{address}没有斜杠(“/”),则将其视为以这种格式生成的路径的“name”部分
stdpath("run").."/{name}.{pid}.{counter}"
如果省略{address},则名称为“nvim”。
echo serverstart()
=> /tmp/nvim.bram/oknANW/nvim.15430.5
列出所有Nvim服务器的示例bash命令
ls ${XDG_RUNTIME_DIR:-${TMPDIR}nvim.${USER}}/*/nvim.*.0
示例命名管道
if has('win32')
  echo serverstart('\\.\pipe\nvim-pipe-1234')
else
  echo serverstart('nvim.sock')
endif
示例TCP/IP地址
echo serverstart('::1:12345')
参数
{address} (string?)
返回值
(任何)
serverstop({address}) serverstop()
关闭{address}处的管道或套接字。如果{address}有效,则返回TRUE,否则返回FALSE。如果v:servername已停止,则将其设置为serverlist()中下一个可用的地址。
参数
{address} (string)
返回值
(任何)
setbufline({buf}, {lnum}, {text}) setbufline()
在缓冲区 {buf} 中将第 {lnum} 行设置为 {text}。这与针对指定缓冲区的 setline() 相似。
此函数仅适用于已加载的缓冲区。如有必要,请首先调用 bufload()
要插入行,请使用 appendbufline()
{text} 可以是用于设置单行的字符串,也可以是用于设置多行的字符串列表。如果列表超出最后一行,则会添加这些行。如果列表为空,则不会进行任何更改,并返回零。
有关{buf}的使用,请参见上面的 bufname()
{lnum} 的使用方法与 setline() 相同。使用 "$" 表示缓冲区 {buf} 中的最后一行。当 {lnum} 恰好在最后一行下方时,{text} 将添加到最后一行下方。成功时返回 0,失败时返回 1。
如果 {buf} 不是有效的缓冲区或 {lnum} 无效,则会显示错误消息。
参数
{buf} (integer|string)
{lnum} (integer)
{text} (string|string[])
返回值
(任何)
setbufvar({buf}, {varname}, {val}) setbufvar()
将缓冲区 {buf} 中的选项或局部变量 {varname} 设置为 {val}。这也适用于全局或局部窗口选项,但不适用于全局或局部窗口变量。对于局部窗口选项,全局值保持不变。关于 {buf} 的使用方法,请参见上面的 bufname(){varname} 参数是字符串。请注意,必须使用不带“b:”的变量名。示例
call setbufvar(1, "&mod", 1)
call setbufvar("todo", "myvar", "foobar")
此函数在 沙盒 中不可用。
参数
{buf} (integer|string)
{varname} (string)
{val} (any)
返回值
(任何)
setcellwidths({list}) setcellwidths()
指定字符范围的单元格宽度的覆盖。这告诉 Vim 在终端中显示字符时,以屏幕单元格计算字符的宽度。这些值将覆盖 'ambiwidth'。示例
call setcellwidths([
             \ [0x111, 0x111, 1],
             \ [0x2194, 0x2199, 2],
             \ ])
{list} 参数是一个列表,包含三个数字的列表:[{low}, {high}, {width}]。 E1109 E1110 {low}{high} 可以相同,在这种情况下,这指的是一个字符。否则,它表示从 {low}{high}(包含)的字符范围。 E1111 E1114 只能使用值 0x80 及更高的字符。
{width} 必须是 1 或 2,表示屏幕单元格中的字符宽度。 E1112
如果参数无效,或者范围与另一个范围重叠,则会显示错误。 E1113
如果新值导致 'fillchars''listchars' 变得无效,则会拒绝该值,并显示错误。
要清除覆盖,请传递一个空的 {list}
call setcellwidths([])
您可以使用脚本 $VIMRUNTIME/scripts/emoji_list.lua 来查看已知表情符号字符的效果。将光标移动到文本中,检查您的终端的单元格宽度是否与 Vim 对每个表情符号的了解一致。如果看起来不对劲,则需要调整 {list} 参数。
参数
{list} (any[])
返回值
(任何)
setcharpos({expr}, {list}) setcharpos()
setpos() 相同,但使用指定的列号作为字符索引,而不是行中的字节索引。
示例:在第 8 行中包含文本“여보세요”
call setcharpos('.', [0, 8, 4, 0])
将光标定位在第四个字符“요”上。
call setpos('.', [0, 8, 4, 0])
将光标定位在第二个字符“보”上。
参数
{expr} (string)
{list} (integer[])
返回值
(任何)
setcharsearch({dict}) setcharsearch()
将当前字符搜索信息设置为 {dict},其中包含以下一个或多个条目
char 用于后续 ,; 命令的字符;空字符串清除字符搜索的正向方向;1 表示正向,0 表示直到字符搜索类型为止的反向;1 表示 tT 字符搜索,0 表示 fF 字符搜索
这对于从脚本中保存/恢复用户的字符搜索非常有用
let prevsearch = getcharsearch()
" Perform a command which clobbers user's search
call setcharsearch(prevsearch)
另请参见 getcharsearch()
参数
{dict} (string)
返回值
(任何)
setcmdline({str} [, {pos}]) setcmdline()
将命令行设置为 {str},并将光标位置设置为 {pos}。如果省略 {pos},则将光标定位在文本之后。成功时返回 0,未编辑命令行时返回 1。
参数
{str} (string)
{pos} (integer?)
返回值
(任何)
setcmdpos({pos}) setcmdpos()
将命令行中的光标位置设置为字节位置 {pos}。第一个位置是 1。使用 getcmdpos() 获取当前位置。仅在编辑命令行时有效,因此您必须使用 c_CTRL-\_ec_CTRL-R_=c_CTRL-R_CTRL-R 以及“=” 。对于 c_CTRL-\_ec_CTRL-R_CTRL-R 以及“=” ,将在命令行设置为表达式后设置位置。对于 c_CTRL-R_= ,将在评估表达式后但插入结果文本之前设置位置。如果数字过大,则将光标置于行尾。数字小于 1 将导致未定义的结果。成功时返回 0,未编辑命令行时返回 1。
参数
{pos} (integer)
返回值
(任何)
setcursorcharpos({lnum}, {col} [, {off}]) setcursorcharpos()
setcursorcharpos({list}) 与 cursor() 相同,但使用指定的列号作为字符索引,而不是行中的字节索引。
示例:在第 4 行中包含文本“여보세요”
call setcursorcharpos(4, 3)
将光标定位在第三个字符“세”上。
call cursor(4, 3)
将光标定位在第一个字符“여”上。
参数
{list} (integer[])
返回值
(任何)
setenv({name}, {val}) setenv()
将环境变量 {name} 设置为 {val}。示例
call setenv('HOME', '/home/myhome')
{val}v:null 时,将删除环境变量。另请参见 expr-env
参数
{name} (字符串)
{val} (string)
返回值
(任何)
setfperm({fname}, {mode}) setfperm() chmod{fname} 的文件权限设置为 {mode}{mode} 必须是一个包含 9 个字符的字符串。它的格式为“rwxrwxrwx”,其中每个“rwx”标志组分别代表文件所有者、文件所属组和其他用户的权限。“-”字符表示权限关闭,任何其他字符表示打开。不支持多字节字符。
例如,“rw-r-----” 表示用户可读可写,组可读,其他用户不可访问。“xx-x-----” 将执行相同的操作。
成功时返回非零值,失败时返回零。
要读取权限,请参见 getfperm()
参数
{fname} (string)
{mode} (string)
返回值
(任何)
setline({lnum}, {text}) setline()
将当前缓冲区的第 {lnum} 行设置为 {text}。要插入行,请使用 append()。要设置另一个缓冲区中的行,请使用 setbufline()
{lnum} 的使用方法与 getline() 相同。当 {lnum} 恰好在最后一行下方时,{text} 将添加到最后一行下方。{text} 可以是任何类型,也可以是任何类型的列表,每个项目都将转换为字符串。当 {text} 是一个空列表时,不会进行任何更改,并将返回 FALSE。
如果成功,则返回 FALSE。如果失败(最可能是因为 {lnum} 无效),则返回 TRUE。
示例
call setline(5, strftime("%c"))
{text} 是一个 List 时,将把第 {lnum} 行和后续行设置为列表中的项目。示例
call setline(5, ['aaa', 'bbb', 'ccc'])
这等效于
for [n, l] in [[5, 'aaa'], [6, 'bbb'], [7, 'ccc']]
  call setline(n, l)
endfor
注意:不会设置“[' 和 ']'”标记。
参数
{lnum} (integer)
{text} (any)
返回值
(任何)
setloclist({nr}, {list} [, {action} [, {what}]]) setloclist()
创建、替换或添加到窗口 {nr} 的位置列表。{nr} 可以是窗口编号或 window-ID。当 {nr} 为零时,将使用当前窗口。
对于位置列表窗口,将修改显示的位置列表。对于无效的窗口编号 {nr},将返回 -1。否则,与 setqflist() 相同。另请参见 location-list
关于 {action},请参见 setqflist-action
如果提供了可选的 {what} 字典参数,则仅设置 {what} 中列出的项目。有关 {what} 中支持的键列表,请参见 setqflist()
参数
{nr} (整数)
{list} (any)
{action} (string?)
{what} (table?)
返回值
(任何)
setmatches({list} [, {win}]) setmatches()
恢复由 getmatches() 为当前窗口保存的匹配列表。成功时返回 0,否则返回 -1。在恢复列表之前,将清除所有当前匹配。请参见 getmatches() 的示例。如果指定了 {win},则使用具有此编号或窗口 ID 的窗口,而不是当前窗口。
参数
{list} (any)
{win} (整数?)
返回值
(任何)
setpos({expr}, {list}) setpos()
设置字符串 {expr} 的位置。可能的值:. 光标 ' 标记 x
{list} 必须是一个包含四个或五个数字的 List:[bufnum, lnum, col, off] [bufnum, lnum, col, off, curswant]
“bufnum” 是缓冲区编号。零可以用于当前缓冲区。设置大写标记时,将“bufnum” 用于标记位置。对于其他标记,它指定要设置标记的缓冲区。您可以使用 bufnr() 函数将文件名转换为缓冲区编号。设置光标和“'”标记时,将忽略“bufnum”,因为这些与窗口关联,而不是缓冲区。不会更改跳转列表。
“lnum” 和“col” 是缓冲区中的位置。第一列是 1。使用零“lnum” 删除标记。如果“col” 小于 1,则使用 1。要使用字符计数而不是字节计数,请使用 setcharpos()
仅当 'virtualedit' 设置时,才会使用“off” 编号。然后,它将是屏幕列中距字符起点的偏移量。例如,<Tab> 内的位置或最后一个字符之后的位置。
仅当设置光标位置时,才会使用“curswant” 编号。它设置垂直移动光标时的首选列。如果缺少“curswant” 编号,则不会设置首选列。如果存在并且正在设置标记位置,则不会使用它。
请注意,对于 '< 和 '>,更改行号可能会导致标记实际上被交换,以便 '< 始终位于 '> 之前。
如果能够设置位置,则返回 0,否则返回 -1。如果 {expr} 无效,则会显示错误消息。
另请参见 setcharpos()getpos()getcurpos()
这不会恢复垂直移动的首选列;如果您使用此方法设置光标位置,则 jk 运动将跳转到以前的列!使用 cursor() 还可以设置首选列。另请参见 winrestview() 中的“curswant” 键。
参数
{expr} (string)
{list} (integer[])
返回值
(任何)
setqflist({list} [, {action} [, {what}]]) setqflist()
创建、替换或添加到快速修复列表。
如果提供了可选的 {what} 字典参数,则仅设置 {what} 中列出的项目。第一个 {list} 参数将被忽略。请参见下方有关 {what} 中支持的项目的说明。 setqflist-what
{what}不存在时,使用{list}中的项目。每个项目必须是一个字典。{list}中的非字典项目将被忽略。每个字典项目可以包含以下条目
bufnr 缓冲区编号;必须是有效缓冲区的编号 文件名 文件的名称;仅当 "bufnr" 不存在或无效时使用。 模块 模块的名称;如果给出,它将在 quickfix 错误窗口中使用,而不是文件名。 lnum 文件中的行号 end_lnum 行的结尾,如果项目跨越多行 pattern 用于定位错误的搜索模式 col 列号 vcol 非零时:"col" 是可视列 零时:"col" 是字节索引 end_col 结束列,如果项目跨越多列 nr 错误编号 text 错误的描述 type 单个字符的错误类型,'E'、'W' 等。有效的识别错误消息 user_data 与项目关联的自定义数据,可以是任何类型。
"col"、"vcol"、"nr"、"type" 和 "text" 条目是可选的。可以使用 "lnum" 或 "pattern" 条目来定位匹配的错误行。如果 "filename" 和 "bufnr" 条目不存在,或者 "lnum" 和 "pattern" 条目都不存在,那么该项目将不会被视为错误行。如果 "pattern" 和 "lnum" 都存在,那么将使用 "pattern"。如果未提供 "valid" 条目,则当 "bufnr" 是有效缓冲区或 "filename" 存在时,将设置有效标志。如果提供一个空的 {list},quickfix 列表将被清除。请注意,该列表与 getqflist() 返回的列表不完全相同。
{action} 值: setqflist-action E927 'a' 将 {list} 中的项目添加到现有的 quickfix 列表中。如果没有现有的列表,则创建一个新的列表。
'r' 用 {list} 中的项目替换当前 quickfix 列表中的项目。这也可以用来清除列表
call setqflist([], 'r')
'u' 与 'r' 相似,但尝试保留 quickfix 列表中的当前选择。 'f' 释放 quickfix 堆栈中的所有 quickfix 列表。
如果 {action} 不存在或设置为 ' ',则创建一个新的列表。新的 quickfix 列表在堆栈中的当前 quickfix 列表之后添加,并且所有后续列表都将被释放。要将新的 quickfix 列表添加到堆栈的末尾,请将 {what} 中的 "nr" 设置为 "$"。
可以在字典 {what} 中指定以下项目: context quickfix 列表上下文。参见 quickfix-context efm 用于解析 "lines" 中文本的 errorformat。如果不存在,则使用 'errorformat' 选项值。参见 quickfix-parse id quickfix 列表标识符 quickfix-ID idx quickfix 列表中当前条目的索引,由 "id" 或 "nr" 指定。如果设置为 '$',则将列表中的最后一项设置为当前项。参见 quickfix-index items quickfix 条目的列表。与 {list} 参数相同。 lines 使用 'errorformat' 解析行列表并将结果条目添加到 quickfix 列表 {nr}{id} 中。只支持 List 值。参见 quickfix-parse nr quickfix 堆栈中的列表编号;零表示当前 quickfix 列表,"$" 表示最后一个 quickfix 列表。 quickfixtextfunc 用于在 quickfix 窗口中获取要显示的文本的函数。该值可以是函数的名称、funcref 或 lambda。有关如何编写函数以及示例,请参阅 quickfix-window-function。 title quickfix 列表标题文本。参见 quickfix-title {what} 中不支持的键将被忽略。如果 "nr" 项目不存在,则修改当前 quickfix 列表。在创建新的 quickfix 列表时,"nr" 可以设置为大于 quickfix 堆栈大小的值。在修改 quickfix 列表时,为了确保修改正确的列表,应该使用 "id" 而不是 "nr" 来指定列表。
示例(另请参阅 setqflist-examples
call setqflist([], 'r', {'title': 'My search'})
call setqflist([], 'r', {'nr': 2, 'title': 'Errors'})
call setqflist([], 'a', {'id':qfid, 'lines':["F1:10:L10"]})
成功返回零,失败返回 -1。
此函数可用于创建独立于 'errorformat' 设置的 quickfix 列表。使用类似 :cc 1 的命令跳转到第一个位置。
参数
{list} (vim.quickfix.entry[])
{action} (string?)
{what} (vim.fn.setqflist.what?)
返回值
(任何)
setreg({regname}, {value} [, {options}]) setreg()
将寄存器 {regname} 设置为 {value}。如果 {regname} 为 "" 或 "@",则使用未命名的寄存器 '"'。{regname} 参数是一个字符串。
{value} 可以是 getreg()getreginfo() 返回的任何值,包括 ListDict。如果 {options} 包含 "a" 或 {regname} 为大写,则追加该值。
{options} 还可以包含寄存器类型规范:"c" 或 "v" 字符方式 模式 "l" 或 "V" 行方式 模式 "b" 或 "<CTRL-V>" 块方式视觉 模式 如果 "b" 或 "<CTRL-V>" 之后紧跟着一个数字,则将其用作选择的宽度 - 如果未指定,则块的宽度将设置为最长行中的字符数(将 <Tab> 计为 1 个字符)。如果 {options} 包含 "u" 或 '"'",则未命名的寄存器将设置为指向寄存器 {regname}
如果 {options} 不包含寄存器设置,则默认情况下使用字符模式,除非 {value} 以字符串 {value}<NL> 结尾,并且对于列表 {value} 使用行方式模式。块方式模式从不自动选择。成功返回零,失败返回非零值。
E883
注意: 您不能使用包含多个项目的 List 来设置搜索和表达式寄存器。不包含项目的列表的行为类似于空字符串。
示例
call setreg(v:register, @*)
call setreg('*', @%, 'ac')
call setreg('a', "1\n2\n3", 'b5')
call setreg('"', { 'points_to': 'a'})
此示例演示如何使用这些函数保存和恢复寄存器
let var_a = getreginfo()
call setreg('a', var_a)
let var_a = getreg('a', 1, 1)
let var_amode = getregtype('a')
" ....
call setreg('a', var_a, var_amode)
注意: 您可能无法可靠地恢复寄存器值,而无需使用 getreg() 的第三个参数,因为没有它,换行符将表示为换行符,并且空字节也将表示为换行符,请参见 NL-used-for-Nul
您还可以通过追加空字符串来更改寄存器的类型
        call setreg('a', '', 'al')
Parameters: ~
  • {regname} (`string`)
  • {value} (`any`)
  • {options} (`string?`)
Return: ~
  (`any`)
settabvar({tabnr}, {varname}, {val}) settabvar()
在标签页 {tabnr} 中将标签页本地变量 {varname} 设置为 {val}t:var {varname} 参数是一个字符串。请注意,必须使用不带 "t:" 的变量名。标签页从 1 开始编号。此功能在 沙箱 中不可用。
参数
{tabnr} (integer)
{varname} (string)
{val} (any)
返回值
(任何)
settabwinvar({tabnr}, {winnr}, {varname}, {val}) settabwinvar()
将窗口 {winnr} 中的选项或本地变量 {varname} 设置为 {val}。标签页从 1 开始编号。对于当前标签页,请使用 setwinvar(){winnr} 可以是窗口编号或 窗口-ID。当 {winnr} 为零时,使用当前窗口。这对于全局或本地缓冲区选项也适用,但不适用于全局或本地缓冲区变量。对于本地缓冲区选项,全局值保持不变。请注意,必须使用不带 "w:" 的变量名。示例
call settabwinvar(1, 1, "&list", 0)
call settabwinvar(3, 2, "myvar", "foobar")
此函数在 沙盒 中不可用。
参数
{tabnr} (integer)
{winnr} (integer)
{varname} (string)
{val} (any)
返回值
(任何)
settagstack({nr}, {dict} [, {action}]) settagstack()
使用 {dict} 修改窗口 {nr} 的标签栈。{nr} 可以是窗口编号或 窗口-ID
有关 {dict} 中支持的项目的列表,请参阅 gettagstack()。"curidx" 在更改标签栈之前生效。 E962
如何修改标签栈取决于 {action} 参数
如果 {action} 不存在或设置为 'r',则替换标签栈。
如果 {action} 设置为 'a',则将 {dict} 中的新条目推入(添加)标签栈。
如果 {action} 设置为 't',则将从标签栈中的当前条目或 {dict} 中的 "curidx" 开始删除所有条目,然后将新条目推入栈。
修改后,当前索引设置为标签栈长度之后的一个。
成功返回零,失败返回 -1。
示例(有关更多示例,请参阅 tagstack-examples):清空窗口 3 的标签栈
call settagstack(3, {'items' : []})
保存和恢复标签栈
let stack = gettagstack(1003)
" do something else
call settagstack(1003, stack)
unlet stack
参数
{nr} (整数)
{dict} (any)
{action} (string?)
返回值
(任何)
setwinvar({nr}, {varname}, {val}) setwinvar()
类似于当前标签页的 settabwinvar()。示例
        call setwinvar(1, "&list", 0)
        call setwinvar(2, "myvar", "foobar")
Parameters: ~
  • {nr} (`integer`)
  • {varname} (`string`)
  • {val} (`any`)
Return: ~
  (`any`)
sha256({string}) sha256()
返回一个包含 64 个十六进制字符的字符串,它是 {string} 的 SHA256 校验和。
参数
{string} (字符串)
返回值
(任何)
shellescape({string} [, {special}]) shellescape()
为用作 shell 命令参数而转义 {string}
在 Windows 上,当 'shellslash' 未设置时,将 {string} 括在双引号中,并将 {string} 中的所有双引号加倍。否则将 {string} 括在单引号中,并将所有 "'" 替换为 "'\''"。
{special} 参数将添加对 Vim 命令中使用的关键字的额外转义。如果它是一个 非零参数
诸如 "!"、"%"、"#" 和 "<cword>" 之类的特殊项目(如 expand() 中所列)将以反斜杠开头。反斜杠将通过 :! 命令再次删除。
<NL> 字符将被转义。
如果 'shell' 的尾部包含 "csh"
"!" 字符将被转义。这是因为 csh 和 tcsh 即使在单引号中也使用 "!" 进行历史替换。
<NL> 字符将被转义(如果 {special} 是一个 非零参数,则转义两次)。
如果 'shell' 的尾部包含 "fish",则将转义 "\" 字符,因为在 fish 中,它用作单引号内的转义字符。
使用 :! 命令的示例
exe '!dir ' .. shellescape(expand('<cfile>'), 1)
这将列出光标下文件的目录。使用 system() 的示例
call system("chmod +w -- " .. shellescape(expand("%")))
另请参见 ::S
参数
{string} (字符串)
{special} (boolean?)
返回值
(任何)
shiftwidth([{col}]) shiftwidth()
返回 'shiftwidth' 的有效值。这是 'shiftwidth' 值,除非它为零,在这种情况下,它是 'tabstop' 值。为了在缩进插件中保持向后兼容性,请使用以下方法
if exists('*shiftwidth')
  func s:sw()
    return shiftwidth()
  endfunc
else
  func s:sw()
    return &sw
  endfunc
endif
然后使用 s:sw() 代替 &sw。
当只有一个参数 {col} 时,它将用作要返回 'shiftwidth' 值的列号。这对于 'vartabstop' 功能很重要。如果没有提供 {col} 参数,则将假定为第 1 列。
参数
{col} (integer?)
返回值
(integer)
sign_define({name} [, {dict}]) sign_define()
sign_define({list}) 定义一个名为 {name} 的新标记或修改现有标记的属性。这类似于 :sign-define 命令。
{name} 添加唯一的文本前缀以避免名称冲突。与放置标记一样,没有 {group}
{name} 可以是字符串或数字。可选的 {dict} 参数指定标记属性。支持以下值:icon 标记位图文件的完整路径。linehl 用于放置标记的整行的突出显示组。priority 标记的默认优先级值。numhl 用于放置标记的行号的突出显示组。text 当没有图标或没有使用 GUI 时显示的文本。texthl 用于文本项的突出显示组。culhl 当光标位于与标记相同的行并且 'cursorline' 启用时,用于文本项的突出显示组。
如果名为 {name} 的标记已存在,则更新标记的属性。
一个参数 {list} 可用于定义标记列表。每个列表项都是一个字典,其中包含 {dict} 中的上述项目和标记名称的 "name" 项目。
成功返回 0,失败返回 -1。当使用一个参数 {list} 时,则返回一个列表,每个定义的标记一个值。
示例
call sign_define("mySign", {
        \ "text" : "=>",
        \ "texthl" : "Error",
        \ "linehl" : "Search"})
call sign_define([
        \ {'name' : 'sign1',
        \  'text' : '=>'},
        \ {'name' : 'sign2',
        \  'text' : '!!'}
        \ ])
参数
{list} (vim.fn.sign_define.dict[])
返回值
((0|-1)[])
sign_getdefined([{name}]) sign_getdefined()
获取定义的标记及其属性的列表。这类似于 :sign-list 命令。
如果没有提供 {name},则返回所有定义的标记的列表。否则返回指定标记的属性。
返回值中的每个列表项都是一个字典,其中包含以下条目:icon 标记位图文件的完整路径。linehl 用于放置标记的整行的突出显示组;如果未设置,则不存在。name 标记的名称。priority 标记的默认优先级值。numhl 用于放置标记的行号的突出显示组;如果未设置,则不存在。text 当没有图标或没有使用 GUI 时显示的文本。texthl 用于文本项的突出显示组;如果未设置,则不存在。culhl 当光标位于与标记相同的行并且 'cursorline' 启用时,用于文本项的突出显示组;如果未设置,则不存在。
如果没有标记并且未找到 {name},则返回一个空列表。
示例
" Get a list of all the defined signs
echo sign_getdefined()
" Get the attribute of the sign named mySign
echo sign_getdefined("mySign")
参数
{name} (string?)
返回值
(vim.fn.sign_getdefined.ret.item[])
sign_getplaced([{buf} [, {dict}]]) sign_getplaced()
返回放置在缓冲区或所有缓冲区中的标记列表。这类似于 :sign-place-list 命令。
如果指定了可选的缓冲区名称 {buf},则仅返回放置在该缓冲区中的标记列表。有关 {buf} 的使用,请参见 bufname()。可选的 {dict} 可以包含以下条目:group 仅选择该组中的标记。id 选择具有此标识符的标记。lnum 选择放置在此行中的标记。有关 {lnum} 的使用,请参见 line()。如果 {group} 为 "*", 则返回所有组(包括全局组)中的标记。如果没有提供 {group} 或为空字符串,则仅返回全局组中的标记。如果没有提供参数,则返回放置在所有缓冲区中的全局组中的标记。请参见 sign-group
返回值中的每个列表项都是一个字典,其中包含以下条目:bufnr 具有标记的缓冲区的编号。signs 放置在 {bufnr} 中的标记列表。每个列表项都是一个字典,其中包含以下列出的条目
每个标记的字典包含以下条目:group 标记组。对于全局组,设置为 ''。id 标记的标识符。lnum 放置标记的行号。name 定义的标记的名称。priority 标记的优先级
返回的缓冲区中的标记按其行号和优先级排序。
如果失败或没有放置的标记,则返回一个空列表。
示例
" Get a List of signs placed in eval.c in the
" global group
echo sign_getplaced("eval.c")
" Get a List of signs in group 'g1' placed in eval.c
echo sign_getplaced("eval.c", {'group' : 'g1'})
" Get a List of signs placed at line 10 in eval.c
echo sign_getplaced("eval.c", {'lnum' : 10})
" Get sign with identifier 10 placed in a.py
echo sign_getplaced("a.py", {'id' : 10})
" Get sign with id 20 in group 'g1' placed in a.py
echo sign_getplaced("a.py", {'group' : 'g1',
                                \  'id' : 20})
" Get a List of all the placed signs
echo sign_getplaced()
参数
{buf} (整数|字符串?)
{dict} (vim.fn.sign_getplaced.dict?)
返回值
(vim.fn.sign_getplaced.ret.item[])
sign_jump({id}, {group}, {buf}) sign_jump()
打开缓冲区 {buf} 或跳转到包含 {buf} 的窗口,并将光标定位在组 {group} 中的标记 {id} 处。这类似于 :sign-jump 命令。
如果 {group} 为空字符串,则使用全局组。有关 {buf} 的使用,请参见 bufname()
返回标记的行号。如果参数无效,则返回 -1。
示例
" Jump to sign 10 in the current buffer
call sign_jump(10, '', '')
参数
{id} (整数)
{group} (string)
{buf} (integer|string)
返回值
(integer)
sign_place({id}, {group}, {name}, {buf} [, {dict}]) sign_place()
将定义为 {name} 的标记放置在文件或缓冲区 {buf} 中的第 {lnum} 行,并将 {id}{group} 分配给标记。这类似于 :sign-place 命令。
如果标记标识符 {id} 为零,则分配一个新的标识符。否则使用指定的数字。{group} 是标记组名称。要使用全局标记组,请使用空字符串。{group} 充当 {id} 的命名空间,因此两个组可以使用相同的 ID。有关更多信息,请参见 sign-identifiersign-group
{name} 指的是定义的标记。{buf} 指的是缓冲区名称或编号。有关接受的值,请参见 bufname()
可选的 {dict} 参数支持以下条目:lnum 要放置标记的文件或缓冲区 {buf} 中的行号。有关接受的值,请参见 line()。priority 标记的优先级。有关更多信息,请参见 sign-priority
如果没有指定可选的 {dict},则它将修改放置的标记 {id}(在组 {group} 中),以使用定义的标记 {name}
成功返回标记标识符,失败返回 -1。
示例
" Place a sign named sign1 with id 5 at line 20 in
" buffer json.c
call sign_place(5, '', 'sign1', 'json.c',
                                \ {'lnum' : 20})
" Updates sign 5 in buffer json.c to use sign2
call sign_place(5, '', 'sign2', 'json.c')
" Place a sign named sign3 at line 30 in
" buffer json.c with a new identifier
let id = sign_place(0, '', 'sign3', 'json.c',
                                \ {'lnum' : 30})
" Place a sign named sign4 with id 10 in group 'g3'
" at line 40 in buffer json.c with priority 90
call sign_place(10, 'g3', 'sign4', 'json.c',
                \ {'lnum' : 40, 'priority' : 90})
参数
{id} (整数)
{group} (string)
{name} (字符串)
{buf} (integer|string)
{dict} (vim.fn.sign_place.dict?)
返回值
(integer)
sign_placelist({list}) sign_placelist()
放置一个或多个标记。这类似于 sign_place() 函数。{list} 参数指定要放置的标记列表。每个列表项都是一个字典,其中包含以下标记属性:buffer 缓冲区名称或编号。有关接受的值,请参见 bufname()。group 标记组。{group} 充当 {id} 的命名空间,因此两个组可以使用相同的 ID。如果未指定或设置为空字符串,则使用全局组。有关更多信息,请参见 sign-group。id 标记标识符。如果未指定或为零,则分配一个新的唯一标识符。否则使用指定的数字。有关更多信息,请参见 sign-identifier。lnum 要放置标记的缓冲区中的行号。有关接受的值,请参见 line()。name 要放置的标记的名称。有关更多信息,请参见 sign_define()。priority 标记的优先级。当在同一行放置多个标记时,将使用优先级最高的标记。如果未指定,则使用默认值 10,除非在标记定义中另有说明。有关更多信息,请参见 sign-priority
如果 {id} 指的是现有标记,则修改现有标记以使用指定的 {name} 和/或 {priority}
返回一个标记标识符列表。如果无法放置标记,则将相应的列表项设置为 -1。
示例
" Place sign s1 with id 5 at line 20 and id 10 at line
" 30 in buffer a.c
let [n1, n2] = sign_placelist([
        \ {'id' : 5,
        \  'name' : 's1',
        \  'buffer' : 'a.c',
        \  'lnum' : 20},
        \ {'id' : 10,
        \  'name' : 's1',
        \  'buffer' : 'a.c',
        \  'lnum' : 30}
        \ ])
" Place sign s1 in buffer a.c at line 40 and 50
" with auto-generated identifiers
let [n1, n2] = sign_placelist([
        \ {'name' : 's1',
        \  'buffer' : 'a.c',
        \  'lnum' : 40},
        \ {'name' : 's1',
        \  'buffer' : 'a.c',
        \  'lnum' : 50}
        \ ])
参数
{list} (vim.fn.sign_placelist.list.item[])
返回值
(integer[])
sign_undefine([{name}]) sign_undefine()
sign_undefine({list}) 删除先前定义的标记 {name}。这类似于 :sign-undefine 命令。如果 {name} 没有提供,则删除所有定义的标记。
一个参数 {list} 可用于取消定义标记列表。每个列表项都是标记的名称。
成功返回 0,失败返回 -1。对于一个参数 {list} 调用,返回一个列表,每个取消定义的标记一个值。
示例
" Delete a sign named mySign
call sign_undefine("mySign")
" Delete signs 'sign1' and 'sign2'
call sign_undefine(["sign1", "sign2"])
" Delete all the signs
call sign_undefine()
参数
{list} (string[]?)
返回值
(integer[])
sign_unplace({group} [, {dict}]) sign_unplace()
删除一个或多个缓冲区中先前放置的标记。这类似于 :sign-unplace 命令。
{group} 是标记组名称。要使用全局标记组,请使用空字符串。如果 {group} 设置为 "*", 则使用所有组(包括全局组)。{group} 中的标记根据 {dict} 中的条目进行选择。支持 {dict} 中的以下可选条目:buffer 缓冲区名称或编号。请参见 bufname()。id 标记标识符。如果 {dict} 没有提供,则删除 {group} 中的所有标记。
成功返回 0,失败返回 -1。
示例
        " Remove sign 10 from buffer a.vim
        call sign_unplace('', {'buffer' : "a.vim", 'id' : 10})
        " Remove sign 20 in group 'g1' from buffer 3
        call sign_unplace('g1', {'buffer' : 3, 'id' : 20})
        " Remove all the signs in group 'g2' from buffer 10
        call sign_unplace('g2', {'buffer' : 10})
        " Remove sign 30 in group 'g3' from all the buffers
        call sign_unplace('g3', {'id' : 30})
        " Remove all the signs placed in buffer 5
        call sign_unplace('*', {'buffer' : 5})
        " Remove the signs in group 'g4' from all the buffers
        call sign_unplace('g4')
        " Remove sign 40 from all the buffers
        call sign_unplace('*', {'id' : 40})
        " Remove all the placed signs from all the buffers
        call sign_unplace('*')
Parameters: ~
  • {group} (`string`)
  • {dict} (`vim.fn.sign_unplace.dict?`)
Return: ~
  (`0|-1`)
sign_unplacelist({list}) sign_unplacelist()
从一个或多个缓冲区中删除先前放置的标记。这类似于 sign_unplace() 函数。
{list} 参数指定要删除的标记列表。每个列表项都是一个字典,其中包含以下标记属性:buffer 缓冲区名称或编号。有关接受的值,请参见 bufname()。如果未指定,则从所有缓冲区中删除指定的标记。group 标记组名称。如果未指定或设置为空字符串,则使用全局标记组。如果设置为 "*", 则使用所有组(包括全局组)。id 标记标识符。如果未指定,则删除指定组中的所有标记。
返回一个列表,其中如果成功删除了相应的标记,则条目设置为 0,否则设置为 -1。
示例
" Remove sign with id 10 from buffer a.vim and sign
" with id 20 from buffer b.vim
call sign_unplacelist([
        \ {'id' : 10, 'buffer' : "a.vim"},
        \ {'id' : 20, 'buffer' : 'b.vim'},
        \ ])
参数
{list} (vim.fn.sign_unplacelist.list.item)
返回值
((0|-1)[])
simplify({filename}) simplify()
尽可能简化文件名,但不要改变其含义。快捷方式(在 MS-Windows 上)或符号链接(在 Unix 上)不会被解析。如果 {filename} 中的第一个路径组件指定当前目录,则结果也应有效。尾随路径分隔符也不会被删除。在 Unix 上,"//path" 保持不变,但 "///path" 将简化为 "/path"(这遵循 Posix 标准)。示例
simplify("./dir/.././/file/") == "./file/"
注意: 只有当 "dir" 是可搜索目录或不存在时,才会删除组合 "dir/.."。在 Unix 上,当 "dir" 是同一目录中的符号链接时,也会将其删除。为了在简化路径名称之前解析所有涉及的符号链接,请使用 resolve().
参数
{filename} (string)
返回值
(任何)
sin({expr}) sin()
返回 {expr} 的正弦值(以弧度为单位),结果为 Float 类型。{expr} 必须计算为 FloatNumber。如果 {expr} 不是 FloatNumber,则返回 0.0。示例
echo sin(100)
-0.506366
echo sin(-4.01)
0.763301
参数
{expr} (number)
返回值
(任何)
sinh({expr}) sinh()
返回 {expr} 的双曲正弦值,结果为 Float 类型,范围为 [-inf, inf]。{expr} 必须计算为 FloatNumber。如果 {expr} 不是 FloatNumber,则返回 0.0。示例
echo sinh(0.5)
0.521095
echo sinh(-0.9)
-1.026517
参数
{expr} (number)
返回值
(任何)
slice({expr}, {start} [, {end}]) slice()
类似于使用 slice "expr[start : end]",但 "end" 是独占的。对于字符串,索引用作字符索引而不是字节索引。此外,组合字符被视为前一个基本字符的一部分。当省略 {end} 时,切片将继续到最后一项。当 {end} 为 -1 时,将省略最后一项。如果 {start}{end} 无效,则返回空值。
参数
{expr} (any)
{start} (integer)
{end_} (integer?)
返回值
(任何)
sockconnect({mode}, {address} [, {opts}]) sockconnect()
将套接字连接到地址。如果 {mode} 为 "pipe",则 {address} 应为本地域套接字(在 unix 上)或命名管道(在 Windows 上)的路径。如果 {mode} 为 "tcp",则 {address} 应采用 "host:port" 的形式,其中 host 应为 IP 地址或主机名,port 为端口号。
对于 "pipe" 模式,请参阅 luv-pipe-handle。对于 "tcp" 模式,请参阅 luv-tcp-handle.
返回一个 channel ID。使用 chanclose() 关闭套接字。使用 chansend() 通过字节套接字发送数据,使用 rpcrequest()rpcnotify() 与 RPC 套接字通信。
{opts} 是一个可选字典,包含以下键: on_data : 当从套接字读取数据时调用的回调 data_buffered : 以 channel-buffered 模式读取套接字数据。rpc : 如果设置,将使用 msgpack-rpc 通过套接字进行通信。返回
成功时为通道 ID(大于零)
参数无效或连接失败时为 0。
参数
{mode} (string)
{address} (string)
{opts} (table?)
返回值
(任何)
sort({list} [, {how} [, {dict}]]) sort() E702{list} 中的项进行就地排序。返回 {list}
如果你希望列表保持不变,请先进行复制
let sortedlist = sort(copy(mylist))
当省略 {how} 或它是字符串时,sort() 使用每个项的字符串表示形式进行排序。数字排在字符串之后,列表 排在数字之后。要对当前缓冲区中的文本进行排序,请使用 :sort.
当给出 {how} 并且它是 'i' 时,将忽略大小写。为了向后兼容,值 1 可用于忽略大小写。0 表示不忽略大小写。
当给出 {how} 并且它是 'l' 时,将使用当前排序区域设置进行排序。实现细节:使用 strcoll() 来比较字符串。请参阅 :language 检查或设置排序区域设置。v:collate 也可用于检查当前区域设置。使用区域设置进行排序通常会忽略大小写。示例
" ö is sorted similarly to o with English locale.
language collate en_US.UTF8
echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l')
['n', 'o', 'O', 'ö', 'p', 'z']
" ö is sorted after z with Swedish locale.
language collate sv_SE.UTF8
echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l')
['n', 'o', 'O', 'p', 'z', 'ö']
这在 Mac 上无法正常工作。
当给出 {how} 并且它是 'n' 时,所有项都将按数字排序(实现细节:这将使用 strtod() 函数来解析数字,字符串、列表、字典和 Funcrefs 将被视为 0)。
当给出 {how} 并且它是 'N' 时,所有项都将按数字排序。这与 'n' 相似,但包含数字的字符串将被用作它们表示的数字。
当给出 {how} 并且它是 'f' 时,所有项都将按数字排序。所有值必须是数字或浮点数。
{how}Funcref 或函数名时,将调用此函数来比较项。函数使用两个项作为参数调用,如果它们相等,则必须返回零,如果第一个项在第二个项之后排序,则返回 1 或更大,如果第一个项在第二个项之前排序,则返回 -1 或更小。
{dict} 用于具有 "dict" 属性的函数。它将用于设置本地变量 "self"。 字典函数
排序是稳定的,比较相等的项(作为数字或字符串)将保持其相对位置。例如,在按数字排序时,文本字符串将彼此相邻排序,顺序与它们最初的顺序相同。
示例
func MyCompare(i1, i2)
   return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1
endfunc
eval mylist->sort("MyCompare")
对于此特定简单情况的较短比较版本,它会忽略溢出
func MyCompare(i1, i2)
   return a:i1 - a:i2
endfunc
对于简单表达式,可以使用 lambda
eval mylist->sort({i1, i2 -> i1 - i2})
参数
{list} (any)
{how} (string|function?)
{dict} (任何?)
返回值
(任何)
soundfold({word}) soundfold()
返回 {word} 的音调折叠等效项。使用当前窗口中 'spelllang' 中支持音调折叠的第一个语言。必须设置 'spell'。如果无法进行音调折叠,则返回未修改的 {word}。这可用于进行拼写建议。请注意,此方法可能非常慢。
参数
{word} (string)
返回值
(任何)
spellbadword([{sentence}]) spellbadword()
无参数:结果是光标下或光标后的拼写错误的单词。光标将移动到错误单词的开头。如果在光标行中没有找到错误单词,则结果为空字符串,光标不会移动。
带参数:结果是 {sentence} 中第一个拼写错误的单词。如果没有任何拼写错误,则结果为空字符串。
返回值是一个包含两个项的列表
拼写错误的单词或空字符串。
拼写错误的类型:"bad" 拼写错误 "rare" 罕见词 "local" 仅在其他区域有效的词 "caps" 词应以大写字母开头示例
echo spellbadword("the quik brown fox")
[quik,bad]
将使用当前窗口的拼写信息以及 'spelllang' 的值。
参数
{sentence} (string?)
返回值
(任何)
spellsuggest({word} [, {max} [, {capital}]]) spellsuggest()
返回一个包含替换 {word} 的拼写建议的 列表。如果给出 {max},则最多返回此数量的建议。否则最多返回 25 个建议。
如果给出 {capital} 参数并且它不为零,则只返回以大写字母开头的建议。在使用 'spellcapcheck' 匹配后使用此方法。
{word} 可以是拼写错误的单词,后面跟着其他文本。这允许连接两个被拆分的单词。建议还包括以下文本,因此你可以替换一行。
{word} 也可能是一个正确的单词。然后将返回相似的单词。{word} 本身不会包含在建议中,尽管它可能会以大写字母出现。
将使用当前窗口的拼写信息。将使用 'spelllang''spellsuggest' 的值。
参数
{word} (string)
{max} (integer?)
{capital} (boolean?)
返回值
(任何)
split({string} [, {pattern} [, {keepempty}]]) split()
{string} 中创建 列表。如果省略或为空 {pattern},则每个空格分隔的字符序列都将成为一项。否则,字符串将在 {pattern} 匹配的地方被拆分,并删除匹配的字符。'ignorecase' 这里没有使用,请添加 \c 来忽略大小写。 /\c 如果第一个或最后一个项为空,则将其省略,除非给出 {keepempty} 参数并且它不为零。当 {pattern} 至少匹配一个字符或 {keepempty} 不为零时,将保留其他空项。示例
let words = split(getline('.'), '\W\+')
将字符串拆分为单个字符
for c in split(mystring, '\zs') | endfor
如果你想保留分隔符,也可以在模式的末尾使用 '\zs'
echo split('abc:def:ghi', ':\zs')
['abc:', 'def:', 'ghi']
拆分表格,其中第一个元素可以为空
let items = split(line, ':', 1)
相反的函数是 join().
参数
{string} (字符串)
{pattern} (string?)
{keepempty} (boolean?)
返回值
(任何)
sqrt({expr}) sqrt()
返回 Float {expr} 的非负平方根,结果为 Float 类型。{expr} 必须计算为 FloatNumber。如果 {expr} 为负数,则结果为 NaN(非数字)。如果 {expr} 不是 FloatNumber,则返回 0.0。示例
echo sqrt(100)
10.0
echo sqrt(-4.01)
str2float("nan") NaN 可能不同,它取决于系统库。
参数
{expr} (number)
返回值
(任何)
srand([{expr}]) srand()
初始化 rand() 使用的种子
如果没有给出 {expr},则会通过从 /dev/urandom 读取(如果可能)或使用 time(NULL)(也称为纪元时间)来初始化种子值;这只有秒级精度。
如果给出 {expr},则它必须是数字。它将用于初始化种子值。这对于测试或需要可预测序列时很有用。
示例
let seed = srand()
let seed = srand(userinput)
echo rand(seed)
参数
{expr} (number?)
返回值
(任何)
state([{what}]) state()
返回一个包含表示当前状态的字符的字符串。主要用于希望执行可能并不总是安全的回调。大致上,它工作方式如下
回调使用 state() 检查工作是否安全执行。是:立即执行。否:添加到工作队列中,并添加 SafeState 自动命令。
当 SafeState 被触发并执行你的自动命令时,使用 state() 检查现在是否可以执行工作,如果是,则将其从队列中移除并执行。如果队列现在为空,则删除自动命令。另请参阅 mode().
如果给出 {what},则只会添加此字符串中的字符。例如,这将检查屏幕是否已滚动
if state('s') == ''
   " screen has not scrolled
这些字符表示状态,通常表示某些事情很忙:m 中途映射,:normal 命令,feedkeys() 或填充命令 o 操作符正在等待,例如在 d 后,插入模式自动完成激活 x 执行自动命令 S 不触发安全状态,例如在 f 或计数 c 后,调用回调,包括计时器(对于递归重复,直到 "ccc")s 屏幕已滚动以显示消息
参数
{what} (string?)
返回值
(任何)
stdioopen({opts}) stdioopen()
使用 --headless,这会将 stdin 和 stdout 作为 通道 打开。只能调用一次。请参阅 通道-stdio。stderr 不由此函数处理,请参阅 v:stderr
使用 chanclose() 关闭 stdio 处理程序。使用 chansend() 将数据发送到 stdout,以及 rpcrequest()rpcnotify() 通过 RPC 进行通信。
{opts} 是一个包含以下键的字典:on_stdin : 当 stdin 被写入时调用的回调。on_print : 当 Nvim 需要打印消息时调用的回调,以消息(其类型为字符串)作为唯一参数。stdin_buffered : 在 通道-缓冲 模式下读取 stdin。rpc : 如果设置,msgpack-rpc 将用于通过 stdio 进行通信 返回
通道-ID,如果成功(值始终为 1)
无效参数时返回 0
参数
{opts} (table)
返回值
(任何)
stdpath({what}) stdpath() E6100 返回各种默认文件和目录的 标准路径 位置。
{what} 类型 描述
cache String 缓存目录:插件等的任意临时存储。config String 用户配置目录。init.vim 存储在此处。config_dirs List 其他配置目录。data String 用户数据目录。data_dirs List 其他数据目录。log String 日志目录(供插件使用)。run String 运行目录:临时,本地存储,用于套接字、命名管道等。state String 会话状态目录:用于文件草稿、交换、撤销、shada 的存储。
示例
echo stdpath("config")
参数
{what} ('cache'|'config'|'config_dirs'|'data'|'data_dirs'|'log'|'run'|'state')
返回值
(string|string[])
str2float({string} [, {quoted}]) str2float()
将字符串 {string} 转换为浮点数。这与在表达式中使用浮点数时基本相同,请参阅 浮点格式。但它更宽松一些。例如,"1e40" 被接受,而在表达式中,您需要写 "1.0e40"。十六进制形式 "0x123" 也被接受,但其他形式不被接受,例如二进制或八进制。当 {quoted} 存在且不为零时,小数点前的嵌入单引号将被忽略,因此 "1'000.0" 为一千。数字后的文本将被静默忽略。小数点始终为 "。",无论 locale 设置为何。逗号结束数字: "12,345.67" 将被转换为 12.0。您可以使用 substitute() 删除千位分隔符
let f = str2float(substitute(text, ',', '', 'g'))
如果转换失败,则返回 0.0。
参数
{string} (字符串)
{quoted} (boolean?)
返回值
(任何)
str2list({string} [, {utf8}]) str2list()
返回一个列表,其中包含表示字符串 {string} 中每个字符的数字值。示例
echo str2list(" ")                " returns [32]
echo str2list("ABC")                " returns [65, 66, 67]
list2str() 做相反的事情。
始终使用 UTF-8 编码,{utf8} 选项无效,仅出于向后兼容性而存在。使用 UTF-8,组合字符将被正确处理
        echo str2list("á")                " returns [97, 769]
Parameters: ~
  • {string} (`string`)
  • {utf8} (`boolean?`)
Return: ~
  (`any`)
str2nr({string} [, {base}]) str2nr()
将字符串 {string} 转换为数字。{base} 是转换基数,可以是 2、8、10 或 16。当 {quoted} 存在且不为零时,嵌入单引号将被忽略,因此 "1'000'000" 为一百万。
{base} 被省略时,使用基数 10。这也意味着前导零不会导致使用八进制转换,与默认的字符串到数字转换一样。示例
let nr = str2nr('0123')
{base} 为 16 时,将忽略前导 "0x" 或 "0X"。对于其他基数,结果将为零。类似地,当 {base} 为 8 时,将忽略前导 "0"、"0o" 或 "0O",而当 {base} 为 2 时,将忽略前导 "0b" 或 "0B"。数字后的文本将被静默忽略。
如果 {string} 为空或发生错误,则返回 0。
参数
{string} (字符串)
{base} (integer?)
返回值
(任何)
strcharlen({string}) strcharlen()
结果为一个数字,表示字符串 {string} 中的字符数。组合字符将被忽略。 strchars() 可以计算字符数,分别计算组合字符。
如果 {string} 为空或发生错误,则返回 0。
另请参阅 strlen()strdisplaywidth()strwidth()
参数
{string} (字符串)
返回值
(任何)
strcharpart({src}, {start} [, {len} [, {skipcc}]]) strcharpart()
strpart() 相似,但使用字符索引和长度,而不是字节索引和长度。当 {skipcc} 被省略或为零时,组合字符将被分别计算。当 {skipcc} 设置为 1 时,组合字符将被视为前一个基本字符的一部分,类似于 slice()。当在不存在字符的位置使用字符索引时,它将被省略并计为一个字符。例如
echo strcharpart('abc', -1, 2)
结果为 'a'。
错误时返回空字符串。
参数
{src} (string)
{start} (integer)
{len} (integer?)
{skipcc} (boolean?)
返回值
(任何)
strchars({string} [, {skipcc}]) strchars()
结果为一个数字,表示字符串 {string} 中的字符数。当 {skipcc} 被省略或为零时,组合字符将被分别计算。当 {skipcc} 设置为 1 时,组合字符将被忽略。 strcharlen() 始终执行此操作。
发生错误时返回零。
另请参阅 strlen()strdisplaywidth()strwidth()
{skipcc} 仅在 7.4.755 之后可用。为了向后兼容性,您可以定义一个包装函数
if has("patch-7.4.755")
  function s:strchars(str, skipcc)
    return strchars(a:str, a:skipcc)
  endfunction
else
  function s:strchars(str, skipcc)
    if a:skipcc
      return strlen(substitute(a:str, ".", "x", "g"))
    else
      return strchars(a:str)
    endif
  endfunction
endif
参数
{string} (字符串)
{skipcc} (boolean?)
返回值
(integer)
strdisplaywidth({string} [, {col}]) strdisplaywidth()
结果为一个数字,表示字符串 {string} 在屏幕上从 {col} 开始(第一列为零)时所占用的显示单元数。当 {col} 被省略时,使用零。否则,它就是屏幕列,从该列开始。这对制表符很重要。使用当前窗口的选项设置。这对任何以不同方式显示的内容都很重要,例如 'tabstop''display'。当 {string} 包含具有东亚宽度类“模棱两可”的字符时,此函数的返回值取决于 'ambiwidth'。如果发生错误,则返回零。另请参阅 strlen()strwidth()strchars()
参数
{string} (字符串)
{col} (integer?)
返回值
(integer)
strftime({format} [, {time}]) strftime()
结果为一个字符串,它是格式化的日期和时间,由 {format} 字符串指定。使用给定的 {time},如果没有给定时间,则使用当前时间。接受的 {format} 取决于您的系统,因此不可移植!有关格式,请参阅 C 函数 strftime() 的手册页。结果的最大长度为 80 个字符。另请参阅 localtime()getftime()strptime()。可以使用 :language 命令更改语言。示例
  echo strftime("%c")                   " Sun Apr 27 11:49:23 1997
  echo strftime("%Y %b %d %X")           " 1997 Apr 27 11:53:25
  echo strftime("%y%m%d %T")           " 970427 11:53:55
  echo strftime("%H:%M")                   " 11:55
  echo strftime("%c", getftime("file.c"))
                                   " Show mod time of file.c.
Parameters: ~
  • {format} (`string`)
  • {time} (`number?`)
Return: ~
  (`string`)
strgetchar({str}, {index}) strgetchar()
获取一个数字,该数字对应于 {str}{index} 处的字符。这使用的是基于零的字符索引,而不是字节索引。组合字符在这里被视为单独的字符。使用 nr2char() 将数字转换为字符串。如果 {index} 无效,则返回 -1。另请参阅 strcharpart()strchars()
参数
{str} (string)
{index} (integer)
返回值
(integer)
stridx({haystack}, {needle} [, {start}]) stridx()
结果为一个数字,它给出 {haystack} 中字符串 {needle} 第一次出现的字节索引。如果指定了 {start},则搜索将从索引 {start} 开始。这可以用于查找第二次匹配
let colon1 = stridx(line, ":")
let colon2 = stridx(line, ":", colon1 + 1)
搜索区分大小写。对于模式搜索,请使用 match()。如果 {needle} 不出现在 {haystack} 中,则返回 -1。另请参阅 strridx()。示例
echo stridx("An Example", "Example")     " 3
echo stridx("Starting point", "Start")   " 0
echo stridx("Starting point", "start")   " -1
strstr() strchr() stridx() 的工作原理与 C 函数 strstr() 相似。当与单个字符一起使用时,它与 strchr() 的工作原理相似。
参数
{haystack} (string)
{needle} (string)
{start} (integer?)
返回值
(integer)
string({expr}) string()
返回 {expr} 转换为字符串。如果 {expr} 是一个数字、浮点数、字符串、Blob 或它们的组合,则结果可以使用 eval() 解析回。
{expr} 类型 结果
Stringstring Number 123 Float 123.123456 或 1.123456e8 或 str2float('inf') Funcref function('name') Blob 0z00112233.44556677.8899 List [item, item] Dictionary {key: value, key: value} 请注意,在字符串值中,' 字符将被加倍。另请参阅 strtrans()。注意 2:输出格式与 YAML 大致兼容,但无穷大值和 NaN 浮点值表示形式使用 str2float()。字符串也将被直接转储,只有单引号转义,这不允许使用 YAML 解析回二进制字符串。不过,eval() 应该始终适用于字符串和浮点数,这是唯一的官方方法。如果需要与其他应用程序共享数据,请使用 msgpackdump()json_encode()
参数
{expr} (any)
返回值
(字符串)
strlen({string}) strlen()
结果为一个数字,表示字符串 {string} 的字节长度。如果参数是一个数字,则首先将其转换为字符串。对于其他类型,将给出错误并返回零。如果要计算多字节字符的数目,请使用 strchars()。另请参阅 len()strdisplaywidth()strwidth()
参数
{string} (字符串)
返回值
(integer)
strpart({src}, {start} [, {len} [, {chars}]]) strpart()
结果为一个字符串,它是 {src} 的一部分,从字节 {start} 开始,字节长度为 {len}。当 {chars} 存在且为 TRUE 时,{len} 是字符位置数(组合字符不会被分别计算,因此 "1" 表示一个基本字符和任何后续组合字符)。要将 {start} 计为字符而不是字节,请使用 strcharpart()
如果选择了不存在的字节,这不会导致错误,这些字节将被简单地省略。如果 {len} 缺失,则复制将从 {start} 继续到 {src} 的末尾。
echo strpart("abcdefg", 3, 2)    " returns 'de'
echo strpart("abcdefg", -2, 4)   " returns 'ab'
echo strpart("abcdefg", 5, 4)    " returns 'fg'
echo strpart("abcdefg", 3)         " returns 'defg'
注意: 要获取第一个字符,{start} 必须为 0。例如,要获取光标下的字符
strpart(getline("."), col(".") - 1, 1, v:true)
错误时返回空字符串。
参数
{src} (string)
{start} (integer)
{len} (integer?)
{chars} (0|1?)
返回值
(字符串)
strptime({format}, {timestring}) strptime()
结果为一个数字,它是一个 Unix 时间戳,表示 {timestring} 中的日期和时间,预计该时间戳将与 {format} 中指定的格式匹配。
接受的 {format} 取决于您的系统,因此不可移植!有关格式,请参阅 C 函数 strptime() 的手册页。尤其要避免使用 "%c"。$TZ 的值也很重要。
如果无法使用 {format} 解析 {timestring},则返回零。如果您不知道 {timestring} 的格式,可以尝试不同的 {format} 值,直到获得非零结果。
另请参阅 strftime()。示例
echo strptime("%Y %b %d %X", "1997 Apr 27 11:49:23")
862156163
echo strftime("%c", strptime("%y%m%d %T", "970427 11:53:55"))
Sun Apr 27 11:53:55 1997
echo strftime("%c", strptime("%Y%m%d%H%M%S", "19970427115355") + 3600)
Sun Apr 27 12:53:55 1997
参数
{format} (string)
{timestring} (string)
返回值
(integer)
strridx({haystack}, {needle} [, {start}]) strridx()
结果是一个数字,它表示在 {haystack} 中 String {needle} 的最后一次出现的字节索引。当指定 {start} 时,将忽略此索引之后的匹配项。这可用于查找先前匹配项之前的匹配项
let lastcomma = strridx(line, ",")
let comma2 = strridx(line, ",", lastcomma - 1)
搜索区分大小写。对于模式搜索,请使用 match()。如果 {needle} 未出现在 {haystack} 中,则返回 -1。如果 {needle} 为空,则返回 {haystack} 的长度。另请参阅 stridx()。示例
echo strridx("an angry armadillo", "an")             3
strrchr()
当与单个字符一起使用时,它的作用类似于 C 函数 strrchr()。
参数
{haystack} (string)
{needle} (string)
{start} (integer?)
返回值
(integer)
strtrans({string}) strtrans()
结果是一个 String,它是 {string},其中所有不可打印字符都被转换为可打印字符 'isprint'。就像它们在窗口中显示一样。示例
echo strtrans(@a)
这会在寄存器 a 中显示换行符为 "^@",而不是开始新行。
错误时返回空字符串。
参数
{string} (字符串)
返回值
(字符串)
strutf16len({string} [, {countcc}]) strutf16len()
结果是一个数字,它表示 String {string} 中的 UTF-16 代码单元数(将其转换为 UTF-16 之后)。
{countcc} 为 TRUE 时,组合字符单独计数。当 {countcc} 被省略或为 FALSE 时,组合字符将被忽略。
发生错误时返回零。
另请参阅 strlen()strcharlen()。示例
echo strutf16len('a')                " returns 1
echo strutf16len('©')                " returns 1
echo strutf16len('😊')                " returns 2
echo strutf16len('ą́')                " returns 1
echo strutf16len('ą́', v:true)        " returns 3
参数
{string} (字符串)
{countcc} (0|1?)
返回值
(integer)
strwidth({string}) strwidth()
结果是一个数字,它表示 String {string} 占用的显示单元数。制表符被计为一个单元,或者使用 strdisplaywidth()。当 {string} 包含具有东亚宽度类别的“不明确”字符时,此函数的返回值取决于 'ambiwidth'。错误时返回零。另请参阅 strlen()strdisplaywidth()strchars()
参数
{string} (字符串)
返回值
(integer)
submatch({nr} [, {list}]) submatch() E935 仅适用于 :substitute 命令或 substitute() 函数中的表达式。返回匹配文本的第 {nr} 个子匹配项。当 {nr} 为 0 时,将返回整个匹配的文本。请注意,字符串中的 NL 可以代表多行匹配的换行符或文本中的 NUL 字符。另请参阅 sub-replace-expression
如果 {list} 存在且非零,则 submatch() 将返回字符串列表,类似于带两个参数的 getline()。文本中的 NL 字符代表文本中的 NUL 字符。仅在 :substitute 中返回多个项目,在 substitute() 中,此列表将始终包含一个或零个项目,因为没有真正的换行符。
当 substitute() 被递归使用时,只能获取当前(最深层)调用中的子匹配项。
错误时返回空字符串或列表。
示例
s/\d\+/\=submatch(0) + 1/
echo substitute(text, '\d\+', '\=submatch(0) + 1', '')
这将找到行中的第一个数字并对其加一。换行符作为换行符包含在内。
参数
{nr} (整数)
{list} (nil?)
返回值
(字符串)
substitute({string}, {pat}, {sub}, {flags}) substitute()
结果是一个 String,它是 {string} 的副本,其中 {pat} 的第一个匹配项被替换为 {sub}。当 {flags} 为“g”时,{string}{pat} 的所有匹配项都被替换。否则 {flags} 应为空字符串。
这就像“:substitute”命令(没有任何标志)一样。但是,使用 {pat} 的匹配始终像 'magic' 选项已设置且 'cpoptions' 为空一样(使脚本可移植)。'ignorecase' 仍然相关,如果您想忽略或匹配大小写并忽略 'ignorecase',请使用 /\c/\C'smartcase' 未使用。有关如何使用 {pat},请参阅 string-match
{sub} 中的“~”不会被先前 {sub} 替换。请注意,{sub} 中的某些代码具有特殊含义 sub-replace-special。例如,要将某事物替换为“\n”(两个字符),请使用“\\\\n”或“\n”。
{pat}{string} 中不匹配时,将返回未修改的 {string}
示例
let &path = substitute(&path, ",\\=[^,]*$", "", "")
这将删除 'path' 选项的最后一个组件。
echo substitute("testing", ".*", "\\U\\0", "")
结果为“TESTING”。
{sub} 以“\=”开头时,剩余部分将被解释为表达式。请参阅 sub-replace-expression。示例
echo substitute(s, '%\(\x\x\)',
   \ '\=nr2char("0x" .. submatch(1))', 'g')
{sub} 是一个 Funcref 时,将调用该函数,并带有一个可选参数。示例
echo substitute(s, '%\(\x\x\)', SubNr, 'g')
可选参数是一个列表,其中包含整个匹配的字符串以及最多九个子匹配项,就像 submatch() 返回的匹配项一样。示例
echo substitute(s, '%\(\x\x\)', {m -> '0x' .. m[1]}, 'g')
错误时返回空字符串。
参数
{string} (字符串)
{pat} (string)
{sub} (string)
{flags} (string)
返回值
(字符串)
swapfilelist() swapfilelist()
返回一个交换文件名的列表,就像“vim -r”显示的那样。请参阅 -r 命令参数。'directory' 选项用于要检查的目录。如果您只想获取当前目录中的交换文件列表,那么暂时将 'directory' 设置为一个点
        let save_dir = &directory
        let &directory = '.'
        let swapfiles = swapfilelist()
        let &directory = save_dir
Return: ~
  (`string[]`)
swapinfo({fname}) swapinfo()
结果是一个字典,其中包含有关交换文件 {fname} 的信息。可用的字段包括:version Vim 版本 user 用户名 host 主机名 fname 原始文件名 pid 创建交换文件的 Nvim 进程的 PID,如果未运行则为零。mtime 最后修改时间(以秒为单位)inode 可选:文件的 INODE 号码 dirty 如果文件已修改则为 1,否则为 0。如果失败,则将添加一个“error”项,其中包含原因:无法打开文件:文件未找到或不可访问 无法读取文件:无法读取第一个块 不是交换文件:不包含正确的块 ID 魔数不匹配:第一个块中的信息无效
参数
{fname} (string)
返回值
(任何)
swapname({buf}) swapname()
结果是缓冲区 {buf} 的交换文件路径。有关 {buf} 的使用,请参阅上面的 bufname()。如果缓冲区 {buf} 是当前缓冲区,则结果等于 :swapname(除非没有交换文件)。如果缓冲区 {buf} 没有交换文件,则返回一个空字符串。
参数
{buf} (integer|string)
返回值
(字符串)
synID({lnum}, {col}, {trans}) synID()
结果是一个数字,它表示当前窗口中位置 {lnum}{col} 处的语法 ID。语法 ID 可与 synIDattr()synIDtrans() 一起使用,以获取有关文本的语法信息。
{col} 代表最左侧列为 1,{lnum} 代表第一行为 1。'synmaxcol' 应用于此,在更长的行中将返回零。请注意,当位置位于最后一个字符之后时,该位置是光标在插入模式下可以位于的位置,synID() 将返回零。{lnum} 的使用方法与 getline() 相同。
{trans}TRUE 时,透明项目将缩减为它们揭示的项目。当想要了解有效颜色时,这很有用。当 {trans}FALSE 时,将返回透明项目。当想要了解哪个语法项目有效(例如,在括号内)时,这很有用。 警告: 此函数可能非常慢。通过正向遍历文件可获得最佳速度。
发生错误时返回零。
示例(回显光标下的语法项目名称)
echo synIDattr(synID(line("."), col("."), 1), "name")
参数
{lnum} (integer)
{col} (integer)
{trans} (0|1)
返回值
(integer)
synIDattr({synID}, {what} [, {mode}]) synIDattr()
结果是一个 String,它是语法 ID {synID}{what} 属性。这可用于获取有关语法项目的详细信息。{mode} 可以是“gui”或“cterm”,以获取该模式的属性。当省略 {mode} 或使用无效值时,将使用当前活动突出显示的属性(GUI 或 cterm)。使用 synIDtrans() 跟踪链接的突出显示组。{what} 结果 "name" 语法项目的名称 "fg" 前景色(GUI:用于设置颜色的颜色名称,cterm:颜色编号作为字符串,term:空字符串) "bg" 背景色(与“fg”相同) "font" 字体名称(仅在 GUI 中可用)highlight-font "sp" 特殊颜色(与“fg”相同)guisp "fg#" 与“fg”相同,但适用于 GUI,并且 GUI 正在运行“#RRGGBB”形式的名称 "bg#" 与“fg#”相同,但适用于“bg” "sp#" 与“fg#”相同,但适用于“sp” "bold" 如果是粗体则为“1” "italic" 如果是斜体则为“1” "reverse" 如果是反转则为“1” "inverse" 如果是反转(= 反转)则为“1” "standout" 如果是突出显示则为“1” "underline" 如果是下划线则为“1” "undercurl" 如果是下划线则为“1” "underdouble" 如果是双下划线则为“1” "underdotted" 如果是点线则为“1” "underdashed" 如果是虚线则为“1” "strikethrough" 如果是删除线则为“1” "altfont" 如果是备用字体则为“1” "nocombine" 如果是非组合则为“1”
错误时返回空字符串。
示例(回显光标下语法项目的颜色)
echo synIDattr(synIDtrans(synID(line("."), col("."), 1)), "fg")
也可以用作 method
echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")
参数
{synID} (integer)
{what} (string)
{mode} (string?)
返回值
(字符串)
synIDtrans({synID}) synIDtrans()
结果是一个数字,它表示 {synID} 的翻译后的语法 ID。这是用于突出显示字符的语法组 ID。使用“:highlight link”给出的突出显示链接将被跟踪。
发生错误时返回零。
参数
{synID} (integer)
返回值
(integer)
synconcealed({lnum}, {col}) synconcealed()
结果是一个 List,目前包含三个项目:1. 列表中的第一个项目为 0 表示位置 {lnum}{col} 处的字符不是可隐藏区域的一部分,为 1 表示是。{lnum} 的使用方法与 getline() 相同。2. 列表中的第二个项目是一个字符串。如果第一个项目为 1,则第二个项目包含将显示在隐藏文本位置的文本,具体取决于 'conceallevel''listchars' 的当前设置。3. 列表中的第三个也是最后一个项目是一个数字,表示在行中匹配的特定语法区域。当字符未被隐藏时,该值为零。如果存在两个具有相同替换字符的连续区域,这将允许检测新可隐藏区域的开始。例如,如果文本为“123456”,“23”和“45”都隐藏并被字符“X”替换,那么
call 返回
synconcealed(lnum, 1) [0, '', 0] synconcealed(lnum, 2) [1, 'X', 1] synconcealed(lnum, 3) [1, 'X', 1] synconcealed(lnum, 4) [1, 'X', 2] synconcealed(lnum, 5) [1, 'X', 2] synconcealed(lnum, 6) [0, '', 0]
注意: 不考虑 matchadd() 突出显示的项,因为语法和匹配突出显示是两种不同的机制 syntax-vs-match
参数
{lnum} (integer)
{col} (integer)
返回值
([整数, 字符串, 整数])
synstack({lnum}, {col}) synstack()
返回一个 List,它是当前窗口中位置 {lnum}{col} 处的语法项堆栈。 {lnum} 的使用方式与 getline() 相同。 List 中的每一项都是一个 ID,类似于 synID() 返回的值。 List 中的第一项是外层区域,后面是包含在其中的项。 最后一个是 synID() 返回的值,除非整个项目没有被突出显示,或者它是透明的项目。 此函数可用于调试语法文件。 例子展示了光标下的语法堆栈
for id in synstack(line("."), col("."))
   echo synIDattr(id, "name")
endfor
当使用 {lnum}{col} 指定的位置无效时,将返回一个空列表。 位于一行最后一个字符之后的最后一个位置和空行中的第一列是有效位置。
参数
{lnum} (integer)
{col} (integer)
返回值
(integer[])
system({cmd} [, {input}]) system() E677 注意: 在 Lua 中,最好使用 vim.system()
获取 {cmd} 的输出作为 字符串 (systemlist() 返回一个 List) 并将 v:shell_error 设置为错误代码。 {cmd} 的处理方式与 jobstart() 中相同:如果 {cmd} 是一个 List,则直接运行(不使用 'shell')。 如果 {cmd} 是一个 String,则在 'shell' 中运行,例如
call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}'])
不要用于交互式命令。
结果是一个 String,已过滤以避免平台特定的问题
<CR><NL> 被替换为 <NL>
NUL 字符被替换为 SOH (0x01)
示例
echo system(['ls', expand('%:h')])
如果 {input} 是一个字符串,它将被写入管道并作为 stdin 传递给命令。 字符串将按原样写入,行分隔符不会改变。 如果 {input} 是一个 List,它将以 writefile() 的方式写入管道,其中 {binary} 设置为 "b"(即在每个列表项之间使用换行符,并将列表项内部的换行符转换为 NUL)。 当 {input} 被给出并且是一个有效的缓冲区 ID 时,缓冲区的内容将逐行写入文件,每行以 NL 结尾(在文本包含 NL 的地方以 NUL 结尾)。 E5677
注意: system() 无法写入或读取后台("&")shell 命令,例如
echo system("cat - &", "foo")
等同于
$ echo foo | bash -c 'cat - &'
在输入到达之前,管道被断开(除非被 shell 重定向语法覆盖)。 使用 jobstart() 代替。
注意: 使用 shellescape()::Sexpand()fnamemodify() 来转义命令参数中的特殊字符。 'shellquote''shellxquote' 必须配置正确。 例如
echo system('ls '..shellescape(expand('%:h')))
echo system('ls '..expand('%:h:S'))
与 ":!cmd" 不同,不会自动检查已修改的文件。 使用 :checktime 强制检查。
参数
{cmd} (string|string[])
{input} (字符串|字符串[]|整数?)
返回值
(字符串)
systemlist({cmd} [, {input} [, {keepempty}]]) systemlist()
system() 相同,但返回一个 List,其中包含行(由 NL 分隔的输出部分),其中 NUL 被转换为 NL。 输出与 readfile() 使用 {binary} 参数设置为 "b" 的输出相同,区别在于不保留最后的换行符,除非 {keepempty} 不为零。 请注意,在 MS-Windows 上,您可能会得到尾部的 CR 字符。
要查看 "echo hello" 和 "echo -n hello" 之间的区别,请使用 system()split()
echo split(system('echo hello'), '\n', 1)
错误时返回空字符串。
参数
{cmd} (string|string[])
{input} (字符串|字符串[]|整数?)
{keepempty} (整数?)
返回值
(string[])
tabpagebuflist([{arg}]) tabpagebuflist()
结果是一个 List,其中每一项都是与当前标签页中的每个窗口关联的缓冲区的编号。 {arg} 指定要使用的标签页编号。 当省略时,使用当前标签页。 当 {arg} 无效时,将返回数字零。 要获取所有标签页中所有缓冲区的列表,请使用以下方法
let buflist = []
for i in range(tabpagenr('$'))
   call extend(buflist, tabpagebuflist(i + 1))
endfor
请注意,一个缓冲区可能出现在多个窗口中。
参数
{arg} (整数?)
返回值
(任何)
tabpagenr([{arg}]) tabpagenr()
结果是一个 Number,表示当前标签页的编号。 第一个标签页的编号为 1。
可选参数 {arg} 支持以下值:$ 最后一个标签页的编号(标签页数量)。 # 上次访问的标签页的编号(g<Tab> 所在的标签页)。 如果没有以前的标签页,则返回 0。 此编号可与 :tab 命令一起使用。
发生错误时返回零。
参数
{arg} ('$'|'#'?)
返回值
(integer)
tabpagewinnr({tabarg} [, {arg}]) tabpagewinnr()
类似于 winnr(),但用于标签页 {tabarg}{tabarg} 指定要使用的标签页编号。 {arg} 的使用方法与 winnr() 相同
当省略时,将返回当前窗口编号。 这是切换到该标签页时将使用的窗口。
当为 "$" 时,将返回窗口数量。
当为 "#" 时,将返回上一个窗口编号。 有用的示例
tabpagewinnr(1)            " current window of tab page 1
tabpagewinnr(4, '$')    " number of windows in tab page 4
{tabarg} 无效时,将返回零。
参数
{tabarg} (整数)
{arg} ('$'|'#'?)
返回值
(integer)
tagfiles() tagfiles()
返回一个 List,其中包含用于搜索当前缓冲区标签的文件名。 这是 'tags' 选项的扩展结果。
返回值
(string[])
taglist({expr} [, {filename}]) taglist()
返回一个 List,其中包含与正则表达式 {expr} 匹配的标签。
如果传递了 {filename},它将用于按与 :tselect 相同的方式对结果进行优先级排序。 请参阅 tag-priority{filename} 应该是文件的完整路径。
每个列表项都是一个字典,至少包含以下条目:name 标签的名称。 filename 定义标签的文件的名称。 它可以是相对于当前目录的路径,也可以是完整路径。 cmd 用于在文件中定位标签的 ex 命令。 kind 标签的类型。 此条目的值取决于语言特定的 kind 值。 仅当使用由 Universal/Exuberant ctags 或 hdrtag 生成的标签文件时可用。 static 文件特定的标签。 有关详细信息,请参阅 static-tag。 可能存在更多条目,具体取决于标签文件的内容:access、implementation、inherits 和 signature。 有关这些字段的信息,请参阅 ctags 文档。 对于 C 代码,可能会出现 "struct"、"class" 和 "enum" 字段,它们给出包含标签的实体的名称。
ex 命令 "cmd" 可以是 ex 搜索模式、行号,或者行号后跟字节号。
如果没有匹配的标签,则返回一个空列表。
要获得精确的标签匹配,应该在 {expr} 中使用锚点 '^' 和 '$'。 这也使函数运行得更快。 有关标签搜索正则表达式模式的更多信息,请参阅 tag-regexp
有关 Vim 如何定位标签文件的信息,请参阅 'tags'。 有关不同 ctags 工具生成的标签文件格式的信息,请参阅 tags-file-format
参数
{expr} (any)
{filename} (字符串?)
返回值
(任何)
tan({expr}) tan()
返回 {expr} 的正切值(以弧度为单位),以 Float 格式表示,范围为 [-inf, inf]。 {expr} 必须计算为 FloatNumber。 如果 {expr} 不是 FloatNumber,则返回 0.0。 例如
echo tan(10)
0.648361
echo tan(-4.01)
-1.181502
参数
{expr} (number)
返回值
(number)
tanh({expr}) tanh()
返回 {expr} 的双曲正切值,以 Float 格式表示,范围为 [-1, 1]。 {expr} 必须计算为 FloatNumber。 如果 {expr} 不是 FloatNumber,则返回 0.0。 例如
echo tanh(0.5)
0.462117
echo tanh(-1)
-0.761594
参数
{expr} (number)
返回值
(number)
tempname() tempname()
生成位于 Nvim 根目录 tempdir 中的(不存在的)文件名。 脚本可以使用该文件名作为临时文件。 例如
let tmpfile = tempname()
exe "redir > " .. tmpfile
返回值
(字符串)
termopen({cmd} [, {opts}]) termopen()
在连接到当前(未修改)缓冲区的新的伪终端会话中生成 {cmd}。 参数和行为与 jobstart() 相同,但 "pty"、"width"、"height" 和 "TERM" 被忽略: "height" 和 "width" 取自当前窗口。 请注意,termopen() 意味着向 jobstart() 传递 "pty" 参数,因此具有在 jobstart() 中记录的含义。
返回与 jobstart() 相同的值。
终端环境的初始化方式与 jobstart-env 中相同,区别在于 $TERM 被设置为 "xterm-256color"。 完整的行为在 terminal 中描述。
参数
{cmd} (string|string[])
{opts} (table?)
返回值
(任何)
test_garbagecollect_now() test_garbagecollect_now()
类似于 garbagecollect(),但立即执行。 这只能直接调用,以避免任何结构在内部存在,并且在调用任何函数之前必须设置 v:testingE1142
返回值
(任何)
timer_info([{id}]) timer_info()
返回一个包含计时器信息的列表。 当给出 {id} 时,仅返回有关此计时器的信息。 当计时器 {id} 不存在时,将返回一个空列表。 当省略 {id} 时,将返回有关所有计时器的信息。
对于每个计时器,信息存储在 Dictionary 中,其中包含以下项: "id" 计时器 ID "time" 计时器启动的时间 "repeat" 计时器将继续触发的次数; -1 表示永远 "callback" 回调函数
参数
{id} (integer?)
返回值
(任何)
timer_pause({timer}, {paused}) timer_pause()
暂停或取消暂停计时器。 暂停的计时器在时间到期时不会调用其回调函数。 取消暂停计时器可能会导致回调函数几乎立即被调用,如果已经过去了足够的时间。
暂停计时器有助于避免回调函数在短时间内被调用。
如果 {paused} 计算为非零 Number 或非空 String,则暂停计时器,否则取消暂停计时器。 请参阅 non-zero-arg
参数
{timer} (整数)
{paused} (布尔值)
返回值
(任何)
timer_start({time}, {callback} [, {options}]) timer_start() timer 创建一个计时器并返回计时器 ID。
{time} 是以毫秒为单位的等待时间。这是调用回调函数前的最小时间。当系统繁忙或 Vim 不等待输入时,时间会更长。零可以用来在 Vim 恢复到主循环时执行回调函数。
{callback} 是要调用的函数。它可以是函数名或 Funcref。它被调用时带有一个参数,即计时器 ID。回调函数只有在 Vim 等待输入时才会被调用。
{options} 是一个字典。支持的条目:"repeat" 回调函数重复的次数。-1 表示永远。默认值为 1。如果计时器连续三次发生错误,则重复将被取消。
如果发生错误,则返回 -1。
示例
func MyHandler(timer)
  echo 'Handler called'
endfunc
let timer = timer_start(500, 'MyHandler',
        \ {'repeat': 3})
这将以 500 毫秒的间隔调用 MyHandler() 三次。
参数
{time} (number)
{callback} (string|function)
{options} (table?)
返回值
(任何)
timer_stop({timer}) timer_stop()
停止一个计时器。计时器回调函数将不再被调用。{timer} 是 timer_start() 返回的 ID,因此它必须是数字。如果{timer} 不存在,则不会发生错误。
参数
{timer} (整数)
返回值
(任何)
timer_stopall() timer_stopall()
停止所有计时器。计时器回调函数将不再被调用。如果某些计时器行为不正常,这很有用。如果不存在计时器,则不会发生错误。
返回值
(任何)
tolower({expr}) tolower()
结果是给定字符串的副本,所有大写字母都被转换为小写字母(就像将 gu 应用于字符串一样)。在发生错误时返回空字符串。
参数
{expr} (string)
返回值
(字符串)
toupper({expr}) toupper()
结果是给定字符串的副本,所有小写字母都被转换为大写字母(就像将 gU 应用于字符串一样)。在发生错误时返回空字符串。
参数
{expr} (string)
返回值
(字符串)
tr({src}, {fromstr}, {tostr}) tr()
结果是{src} 字符串的副本,其中所有出现在{fromstr} 中的字符都被替换为{tostr} 字符串中该位置的字符。因此,{fromstr} 中的第一个字符将被转换为{tostr} 中的第一个字符,以此类推。就像 unix 的 "tr" 命令一样。此代码也正确地处理了多字节字符。
错误时返回空字符串。
示例
echo tr("hello there", "ht", "HT")
返回 "Hello THere"
echo tr("<blob>", "<>", "{}")
返回 "{blob}"
参数
{src} (string)
{fromstr} (string)
{tostr} (string)
返回值
(字符串)
trim({text} [, {mask} [, {dir}]]) trim()
{text} 作为字符串返回,其中{mask} 中的任何字符都从{text} 的开头和/或结尾删除。
如果{mask} 未给出或为空字符串,则{mask} 将是所有小于 0x20 的字符,包括 Tab、空格、NL 和 CR,以及不间断空格字符 0xa0。
可选的{dir} 参数指定删除字符的位置:0 从{text} 的开头和结尾删除 1 仅从{text} 的开头删除 2 仅从{text} 的结尾删除 如果省略,则修剪两端。
此函数正确地处理多字节字符。在发生错误时返回空字符串。
示例
echo trim("   some text ")
返回 "some text"
echo trim("  \r\t\t\r RESERVE \t\n\x0B\xA0") .. "_TAIL"
返回 "RESERVE_TAIL"
echo trim("rm<Xrm<>X>rrm", "rm<>")
返回 "Xrm<>X"(中间的字符不会被删除)
echo trim("  vim  ", " ", 2)
返回 " vim"
参数
{text} (string)
{mask} (string?)
{dir} (0|1|2?)
返回值
(字符串)
trunc({expr}) trunc()
将小于或等于{expr} 的最大整数值作为 Float 返回(向零截断)。{expr} 必须计算为 FloatNumber。如果{expr} 不是 FloatNumber,则返回 0.0。示例
echo trunc(1.456)
1.0
echo trunc(-5.456)
-5.0
echo trunc(4.0)
4.0
参数
{expr} (number)
返回值
(integer)
type({expr}) type()
结果是一个表示{expr} 类型的数字。最好不要直接使用该数字,而应使用 v:t_ 变量,该变量的值为:Number: 0 v:t_number String: 1 v:t_string Funcref: 2 v:t_func List: 3 v:t_list Dictionary: 4 v:t_dict Float: 5 v:t_float Boolean: 6 v:t_bool (v:falsev:true) Null: 7 (v:null) Blob: 10 v:t_blob 为了向后兼容,可以使用此方法
if type(myvar) == type(0) | endif
if type(myvar) == type("") | endif
if type(myvar) == type(function("tr")) | endif
if type(myvar) == type([]) | endif
if type(myvar) == type({}) | endif
if type(myvar) == type(0.0) | endif
if type(myvar) == type(v:true) | endif
最好直接检查 v:null 而不是检查 v:null 类型,因为它只是此类型的唯一值。
if myvar is v:null | endif
要检查 v:t_ 变量是否存在,请使用以下方法
if exists('v:t_number') | endif
参数
{expr} (any)
返回值
(integer)
undofile({name}) undofile()
返回用于写入名为{name} 的文件的撤销文件的名称。这将使用 'undodir' 选项,找到存在的目录。它不检查撤销文件是否存在。{name} 始终扩展为完整路径,因为这是内部使用的路径。如果{name} 为空,undofile() 将返回空字符串,因为没有文件名的缓冲区将不会写入撤销文件。与 :wundo:rundo 结合使用很有用。
参数
{name} (字符串)
返回值
(字符串)
undotree([{buf}]) undotree()
返回当前缓冲区的撤销树的当前状态,或者如果给出了{buf},则返回特定缓冲区的撤销树的当前状态。结果是一个包含以下项目的字典:"seq_last" 使用的最高撤销序列号。"seq_cur" 撤销树中当前位置的序列号。当撤销了一些更改时,它与 "seq_last" 不同。"time_cur" 最后用于 :earlier 和相关命令的时间。使用 strftime() 转换为可读的内容。"save_last" 最后一次文件写入的编号。写入之前为零。"save_cur" 撤销树中当前位置的编号。"synced" 最后一个撤销块同步时为非零。当等待用户输入时会发生这种情况。参见 undo-blocks。"entries" 包含有关撤销块的信息的字典列表。
"entries" 列表中的第一个项目是最早的撤销项目。每个列表项都是一个 Dictionary,包含以下项目:"seq" 撤销序列号。与 :undolist 中显示的相同。"time" 发生更改的时间戳。使用 strftime() 转换为可读的内容。"newhead" 仅出现在最后添加的项目中。这标志着最后的更改以及进一步更改将添加的位置。"curhead" 仅出现在最后撤销的项目中。这标志着撤销树中的当前位置,即撤销命令将使用的块。当在最后一次更改后没有撤销任何操作时,此项目不会出现在任何位置。"save" 仅出现在文件写入之前的最后一个块上。该数字是写入计数。第一次写入的数字为 1,最后一次写入的数字为上面提到的 "save_last"。"alt" 备用条目。这也是一个撤销块列表。每个项目可能又包含一个 "alt" 项目。
参数
{buf} (整数|字符串?)
返回值
(vim.fn.undotree.ret)
uniq({list} [, {func} [, {dict}]]) uniq() E882 删除{list} 中重复相邻项目的第二个和后续副本(就地操作)。返回{list}。如果您希望列表保持不变,请先复制一份
let newlist = uniq(copy(mylist))
默认比较函数使用每个项目的字符串表示形式。有关{func}{dict} 的使用,请参见 sort()
如果{list} 不是 List,则返回零。
参数
{list} (any)
{func} (any?)
{dict} (任何?)
返回值
(any[]|0)
utf16idx({string}, {idx} [, {countcc} [, {charidx}]]) utf16idx()
charidx() 相同,但返回{string}{idx} 处的字节的 UTF-16 代码单元索引(在将其转换为 UTF-16 后)。
{charidx} 存在且为 TRUE 时,{idx} 被用作字符串{string} 中的字符索引,而不是字节索引。{string} 中 UTF-8 序列中间的{idx} 将向下舍入到该序列的开头。
如果参数无效或{string} 中的字节少于{idx} 个,则返回 -1。如果字节恰好为{idx} 个,则返回字符串在 UTF-16 代码单元中的长度。
参见 byteidx()byteidxcomp(),了解如何从 UTF-16 索引获取字节索引,以及 charidx(),了解如何从 UTF-16 索引获取字符索引。有关更多信息,请参阅 string-offset-encoding。示例
echo utf16idx('a😊😊', 3)        " returns 2
echo utf16idx('a😊😊', 7)        " returns 4
echo utf16idx('a😊😊', 1, 0, 1)        " returns 2
echo utf16idx('a😊😊', 2, 0, 1)        " returns 4
echo utf16idx('aą́c', 6)                " returns 2
echo utf16idx('aą́c', 6, 1)        " returns 4
echo utf16idx('a😊😊', 9)        " returns -1
参数
{string} (字符串)
{idx} (整数)
{countcc} (布尔值?)
{charidx} (boolean?)
返回值
(integer)
values({dict}) values()
返回一个包含{dict} 中所有值的 List。该 List 的顺序是任意的。另请参见 items()keys()。如果{dict} 不是 Dict,则返回零。
参数
{dict} (any)
返回值
(任何)
virtcol({expr} [, {list} [, {winid}]]) virtcol()
结果是一个数字,即使用{expr} 给出的文件位置的屏幕列。也就是说,当屏幕宽度无限时,该位置的字符占据的最后一个屏幕位置。当位置处有<Tab> 时,返回的数字将是<Tab> 结尾处的列。例如,对于列 1 中的<Tab>,如果将 'ts' 设置为 8,则返回 8。忽略 conceal。对于字节位置,请使用 col()
有关{expr} 的使用,请参见 getpos()col()。当{expr} 为 "$" 时,表示光标行的末尾,因此结果为光标行中的单元格数加一。
当使用 'virtualedit' 时,{expr} 可以是 [lnum, col, off],其中 "off" 是从字符开头到屏幕列的偏移量。例如,<Tab> 中的位置或最后一个字符之后的位置。如果省略 "off",则使用零。当在当前模式下激活虚拟编辑时,可以返回超过行尾的位置。另请参见 'virtualedit'
如果{list} 存在且非零,则 virtcol() 返回一个列表,其中包含字符占据的第一个和最后一个屏幕位置。
使用可选的{winid} 参数,将为该窗口而不是当前窗口获取值。
请注意,只能使用当前文件中的标记。示例
" With text "foo^Lbar" and cursor on the "^L":
echo virtcol(".")        " returns 5
echo virtcol(".", 1)        " returns [4, 5]
echo virtcol("$")        " returns 9
" With text "          there", with 't at 'h':
echo virtcol("'t")        " returns 6
第一列为 1。对于错误,返回 0 或 [0, 0]。
一个更高级的示例,用于回显所有行的最大长度
echo max(map(range(1, line('$')), "virtcol([v:val, '$'])"))
参数
{expr} (字符串|整数[])
{list} (boolean?)
{winid} (integer?)
返回值
(任何)
virtcol2col({winid}, {lnum}, {col}) virtcol2col()
结果是一个数字,即窗口{winid} 中缓冲区行{lnum} 和虚拟列{col} 处的字符的字节索引。
如果缓冲区行 {lnum} 为空行,则返回 0。
如果 {col} 大于行 {lnum} 中最后一个虚拟列,则返回最后一个虚拟列字符的字节索引。
对于多字节字符,返回字符中第一个字节的列号。
{winid} 参数可以是窗口号或窗口 ID。如果为零,则使用当前窗口。
如果窗口 {winid} 不存在,或者缓冲区行 {lnum} 或虚拟列 {col} 无效,则返回 -1。
另请参阅 screenpos()virtcol()col()
参数
{winid} (integer)
{lnum} (integer)
{col} (integer)
返回值
(任何)
visualmode([{expr}]) visualmode()
结果是一个字符串,描述了当前缓冲区中最后使用的 Visual 模式。最初它返回一个空字符串,但一旦使用了 Visual 模式,它将分别针对字符级、行级或块级 Visual 模式返回 "v"、"V" 或 "<CTRL-V>"(单个 CTRL-V 字符)。示例
exe "normal " .. visualmode()
这将进入与之前相同的 Visual 模式。如果您希望根据使用的 Visual 模式采取不同的操作,它在脚本中也很有用。如果 Visual 模式处于活动状态,请使用 mode() 获取 Visual 模式(例如,在 :vmap 中)。如果提供了 {expr} 并且它计算结果为非零数字或非空字符串,则将清除 Visual 模式,并返回旧值。请参阅 non-zero-arg
参数
{expr} (boolean?)
返回值
(任何)
wait({timeout}, {condition} [, {interval}]) wait()
等待直到 {condition} 计算结果为 TRUE,其中 {condition} 是一个 Funcref 或包含表达式的 字符串
{timeout} 是以毫秒为单位的最大等待时间,-1 表示永远等待。
在用户事件、内部事件和每 {interval} 毫秒(默认值:200)时评估条件。
返回一个状态整数:0 表示在超时之前满足条件 -1 表示超时 -2 表示函数被中断(通过 CTRL-C) -3 表示发生错误
参数
{timeout} (integer)
{condition} (any)
{interval} (number?)
返回值
(任何)
wildmenumode() wildmenumode()
当 wildmenu 处于活动状态时返回 TRUE,否则返回 FALSE。请参阅 'wildmenu''wildmode'。这可以在映射中用于优雅地处理 'wildcharm' 选项。(仅对 mapmode-c 映射有意义)。
例如,要使 <c-j> 在 wildmode 中像 <down> 一样工作,请使用
cnoremap <expr> <C-j> wildmenumode() ? "\<Down>\<Tab>" : "\<c-j>"
(注意:这需要将 'wildcharm' 选项设置为适当的值)。
返回值
(任何)
win_execute({id}, {command} [, {silent}]) win_execute()
execute() 相似,但在窗口 {id} 的上下文中。该窗口将暂时变为当前窗口,而不会触发自动命令或更改目录。执行 {command} 时,将触发自动命令,这可能产生意想不到的副作用。如果需要,请使用 :noautocmd。示例
call win_execute(winid, 'syntax enable')
使用 setwinvar() 执行相同操作不会触发自动命令,也不会真正显示语法高亮显示。
当窗口 {id} 不存在时,不会给出错误,并返回一个空字符串。
参数
{id} (整数)
{command} (string)
{silent} (boolean?)
返回值
(任何)
win_findbuf({bufnr}) win_findbuf()
返回一个包含 窗口 ID列表,这些窗口包含缓冲区 {bufnr}。如果没有,则列表为空。
参数
{bufnr} (integer)
返回值
(integer[])
win_getid([{win} [, {tab}]]) win_getid()
获取指定窗口的 窗口 ID。如果缺少 {win},则使用当前窗口。对于 {win},这是窗口号。最顶部的窗口的编号为 1。如果 {tab} 不存在,则使用当前标签页,否则使用编号为 {tab} 的标签页。第一个标签页的编号为 1。如果找不到窗口,则返回零。
参数
{win} (整数?)
{tab} (integer?)
返回值
(integer)
win_gettype([{nr}]) win_gettype()
返回窗口的类型:"autocmd" 自动命令窗口。用于执行自动命令的临时窗口。 "command" 命令行窗口 cmdwin (empty) 普通窗口 "loclist" 位置列表窗口 "popup" 浮动窗口 api-floatwin "preview" 预览窗口 预览窗口 "quickfix" 快速修复窗口 "unknown" 窗口 {nr} 未找到
如果省略 {nr},则返回当前窗口的类型。如果提供了 {nr},则通过编号或 窗口 ID 返回该窗口的类型。
另请参阅 'buftype' 选项。
参数
{nr} (integer?)
返回值
('autocmd'|'command'|''|'loclist'|'popup'|'preview'|'quickfix'|'unknown')
win_gotoid({expr}) win_gotoid()
转到 ID 为 {expr} 的窗口。这也会更改当前标签页。如果成功,则返回 TRUE,如果找不到窗口,则返回 FALSE。
参数
{expr} (integer)
返回值
(0|1)
win_id2tabwin({expr}) win_id2tabwin()
返回包含 ID 为 {expr} 的窗口的标签页号和窗口号的列表:[tabnr, winnr]。如果找不到窗口,则返回 [0, 0]。
参数
{expr} (integer)
返回值
(任何)
win_id2win({expr}) win_id2win()
返回 ID 为 {expr} 的窗口的窗口号。如果在当前标签页中找不到窗口,则返回 0。
参数
{expr} (integer)
返回值
(任何)
win_move_separator({nr}, {offset}) win_move_separator()
将窗口 {nr} 的垂直分隔线(即右边界)移动 {offset} 列,就像用鼠标拖动一样。{nr} 可以是窗口号或 窗口 ID。正数的 {offset} 向右移动,负数的 {offset} 向左移动。移动窗口的垂直分隔线将更改窗口的宽度以及与垂直分隔线相邻的其他窗口的宽度。移动的幅度可能小于指定的幅度(例如,由于要维护 'winminwidth')。如果找到窗口,则返回 TRUE,否则返回 FALSE。这对于最右边的窗口和全宽窗口将失败,因为它们在右侧没有分隔线。仅对当前标签页起作用。 E1308
参数
{nr} (整数)
{offset} (integer)
返回值
(任何)
win_move_statusline({nr}, {offset}) win_move_statusline()
将窗口 {nr} 的状态行(即底部边界)移动 {offset} 行,就像用鼠标拖动一样。{nr} 可以是窗口号或 窗口 ID。正数的 {offset} 向下移动,负数的 {offset} 向上移动。移动窗口的状态行将更改窗口的高度以及与状态行相邻的其他窗口的高度。移动的幅度可能小于指定的幅度(例如,由于要维护 'winminheight')。如果找到窗口,则返回 TRUE,否则返回 FALSE。仅对当前标签页起作用。
参数
{nr} (整数)
{offset} (integer)
返回值
(任何)
win_screenpos({nr}) win_screenpos()
返回窗口 {nr} 的屏幕位置,这是一个包含两个数字的列表:[row, col]。第一个窗口的位置始终为 [1, 1],除非存在标签页线,否则为 [2, 1]。{nr} 可以是窗口号或 窗口 ID。对于当前窗口,请使用零。如果找不到窗口,则返回 [0, 0]。
参数
{nr} (整数)
返回值
(任何)
win_splitmove({nr}, {target} [, {options}]) win_splitmove()
暂时切换到窗口 {target},然后将窗口 {nr} 移动到与 {target} 相邻的新分割处。与 :split 等命令不同,不会创建新的窗口(窗口 {nr}窗口 ID 在移动后保持不变)。
{nr}{target} 都可以是窗口号或 窗口 ID。两者都必须在当前标签页中。
成功返回零,失败返回非零值。
{options} 是一个包含以下可选条目的 字典:"vertical" 当为 TRUE 时,分割将垂直创建,就像使用 :vsplit 一样。"rightbelow" 当为 TRUE 时,分割将在下方或右侧(如果为垂直)创建。当为 FALSE 时,将在上方或左侧(如果为垂直)创建。如果不存在,则使用 'splitbelow''splitright' 的值。
参数
{nr} (整数)
{target} (integer)
{options} (table?)
返回值
(任何)
winbufnr({nr}) winbufnr()
结果是一个数字,它是与窗口 {nr} 关联的缓冲区的编号。{nr} 可以是窗口号或 窗口 ID。当 {nr} 为零时,将返回当前窗口中缓冲区的编号。当窗口 {nr} 不存在时,将返回 -1。示例
echo "The file in the current window is " .. bufname(winbufnr(0))
参数
{nr} (整数)
返回值
(integer)
wincol() wincol()
结果是一个数字,它是窗口中光标的虚拟列。这是从窗口左侧开始计算屏幕单元格的。最左侧的列为 1。
返回值
(integer)
windowsversion() windowsversion()
结果是一个字符串。对于 MS-Windows,它表示操作系统版本。例如,Windows 10 为 "10.0",Windows 8 为 "6.2",Windows XP 为 "5.1"。对于非 MS-Windows 系统,结果为空字符串。
返回值
(字符串)
winheight({nr}) winheight()
结果是一个数字,它是窗口 {nr} 的高度。{nr} 可以是窗口号或 窗口 ID。当 {nr} 为零时,将返回当前窗口的高度。当窗口 {nr} 不存在时,将返回 -1。现有的窗口始终具有零或更大的高度。这排除了任何窗口工具栏行。示例
echo "The current window has " .. winheight(0) .. " lines."
参数
{nr} (整数)
返回值
(integer)
winlayout([{tabnr}]) winlayout()
结果是一个嵌套列表,其中包含标签页中窗口的布局。
如果缺少 {tabnr},则使用当前标签页,否则使用编号为 {tabnr} 的标签页。如果找不到标签页 {tabnr},则返回一个空列表。
对于叶节点窗口,它返回
["leaf", {winid}]
对于水平分割的窗口(形成一列),它返回
["col", [{nested list of windows}]]
对于垂直分割的窗口(形成一行),它返回
["row", [{nested list of windows}]]
示例
" Only one window in the tab page
echo winlayout()
['leaf', 1000]
" Two horizontally split windows
echo winlayout()
['col', [['leaf', 1000], ['leaf', 1001]]]
" The second tab page, with three horizontally split
" windows, with two vertically split windows in the
" middle window
echo winlayout(2)
['col', [['leaf', 1002], ['row', [['leaf', 1003],
                    ['leaf', 1001]]], ['leaf', 1000]]]
参数
{tabnr} (integer?)
返回值
(任何)
winline() winline()
结果是一个数字,它是窗口中光标的屏幕行。这是从窗口顶部开始计算屏幕行的。第一行的编号为 1。如果移动了光标,则将首先更新文件上的视图,这可能会导致滚动。
返回值
(integer)
winnr([{arg}]) winnr()
结果是一个数字,它是当前窗口的编号。最顶部的窗口的编号为 1。对于弹出窗口,返回零。
可选参数 {arg} 支持以下值:$ 上一个窗口的编号(窗口数量)。# 上一个访问窗口的编号(CTRL-W_p 所指向的窗口)。如果没有之前的窗口或它在另一个标签页,则返回 0。在某些情况下可能引用当前窗口(例如,在评估 'statusline' 表达式时)。{N}j 当前窗口下方第 N 个窗口的编号(CTRL-W_j 所指向的窗口)。{N}k 当前窗口上方第 N 个窗口的编号(CTRL-W_k 所指向的窗口)。{N}h 当前窗口左侧第 N 个窗口的编号(CTRL-W_h 所指向的窗口)。{N}l 当前窗口右侧第 N 个窗口的编号(CTRL-W_l 所指向的窗口)。该编号可与 CTRL-W_w 和 ":wincmd w" :wincmd 一起使用。当 {arg} 无效时,会给出错误并返回零。另请参阅 tabpagewinnr()win_getid()。示例
let window_count = winnr('$')
let prev_window = winnr('#')
let wnum = winnr('3k')
参数
{arg} (string|integer?)
返回值
(任何)
winrestcmd() winrestcmd()
返回一个 :resize 命令序列,该序列应该恢复当前窗口的大小。只有在没有打开或关闭任何窗口并且当前窗口和标签页保持不变的情况下才能正常工作。示例
let cmd = winrestcmd()
call MessWithWindowSizes()
exe cmd
返回值
(任何)
winrestview({dict}) winrestview()
使用 Dictionary(由 winsaveview() 返回)来恢复当前窗口的视图。 注意:{dict} 不必包含由 winsaveview() 返回的所有值。如果缺少值,则不会恢复这些设置。因此,您可以使用
call winrestview({'curswant': 4})
这只会将光标的 curswant 值(光标在垂直移动时想要移动到的列)设置为第 5 列(是的,是 5),而所有其他设置将保持不变。如果您手动设置了光标位置,这将很有用。
如果您更改了值,结果将不可预测。如果窗口大小发生变化,结果将不再相同。
参数
{dict} (vim.fn.winrestview.dict)
返回值
(任何)
winsaveview() winsaveview()
返回一个 Dictionary,其中包含恢复当前窗口视图的信息。使用 winrestview() 来恢复视图。如果您有一个在缓冲区中跳转的映射,并且想要返回到原始视图,这将很有用。这不会保存折叠信息。使用 'foldenable' 选项临时关闭折叠,以便在移动时不会打开折叠。这可能会产生副作用。返回值包括:lnum 光标行号 col 光标列(注意:第一列为零,与 getcurpos() 返回的值相反)coladd 光标列偏移量(用于 'virtualedit')curswant 垂直移动的列(注意:第一列为零,与 getcurpos() 返回的值相反)。在 $ 命令之后,它将是一个非常大的数字,等于 v:maxcol。topline 窗口中的第一行 topfill 填充行,仅在 diff 模式下 leftcol 显示的第一列;仅在 'wrap' 关闭时使用 skipcol 跳过的列 请注意,没有保存任何选项值。
返回值
(vim.fn.winsaveview.ret)
winwidth({nr}) winwidth()
结果是一个数字,表示窗口 {nr} 的宽度。{nr} 可以是窗口编号或 窗口 ID。当 {nr} 为零时,返回当前窗口的宽度。当窗口 {nr} 不存在时,返回 -1。现有窗口的宽度始终为零或大于零。示例
echo "The current window has " .. winwidth(0) .. " columns."
if winwidth(0) <= 50
  50 wincmd |
endif
要获取终端或屏幕大小,请参阅 'columns' 选项。
参数
{nr} (整数)
返回值
(任何)
wordcount() wordcount()
结果是当前缓冲区的字节/字符/单词统计信息的字典。这与 g_CTRL-G 提供的信息相同。返回值包括:bytes 缓冲区中的字节数 chars 缓冲区中的字符数 words 缓冲区中的单词数 cursor_bytes 光标位置之前的字节数(非 Visual 模式)cursor_chars 光标位置之前的字符数(非 Visual 模式)cursor_words 光标位置之前的单词数(非 Visual 模式)visual_bytes 可视选择的字节数(仅在 Visual 模式下)visual_chars 可视选择的字符数(仅在 Visual 模式下)visual_words 可视选择的单词数(仅在 Visual 模式下)
返回值
(任何)
writefile({object}, {fname} [, {flags}]) writefile()
{object}List 时,将其写入文件 {fname}。每个列表项用 NL 分隔。每个列表项必须是字符串或数字。所有 NL 字符都将替换为 NUL 字符。在将 {list} 传递给 writefile() 之前,需要插入 CR 字符。
{object}Blob 时,将字节写入文件 {fname},不修改,即使未指定二进制模式。
{flags} 必须是字符串。识别以下字符
'b' 使用二进制模式:最后一个列表项后面没有 NL。末尾的空项会导致文件中的最后一行以 NL 结尾。
'a' 使用追加模式,行将追加到文件
call writefile(["foo"], "event.log", "a")
call writefile(["bar"], "event.log", "a")
'D' 在当前函数结束时删除文件。这类似于
defer delete({fname})
如果不在函数中,则会失败。另请参阅 :defer
's' 在写入文件后调用 fsync()。这会将文件刷新到磁盘(如果可能)。这需要更多时间,但可以避免系统崩溃时丢失文件。
'S' 不调用 fsync(),即使 'fsync' 已设置。
{flags} 不包含 "S" 或 "s" 时,如果设置了 'fsync' 选项,则会调用 fsync()。
如果可能,将覆盖现有文件。
如果写入失败,则返回 -1,否则返回 0。如果无法创建文件或写入失败,则会出现错误消息。
另请参阅 readfile()。要逐字节复制文件
let fl = readfile("foo", "b")
call writefile(fl, "foocopy", "b")
参数
{object} (any)
{fname} (string)
{flags} (string?)
返回值
(任何)
xor({expr}, {expr}) xor()
对两个参数进行按位异或运算。参数将转换为数字。列表、字典或浮点数参数会导致错误。另请参阅 and()or()。示例
let bits = xor(bits, 0x80)
参数
{expr} (number)
{expr1} (number)
返回值
(任何)

2. 在字符串中匹配模式 string-match

这在几个函数中很常见。在 pattern 中解释的正则表达式模式通常用于在缓冲区行中查找匹配项。当使用模式在字符串中查找匹配项时,几乎所有内容都以相同的方式工作。区别在于字符串被视为一行。如果它包含 "\n" 字符,则它不会被视为模式的行分隔符。它可以使用模式中的 "\n" 或 "." 来匹配。示例
let a = "aaaa\nxxxx"
echo matchstr(a, "..\n..")
" aa
" xx
echo matchstr(a, "a.x")
" a
" x
不要忘记 "^" 只匹配字符串的第一个字符,"$" 只匹配字符串的最后一个字符。它们不会匹配 "\n" 之后或之前。
主要
命令索引
快速参考