Nvim :help
页面,生成 自 来源 使用 tree-sitter-vimdoc 解析器。
{expr}
) abs(){expr}
的绝对值。当{expr}
评估为 Float 时,abs() 返回 Float。当{expr}
可以转换为 Number 时,abs() 返回 Number。否则 abs() 给出错误消息并返回 -1。示例echo abs(1.456)
echo abs(-5.456)
echo abs(-4)
{expr}
(number
)number
){expr}
) acos(){expr}
以弧度为单位的反正弦,以范围为 [0, pi] 的 Float 表示。{expr}
必须评估为范围为 [-1, 1] 的 Float 或 Number。如果{expr}
超出范围 [-1, 1],则返回 NaN。如果{expr}
不是 Float 或 Number,则返回 0.0。示例echo acos(0)
echo acos(-0.5)
{expr}
(number
)number
){object}
, {expr}
) add(){expr}
附加到 List 或 Blob {object}
。返回结果 List 或 Blob。示例let alist = add([1, 2, 3], item)
call add(mylist, "woodstock")
{expr}
是 List 时,它将作为一个单独的项目附加。使用 extend() 连接 Lists。当{object}
是 Blob 时,{expr}
必须是一个数字。使用 insert() 在另一个位置添加项目。如果{object}
不是 List 或 Blob,则返回 1。{object}
(any
){expr}
(any
){expr}
, {expr}
) and()or()
和 xor()
。示例let flag = and(bits, 0x80)
{expr}
(number
){expr1}
(number
)integer
)lua vim.print(vim.fn.api_info())
table
){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
){buf}
的用法,请参阅 bufname().{lnum}
是要附加在其下方的行号。请注意,使用 line() 将使用当前缓冲区,而不是正在附加到的缓冲区。使用 "$" 在缓冲区末尾附加。不支持其他字符串值。{buf}
不是有效缓冲区,或者{lnum}
无效,则会显示错误消息。示例let failed = appendbufline(13, 0, "# THE START")
{text}
是一个空列表时,对于无效的{lnum}
不会显示错误消息,因为{lnum}
实际上没有被使用。{buf}
(integer|string
){lnum}
(integer
){text}
(string
)0|1
){winid}
]) argc(){winid}
,则使用当前窗口的参数列表。如果{winid}
为 -1,则使用全局参数列表。否则,{winid}
指定使用其参数列表的窗口:窗口号或窗口 ID。如果{winid}
参数无效,则返回 -1。{winid}
(integer?
)integer
)integer
){winnr}
[, {tabnr}
]]) arglistid(){winnr}
,则仅使用当前选项卡页中的此窗口。如果提供{winnr}
和{tabnr}
,则使用指定选项卡页中的窗口。{winnr}
可以是窗口号或 window-ID.{winnr}
(integer?
){tabnr}
(integer?
)integer
){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}
个参数,则返回一个空字符串。如果{winid}
参数无效,则返回一个空列表。{nr}
(integer?
){winid}
(integer?
)string|string[]
){expr}
) asin(){expr}
以弧度为单位的反正弦,以范围为 [-pi/2, pi/2] 的 Float 表示。{expr}
必须评估为范围为 [-1, 1] 的 Float 或 Number。如果{expr}
超出范围 [-1, 1],则返回 NaN。如果{expr}
不是 Float 或 Number,则返回 0.0。示例echo asin(0.8)
echo asin(-0.5)
{expr}
(any
)number
){cmd}
) assert_beeps(){cmd}
,如果它不产生蜂鸣声或视觉响铃,则将错误消息添加到 v:errors 中。另见 assert_fails()、assert_nobeep() 和 assert-return.{cmd}
(string
)0|1
){expected}
, {actual}
[, {msg}
]) assert_equal(){expected}
和{actual}
不相等时,将错误消息添加到 v:errors 中,并返回 1。否则返回零。 assert-return 错误的格式为 "Expected {expected}
but got {actual}
"。当{msg}
存在时,它将与错误消息的开头一起添加,以及运行脚本时的断言位置。call assert_equal('foo', 'bar', 'baz')
{expected}
(any
){actual}
(any
){msg}
(any?
)0|1
){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
){error}
[, {msg}
]) assert_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
){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}
所在的上下文(脚本名称或函数名称)进行匹配。{cmd}
(string
){error}
(任何类型?
){msg}
(any?
){lnum}
(整数?
){context}
(任何类型?
)0|1
){actual}
[, {msg}
]) assert_false(){actual}
不是假时,一个错误信息将被添加到 v:errors 中,与 assert_equal() 相同。错误信息格式为 "Expected False but got {actual}
"。当 {msg}
存在时,它将被添加到错误信息的最前面,连同断言在脚本中运行的位置。另请参阅 assert-return.{actual}
不是一个数字时,断言失败。{actual}
(any
){msg}
(any?
)0|1
){lower}
, {upper}
, {actual}
[, {msg}
]) assert_inrange(){actual}
小于 {lower}
或大于 {upper}
时,一个错误信息将被添加到 v:errors 中。另请参阅 assert-return。错误信息格式为 "Expected range {lower}
- {upper}
, but got {actual}
"。当 {msg}
存在时,它将被添加到错误信息的最前面。{lower}
(数字
){upper}
(数字
){actual}
(数字
){msg}
(字符串?
)0|1
){pattern}
, {actual}
[, {msg}
]) assert_match(){pattern}
与 {actual}
不匹配时,一个错误信息将被添加到 v:errors 中。另请参阅 assert-return。错误信息格式为 "Pattern {pattern}
does not match {actual}
"。当 {msg}
存在时,它将被添加到错误信息的最前面,连同断言在脚本中运行的位置。{actual}
用作字符串,应用自动转换。使用 "^" 和 "$" 与文本的开头和结尾匹配。同时使用两者以匹配整个文本。call assert_match('^f.*o$', 'foobar')
{pattern}
(字符串
){actual}
(字符串
){msg}
(字符串?
)0|1
){cmd}
) assert_nobeep(){cmd}
并将一个错误信息添加到 v:errors 中,如果它产生了蜂鸣声或视觉铃声。另请参阅 assert_beeps().{cmd}
(string
)0|1
){expected}
, {actual}
[, {msg}
]) assert_notequal()assert_equal()
的反面:当 {expected}
和 {actual}
相等时,将一个错误信息添加到 v:errors 中。另请参阅 assert-return.{expected}
(any
){actual}
(any
){msg}
(any?
)0|1
){pattern}
, {actual}
[, {msg}
]) assert_notmatch()assert_match()
的反面:当 {pattern}
与 {actual}
匹配时,将一个错误信息添加到 v:errors 中。另请参阅 assert-return.{pattern}
(字符串
){actual}
(字符串
){msg}
(字符串?
)0|1
){msg}
(字符串
)0|1
){actual}
[, {msg}
]) assert_true(){actual}
不是真时,一个错误信息将被添加到 v:errors 中,与 assert_equal() 相同。另请参阅 assert-return。当一个值是一个非零数字或 v:true 时,它就是 TRUE。当 {actual}
不是一个数字或 v:true 时,断言失败。当 {msg}
被给出时,它将被添加到默认信息的前面,连同断言在脚本中运行的位置。{actual}
(any
){msg}
(字符串?
)0|1
){expr}
) atan(){expr}
的反正切函数的主值,以弧度表示,范围在 [-pi/2, +pi/2] 之间,作为 Float。{expr}
必须求值为 Float 或 Number。如果 {expr}
不是 Float 或 Number,则返回 0.0。示例echo atan(100)
echo atan(-4.01)
{expr}
(number
)number
){expr1}
, {expr2}
) atan2(){expr1}
/ {expr2}
的反正切函数,以弧度表示,作为 Float,范围在 [-pi, pi] 之间。{expr1}
和 {expr2}
必须求值为 Float 或 Number。如果 {expr1}
或 {expr2}
不是 Float 或 Number,则返回 0.0。示例echo atan2(-1, 1)
echo atan2(1, -1)
{expr1}
(number
){expr2}
(数字
)number
){blob}
) blob2list(){blob}
中每个字节的数字值。示例blob2list(0z0102.0304) " returns [1, 2, 3, 4]
blob2list(0z) " returns []
{blob}
(任何类型
)任何类型[]
){save}
, {title}
, {initdir}
, {default}
) browse(){save}
当为 TRUE 时,选择要写入的文件 {title}
文件选择器的标题 {initdir}
开始浏览的目录 {default}
默认文件名 当点击“取消”按钮、出现错误或无法浏览时,将返回一个空字符串。{save}
(任何类型
){title}
(字符串
){initdir}
(字符串
){default}
(字符串
)0|1
){title}
, {initdir}
) browsedir(){title}
文件选择器的标题 {initdir}
开始浏览的目录 当点击“取消”按钮、出现错误或无法浏览时,将返回一个空字符串。{title}
(字符串
){initdir}
(字符串
)0|1
){name}
) bufadd(){name}
(必须是字符串)。如果文件 {name}
的缓冲区已经存在,则返回该缓冲区编号。否则,返回新创建缓冲区的缓冲区编号。当 {name}
为空字符串时,将始终创建一个新缓冲区。缓冲区将没有设置 'buflisted',并且尚未加载。要向缓冲区添加一些文本,请使用以下方法let bufnr = bufadd('someName')
call bufload(bufnr)
call setbufline(bufnr, 1, ['some', 'text'])
{name}
(字符串
)integer
){buf}
) bufexists(){buf}
的缓冲区存在,则为 TRUE。如果 {buf}
参数是一个数字,则使用缓冲区编号。数字 0 是当前窗口的备用缓冲区。{buf}
(任何类型
)0|1
){buf}
) buflisted(){buf}
的缓冲区存在并且已列出(已设置 'buflisted' 选项),则为 TRUE。{buf}
参数的使用方式与 bufexists() 相同。{buf}
(任何类型
)0|1
){buf}
) bufload(){buf}
已加载。如果缓冲区名称引用一个现有文件,则读取该文件。否则,缓冲区将为空。如果缓冲区已经加载,则不会有任何变化。如果缓冲区与文件无关,则不会读取任何文件(例如,当 'buftype' 为 "nofile" 时)。如果缓冲区文件存在现有交换文件,则不会有任何对话框,缓冲区将照常加载。{buf}
参数的使用方式与 bufexists() 相同。{buf}
(任何类型
){buf}
) bufloaded(){buf}
的缓冲区存在并且已加载(在窗口中显示或隐藏),则为 TRUE。{buf}
参数的使用方式与 bufexists() 相同。{buf}
(任何类型
)0|1
){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}
(整数|字符串?
)字符串
){buf}
[, {create}
]]) bufnr():ls
命令显示的编号相同。有关 {buf}
的使用,请参阅上面的 bufname()。如果缓冲区不存在,则返回 -1。或者,如果 {create}
参数存在且为 TRUE,则创建一个新的、未列出的缓冲区,并返回其编号。bufnr("$") 是最后一个缓冲区let last_buffer = bufnr("$")
{buf}
(整数|字符串?
){create}
(任何类型?
)integer
){buf}
) bufwinid(){buf}
关联的第一个窗口的窗口 ID。关于{buf}
的使用,请参见上面的bufname()。如果缓冲区{buf}
不存在或没有这样的窗口,则返回 -1。示例echo "A window containing buffer 1 is " .. (bufwinid(1))
{buf}
(任何类型
)integer
){buf}
) bufwinnr(){buf}
不存在或没有这样的窗口,则返回 -1。示例echo "A window containing buffer 1 is " .. (bufwinnr(1))
{buf}
(任何类型
)integer
){byte}
) byte2line(){byte}
处字符的行号。这包括行尾字符,具体取决于当前缓冲区的'fileformat' 选项。第一个字符的字节计数为 1。另请参见line2byte()、go 和:goto。{byte}
值无效,则返回 -1。{byte}
(任何
)integer
){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))
{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
){expr}
, {nr}
[, {utf16}
]) byteidxcomp()let s = 'e' .. nr2char(0x301)
echo byteidx(s, 1)
echo byteidxcomp(s, 1)
echo byteidxcomp(s, 2)
{expr}
(any
){nr}
(整数
){utf16}
(任何?
)integer
){func}
, {arglist}
[, {dict}
]) call() E699 使用列表 {arglist}
中的项作为参数来调用函数{func}
。{func}
可以是Funcref 也可以是函数的名称。a:firstline 和 a:lastline 设置为光标行。返回被调用函数的返回值。{dict}
用于具有“dict”属性的函数。它将用于设置局部变量“self”。字典函数{func}
(任何
){arglist}
(任何
){dict}
(任何?
)任何
)echo ceil(-5.456)
echo ceil(4.0)
{expr}
(number
)number
){id}
[, {stream}
]) chanclose(){stream}
可以是“stdin”、“stdout”、“stderr” 或“rpc”(为使用"rpc":v:true
启动的作业关闭 stdin/stdout)。如果省略{stream}
,则所有流都将关闭。如果通道是 pty,则这将关闭 pty 主机,向作业进程发送 SIGHUP。对于套接字,只有一个流,并且应省略{stream}
。{id}
(整数
){stream}
(字符串?
)0|1
)integer
){id}
, {data}
) chansend(){id}
。对于作业,它将数据写入进程的 stdin。对于 stdio 通道channel-stdio,它将写入 Nvim 的 stdout。如果写入成功,则返回写入的字节数,否则返回 0。有关更多信息,请参见channel-bytes。{data}
可以是字符串、字符串可转换、Blob 或列表。如果{data}
是列表,则其项将用换行符连接;项中的任何换行符都将作为 NUL 发送。要发送最后的换行符,请包含最后的空字符串。示例call chansend(id, ["abc", "123\n456", ""])
{id}
(数字
){data}
(字符串|字符串[]
)0|1
){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
{utf8}
被忽略,它仅存在于向后兼容性方面。组合字符是单独的字符。 nr2char() 执行相反的操作。{string}
不是字符串,则返回 0。{string}
(字符串
){utf8}
(任何?
)0|1
){string}
) charclass(){string}
中第一个字符的字符类别。字符类别为以下之一:0 空格 1 标点符号 2 字词字符(取决于'iskeyword')3 表情符号 其他特定 Unicode 类别 该类别用于模式和字词移动。如果{string}
不是字符串,则返回 0。{string}
(字符串
)0|1|2|3|'other'
)echo charcol('.') " returns 3
echo col('.') " returns 7
{expr}
(字符串|整数[]
){winid}
(integer?
)integer
){string}
, {idx}
[, {countcc}
[, {utf16}
]]) charidx(){string}
中位于{idx}
处的字节的字符索引。第一个字符的索引为零。如果没有多字节字符,则返回值等于{idx}
。{utf16}
存在且为 TRUE 时,{idx}
用作字符串{expr}
中的 UTF-16 索引,而不是字节索引。{idx}
个,则返回 -1。如果正好有{idx}
个字节,则返回字符串的字符长度。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
){dir}
) chdir(){dir}
。目录更改的范围取决于当前窗口的目录{dir}
必须是字符串。如果成功,则返回上一个工作目录。将其传递给另一个 chdir() 以恢复目录。失败时,返回空字符串。let save_dir = chdir(newdir)
if save_dir != ""
" ... do some work
call chdir(save_dir)
endif
{dir}
(字符串
)字符串
){lnum}
) cindent(){lnum}
行的缩进量,就像'cindent' 一样。缩进量以空格计算,'tabstop' 的值很重要。{lnum}
的用法与getline() 中的用法相同。当{lnum}
无效时,返回 -1。参见C 缩进。{lnum}
(integer
)integer
){win}
]) clearmatches(){win}
,则使用此编号或窗口 ID 的窗口,而不是当前窗口。{win}
(整数?
){expr}
[, {winid}
]) col(){expr}
给出的列位置的字节索引。有关接受的位置,请参见getpos()。当{expr}
为“$”时,表示光标行的结尾,因此结果是光标行中的字节数加 1。此外,{expr}
可以是 [lnum, col]:包含行号和列号的列表。当列为“$”时最有用,用于获取特定行的最后一列。当“lnum”或“col”超出范围时,col() 返回零。{winid}
参数,将为该窗口而不是当前窗口获取值。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
{expr}
无效或找不到 ID 为 {winid}
的窗口,则返回 0。对于大写标记,列实际上可能位于另一个缓冲区中。对于光标位置,当 'virtualedit' 处于活动状态时,如果光标位于行尾之后,则列会高一位。此外,当使用 <Cmd>
映射时,光标不会移动,这可以用来在插入模式下获取列。imap <F2> <Cmd>echo col(".").."\n"<CR>
{expr}
(字符串|整数[]
){winid}
(integer?
)integer
){startcol}
, {matches}
) complete() E785 设置插入模式补全的匹配项。只能在插入模式下使用。您需要使用带 CTRL-R
的映射(参见 i_CTRL-R)。在 CTRL-O
之后或使用表达式映射时,它不起作用。{startcol}
是完成文本开始的行的字节偏移量。直到光标的文本是将被匹配项替换的原始文本。对于空字符串,请使用 col('.')。"col('.') - 1" 将用匹配项替换一个字符。{matches}
必须是 List。每个 List 项目都是一个匹配项。有关可能的项目类型,请参见 complete-items。"longest" in 'completeopt' 被忽略。请注意,在调用此函数后,您需要避免插入任何会导致补全停止的内容。匹配项可以使用 CTRL-N
和 CTRL-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[]
){expr}
) complete_add(){expr}
添加到匹配项列表。仅供使用 'completefunc' 选项指定的函数使用。如果失败(空字符串或内存不足),则返回 0;如果匹配项已添加,则返回 1;如果匹配项已存在于列表中,则返回 2。有关 {expr}
的解释,请参见 complete-functions。它与 'omnifunc' 返回的列表中的一个项目相同。{expr}
(any
)0|1|2
)0|1
){what}
]) complete_info()<Up>
或 <Down>
键时,最后一个补全在未选择任何项目后),则索引为 -1。inserted 插入的字符串。[尚未实现] preview_winid 信息浮动预览窗口 ID。preview_bufnr 信息浮动预览缓冲区 ID。CTRL-X
i_CTRL-X "scroll" 使用 i_CTRL-X_CTRL-E 或 i_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}
中不受支持的项目将被静默忽略。" 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
){msg}
[, {choices}
[, {default}
[, {type}
]]]) confirm(){msg}
在一个带有 {choices}
作为备选方案的对话框中显示。当 {choices}
缺失或为空时,将使用 "&OK"(并进行翻译)。{msg}
是一个 String,使用 '\n' 来包含换行符。仅在某些系统中,当字符串不适合时,才会换行。{choices}
是一个 String,其中各个选择以 '\n' 分隔,例如:confirm("Save changes?", "&Yes\n&No\n&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
{msg}
(字符串
){choices}
(string?
){default}
(integer?
){type}
(string?
)integer
){expr}
) copy(){expr}
。对于 Numbers 和 Strings,这与直接使用 {expr}
没有区别。当 {expr}
是 List 时,将创建一个浅拷贝。这意味着可以更改原始 List 而不更改副本,反之亦然。但项目是相同的,因此更改一个项目会更改两个 Lists 的内容。一个 Dictionary 的复制方式与 List 相似。另请参见 deepcopy()。{expr}
(any
)任何
){expr}
) cos(){expr}
的余弦值,以弧度为单位,作为 Float。{expr}
必须计算为 Float 或 Number。如果 {expr}
不是 Float 或 Number,则返回 0.0。示例echo cos(100)
echo cos(-4.01)
{expr}
(number
)number
){expr}
) cosh(){expr}
的双曲余弦值,作为 [1, inf] 范围内的 Float。{expr}
必须计算为 Float 或 Number。如果 {expr}
不是 Float 或 Number,则返回 0.0。示例echo cosh(0.5)
echo cosh(-0.5)
{expr}
(number
)number
){comp}
, {expr}
[, {ic}
[, {start}
]]) count() E706 返回值 {expr}
的项目在 String、List 或 Dictionary {comp}
中出现的次数。{ic}
并且它是 TRUE,则不区分大小写。{comp}
是字符串时,将返回 {expr}
的非重叠出现的次数。如果 {expr}
是空字符串,则返回零。{comp}
(string|table|any[]
){expr}
(any
){ic}
(boolean?
){start}
(integer?
)integer
){index}
]) ctxget(){index}
,则假定为 0(即:顶部)。{index}
(integer?
)table
)任何
){types}
]) ctxpush(){types}
并且它是一个 List,其中包含 String,则它指定要包含在推送的 context 中的 context-types。否则,将包含所有 context 类型。{types}
(string[]?
)任何
){context}
[, {index}
]) ctxset(){index}
处的 context 设置为 {context}
所表示的 context。{context}
是一个包含 context 数据的 Dictionary(参见 context-dict)。如果未提供 {index}
,则假定为 0(即:顶部)。{context}
(table
){index}
(integer?
)任何
)任何
){list}
时,它将用作一个包含两个、三个或四个项目的 List:[{lnum}
, {col}
] [{lnum}
, {col}
, {off}
] [{lnum}
, {col}
, {off}
, {curswant}
] 这类似于 getpos() 或 getcurpos() 的返回值,但没有第一个项目。{col}
作为字符计数来定位光标,请使用setcursorcharpos()。{lnum}
的使用方式与getline()相同,但如果{lnum}
为零,光标将保持在当前行。如果{lnum}
大于缓冲区中的行数,光标将定位在缓冲区中的最后一行。如果{col}
大于行中的字节数,光标将定位在行中的最后一个字符。如果{col}
为零,光标将保持在当前列。如果给出{curswant}
,则将其用于设置垂直移动的首选列。否则使用{col}
。{list}
(integer[]
)任何
){pid}
) debugbreak(){pid}
收到 SIGTRAP 信号。对于其他进程的行为未定义。参见 terminal-debug。(向非 MS-Windows 的进程{pid}
发送 SIGINT 信号){pid}
(integer
)任何
){expr}
[, {noref}
]) deepcopy() E698 复制{expr}
。对于数字和字符串,这与直接使用{expr}
没有区别。当{expr}
是一个List时,将创建一个完整副本。这意味着可以更改原始的List而不改变副本,反之亦然。当一个项目是一个List时,会递归地为它创建一个副本。因此,更改副本中的一个项目不会更改原始List的内容。{noref}
为零时,包含的List或Dictionary只复制一次。所有引用都指向这个单一副本。当{noref}
设置为 1 时,List或Dictionary的每次出现都会产生一个新的副本。这也意味着循环引用会导致 deepcopy() 失败。E724{noref}
设置为 1 进行深层复制将失败。另请参见 copy()。{expr}
(any
){noref}
(boolean?
)任何
){fname}
是符号链接时,这也适用。符号链接本身将被删除,而不是它指向的内容。{flags}
为“d”时:删除名为{fname}
的目录。如果目录{fname}
不为空,则此操作将失败。{flags}
为“rf”时:递归地删除名为{fname}
的目录及其所有内容。请小心! 注意:在 MS-Windows 上,无法删除正在使用的目录。{fname}
(string
){flags}
(string?
)integer
){buf}
, {first}
[, {last}
]) deletebufline(){buf}
中删除第{first}
行到第{last}
行(包含)的所有行。如果省略了{last}
,则仅删除第{first}
行。成功则返回 0,失败则返回 1。{buf}
的使用,请参见上面的 bufname()。{buf}
(integer|string
){first}
(integer|string
){last}
(integer|string?
)任何
){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}
接收三个参数old
和new
,则表示更新了键。new
,则表示添加了键。old
,则表示删除了键。{dict}
(table
){pattern}
(字符串
){callback}
(function
)任何
){dict}
, {pattern}
, {callback}
) dictwatcherdel(){dict}
(any
){pattern}
(字符串
){callback}
(function
)任何
):setf FALLBACK
时,返回 FALSE。当编辑另一个文件时,计数器将重置,因此这实际上检查了当前缓冲区是否触发过 FileType 事件。这允许在开始编辑另一个缓冲区的自动命令中设置'filetype'并加载语法文件。任何
){lnum}
) diff_filler(){lnum}
行上方的填充行数。这些是另一个差异窗口中在此处插入的行。这些填充行在显示中显示,但不存在于缓冲区中。{lnum}
的使用方式与getline()相同。因此,“.”是当前行,“'m”是标记 m,等等。如果当前窗口不在差异模式下,则返回 0。{lnum}
(integer
)任何
){lnum}
, {col}
) diff_hlID(){lnum}
行第{col}
列(字节索引)处差异模式的突出显示 ID。如果当前行没有差异更改,则返回零。{lnum}
的使用方式与getline()相同。因此,“.”是当前行,“'m”是标记 m,等等。{col}
对于最左边的列为 1,{lnum}
对于第一行为 1。突出显示 ID 可以与synIDattr()一起使用,以获取有关突出显示的语法信息。{lnum}
(integer
){col}
(integer
)任何
){chars}
) digraph_get() E1214 返回{chars}
的双字符。这应该是一个恰好包含两个字符的字符串。如果{chars}
不仅仅是两个字符,或者{chars}
的双字符不存在,则会给出错误并返回一个空字符串。" 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
)任何
){listall}
]) digraph_getlist(){listall}
参数并且它为 TRUE,则返回所有双字符,包括默认双字符。否则,只返回用户定义的双字符。" Get user-defined digraphs
echo digraph_getlist()
" Get all the digraphs, including default digraphs
echo digraph_getlist(1)
{listall}
(boolean?
)任何
){chars}
, {digraph}
) digraph_set(){chars}
添加到列表中。{chars}
必须是一个包含两个字符的字符串。{digraph}
是一个包含一个 UTF-8 编码字符的字符串。E1215 请注意,合成字符不会被忽略。此函数类似于:digraphs命令,但对于添加以空格开头的双字符很有用。call digraph_set(' ', 'あ')
{chars}
(string
){digraph}
(string
)任何
){digraphlist}
) digraph_setlist(){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[]>
)任何
){expr}
(any
)任何
)echo index(keys(environ()), 'HOME', 0, 1) != -1
任何
){string}
, {chars}
) escape(){string}
中出现的{chars}
中的字符。例如echo escape('c:\program files\vim', ' \')
c:\\program\ files\\vim
{string}
(字符串
){chars}
(string
)任何
){string}
) eval(){string}
并返回结果。特别适用于将 string() 的结果转换为原始值。这适用于数字、浮点数、字符串、Blob 以及它们的组合。也适用于引用现有函数的 Funcref。{string}
(字符串
)任何
)任何
){expr}
(string
)0|1
){command}
[, {silent}
]) execute(){command}
并捕获其输出。如果 {command}
是一个 String,则返回 {command}
输出。如果 {command}
是一个 List,则返回连接的输出。{command}
中的行延续不被识别。示例echo execute('echon "foo"')
echo execute(['echon "foo"', 'echon "bar"'])
{silent}
参数可以具有以下值:" " 不使用 :silent
"silent" 使用 :silent
"silent!" 使用 :silent!
默认值为 "silent"。请注意,与 :redir
不同,使用 "silent!" 时,错误消息会被丢弃。split()
execute('args')->split("\n")
win_execute()
。{command}
(string|string[]
){silent}
(''|'silent'|'silent!'?
)字符串
){expr}
) exepath(){expr}
是一个可执行文件,并且作为(部分或完整)路径给出或在 $PATH 中找到,则返回 {expr}
的完整路径。否则返回空字符串。如果 {expr}
以 "./" 开头,则使用 当前目录。{expr}
(string
)字符串
){expr}
参数是一个字符串,它包含以下内容之一:varname 内部变量(参见 dict.key 内部变量)。也适用于 花括号名称 的 list[i]、字典 条目、列表 项目等。注意,评估索引可能会对无效表达式导致错误消息。例如let l = [1, 2, 3]
echo exists("l[5]")
echo exists("l[xx]")
*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)
{expr}
(string
)0|1
){expr}
) exp(){expr}
的指数,范围为 [0, inf]。{expr}
必须计算为 Float 或 Number。如果 {expr}
不是 Float 或 Number,则返回 0.0。示例echo exp(2)
echo exp(-1)
{expr}
(number
)任何
){string}
不以 '%'、'#' 或 '<' 开头,否则不会包含不存在文件的名称,请参见下文。{string}
以 '%'、'#' 或 '<' 开头时,扩展就像对带有其关联修饰符的 命令行特殊 变量进行扩展一样。以下是一个简要概述<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"
echo expand(expand("<cfile>"))
{string}
不以 '%'、'#' 或 '<' 开头时,它就像在命令行上展开文件名一样进行扩展。将使用 'suffixes' 和 'wildignore',除非给出了可选的 {nosuf}
参数并且它为 TRUE。包含不存在文件的名称。"**" 项可用于在目录树中搜索。例如,要查找当前目录及其子目录中的所有 "README" 文件echo expand("**/README")
{string}
(字符串
){nosuf}
(boolean?
){list}
(nil|false?
)字符串
){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?
)任何
){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?
)任何
){expr1}
, {expr2}
[, {expr3}
]) extendnew(){expr1}
中,而是创建一个新的列表或字典并返回。{expr1}
保持不变。{expr1}
(table
){expr2}
(table
){expr3}
(table?
)任何
){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 有用。{string}
(字符串
){mode}
(string?
)任何
){from}
, {to}
) filecopy(){from}
指向的文件复制到 {to}
中。结果是一个数字,如果文件复制成功,则为 TRUE,如果复制失败,则为 FALSE。如果名为 {to}
的文件已存在,则会失败。请注意,它不处理目录(目前)。{from}
(string
){to}
(string
)0|1
){file}
) filereadable(){file}
的文件存在,并且可以读取,则为 TRUE。如果 {file}
不存在,或者是一个目录,则结果为 FALSE。{file}
是任何表达式,用作字符串。如果你不关心文件是否可读,可以使用 glob()。{file}
按原样使用,你可能需要先扩展通配符echo filereadable('~/.vimrc')
0
echo filereadable(expand('~/.vimrc'))
1
{file}
(string
)0|1
){file}
) filewritable(){file}
的文件存在,并且可以写入,则为 1。如果 {file}
不存在,或者不可写,则结果为 0。如果 {file}
是一个目录,并且可以写入,则结果为 2。{file}
(string
)0|1
){expr1}
, {expr2}
) filter(){expr1}
必须是 列表、字符串、Blob 或 字典。对于 {expr1}
中的每个项目,评估 {expr2}
,当结果为零或假时,从 列表 或 字典 中删除该项目。类似地,对于 Blob 中的每个字节和 字符串 中的每个字符。{expr2}
是一个 字符串,则在 {expr2}
内部 v:val 具有当前项目的价值。对于 字典 v:key 具有当前项目的键,对于 列表 v:key 具有当前项目的索引。对于 Blob v:key 具有当前字节的索引。对于 字符串 v:key 具有当前字符的索引。示例call filter(mylist, 'v:val !~ "OLD"')
call filter(mydict, 'v:key >= 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'))
call filter(myList, {idx, val -> idx * val <= 42})
call filter(myList, {idx -> idx % 2 == 1})
{expr1}
,即被过滤的 列表 或 字典,或一个新的 Blob 或 字符串。当在评估 {expr2}
时遇到错误时,不会处理 {expr1}
中的任何其他项目。当 {expr2}
是一个 Funcref 时,函数内部的错误会被忽略,除非它是用 "abort" 标记定义的。{expr1}
(string|table
){expr2}
(string|function
)任何
){name}
[, {path}
[, {count}
]]) finddir(){path}
中查找目录 {name}
。支持向下和向上递归目录搜索。有关 {path}
的语法,请参见 文件搜索。{path}
,则使用 'path'。:find
非常相似。{name}
(字符串
){path}
(string?
){count}
(integer?
)任何
){name}
[, {path}
[, {count}
]]) findfile()echo findfile("tags.vim", ".;")
{name}
(字符串
){path}
(string?
){count}
(any?
)任何
){list}
[, {maxdepth}
]) flatten(){list}
展平到 {maxdepth}
级。如果没有 {maxdepth}
,则结果是 列表,没有嵌套,就好像 {maxdepth}
是一个非常大的数字。{list}
在原地被修改,如果你不想要这样,请使用 flattennew()。 E900{maxdepth}
表示嵌套列表中发生更改的深度。当 {maxdepth}
为 0 时,{list}
不会被修改。{maxdepth}
必须是正数。echo flatten([1, [2, [3, 4]], 5])
echo flatten([1, [2, [3, 4]], 5], 1)
{list}
(any[]
){maxdepth}
(integer?
)any[]|0
){list}
(any[]
){maxdepth}
(integer?
)any[]|0
){expr}
) float2nr(){expr}
转换为数字。{expr}
必须评估为 Float 或 Number。如果 {expr}
不是 Float 或 Number,则返回 0。当 {expr}
的值超出 Number 的范围时,结果将被截断为 0x7fffffff 或 -0x7fffffff(或当启用 64 位 Number 支持时,为 0x7fffffffffffffff 或 -0x7fffffffffffffff)。NaN 导致 -0x80000000(或当启用 64 位 Number 支持时,为 -0x8000000000000000)。示例echo float2nr(3.95)
echo float2nr(-23.45)
echo float2nr(1.0e100)
echo float2nr(-1.0e150)
echo float2nr(1.0e-100)
{expr}
(number
)任何
){expr}
) floor(){expr}
的最大整数,作为 Float(向下取整)。{expr}
必须评估为 Float 或 Number。如果 {expr}
不是 Float 或 Number,则返回 0.0。示例echo floor(1.856)
echo floor(-5.456)
echo floor(4.0)
{expr}
(number
)任何
){expr1}
, {expr2}
) fmod(){expr1}
/ {expr2}
的余数,即使除法不可表示。返回 {expr1}
- i * {expr2}
,其中 i 是一个整数,使得如果 {expr2}
非零,则结果与 {expr1}
符号相同,且大小小于 {expr2}
的大小。如果 {expr2}
为零,则返回的值为零。返回值为一个 Float。{expr1}
和 {expr2}
必须计算为一个 Float 或 Number。如果 {expr1}
或 {expr2}
不是 Float 或 Number,则返回 0.0。示例echo fmod(12.33, 1.22)
echo fmod(-12.33, 1.22)
{expr1}
(number
){expr2}
(数字
)任何
){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}
(字符串
)字符串
){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
)字符串
){lnum}
) foldclosed(){lnum}
位于一个封闭的折叠中,则结果是该折叠中第一行的行号。如果行 {lnum}
不在封闭的折叠中,则返回 -1。{lnum}
的使用方式与 getline() 相同。因此 "." 是当前行,"'m" 是标记 m,等等。{lnum}
(integer
)integer
){lnum}
) foldclosedend(){lnum}
位于一个封闭的折叠中,则结果是该折叠中最后一行行号。如果行 {lnum}
不在封闭的折叠中,则返回 -1。{lnum}
的使用方式与 getline() 相同。因此 "." 是当前行,"'m" 是标记 m,等等。{lnum}
(integer
)integer
){lnum}
) foldlevel(){lnum}
的折叠级别。对于嵌套折叠,将返回最深级别。如果行 {lnum}
没有折叠,则返回零。无论折叠是打开还是关闭,都无关紧要。在更新折叠时使用(来自 'foldexpr')-1 会返回给行,其中折叠仍有待更新,并且折叠级别未知。作为特例,通常可以使用上一行的级别。{lnum}
的使用方式与 getline() 相同。因此 "." 是当前行,"'m" 是标记 m,等等。{lnum}
(integer
)integer
)+-- 45 lines: abcdef
字符串
){lnum}
) foldtextresult(){lnum}
处显示的封闭折叠的文本。在适当的上下文中评估 'foldtext'。当行 {lnum}
处没有封闭折叠时,将返回空字符串。{lnum}
的使用方式与 getline() 相同。因此 "." 是当前行,"'m" 是标记 m,等等。在导出折叠文本时很有用,例如导出到 HTML。{lnum}
(integer
)字符串
){expr1}
, {expr2}
) foreach(){expr1}
必须是一个 List、String、Blob 或 Dictionary。对于 {expr1}
中的每个项目,执行 {expr2}
。{expr1}
不会被修改;其值可能会被修改,就像使用 :lockvar 1 一样。 E741 参见 map() 和 filter() 以修改 {expr1}
。{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
)任何
){name}
可以以 :
开头,并且可以包含 [范围],这些都会被跳过,不会被返回。如果命令不存在或存在歧义(对于用户定义的命令),则返回空字符串。fullcommand('s')
、fullcommand('sub')
、fullcommand(':%substitute')
都返回 "substitute"。{name}
(字符串
)字符串
){name}
[, {arglist}
] [, {dict}
]) funcref(){name}
之后被重新定义时很重要。{name}
必须是已存在的用户函数。它仅适用于已加载的自动加载函数(为了避免在仅打算使用函数名称时错误地加载自动加载脚本,请使用 function() )。{name}
不能是内置函数。发生错误时返回 0。{name}
(字符串
){arglist}
(any?
){dict}
(任何?
)任何
){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)
{name}
找到。使用 funcref() 来保持相同的函数。{arglist}
或 {dict}
存在时,这会创建一个 partial。这意味着参数列表和/或字典存储在 Funcref 中,并在调用 Funcref 时使用。func Callback(arg1, arg2, name)
"...
endfunc
let Partial = function('Callback', ['one', 'two'])
"...
call Partial('name')
call Callback('one', 'two', 'name')
func Callback(one, two, three)
"...
endfunc
let Partial = function('Callback', ['two'])
"...
eval 'one'->Partial('three')
call Callback('one', 'two', 'three')
func Callback(arg1, arg2, name)
"...
endfunc
let Func = function('Callback', ['one'])
let Func2 = function(Func, ['two'])
"...
call Func2('name')
call Callback('one', 'two', 'name')
{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
let Func = function('Callback', context)
let Func = context.Callback
function Callback(arg1, count) dict
"...
endfunction
let context = {"name": "example"}
let Func = function('Callback', ['one'], context)
"...
call Func(500)
call context.Callback('one', 500)
{name}
(字符串
){arglist}
(any?
){dict}
(任何?
)任何
){atexit}
参数为 1 时,如果之前没有完成垃圾回收,则在退出 Vim 时也会执行垃圾回收。这在检查内存泄漏时非常有用。{atexit}
(boolean?
)任何
){list}
, {idx}
[, {default}
]) get() get()-list 从 List {list}
中获取项目 {idx}
。当该项目不可用时,返回 {default}
。当省略 {default}
时,返回零。{list}
(any[]
){idx}
(整数
){default}
(any?
)任何
){blob}
, {idx}
[, {default}
]) get()-blob{blob}
中获取字节 {idx}
。当该字节不可用时,返回 {default}
。当省略 {default}
时,返回 -1。{blob}
(string
){idx}
(整数
){default}
(any?
)任何
){dict}
, {key}
[, {default}
]) get()-dict{dict}
中获取具有键 {key}
的项目。当该项目不可用时,返回 {default}
。当省略 {default}
时,返回零。有用的示例let val = get(g:, 'var_name', 'default')
{dict}
(table<string,any>
){key}
(string
){default}
(any?
)任何
){func}
, {what}
) get()-func{func}
中获取项目 {what}
。{what}
的可能值是:"name" 函数名称 "func" 函数 "dict" 字典 "args" 包含参数的列表 "arity" 一个字典,包含有关函数接受的参数数量(减去 {arglist}
)的信息,具有以下字段:required 位置参数的数量 optional 可选参数的数量,除了必需的参数之外 varargs 如果函数接受可变数量的参数,则为 TRUE ...{arglist}
包含的参数数量超过 Funcref 预期的数量,则不会出现错误,它不会被验证。{func}
(function
){what}
(string
)任何
){dict}
中可以指定以下键:buflisted 只包含列出的缓冲区。bufloaded 只包含加载的缓冲区。bufmodified 只包含修改过的缓冲区。echo line('.', {winid})
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[]
){buf}
, {lnum}
[, {end}
]) getbufline(){lnum}
到 {end}
(包含)的行的 列表,这些行位于缓冲区 {buf}
中。如果省略 {end}
,则返回一个仅包含行 {lnum}
的 列表。有关仅获取行的信息,请参见 getbufoneline()
。{buf}
的使用,请参见上面的 bufname()。{lnum}
和 {end}
,可以使用 "$" 来表示缓冲区的最后一行。否则,必须使用数字。{lnum}
小于 1 或大于缓冲区中的行数时,将返回一个空的 列表。let lines = getbufline(bufnr("myfile"), 1, "$")
{buf}
(integer|string
){lnum}
(integer
){end_}
(integer?
)任何
){buf}
(integer|string
){lnum}
(integer
)字符串
){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()任何
){buf}
]) getchangelist(){buf}
的 changelist。有关 {buf}
的用法,请参见上面的 bufname()。如果缓冲区 {buf}
不存在,则返回一个空的列表。{buf}
是当前缓冲区,则当前位置指的是列表中的位置。对于其他缓冲区,它设置为列表的长度。{buf}
(整数|字符串?
)table[]
){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() 将其转换为字符串。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>"
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
)integer
){expr}
) getcharpos(){expr}
的位置。与 getpos() 相同,但返回的列表中的列号是字符索引而不是字节索引。如果 getpos() 返回一个非常大的列号,等于 v:maxcol,则 getcharpos() 将返回最后一个字符的字符索引。getcharpos('.') returns [0, 5, 3, 0]
getpos('.') returns [0, 5, 7, 0]
{expr}
(string
)integer[]
)nnoremap <expr> ; getcharsearch().forward ? ';' : ','
nnoremap <expr> , getcharsearch().forward ? ',' : ';'
table
){expr}
]) getcharstr(){expr}
,则等待直到有字符可用。如果 {expr}
为 0 或 false,则仅在有字符可用时获取字符。否则,返回空字符串。如果 {expr}
为 1 或 true,则仅检查是否有字符可用,但不会使用它。如果字符不可用,则返回空字符串。否则,其工作方式类似于 getchar(),只是数字结果将被转换为字符串。{expr}
(0|1?
)字符串
)字符串
)字符串
)cmap <F7> <C-\>eescape(getcmdline(), ' \')<CR>
字符串
)integer
)字符串
)任何
)-
:insert 或 :append 命令 = i_CTRL-R_= 仅在编辑命令行时有效,因此需要使用 c_CTRL-\_e 或 c_CTRL-R_= 或表达式映射。否则返回空字符串。另请参见 getcmdpos()、setcmdpos() 和 getcmdline()。':'|'>'|'/'|'?'|'@'|'-'|'='
)':'|'>'|'/'|'?'|'@'|'-'|'='
){pat}
, {type}
[, {filtered}
]) getcompletion(){type}
参数指定补全类型。支持以下补全类型{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 用户变量{type}
为 "cmdline",则返回 cmdline-completion 结果。例如,要补全 ":call" 命令后的可能值echo getcompletion('call ', 'cmdline')
{type}
的无效值会导致错误。{pat}
(string
){type}
(string
){filtered}
(boolean?
)string[]
){winid}
]) getcurpos(){winid}
参数可以指定窗口。它可以是窗口编号或 window-ID。返回最后已知的光标位置,如果它不是当前窗口,则可能与缓冲区的当前值无效。如果 {winid}
无效,则返回一个包含零的列表。let save_cursor = getcurpos()
MoveTheCursorAround
call setpos('.', save_cursor)
{winid}
(integer?
)任何
)getcursorcharpos() " returns [0, 3, 2, 0, 3]
getcurpos() " returns [0, 3, 4, 0, 3]
{winid}
(integer?
)任何
){winnr}
[, {tabnr}
]]) getcwd(){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?
)字符串
){name}
(字符串
)字符串
){name}
]) getfontname(){name}
是否为有效的字体名称。如果不是,则返回空字符串。否则,将返回实际的字体名称,或者如果 GUI 不支持获取实际名称,则返回 {name}
。仅在 GUI 运行时有效,因此不在您的 vimrc 或 gvimrc 文件中。使用 GUIEnter autocommand 在 GUI 启动后立即使用此函数。{name}
(string?
)字符串
){fname}
) getfperm(){fname}
的读、写和执行权限。如果 {fname}
不存在或其目录不可读,则返回空字符串。结果格式为 "rwxrwxrwx",其中每组 "rwx" 标志分别表示文件所有者、文件所属组和其它用户的权限。如果用户没有给定的权限,则该标志将被替换为字符串 "-"。示例echo getfperm("/etc/passwd")
echo getfperm(expand("~/.config/nvim/init.vim"))
{fname}
(string
)字符串
){fname}
) getfsize(){fname}
的大小(以字节为单位)。如果 {fname}
是目录,则返回 0。如果找不到文件 {fname}
,则返回 -1。如果 {fname}
的大小太大而无法放入 Number 中,则返回 -2。{fname}
(string
)integer
){fname}
) getftime(){fname}
的最后修改时间。该值以 1970 年 1 月 1 日以来的秒数为单位,可以传递给 strftime()。另请参见 localtime() 和 strftime()。如果找不到文件 {fname}
,则返回 -1。{fname}
(string
)integer
){fname}
) getftype(){fname}
的文件类型的描述。如果 {fname}
不存在,则返回空字符串。以下是一个表格,列出了不同类型的文件及其结果:正常文件 "file" 目录 "dir" 符号链接 "link" 块设备 "bdev" 字符设备 "cdev" 套接字 "socket" FIFO "fifo" 所有其他 "other" 示例getftype("/home")
{fname}
(string
)'file'|'dir'|'link'|'bdev'|'cdev'|'socket'|'fifo'|'other'
){winnr}
时,仅在当前选项卡页中使用此窗口。{winnr}
也可以是 window-ID。使用 {winnr}
和 {tabnr}
时,在指定的选项卡页中使用窗口。如果 {winnr}
或 {tabnr}
无效,则返回空列表。{winnr}
(integer?
){tabnr}
(integer?
)vim.fn.getjumplist.ret
){lnum}
是一个小于 1 或大于缓冲区行数的数字时,将返回一个空字符串。{end}
时,结果是一个 List,其中每个项目都是当前缓冲区中从 {lnum}
到 {end}
(包括第 {end}
行)范围内的行。{end}
的使用方式与 {lnum}
相同。非存在的行将被静默地省略。当 {end}
在 {lnum}
之前时,将返回一个空 List。例如let start = line('.')
let end = search("^$") - 1
let lines = getline(start, end)
{lnum}
(integer|string
){end_}
(nil|false?
)字符串
){nr}
[, {what}
]) getloclist(){nr}
位置列表中所有条目的 List。{nr}
可以是窗口编号或 window-ID。当 {nr}
为零时,将使用当前窗口。{nr}
,将返回一个空列表。否则,与 getqflist() 相同。echo getloclist(3, {'all': 0})
echo getloclist(5, {'filewinid': 0})
{nr}
(整数
){what}
(table?
)任何
){buf}
(integer??
)vim.fn.getmarklist.ret.item[]
){win}
]) 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}
(整数?
)任何
)vim.fn.getmousepos.ret
)integer
){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" 与 '< 和 '> 不同,因为它会立即更新。注意,可以使用另一个文件中的标记。然后,行号将应用于另一个缓冲区。<Tab>
内的位置或最后一个字符之后的位置。{expr}
无效,则返回一个包含全零的列表。let save_a_mark = getpos("'a")
" ...
call setpos("'a", save_a_mark)
{expr}
(string
)integer[]
){what}
]) getqflist()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" 条目,其中包含条目列表。echo getqflist({'all': 1})
echo getqflist({'nr': 2, 'title': 1})
echo getqflist({'lines' : ["F1:10:L10"]})
{what}
(table?
)任何
){regname}
[, 1 [, {list}
]]]) getreg(){regname}
的内容。示例let cliptext = getreg('*')
{regname}
未设置时,结果为空字符串。{regname}
参数必须是一个字符串。{list}
存在并且为 TRUE,则结果类型将更改为 List。每个列表项都是一行文本。如果你关心寄存器中可能存在的零字节,请使用它:如果没有第三个参数,则 NL 和零字节都被表示为 NL (参见 NL-used-for-Nul)。当寄存器未设置时,将返回一个空列表。{regname}
,则使用 v:register。{regname}
(string?
){list}
(nil|false?
)字符串
){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
){opts}
是一个 Dict,并支持以下项目{pos1}
和 {pos2}
的顺序无关紧要,它始终会返回从左上角位置到右下角位置的内容。{pos1}
和 {pos2}
不在同一个缓冲区中,则将返回一个空列表。xnoremap <CR>
\ <Cmd>echom getregion(
\ getpos('v'), getpos('.'), #{ type: mode() })<CR>
{pos1}
(table
){pos2}
(table
){opts}
(table?
)string[]
){pos1}
, {pos2}
[, {opts}
]) getregionpos(){pos1}
和 {pos2}
绑定的缓冲区文本段。每个段都是每行的两个位置对[[{start_pos}, {end_pos}], ...]
<Tab>
内或最后一个字符之后的位置。如果结束位置的 "off" 编号非零,则它是字符的第一个单元格的偏移量,该单元格未包含在选择中,否则其所有单元格都包含在选择中。{opts}
还支持以下选项{pos1}
(table
){pos2}
(table
){opts}
(table?
)integer[][][]
){regname}
]) getregtype(){regname}
的类型。该值将是以下之一:"v" 表示 字符级 文本 "V" 表示 行级 文本 "<CTRL-V>{width}" 表示 块级视觉 文本 "" 表示空寄存器或未知寄存器 <CTRL-V>
是值为 0x16 的一个字符。{regname}
参数是一个字符串。如果未指定 {regname}
,则使用 v:register。{regname}
(string?
)字符串
){opts}
]) getscriptinfo():scriptnames
所显示的那样。{opts}
支持以下可选项目: name 脚本名称匹配模式。如果指定,并且未指定 "sid",则返回有关名称与模式 "name" 匹配的脚本的信息。 sid 脚本 ID <SID>。如果指定,则仅返回有关 ID 为 "sid" 的脚本的信息,并忽略 "name"。{opts}
中的 "sid" 项目指定特定脚本时才出现。 name Vim 脚本文件名。 sid 脚本 ID <SID>。 variables 包含脚本局部变量的字典。仅在使用 {opts}
中的 "sid" 项目指定特定脚本时才出现。请注意,这是一个副本,无法使用此字典更改脚本局部变量的值。 version Vim 脚本版本,始终为 1echo getscriptinfo({'name': 'myscript'})
echo getscriptinfo({'sid': 15})[0].variables
{opts}
(table?
)vim.fn.getscriptinfo.ret[]
){tabnr}
]) gettabinfo(){tabnr}
,则返回有关所有选项卡页面的信息,作为 List。每个 List 项目都是一个 Dictionary。否则,{tabnr}
指定选项卡页面的编号,并返回有关该页面的信息。如果选项卡页面不存在,则返回一个空 List。{tabnr}
(integer?
)任何
){tabnr}
, {varname}
[, {def}
]) gettabvar(){tabnr}
中的选项卡局部变量 {varname}
的值。 t:var 选项卡的编号从 1 开始。{varname}
参数是一个字符串。当 {varname}
为空时,将返回一个包含所有选项卡局部变量的字典。请注意,必须使用不带 "t:" 的名称。当选项卡或变量不存在时,将返回 {def}
或空字符串,不会出现错误消息。{tabnr}
(integer
){varname}
(string
){def}
(any?
)任何
){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?
)任何
){winnr}
]) {winnr}
的标记栈。{winnr}
可以是窗口编号或 窗口 ID。当未指定 {winnr}
时,将使用当前窗口。当窗口 {winnr}
不存在时,将返回一个空 Dict。{winnr}
(integer?
)任何
){text}
) gettext(){text}
。这主要用于分布式 Vim 脚本。生成消息翻译时,{text}
由 xgettext 提取,翻译人员可以在 .po 文件中添加翻译后的消息,Vim 会在调用 gettext() 时查找翻译。对于 {text}
,首选双引号字符串,因为 xgettext 不理解单引号字符串中的转义。{text}
(string
)任何
){winid}
,则返回有关具有该 ID 的窗口的信息,以 List 和一个项目的形式。如果窗口不存在,则结果为空列表。{winid}
,则返回有关所有选项卡页中的所有窗口的信息。{winid}
(integer?
)vim.fn.getwininfo.ret.item[]
){timeout}
]) getwinpos(){timeout}
可用于指定等待终端响应的时间(以毫秒为单位)。如果省略,则使用 100 毫秒。while 1
let res = getwinpos(1)
if res[0] >= 0
break
endif
" Do some work here
endwhile
{timeout}
(integer?
)任何
)integer
)integer
){winnr}
, {varname}
[, {def}
]) getwinvar() 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>
字符分隔。{alllinks}
参数存在并且它为 TRUE 时,将包含所有符号链接。let tagfiles = glob("`find . -name tags -print`")
let &tags = substitute(tagfiles, "\n", ",", "g")
{expr}
(string
){nosuf}
(boolean?
){list}
(boolean?
){alllinks}
(boolean?
)任何
){string}
) glob2regpat()if filename =~ glob2regpat('Make*.mak')
" ...
endif
if filename =~ '^Make.*\.mak$'
" ...
endif
{string}
为空字符串时,结果为 "^$",匹配空字符串。请注意,结果取决于系统。在 MS-Windows 上,反斜杠通常表示路径分隔符。{string}
(字符串
)任何
){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() 相同。echo globpath(&rtp, "**/README.txt")
{path}
(string
){expr}
(string
){nosuf}
(boolean?
){list}
(boolean?
){allinks}
(boolean?
)任何
){feature}
) has(){feature}
,则返回 1,否则返回 0。{feature}
参数是一个特性名称,例如 "nvim-0.2.1" 或 "win32",见下文。另请参见 exists()。print(vim.uv.os_uname().sysname)
if has('feature')
let x = this_breaks_without_the_feature()
endif
if has("nvim-0.2.1")
" ...
endif
if has("win32")
" ...
endif
if v:version > 602 || v:version == 602 && has("patch148")
" ...
endif
if has("patch-7.4.237")
" ...
endif
{feature}
(string
)0|1
){dict}
, {key}
) has_key(){dict}
具有键为 {key}
的条目,则该数字为 TRUE。否则为 FALSE。{key}
参数是一个字符串。{dict}
(table
){key}
(string
)0|1
){winnr}
[, {tabnr}
]]) haslocaldir(){winnr}
为 -1 且选项卡页通过 :tcd 设置了本地路径时,该数字为 1,否则为 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
){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”。if !hasmapto('\ABCdoit')
map <Leader>d \ABCdoit
endif
{what}
(any
){mode}
(string?
){abbr}
(boolean?
)0|1
){history}
, {item}
) histadd(){item}
添加到历史记录 {history}
中,它可以是以下之一:hist-names{history}
字符串不需要是整个名称,一个字符就足够了。如果 {item}
已经存在于历史记录中,它将被移到最新条目。结果是一个数字:如果操作成功,则为 TRUE,否则返回 FALSE。call histadd("input", strftime("%Y %b %d"))
let date=input("Enter date: ")
{history}
(string
){item}
(any
)0|1
){item}
的值为字符串,则将其用作正则表达式。所有匹配该表达式的条目将从历史记录中删除(如果有)。除非使用“\c”,否则大小写必须匹配 /\c。如果 {item}
的值为数字,则将其解释为索引,请参见 :history-indexing。如果该条目存在,则将其删除。call histdel("expr")
call histdel("/", '^\*')
call histdel("search", histnr("search"))
call histdel("search", -1)
call histdel("search", '^' .. histget("search", -1) .. '$')
call histdel("search", -1)
let @/ = histget("search", -1)
{history}
(string
){item}
(any?
)0|1
){history}
[, {index}
]) histget(){history}
的编号为 {index}
的条目。有关 {history}
的可能值,请参见 hist-names,有关 {index}
,请参见 :history-indexing。如果不存在此条目,则返回一个空字符串。当 {index}
被省略时,将使用历史记录中的最新条目。execute '/' .. histget("search", -2)
{num}
”,它支持重新执行来自 :history 输出的第 {num}
个条目。command -nargs=1 H execute histget("cmd", 0+<args>)
{history}
(string
){index}
(integer|string?
)字符串
)let inp_index = histnr("expr")
{history}
(string
)integer
){name}
) hlID(){name}
的高亮组的 ID。如果高亮组不存在,则返回零。这可用于检索有关高亮组的信息。例如,要获取“Comment”组的背景颜色echo synIDattr(synIDtrans(hlID("Comment")), "bg")
{name}
(字符串
)integer
){name}
) hlexists(){name}
的高亮组存在,则为 TRUE。如果该组以某种方式定义过,则说明存在。不一定是为其定义了高亮,也可以是为语法项使用过。{name}
(字符串
)0|1
)字符串
){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
)任何
){expr}
) id()id(v1) ==# id(v2)
返回 true,当且仅当 type(v1) == type(v2) && v1 is v2
时。请注意,v:_null_string
、v:_null_list
、v:_null_dict
和 v:_null_blob
具有相同的 id()
,但类型不同,因为它们在内部表示为 NULL 指针。id()
返回容器指针的十六进制表示形式(例如,像 0x994a40
),与 asprintf("%p", {expr}
) 相同,但建议不要依赖返回值的具体格式。id(no_longer_existing_container)
不会等于其他 id()
:新容器可能会重用已垃圾回收的容器的标识符。{expr}
(any
)任何
){lnum}
) indent(){lnum}
行的缩进。缩进以空格计算,'tabstop' 的值相关。{lnum}
的用法与 getline() 中相同。当 {lnum}
无效时,返回 -1。{lnum}
(integer|string
)integer
){object}
, {expr}
[, {start}
[, {ic}
]]) index(){object}
中查找 {expr}
并返回其索引。有关使用 lambda 选择项目的说明,请参见 indexof()。{object}
是一个 列表,则返回项目值等于 {expr}
的最低索引。没有自动转换,因此字符串“4”与数字 4 不同。数字 4 与浮点数 4.0 也不同。'ignorecase' 的值在此处不用,大小写与 {ic}
参数指示的一致。{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?
)任何
){object}
, {expr}
[, {opts}
]) indexof(){object}
中 {expr}
为 v:true 的项目的索引。{object}
必须是 列表 或 Blob。{expr}
是一个 字符串:如果 {object}
是一个 列表,则在 {expr}
内,v:key 具有当前列表项目的索引,而 v:val 具有该项目的 value。如果 {object}
是一个 Blob,则在 {expr}
内,v:key 具有当前字节的索引,而 v:val 具有该字节的值。{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?
)任何
){prompt}
(string
){text}
(string?
){completion}
(string?
)任何
){opts}
) 结果是一个字符串,即用户在命令行上键入的任何内容。{prompt}
参数可以是提示字符串,也可以是空字符串(无提示)。提示符中可以使用“\n”来开始新行。{prompt}
相同。 default "" 与第一种形式中的 {text}
相同。 completion nothing 与第一种形式中的 {completion}
相同。 cancelreturn "" 取消对话框时返回的值。 highlight nothing 高亮处理程序:函数引用。if input("Coffee or beer? ") == "beer"
echo "Cheers!"
endif
{text}
参数且不为空,则将其用作默认回复,就像用户键入了该内容一样。示例let color = input("Color? ", "white")
{completion}
参数指定对输入支持的完成类型。如果没有它,则不会执行完成。支持的完成类型与可以使用“ -complete=”参数提供给用户定义命令的类型相同。有关更多信息,请参见 :command-completion。示例let fname = input("File: ", "", "file")
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'})
nmap \x :call GetFoo()<CR>:exe "/" .. Foo<CR>
function GetFoo()
call inputsave()
let g:Foo = input("enter search pattern: ")
call inputrestore()
endfunction
{opts}
(table
)任何
){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()任何
)任何
){prompt}
[, {text}
]) inputsecret(){prompt}
(string
){text}
(string?
)任何
){idx}
,则在索引为 {idx}
的项目之前插入 {item}
。如果 {idx}
为零,它将位于第一个项目之前,就像省略 {idx}
一样。负 {idx}
也是可能的,参见 list-index。-1 在最后一个项目之前插入。let mylist = insert([2, 3, 5], 1)
call insert(mylist, 4, -1)
call insert(mylist, 6, len(mylist))
{object}
(any
){item}
(any
){idx}
(integer?
)任何
)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>'))
任何
){expr}
(number
)任何
){path}
) isabsolutepath(){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
){directory}
) isdirectory(){directory}
的目录时,它是 TRUE。如果 {directory}
不存在,或者不是目录,则结果为 FALSE。{directory}
是任何表达式,用作 String。{directory}
(string
)0|1
)echo isinf(-1.0 / 0.0)
{expr}
(number
)1|0|-1
){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
){expr}
(number
)0|1
){dict}
) items(){dict}
中所有键值对的 List。每个 List 项目都是一个包含两个项目的列表:{dict}
条目的键和此条目的值。此 List 是按任意顺序排列的。另请参见 keys() 和 values()。示例for [key, value] in items(mydict)
echo key .. ': ' .. value
endfor
{dict}
(any
)任何
){job}
(integer
)integer
){job}
, {width}
, {height}
) jobresize(){job}
的伪终端窗口调整大小为 {width}
列和 {height}
行。如果作业不是使用 "pty":v:true
启动的,则会失败。{job}
(integer
){width}
(integer
){height}
(integer
)任何
){cmd}
作为作业启动。如果 {cmd}
是一个 List,它将直接运行(没有 'shell')。如果 {cmd}
是一个 String,它将在 'shell' 中运行,如下所示call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}'])
call jobstart('nvim -h', {'on_stdout':{j,d,e->append(line('.'),d)}})
{cmd}
[0] 或 'shell' 不可执行,则返回 -1。返回的 job-id 是一个有效的 channel-id,表示作业的 stdio 流。使用 chansend()(或 rpcnotify() 和 rpcrequest(),如果启用了 "rpc")向 stdin 发送数据,并使用 chanclose() 关闭流,而不停止作业。{cmd}
是一个 Listcall jobstart(['ping', 'neovim.io'])
call jobstart(['System32\ping.exe', 'neovim.io'])
{cmd}
将被折叠为一个包含引号引起来的参数的字符串,正如 CommandLineToArgvW 所预期的那样 https://msdn.microsoft.com/bb776391,除非 cmd[0] 是某种形式的 "cmd.exe"。env
选项来设置它们。{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 字典传递给回调函数;调用者可以设置其他键以传递应用程序特定的数据。{cmd}
(string|string[]
){opts}
(table?
)任何
){id}
) jobstop(){id}
。如果进程在超时后没有终止,则将发送 SIGKILL。当作业终止时,将调用其 on_exit 处理程序(如果有)。参见 job-control。{id}
(整数
)任何
)let running = jobwait([{job-id}], 0)[0] == -1
{jobs}
列表中的作业的回调函数。除非回调函数调用 :redraw,否则屏幕不会重新绘制。{jobs}
) 的整数列表,其中每个整数都是对应作业的状态:如果作业退出,则为退出代码,如果超时,则为 -1,如果作业被中断(通过 CTRL-C),则为 -2,如果作业 ID 无效,则为 -3{jobs}
(integer[]
){timeout}
(integer?
)任何
){list}
[, {sep}
]) join(){list}
中的项目连接成一个字符串。当指定 {sep}
时,它被放在项目之间。如果省略 {sep}
,则使用单个空格。请注意,{sep}
不会添加到末尾。您可能希望也将其添加到末尾let lines = join(mylist, "\n") .. "\n"
{list}
(any[]
){sep}
(string?
)任何
){expr}
) json_decode(){expr}
从 JSON 对象转换为 Vim 值。接受 readfile() 风格的列表作为输入,以及常规字符串。可以输出任何 Vim 值。在以下情况下,它将输出 msgpack-special-dict:1. 字典包含重复键。2. 字符串包含 NUL 字节。如果包含 NUL 字节的字符串是字典键,则将发出两个特殊字典:用于字典和字符串。{expr}
(any
)任何
){expr}
) json_encode(){expr}
转换为 JSON 字符串。接受 msgpack-special-dict 作为输入。不会转换 Funcref、具有非字符串键的映射(可以创建为 msgpack-special-dict)、具有自引用容器的值、包含非 UTF-8 字符的字符串、包含为代理对保留的代码点的伪 UTF-8 字符串(此类字符串不是有效的 UTF-8 字符串)。不可打印字符将转换为 "\u1234" 转义符或特殊转义符(如 "\t"),其他将按原样转储。 Blob 将转换为单个字节的数组。{expr}
(any
)任何
){dict}
(table
)任何
)<C-Home>
{string}
(字符串
)任何
){expr}
) len() E701 结果是一个数字,它是参数的长度。当 {expr}
是一个字符串或一个数字时,使用字节长度,就像 strlen() 一样。当 {expr}
是一个 列表 时,返回 列表 中的项目数。当 {expr}
是一个 Blob 时,返回字节数。当 {expr}
是一个 字典 时,返回 字典 中的条目数。否则,将给出错误并返回零。{expr}
(any
)任何
){libname}
, {funcname}
, {argument}
) libcall() E364 E368 使用单个参数 {argument}
调用运行时库 {libname}
中的函数 {funcname}
。这对于调用专门用于 Vim 的库中的函数很有用。由于只可能使用一个参数,所以调用标准库函数相当有限。结果是函数返回的字符串。如果函数返回 NULL,则 Vim 将将其显示为一个空字符串 ""。如果函数返回一个数字,请使用 libcallnr()!如果 {argument}
是一个数字,则将其作为 int 传递给函数;如果 {argument}
是一个字符串,则将其作为以 null 结尾的字符串传递。{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()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
)任何
){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
{expr}
(字符串|整数[]
){winid}
(integer?
)integer
){lnum}
) line2byte(){lnum}
行的字节数。这包括行尾字符,取决于当前缓冲区的 'fileformat' 选项。第一行返回 1。使用 UTF-8 编码,'fileencoding' 被忽略。这也可用于获取最后一行下方行的字节数echo line2byte(line("$") + 1)
{lnum}
的使用方式与 getline() 相同。当 {lnum}
无效时,返回 -1。另请参见 byte2line()、go 和 :goto。{lnum}
(integer
)integer
){lnum}
) lispindent(){lnum}
行的缩进量,就像 'lisp' 一样。缩进量以空格计算,'tabstop' 的值是相关的。{lnum}
的使用方式与 getline() 相同。当 {lnum}
无效时,返回 -1。{lnum}
(integer
)任何
){list}
) list2blob(){list}
中的所有数字值连接起来。示例echo list2blob([1, 2, 3, 4]) " returns 0z01020304
echo list2blob([]) " returns 0z
{list}
(any[]
)任何
){list}
[, {utf8}
]) list2str(){list}
中的每个数字转换为一个字符字符串,并将它们连接起来。示例echo list2str([32]) " returns " "
echo list2str([65, 66, 67]) " returns "ABC"
echo join(map(list, {nr, val -> nr2char(val)}), '')
{utf8}
选项无效,仅出于向后兼容性而存在。使用 UTF-8 组成字符按预期工作。echo list2str([97, 769]) " returns "á"
{list}
(any[]
){utf8}
(boolean?
)任何
)任何
){expr}
) log(){expr}
的自然对数(以 e 为底)作为 Float。{expr}
必须计算为范围为 (0, inf] 的 Float 或 Number。如果{expr}
不是 Float 或 Number,则返回 0.0。示例echo log(10)
echo log(exp(5))
{expr}
(number
)任何
){expr}
) log10(){expr}
的以 10 为底的对数返回为 Float。{expr}
必须计算为 Float 或 Number。如果{expr}
不是 Float 或 Number,则返回 0.0。示例echo log10(1000)
echo log10(0.01)
{expr}
(number
)任何
){expr}
(string
){expr1}
(any[]?
)任何
){expr1}
, {expr2}
) map(){expr1}
必须是 List、String、Blob 或 Dictionary。当{expr1}
是 List 或 Dictionary 时,使用计算{expr2}
的结果替换{expr1}
中的每个项目。对于 Blob,替换每个字节。对于 String,替换每个字符,包括组成字符。如果项目类型发生更改,您可能希望使用 mapnew() 创建新的 List 或 Dictionary。{expr2}
是 String,则在{expr2}
中,v:val 具有当前项目的 value。对于 Dictionary,v:key 具有当前项目的键,而对于 List,v:key 具有当前项目的索引。对于 Blob,v:key 具有当前字节的索引。对于 String,v:key 具有当前字符的索引。示例call map(mylist, '"> " .. v:val .. " <"')
{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'))
call map(myDict, {key, val -> key .. '-' .. val})
call map(myDict, {key -> 'item: ' .. key})
call map(myDict, {_, val -> 'item: ' .. val})
{expr1}
,即被过滤的 列表 或 字典,或一个新的 Blob 或 字符串。当在评估 {expr2}
时遇到错误时,不会处理 {expr1}
中的任何其他项目。当 {expr2}
是一个 Funcref 时,函数内部的错误会被忽略,除非它是用 "abort" 标记定义的。{expr1}
(string|table|any[]
){expr2}
(string|function
)任何
){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}
,就像键入一样 "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,将来可能会更改。exe 'nnoremap <Tab> ==' .. maparg('<Tab>', 'n')
{name}
(字符串
){mode}
(string?
){abbr}
(boolean?
){dict}
(false?
)字符串
){name}
[, {mode}
[, {abbr}
]]) mapcheck(){mode}
中的{name}
匹配的映射。有关{mode}
和{name}
中的特殊名称,请参阅 maparg()。当{abbr}
存在且非零时,使用缩写而不是映射。与以{name}
开头的映射以及与{name}
的开头相等的映射匹配。{name}
匹配的映射,而 maparg() 仅查找完全匹配{name}
的映射。当没有以{name}
开头的映射时,将返回空 String。如果存在,则返回该映射的 RHS。如果存在多个以{name}
开头的映射,则返回其中一个的 RHS。如果 RHS 为空,则这将是 "<Nop>"。首先检查当前缓冲区的本地映射,然后检查全局映射。此函数可用于检查是否可以在不产生歧义的情况下添加映射。示例if mapcheck("_vv") == ""
map _vv :set guifont=7x13<CR>
endif
{name}
(字符串
){mode}
(string?
){abbr}
(boolean?
)任何
){abbr}
]) maplist(){abbr}
存在且为 TRUE 时,使用缩写而不是映射。echo maplist()->filter({_, m ->
\ match(get(m, 'rhs', ''), 'MultiMatch') >= 0
\ })
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})
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[]
){expr1}
, {expr2}
) mapnew(){expr1}
中的项目,而是创建一个新的 List 或 Dictionary 并返回它。{expr1}
保持不变。{expr2}
仍然可以更改项目,如果您不希望这样做,请先使用 deepcopy()。{expr1}
(any
){expr2}
(any
)任何
){mode}
, {abbr}
, {dict}
) 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
)任何
){expr}
, {pat}
[, {start}
[, {count}
]]) match(){expr}
是一个 列表 时,这将返回第一个匹配 {pat}
的项目的索引。每个项目都作为字符串使用,列表 和 字典 则作为回声使用。{expr}
将用作字符串。结果是一个数字,它给出 {pat}
在 {expr}
中匹配的索引(字节偏移量)。echo match("testing", "ing") " results in 4
echo match([1, 'x'], '\a') " results in 1
{pat}
,请参见 string-match。 strpbrk()let sepidx = match(line, '[.,;: \t]')
{start}
,则搜索将从字符串中的字节索引 {start}
或 列表 中的项目 {start}
开始。但是,结果仍然是从第一个字符/项目开始计算的索引。示例echo match("testing", "ing", 2)
echo match("testing", "ing", 4)
echo match("testing", "t", 2)
{start}
> 0,则它就像字符串从 {start}
个字节后开始一样,因此 "^" 将在 {start}
处匹配。除非给定了 {count}
,否则它就像在 {start}
字节之前的匹配项被忽略一样(为了保持向后兼容,这有点复杂)。对于字符串,如果 {start}
< 0,它将被设置为 0。对于列表,索引是从末尾开始计算的。如果 {start}
超出范围(对于字符串,{start}
> strlen({expr}
) 或对于 列表,{start}
> len({expr}
)),则返回 -1。{count}
时,使用第 {count}
个匹配项。当在字符串中找到匹配项时,对下一个匹配项的搜索将从下一个字符开始。因此,此示例的结果为 1echo match("testing", "..", 0, 2)
{expr}
(string|any[]
){pat}
(string
){start}
(integer?
){count}
(integer?
)任何
){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 突出显示的匹配项中。该字典可以包含以下成员highlight MyGroup ctermbg=green guibg=green
let m = matchadd("MyGroup", "TODO")
call matchdelete(m)
{group}
(integer|string
){pattern}
(字符串
){priority}
(integer?
){id}
(integer?
){dict}
(string?
)任何
){group}
, {pos}
[, {priority}
[, {id}
[, {dict}
]]]) matchaddpos() 与 matchadd() 相同,但需要一个位置列表 {pos}
而不是模式。此命令比 matchadd() 更快,因为它不处理正则表达式,并且它设置缓冲区行边界以重新绘制屏幕。它应该在需要快速添加和删除匹配项的情况下使用,例如突出显示匹配的括号。 E5030 E5031 {pos}
是一个位置列表。每个位置可以是以下之一highlight MyGroup ctermbg=green guibg=green
let m = matchaddpos("MyGroup", [[23, 24], 34])
call matchdelete(m)
{group}
(integer|string
){pos}
(any[]
){priority}
(integer?
){id}
(integer?
){dict}
(string?
)任何
){nr}
) matcharg(){nr}
个匹配项,如使用 :match、:2match 或 :3match 命令设置的那样。返回一个包含两个元素的 列表:使用的突出显示组的名称,使用的模式。当 {nr}
不为 1、2 或 3 时,返回一个空的 列表。当没有设置匹配项时,返回 ['', '' ]。这对于保存和恢复 :match 很有用。使用 :match 命令突出显示的匹配项最多只能有三个匹配项。 matchadd() 没有这个限制。{nr}
(整数
)任何
){buf}
, {pat}
, {lnum}
, {end}
, [, {dict}
]) matchbufline(){buf}
中从 {lnum}
到 {end}
行中匹配 {pat}
的匹配项的 列表。{lnum}
和 {end}
可以是行号,也可以是字符串 "$",表示 {buf}
中的最后一行。{dict}
参数支持以下项目:submatches 包含子匹配信息 (/\()" 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?
)任何
){id}
[, {win}
]) matchdelete() E802 E803 删除先前由 matchadd() 或其中一个 :match 命令定义的 ID 为 {id}
的匹配项。如果成功,则返回 0,否则返回 -1。请参见 matchadd() 的示例。可以使用 clearmatches() 一次删除所有匹配项。如果指定了 {win}
,则使用此编号或窗口 ID 的窗口,而不是当前窗口。{id}
(整数
){win}
(整数?
)任何
){expr}
, {pat}
[, {start}
[, {count}
]]) matchend()echo matchend("testing", "ing")
let span = matchend(line, '[a-zA-Z]')
let span = matchend(line, '[^a-zA-Z]')
echo matchend("testing", "ing", 5)
{expr}
(any
){pat}
(string
){start}
(integer?
){count}
(integer?
)任何
){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}
中找到最多此数量的匹配项,并按排序顺序返回它们。echo matchfuzzy(["clay", "crow"], "cay")
echo getbufinfo()->map({_, v -> v.name})->matchfuzzy("ndl")
echo getbufinfo()->matchfuzzy("ndl", {'key' : 'name'})
echo getbufinfo()->matchfuzzy("spl",
\ {'text_cb' : {v -> v.name}})
echo v:oldfiles->matchfuzzy("test")
let l = readfile("buffer.c")->matchfuzzy("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?
)任何
){list}
, {str}
[, {dict}
]) matchfuzzypos(){str}
中字符匹配的字符位置列表以及匹配分数列表。 您可以使用 byteidx() 将字符位置转换为字节位置。{str}
在一个字符串中多次匹配,则仅返回最佳匹配的位置。echo matchfuzzypos(['testing'], 'tsg')
echo matchfuzzypos(['clay', 'lacy'], 'la')
echo [{'text': 'hello', 'id' : 10}]
\ ->matchfuzzypos('ll', {'key' : 'text'})
[[{"id": 10, "text": "hello"}], [[2, 3]], [127]]
{list}
(any[]
){str}
(string
){dict}
(string?
)任何
){expr}
, {pat}
[, {start}
[, {count}
]]) matchlist()echo matchlist('acd', '\(a\)\?\(b\)\?\(c\)\?\(.*\)')
{expr}
(any
){pat}
(string
){start}
(integer?
){count}
(integer?
)任何
){expr}
, {pat}
[, {start}
[, {count}
]]) matchstr()echo matchstr("testing", "ing")
echo matchstr("testing", "ing", 5)
{expr}
是一个 List 时,将返回匹配的项目。 类型不会改变,它不一定是字符串。{expr}
(any
){pat}
(string
){start}
(integer?
){count}
(integer?
)任何
){list}
, {pat}
[, {dict}
]) matchstrlist(){list}
中匹配项的 List,其中 {pat}
匹配。 {list}
是一个字符串的 List。 {pat}
与 {list}
中的每个字符串匹配。{dict}
参数支持以下项目:submatches 包含子匹配信息 (/\(){list}
中匹配项的索引。 text 匹配的字符串 submatches 子匹配的 List。 仅当 {dict}
中将 "submatches" 设置为 v:true 时存在。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'}]
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?
)任何
){expr}
, {pat}
[, {start}
[, {count}
]]) matchstrpos()echo matchstrpos("testing", "ing")
{start}
,则其含义与 match() 中的相同。echo matchstrpos("testing", "ing", 2)
echo matchstrpos("testing", "ing", 5)
{expr}
是一个 List 时,将返回匹配的项目、{pat}
匹配的第一个项目的索引、匹配项的起始位置和结束位置。echo matchstrpos([1, '__x'], '\a')
{expr}
(any
){pat}
(string
){start}
(integer?
){count}
(integer?
)任何
){expr}
可以是 List 或 Dictionary。 对于 Dictionary,它返回 Dictionary 中所有值的最高值。 如果 {expr}
既不是 List 也不是 Dictionary,或者 {expr}
中的某个项目无法用作 Number,则会导致错误。 一个空的 List 或 Dictionary 将返回零。{expr}
(any
)任何
){path}
[, {modes}
]) {path}
按名称匹配菜单,如果 {path}
为空字符串,则匹配所有菜单。 例如echo menu_get('File','')
echo menu_get('')
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?
)任何
){name}
[, {mode}
]) {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}
时,将使用 "" 的模式。{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?
)任何
){expr}
可以是 List 或 Dictionary。 对于 Dictionary,它返回 Dictionary 中所有值的最小值。 如果 {expr}
既不是 List 也不是 Dictionary,或者 {expr}
中的某个项目无法用作 Number,则会导致错误。 一个空的 List 或 Dictionary 将返回零。{expr}
(any
)任何
){flags}
,则它必须是一个字符串。 空字符串无效。{flags}
可以包含以下字符标志: "p" 将根据需要创建中间目录 "D" {name}
将在当前函数结束时删除,但不会递归删除 :defer "R" {name}
将在当前函数结束时递归删除 :defer{name}
包含多个部分并且使用 "p" 时,某些目录可能已经存在。 仅创建的第一个目录及其包含的内容将安排删除。 例如,当使用call mkdir('subdir/tmp/autoload', 'pR')
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() 将静默退出。{name}
(字符串
){flags}
(string?
){prot}
(string?
)任何
){expr}
]) mode(){expr}
并且它计算为一个非零 Number 或一个非空字符串 (non-zero-arg),则返回完整模式,否则仅返回第一个字母。 另请参阅 state()。CTRL-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-V
s 可视化块级使用 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 终端模式:键进入作业{expr}
(any?
)任何
){list}
[, {type}
]) msgpackdump(){type}
包含“B”时,将返回一个 Blob。示例call writefile(msgpackdump([{}]), 'fname.mpack', 'b')
call writefile(msgpackdump([{}], 'B'), 'fname.mpack')
fname.mpack
文件(包含零个项目的字典在 messagepack 中由 0x80 字节表示)。{list}
(any
){type}
(any?
)任何
){data}
) msgpackparse()let fname = expand('~/.config/nvim/shada/main.shada')
let mpack = readfile(fname, 'b')
let shada_objects = msgpackparse(mpack)
shada_objects
列表。_TYPE
和 _VAL
。 2. _TYPE
键是 v:msgpack_types 变量中找到的类型之一。 3. _VAL
的值具有以下格式(键列包含 v:msgpack_types 中的键名)_VAL[0] * ((_VAL[1] << 62) & (_VAL[2] << 31) & _VAL[3])
{data}
(any
)任何
){lnum}
) nextnonblank(){lnum}
或其下方。示例if getline(nextnonblank(1)) =~ "Java" | endif
{lnum}
(integer
)任何
){expr}
[, {utf8}
]) nr2char(){expr}
。示例echo nr2char(64) " returns '@'
echo nr2char(32) " returns ' '
echo nr2char(300) " returns I with bow character
{utf8}
选项无效,仅出于向后兼容性而存在。请注意,文件中 NUL 字符由 nr2char(10) 指定,因为 NUL 由换行符表示。nr2char(0) 是一个真正的 NUL 并终止字符串,因此会导致空字符串。{expr}
(integer
){utf8}
(boolean?
)任何
){...}
) nvim_...() E5555 eval-api 调用 nvim api 函数。参数类型检查将比大多数其他内置函数更严格。例如,如果期望 Integer,则必须传入一个 Number,String 不会自动转换。缓冲区编号(由 bufnr() 返回)可以用作 nvim_buf_... 函数的第一个参数。所有期望对象的函数(缓冲区、窗口或标签页)也可以采用数字值 0 来指示当前(聚焦)对象。{...}
(any
)任何
){expr}
, {expr}
) or()and()
和 xor()
。示例let bits = or(bits, 0x80)
{expr}
(number
){expr1}
(number
)任何
){path}
[, {len}
]) pathshorten(){path}
中的目录名并返回结果。尾部(文件名)保持不变。路径中的其他组件将缩短到 {len}
个字母。如果 {len}
被省略或小于 1,则使用 1(单个字母)。保留前导的“~”和“.”字符。示例echo pathshorten('~/.config/nvim/autoload/file1.vim')
echo pathshorten('~/.config/nvim/autoload/file2.vim', 2)
{path}
(string
){len}
(integer?
)任何
){expr}
) perleval(){expr}
并返回其结果,转换为 Vim 数据结构。数字和字符串按原样返回(字符串被复制)。列表用 Vim List 类型表示。字典用 Vim Dictionary 类型表示,非字符串键会导致错误。{expr}
必须返回对其的引用。示例echo perleval('[1 .. 4]')
{expr}
(any
)任何
){x}
, {y}
) pow(){x}
的 {y}
次方,以 Float 类型表示。{x}
和 {y}
必须计算为 Float 或 Number。如果 {x}
或 {y}
不是 Float 或 Number,则返回 0.0。示例echo pow(3, 3)
echo pow(2, 16)
echo pow(32, 0.20)
{x}
(number
){y}
(number
)任何
){lnum}
) prevnonblank(){lnum}
或其上方。示例let ind = indent(prevnonblank(v:lnum - 1))
{lnum}
(integer
)任何
){fmt}
, {expr1}
...) printf(){fmt}
的 String,其中“%”项被其各自参数的格式化形式替换。示例echo printf("%4d: E%d %.30s", lnum, errno, msg)
Compute()->printf("result: %d")
call()
将项目作为列表传递。{n$}
,其中 n >= 1。echo printf("%d: %.*s", nr, width, line)
{n$}
位置参数说明符指定。参见 printf-$。echo printf("%.2f", 12.115)
#, c-format
msgid "%s returning %s"
msgstr "waarde %2$s komt terug van %1$s"
echo printf(
"In The Netherlands, vim's creator's name is: %1$s %2$s",
"Bram", "Moolenaar")
echo printf(
"In Belgium, vim's creator's name is: %2$s %1$s",
"Bram", "Moolenaar")
echo printf("%1$*2$.*3$d", 1, 2, 3)
echo printf("%2$*3$.*1$d", 1, 2, 3)
echo printf("%3$*1$.*2$d", 1, 2, 3)
echo printf("%1$*2$.*3$g", 1.4142, 2, 3)
echo printf("%1$4.*2$f", 1.4142135, 6)
echo printf("%1$*2$.4f", 1.4142135, 6)
echo printf("%1$*2$.*3$f", 1.4142135, 6, 2)
echo printf("%1$d at width %2$ld is: %01$*2$d", 1, 2)
echo printf("%01$*2$.*3$d %4$d", 1, 2)
echo printf("%1$s %2$s %1$d", "One", "Two")
{fmt}
(string
){expr1}
(any?
)字符串
){buf}
(integer|string
)任何
){buf}
, {expr}
) prompt_setcallback(){buf}
的提示回调设置为 {expr}
。当 {expr}
为空字符串时,回调将被删除。这只有在 {buf}
的 'buftype' 设置为“prompt”时才有效。 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
)任何
){buf}
, {text}
) prompt_setprompt(){buf}
的提示设置为 {text}
。您可能希望 {text}
以空格结尾。结果只有在 {buf}
的 'buftype' 设置为 "prompt" 时才可见。示例call prompt_setprompt(bufnr(''), 'command: ')
{buf}
(integer|string
){text}
(string
)任何
)任何
)任何
){expr}
) py3eval(){expr}
并返回其结果,该结果已转换为 Vim 数据结构。数字和字符串按原样返回(字符串被复制,Unicode 字符串被额外转换为 UTF-8)。列表以 Vim List 类型表示。字典以 Vim Dictionary 类型表示,键被转换为字符串。{expr}
(any
)任何
){expr}
) pyeval() E858 E859 评估 Python 表达式 {expr}
并返回其结果,该结果已转换为 Vim 数据结构。数字和字符串按原样返回(字符串被复制)。列表以 Vim List 类型表示。字典以 Vim Dictionary 类型表示,非字符串键会导致错误。{expr}
(any
)任何
){expr}
) pyxeval(){expr}
并返回其结果,该结果已转换为 Vim 数据结构。使用 Python 2 或 3,参见 python_x 和 'pyxversion'。另见:pyeval(),py3eval(){expr}
(any
)任何
){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?
)任何
){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?
)任何
){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)
{fname}
(string
){offset}
(integer?
){size}
(integer?
)任何
){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?
)任何
){fname}
[, {type}
[, {max}
]]) readfile(){fname}
并返回一个 List,文件的每一行作为一个项目。行在 NL 字符处断开。以 CR 分隔的 Macintosh 文件将导致单行长行(除非在某处出现 NL)。所有 NUL 字符将被替换为 NL 字符。如果 {type}
包含 "b",则使用二进制模式{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?
)任何
){object}
, {func}
[, {initial}
]) reduce() E998 {func}
将为 {object}
中的每个项目调用,{object}
可以是 String、List 或 Blob。{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?
)任何
)任何
)任何
)任何
){start}
) reltime({start}
, {end}
) 返回一个表示时间值的项目。该项目是一个列表,其项目取决于系统。该项目可以传递给 reltimestr() 以将其转换为字符串,或者传递给 reltimefloat() 以将其转换为浮点数。{start}
和 {end}
之间的经过时间。{start}
和 {end}
参数必须是 reltime() 返回的值。在出错时返回零。{start}
(any?
){end_}
(any?
)任何
){time}
) reltimefloat(){time}
时间值的浮点数。时间单位为秒。示例:让 start = reltime() 调用 MyFunction() 让 seconds = reltimefloat(reltime(start)) 参见 reltimestr() 关于开销的说明。另见 profiling。如果出现错误,则返回空字符串{time}
(any
)任何
){time}
) reltimestr(){time}
时间值的字符串。这是秒数、一个点以及微秒数。示例let start = reltime()
call MyFunction()
echo reltimestr(reltime(start))
echo split(reltimestr(reltime(start)))[0]
{time}
(any
)任何
){list}
, {idx}
) 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)
{list}
(any[]
){idx}
(整数
){end_}
(integer?
)任何
){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?
)任何
){dict}
, {key}
) 从 {dict}
中删除键为 {key}
的条目并返回它。示例echo "removed " .. remove(dict, "one")
{dict}
中没有 {key}
,则这是一个错误。发生错误时返回零。{dict}
(any
){key}
(string
)任何
){from}
, {to}
) rename(){from}
的文件重命名为名为 {to}
的文件。这也可以用于跨文件系统移动文件。结果是一个数字,如果文件成功重命名,则为 0,如果重命名失败,则为非零。 注意:如果 {to}
存在,它将被覆盖,不会发出警告。此函数在 sandbox 中不可用。{from}
(string
){to}
(string
)任何
){count}
为零或负数时,结果为空。当 {expr}
是 List 或 Blob 时,结果是 {expr}
连接 {count}
次。示例let longlist = repeat(['a', 'b'], 3)
{expr}
(any
){count}
(integer
)任何
){filename}
) resolve() E655 在 MS-Windows 上,当 {filename}
是快捷方式(.lnk 文件)时,以简化的形式返回快捷方式指向的路径。在 Unix 上,在 {filename}
的所有路径组件中重复解析符号链接并返回简化的结果。为了应对链接循环,解析符号链接将在 100 次迭代后停止。在其他系统上,返回简化的 {filename}
。简化步骤与 simplify() 相同。resolve() 保持一个指定当前目录的领先路径组件(前提是结果仍然是相对路径名),并且还保留一个尾随路径分隔符。{filename}
(string
)任何
){object}
) reverse(){object}
中项目的顺序。{object}
可以是 List、Blob 或 String。对于 List 和 Blob,项目将被就地反转,并返回 {object}
。对于 String,将返回一个新的 String。如果 {object}
不是 List、Blob 或 String,则返回零。如果您希望 List 或 Blob 保持不变,请先制作一份副本let revlist = reverse(copy(mylist))
{object}
(any
)任何
){expr}
) round(){expr}
四舍五入到最接近的整数值,并将其作为 Float 返回。如果 {expr}
位于两个整数值之间,则使用较大的那个(远离零)。{expr}
必须计算为 Float 或 Number。如果 {expr}
不是 Float 或 Number,则返回 0.0。示例echo round(0.456)
echo round(4.5)
echo round(-4.5)
{expr}
(number
)任何
){channel}
, {event}
[, {args}
...]) rpcnotify(){event}
发送到 {channel}
并立即返回。如果 {channel}
为 0,则该事件将广播到所有通道。示例au VimLeave call rpcnotify(0, "leaving")
{channel}
(integer
){event}
(string
){args}
(any?
)任何
){channel}
, {method}
[, {args}
...]) rpcrequest(){channel}
发送请求以通过 RPC 调用 {method}
,并在收到响应之前阻塞。示例let result = rpcrequest(rpc_chan, "func", 1, 2, 3)
{channel}
(integer
){method}
(string
){args}
(any?
)任何
){expr}
) rubyeval(){expr}
并返回将其结果转换为 Vim 数据结构。数字、浮点数和字符串按原样返回(字符串被复制)。数组表示为 Vim List 类型。哈希表示为 Vim Dictionary 类型。其他对象表示为其 "Object#to_s" 方法返回的字符串。{expr}
(any
)任何
){row}
, {col}
) screenattr(){row}
(integer
){col}
(integer
)任何
){row}
, {col}
) screenchar(){row}
(integer
){col}
(integer
)任何
){row}
, {col}
) screenchars(){row}
(integer
){col}
(integer
)任何
)nnoremap <expr> GG ":echom " .. screencol() .. "\n"
nnoremap <silent> GG :echom screencol()<CR>
noremap GG <Cmd>echom screencol()<CR>
任何
){winid}
, {lnum}
, {col}
) screenpos(){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
)任何
)任何
){row}
, {col}
) screenstring(){row}
(integer
){col}
(integer
)任何
){pattern}
[, {flags}
[, {stopline}
[, {timeout}
[, {skip}
]]]]) search() 搜索正则表达式模式 {pattern}
。搜索从光标位置开始(您可以使用 cursor() 设置它)。{flags}
是一个 String,它可以包含以下字符标志:'b' 向后搜索而不是向前搜索 'c' 接受光标位置的匹配 'e' 移动到匹配的末尾 'n' 不要移动光标 'p' 返回匹配子模式的编号(见下文)'s' 在光标的前一个位置设置 ' 标记 'w' 在文件末尾环绕 'W' 不要在文件末尾环绕 'z' 从光标列而不是零开始搜索 如果没有给出 'w' 或 'W',则 'wrapscan' 选项适用。{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-matchlet 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')
{pattern}
(字符串
){flags}
(string?
){stopline}
(integer?
){timeout}
(integer?
){skip}
(string|function?
)任何
){options}
]) searchcount(){options}
,请参阅下面的内容。recompute: 0
调用此函数。这有时会返回错误信息,因为n和N的最大计数为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()
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() : ""}'
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
" 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。它可以包含let @/ = pattern
maxcount + 1
(默认:0) pos List [lnum, col, off]
重新计算结果时的值。这将更改“current”结果值。请参见cursor()、getpos()(默认:光标位置){options}
(table?
)任何
){thisblock}
参数,将忽略在光标位置之前结束的{}块中的匹配项。避免只在另一个范围内找到变量声明。if searchdecl('myvar') == 0
echo getline('.')
endif
{name}
(字符串
){global}
(boolean?
){thisblock}
(boolean?
)任何
){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。其他任何内容都将使函数失败。{start}
、{middle}
或{end}
的匹配项是找到的第一个匹配项。例如if 1
if 2
endif 2
endif 1
{end}
超过一个字符时,在模式末尾添加“\zs”可能会有用,这样,当光标位于带有结束的匹配项中时,它将找到匹配的开始。echo searchpair('\<if\>', '\<el\%[seif]\>', '\<en\%[dif]\>', 'W',
\ 'getline(".") =~ "^\\s*\""')
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
){start}
, {middle}
, {end}
[, {flags}
[, {skip}
[, {stopline}
[, {timeout}
]]]]) 与searchpair()相同,但返回一个带有匹配项的行和列位置的List。 List的第一个元素是行号,第二个元素是匹配项列位置的字节索引。如果未找到匹配项,则返回[0, 0]。let [lnum,col] = searchpairpos('{', '', '}', 'n')
{start}
(string
){middle}
(string
){end_}
(string
){flags}
(string?
){skip}
(string|function?
){stopline}
(integer?
){timeout}
(integer?
)[integer, integer]
){pattern}
[, {flags}
[, {stopline}
[, {timeout}
[, {skip}
]]]]) 与search()相同,但返回一个带有匹配项的行和列位置的List。 List的第一个元素是行号,第二个元素是匹配项列位置的字节索引。如果未找到匹配项,则返回[0, 0]。例如let [lnum, col] = searchpos('mypattern', 'n')
let [lnum, col, submatch] = searchpos('\(\l\)\|\(\u\)', 'np')
{pattern}
(字符串
){flags}
(string?
){stopline}
(integer?
){timeout}
(integer?
){skip}
(string|function?
)任何
)任何
){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
ls ${XDG_RUNTIME_DIR:-${TMPDIR}nvim.${USER}}/*/nvim.*.0
if has('win32')
echo serverstart('\\.\pipe\nvim-pipe-1234')
else
echo serverstart('nvim.sock')
endif
echo serverstart('::1:12345')
{address}
(string?
)任何
){address}
) serverstop(){address}
处的管道或套接字。如果{address}
有效,则返回TRUE,否则返回FALSE。如果v:servername已停止,则将其设置为serverlist()中下一个可用的地址。{address}
(string
)任何
){buf}
, {lnum}
, {text}
) setbufline(){buf}
中将第 {lnum}
行设置为 {text}
。这与针对指定缓冲区的 setline() 相似。{text}
可以是用于设置单行的字符串,也可以是用于设置多行的字符串列表。如果列表超出最后一行,则会添加这些行。如果列表为空,则不会进行任何更改,并返回零。{buf}
的使用,请参见上面的 bufname()。{lnum}
的使用方法与 setline() 相同。使用 "$" 表示缓冲区 {buf}
中的最后一行。当 {lnum}
恰好在最后一行下方时,{text}
将添加到最后一行下方。成功时返回 0,失败时返回 1。{buf}
不是有效的缓冲区或 {lnum}
无效,则会显示错误消息。{buf}
(integer|string
){lnum}
(integer
){text}
(string|string[]
)任何
){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
)任何
){list}
) setcellwidths()call setcellwidths([
\ [0x111, 0x111, 1],
\ [0x2194, 0x2199, 2],
\ ])
{list}
参数是一个列表,包含三个数字的列表:[{low}
, {high}
, {width}
]。 E1109 E1110 {low}
和 {high}
可以相同,在这种情况下,这指的是一个字符。否则,它表示从 {low}
到 {high}
(包含)的字符范围。 E1111 E1114 只能使用值 0x80 及更高的字符。{list}
。call setcellwidths([])
{list}
参数。{list}
(any[]
)任何
)call setcharpos('.', [0, 8, 4, 0])
call setpos('.', [0, 8, 4, 0])
{expr}
(string
){list}
(integer[]
)任何
)let prevsearch = getcharsearch()
" Perform a command which clobbers user's search
call setcharsearch(prevsearch)
{dict}
(string
)任何
){str}
[, {pos}
]) setcmdline(){str}
,并将光标位置设置为 {pos}
。如果省略 {pos}
,则将光标定位在文本之后。成功时返回 0,未编辑命令行时返回 1。{str}
(string
){pos}
(integer?
)任何
){pos}
) setcmdpos(){pos}
。第一个位置是 1。使用 getcmdpos() 获取当前位置。仅在编辑命令行时有效,因此您必须使用 c_CTRL-\_e、c_CTRL-R_= 或 c_CTRL-R_CTRL-R 以及“=” 。对于 c_CTRL-\_e 和 c_CTRL-R_CTRL-R 以及“=” ,将在命令行设置为表达式后设置位置。对于 c_CTRL-R_= ,将在评估表达式后但插入结果文本之前设置位置。如果数字过大,则将光标置于行尾。数字小于 1 将导致未定义的结果。成功时返回 0,未编辑命令行时返回 1。{pos}
(integer
)任何
){lnum}
, {col}
[, {off}
]) setcursorcharpos(){list}
) 与 cursor() 相同,但使用指定的列号作为字符索引,而不是行中的字节索引。call setcursorcharpos(4, 3)
call cursor(4, 3)
{list}
(integer[]
)任何
){name}
(字符串
){val}
(string
)任何
){fname}
, {mode}
) setfperm() chmod 将 {fname}
的文件权限设置为 {mode}
。{mode}
必须是一个包含 9 个字符的字符串。它的格式为“rwxrwxrwx”,其中每个“rwx”标志组分别代表文件所有者、文件所属组和其他用户的权限。“-”字符表示权限关闭,任何其他字符表示打开。不支持多字节字符。{fname}
(string
){mode}
(string
)任何
){lnum}
, {text}
) setline(){lnum}
行设置为 {text}
。要插入行,请使用 append()。要设置另一个缓冲区中的行,请使用 setbufline()。{lnum}
的使用方法与 getline() 相同。当 {lnum}
恰好在最后一行下方时,{text}
将添加到最后一行下方。{text}
可以是任何类型,也可以是任何类型的列表,每个项目都将转换为字符串。当 {text}
是一个空列表时,不会进行任何更改,并将返回 FALSE。{lnum}
无效),则返回 TRUE。call setline(5, strftime("%c"))
for [n, l] in [[5, 'aaa'], [6, 'bbb'], [7, 'ccc']]
call setline(n, l)
endfor
{lnum}
(integer
){text}
(any
)任何
){nr}
, {list}
[, {action}
[, {what}
]]) setloclist(){nr}
的位置列表。{nr}
可以是窗口编号或 window-ID。当 {nr}
为零时,将使用当前窗口。{action}
,请参见 setqflist-action。{nr}
(整数
){list}
(any
){action}
(string?
){what}
(table?
)任何
){list}
[, {win}
]) setmatches(){win}
,则使用具有此编号或窗口 ID 的窗口,而不是当前窗口。{list}
(any
){win}
(整数?
)任何
){list}
必须是一个包含四个或五个数字的 List:[bufnum, lnum, col, off] [bufnum, lnum, col, off, curswant]<Tab>
内的位置或最后一个字符之后的位置。{expr}
无效,则会显示错误消息。{expr}
(string
){list}
(integer[]
)任何
){what}
字典参数,则仅设置 {what}
中列出的项目。第一个 {list}
参数将被忽略。请参见下方有关 {what}
中支持的项目的说明。 setqflist-what{what}
不存在时,使用{list}
中的项目。每个项目必须是一个字典。{list}
中的非字典项目将被忽略。每个字典项目可以包含以下条目{list}
,quickfix 列表将被清除。请注意,该列表与 getqflist() 返回的列表不完全相同。{list}
中的项目替换当前 quickfix 列表中的项目。这也可以用来清除列表call setqflist([], 'r')
{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" 来指定列表。call setqflist([], 'r', {'title': 'My search'})
call setqflist([], 'r', {'nr': 2, 'title': 'Errors'})
call setqflist([], 'a', {'id':qfid, 'lines':["F1:10:L10"]})
:cc 1
的命令跳转到第一个位置。{list}
(vim.quickfix.entry[]
){action}
(string?
){what}
(vim.fn.setqflist.what?
)任何
){regname}
, {value}
[, {options}
]) setreg(){regname}
设置为 {value}
。如果 {regname}
为 "" 或 "@",则使用未命名的寄存器 '"'。{regname}
参数是一个字符串。{value}
可以是 getreg() 或 getreginfo() 返回的任何值,包括 List 或 Dict。如果 {options}
包含 "a" 或 {regname}
为大写,则追加该值。{options}
还可以包含寄存器类型规范:"c" 或 "v" 字符方式 模式 "l" 或 "V" 行方式 模式 "b" 或 "<CTRL-V>" 块方式视觉 模式 如果 "b" 或 "<CTRL-V>" 之后紧跟着一个数字,则将其用作选择的宽度 - 如果未指定,则块的宽度将设置为最长行中的字符数(将 <Tab>
计为 1 个字符)。如果 {options}
包含 "u" 或 '"'",则未命名的寄存器将设置为指向寄存器 {regname}
。{options}
不包含寄存器设置,则默认情况下使用字符模式,除非 {value}
以字符串 {value}
的 <NL>
结尾,并且对于列表 {value}
使用行方式模式。块方式模式从不自动选择。成功返回零,失败返回非零值。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)
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
)任何
){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
)任何
){dict}
中支持的项目的列表,请参阅 gettagstack()。"curidx" 在更改标签栈之前生效。 E962{action}
参数{action}
不存在或设置为 'r',则替换标签栈。{action}
设置为 'a',则将 {dict}
中的新条目推入(添加)标签栈。{action}
设置为 't',则将从标签栈中的当前条目或 {dict}
中的 "curidx" 开始删除所有条目,然后将新条目推入栈。call settagstack(3, {'items' : []})
let stack = gettagstack(1003)
" do something else
call settagstack(1003, stack)
unlet stack
{nr}
(整数
){dict}
(any
){action}
(string?
)任何
){nr}
, {varname}
, {val}
) setwinvar() call setwinvar(1, "&list", 0)
call setwinvar(2, "myvar", "foobar")
Parameters: ~
• {nr} (`integer`)
• {varname} (`string`)
• {val} (`any`)
Return: ~
(`any`)
sha256({string}
) sha256(){string}
的 SHA256 校验和。{string}
(字符串
)任何
){string}
括在双引号中,并将 {string}
中的所有双引号加倍。否则将 {string}
括在单引号中,并将所有 "'" 替换为 "'\''"。exe '!dir ' .. shellescape(expand('<cfile>'), 1)
call system("chmod +w -- " .. shellescape(expand("%")))
{string}
(字符串
){special}
(boolean?
)任何
){col}
]) shiftwidth()if exists('*shiftwidth')
func s:sw()
return shiftwidth()
endfunc
else
func s:sw()
return &sw
endfunc
endif
{col}
(integer?
)integer
){name}
[, {dict}
]) sign_define(){list}
) 定义一个名为 {name}
的新标记或修改现有标记的属性。这类似于 :sign-define 命令。{name}
添加唯一的文本前缀以避免名称冲突。与放置标记一样,没有 {group}
。{name}
可以是字符串或数字。可选的 {dict}
参数指定标记属性。支持以下值:icon 标记位图文件的完整路径。linehl 用于放置标记的整行的突出显示组。priority 标记的默认优先级值。numhl 用于放置标记的行号的突出显示组。text 当没有图标或没有使用 GUI 时显示的文本。texthl 用于文本项的突出显示组。culhl 当光标位于与标记相同的行并且 'cursorline' 启用时,用于文本项的突出显示组。{name}
的标记已存在,则更新标记的属性。{list}
可用于定义标记列表。每个列表项都是一个字典,其中包含 {dict}
中的上述项目和标记名称的 "name" 项目。{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)[]
){name}
,则返回所有定义的标记的列表。否则返回指定标记的属性。{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[]
){buf}
,则仅返回放置在该缓冲区中的标记列表。有关 {buf}
的使用,请参见 bufname()。可选的 {dict}
可以包含以下条目:group 仅选择该组中的标记。id 选择具有此标识符的标记。lnum 选择放置在此行中的标记。有关 {lnum}
的使用,请参见 line()。如果 {group}
为 "*", 则返回所有组(包括全局组)中的标记。如果没有提供 {group}
或为空字符串,则仅返回全局组中的标记。如果没有提供参数,则返回放置在所有缓冲区中的全局组中的标记。请参见 sign-group。{bufnr}
中的标记列表。每个列表项都是一个字典,其中包含以下列出的条目" 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[]
){id}
, {group}
, {buf}
) sign_jump(){buf}
或跳转到包含 {buf}
的窗口,并将光标定位在组 {group}
中的标记 {id}
处。这类似于 :sign-jump 命令。" Jump to sign 10 in the current buffer
call sign_jump(10, '', '')
{id}
(整数
){group}
(string
){buf}
(integer|string
)integer
){id}
, {group}
, {name}
, {buf}
[, {dict}
]) sign_place(){name}
的标记放置在文件或缓冲区 {buf}
中的第 {lnum}
行,并将 {id}
和 {group}
分配给标记。这类似于 :sign-place 命令。{id}
为零,则分配一个新的标识符。否则使用指定的数字。{group}
是标记组名称。要使用全局标记组,请使用空字符串。{group}
充当 {id}
的命名空间,因此两个组可以使用相同的 ID。有关更多信息,请参见 sign-identifier 和 sign-group。{dict}
参数支持以下条目:lnum 要放置标记的文件或缓冲区 {buf}
中的行号。有关接受的值,请参见 line()。priority 标记的优先级。有关更多信息,请参见 sign-priority。{dict}
,则它将修改放置的标记 {id}
(在组 {group}
中),以使用定义的标记 {name}
。" 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
){list}
) sign_placelist(){list}
参数指定要放置的标记列表。每个列表项都是一个字典,其中包含以下标记属性:buffer 缓冲区名称或编号。有关接受的值,请参见 bufname()。group 标记组。{group}
充当 {id}
的命名空间,因此两个组可以使用相同的 ID。如果未指定或设置为空字符串,则使用全局组。有关更多信息,请参见 sign-group。id 标记标识符。如果未指定或为零,则分配一个新的唯一标识符。否则使用指定的数字。有关更多信息,请参见 sign-identifier。lnum 要放置标记的缓冲区中的行号。有关接受的值,请参见 line()。name 要放置的标记的名称。有关更多信息,请参见 sign_define()。priority 标记的优先级。当在同一行放置多个标记时,将使用优先级最高的标记。如果未指定,则使用默认值 10,除非在标记定义中另有说明。有关更多信息,请参见 sign-priority。{id}
指的是现有标记,则修改现有标记以使用指定的 {name}
和/或 {priority}
。" 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[]
){name}
]) sign_undefine(){list}
) 删除先前定义的标记 {name}
。这类似于 :sign-undefine 命令。如果 {name}
没有提供,则删除所有定义的标记。{list}
可用于取消定义标记列表。每个列表项都是标记的名称。{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[]
){group}
是标记组名称。要使用全局标记组,请使用空字符串。如果 {group}
设置为 "*", 则使用所有组(包括全局组)。{group}
中的标记根据 {dict}
中的条目进行选择。支持 {dict}
中的以下可选条目:buffer 缓冲区名称或编号。请参见 bufname()。id 标记标识符。如果 {dict}
没有提供,则删除 {group}
中的所有标记。 " 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(){list}
参数指定要删除的标记列表。每个列表项都是一个字典,其中包含以下标记属性:buffer 缓冲区名称或编号。有关接受的值,请参见 bufname()。如果未指定,则从所有缓冲区中删除指定的标记。group 标记组名称。如果未指定或设置为空字符串,则使用全局标记组。如果设置为 "*", 则使用所有组(包括全局组)。id 标记标识符。如果未指定,则删除指定组中的所有标记。" 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)[]
){filename}
) simplify(){filename}
中的第一个路径组件指定当前目录,则结果也应有效。尾随路径分隔符也不会被删除。在 Unix 上,"//path" 保持不变,但 "///path" 将简化为 "/path"(这遵循 Posix 标准)。示例simplify("./dir/.././/file/") == "./file/"
{filename}
(string
)任何
){expr}
) sin(){expr}
的正弦值(以弧度为单位),结果为 Float 类型。{expr}
必须计算为 Float 或 Number。如果 {expr}
不是 Float 或 Number,则返回 0.0。示例echo sin(100)
echo sin(-4.01)
{expr}
(number
)任何
){expr}
) sinh(){expr}
的双曲正弦值,结果为 Float 类型,范围为 [-inf, inf]。{expr}
必须计算为 Float 或 Number。如果 {expr}
不是 Float 或 Number,则返回 0.0。示例echo sinh(0.5)
echo sinh(-0.9)
{expr}
(number
)任何
){expr}
, {start}
[, {end}
]) slice(){end}
时,切片将继续到最后一项。当 {end}
为 -1 时,将省略最后一项。如果 {start}
或 {end}
无效,则返回空值。{expr}
(any
){start}
(integer
){end_}
(integer?
)任何
){mode}
, {address}
[, {opts}
]) sockconnect(){mode}
为 "pipe",则 {address}
应为本地域套接字(在 unix 上)或命名管道(在 Windows 上)的路径。如果 {mode}
为 "tcp",则 {address}
应采用 "host:port" 的形式,其中 host 应为 IP 地址或主机名,port 为端口号。{opts}
是一个可选字典,包含以下键: on_data : 当从套接字读取数据时调用的回调 data_buffered : 以 channel-buffered 模式读取套接字数据。rpc : 如果设置,将使用 msgpack-rpc 通过套接字进行通信。返回{mode}
(string
){address}
(string
){opts}
(table?
)任何
)let sortedlist = sort(copy(mylist))
{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')
" ö is sorted after z with Swedish locale.
language collate sv_SE.UTF8
echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l')
{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
eval mylist->sort({i1, i2 -> i1 - i2})
{list}
(any
){how}
(string|function?
){dict}
(任何?
)任何
){word}
) soundfold(){word}
的音调折叠等效项。使用当前窗口中 'spelllang' 中支持音调折叠的第一个语言。必须设置 'spell'。如果无法进行音调折叠,则返回未修改的 {word}
。这可用于进行拼写建议。请注意,此方法可能非常慢。{word}
(string
)任何
){sentence}
]) spellbadword(){sentence}
中第一个拼写错误的单词。如果没有任何拼写错误,则结果为空字符串。echo spellbadword("the quik brown fox")
{sentence}
(string?
)任何
){word}
[, {max}
[, {capital}
]]) spellsuggest(){word}
的拼写建议的 列表。如果给出 {max}
,则最多返回此数量的建议。否则最多返回 25 个建议。{capital}
参数并且它不为零,则只返回以大写字母开头的建议。在使用 'spellcapcheck' 匹配后使用此方法。{word}
可以是拼写错误的单词,后面跟着其他文本。这允许连接两个被拆分的单词。建议还包括以下文本,因此你可以替换一行。{word}
也可能是一个正确的单词。然后将返回相似的单词。{word}
本身不会包含在建议中,尽管它可能会以大写字母出现。{word}
(string
){max}
(integer?
){capital}
(boolean?
)任何
){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
echo split('abc:def:ghi', ':\zs')
['abc:', 'def:', 'ghi']
let items = split(line, ':', 1)
{string}
(字符串
){pattern}
(string?
){keepempty}
(boolean?
)任何
){expr}
) sqrt(){expr}
的非负平方根,结果为 Float 类型。{expr}
必须计算为 Float 或 Number。如果 {expr}
为负数,则结果为 NaN(非数字)。如果 {expr}
不是 Float 或 Number,则返回 0.0。示例echo sqrt(100)
echo sqrt(-4.01)
{expr}
(number
)任何
){expr}
]) srand(){expr}
,则会通过从 /dev/urandom 读取(如果可能)或使用 time(NULL)(也称为纪元时间)来初始化种子值;这只有秒级精度。{expr}
,则它必须是数字。它将用于初始化种子值。这对于测试或需要可预测序列时很有用。let seed = srand()
let seed = srand(userinput)
echo rand(seed)
{expr}
(number?
)任何
){what}
]) state()state()
检查现在是否可以执行工作,如果是,则将其从队列中移除并执行。如果队列现在为空,则删除自动命令。另请参阅 mode().{what}
,则只会添加此字符串中的字符。例如,这将检查屏幕是否已滚动if state('s') == ''
" screen has not scrolled
{what}
(string?
)任何
){opts}
) stdioopen(){opts}
是一个包含以下键的字典:on_stdin : 当 stdin 被写入时调用的回调。on_print : 当 Nvim 需要打印消息时调用的回调,以消息(其类型为字符串)作为唯一参数。stdin_buffered : 在 通道-缓冲 模式下读取 stdin。rpc : 如果设置,msgpack-rpc 将用于通过 stdio 进行通信 返回{opts}
(table
)任何
){what}
类型 描述echo stdpath("config")
{what}
('cache'|'config'|'config_dirs'|'data'|'data_dirs'|'log'|'run'|'state'
)string|string[]
){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'))
{string}
(字符串
){quoted}
(boolean?
)任何
){string}
[, {utf8}
]) str2list(){string}
中每个字符的数字值。示例echo str2list(" ") " returns [32]
echo str2list("ABC") " returns [65, 66, 67]
{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?
)任何
){string}
) strcharlen(){string}
中的字符数。组合字符将被忽略。 strchars() 可以计算字符数,分别计算组合字符。{string}
为空或发生错误,则返回 0。{string}
(字符串
)任何
){src}
, {start}
[, {len}
[, {skipcc}
]]) strcharpart(){skipcc}
被省略或为零时,组合字符将被分别计算。当 {skipcc}
设置为 1 时,组合字符将被视为前一个基本字符的一部分,类似于 slice()。当在不存在字符的位置使用字符索引时,它将被省略并计为一个字符。例如echo strcharpart('abc', -1, 2)
{src}
(string
){start}
(integer
){len}
(integer?
){skipcc}
(boolean?
)任何
){string}
[, {skipcc}
]) strchars(){string}
中的字符数。当 {skipcc}
被省略或为零时,组合字符将被分别计算。当 {skipcc}
设置为 1 时,组合字符将被忽略。 strcharlen() 始终执行此操作。{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
){string}
[, {col}
]) strdisplaywidth(){string}
在屏幕上从 {col}
开始(第一列为零)时所占用的显示单元数。当 {col}
被省略时,使用零。否则,它就是屏幕列,从该列开始。这对制表符很重要。使用当前窗口的选项设置。这对任何以不同方式显示的内容都很重要,例如 'tabstop' 和 'display'。当 {string}
包含具有东亚宽度类“模棱两可”的字符时,此函数的返回值取决于 'ambiwidth'。如果发生错误,则返回零。另请参阅 strlen()、strwidth() 和 strchars()。{string}
(字符串
){col}
(integer?
)integer
){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
){haystack}
, {needle}
[, {start}
]) stridx(){haystack}
中字符串 {needle}
第一次出现的字节索引。如果指定了 {start}
,则搜索将从索引 {start}
开始。这可以用于查找第二次匹配let colon1 = stridx(line, ":")
let colon2 = stridx(line, ":", colon1 + 1)
{needle}
不出现在 {haystack}
中,则返回 -1。另请参阅 strridx()。示例echo stridx("An Example", "Example") " 3
echo stridx("Starting point", "Start") " 0
echo stridx("Starting point", "start") " -1
{haystack}
(string
){needle}
(string
){start}
(integer?
)integer
){expr}
) string(){expr}
转换为字符串。如果 {expr}
是一个数字、浮点数、字符串、Blob 或它们的组合,则结果可以使用 eval() 解析回。{expr}
类型 结果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
)字符串
){string}
) strlen(){string}
的字节长度。如果参数是一个数字,则首先将其转换为字符串。对于其他类型,将给出错误并返回零。如果要计算多字节字符的数目,请使用 strchars()。另请参阅 len()、strdisplaywidth() 和 strwidth()。{string}
(字符串
)integer
){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?
)字符串
){format}
, {timestring}
) strptime(){timestring}
中的日期和时间,预计该时间戳将与 {format}
中指定的格式匹配。{format}
取决于您的系统,因此不可移植!有关格式,请参阅 C 函数 strptime() 的手册页。尤其要避免使用 "%c"。$TZ 的值也很重要。{format}
解析 {timestring}
,则返回零。如果您不知道 {timestring}
的格式,可以尝试不同的 {format}
值,直到获得非零结果。echo strptime("%Y %b %d %X", "1997 Apr 27 11:49:23")
echo strftime("%c", strptime("%y%m%d %T", "970427 11:53:55"))
echo strftime("%c", strptime("%Y%m%d%H%M%S", "19970427115355") + 3600)
{format}
(string
){timestring}
(string
)integer
){haystack}
, {needle}
[, {start}
]) strridx(){haystack}
中 String {needle}
的最后一次出现的字节索引。当指定 {start}
时,将忽略此索引之后的匹配项。这可用于查找先前匹配项之前的匹配项let lastcomma = strridx(line, ",")
let comma2 = strridx(line, ",", lastcomma - 1)
{needle}
未出现在 {haystack}
中,则返回 -1。如果 {needle}
为空,则返回 {haystack}
的长度。另请参阅 stridx()。示例echo strridx("an angry armadillo", "an") 3
{haystack}
(string
){needle}
(string
){start}
(integer?
)integer
){string}
) strtrans(){string}
,其中所有不可打印字符都被转换为可打印字符 'isprint'。就像它们在窗口中显示一样。示例echo strtrans(@a)
{string}
(字符串
)字符串
){string}
[, {countcc}
]) strutf16len(){string}
中的 UTF-16 代码单元数(将其转换为 UTF-16 之后)。{countcc}
为 TRUE 时,组合字符单独计数。当 {countcc}
被省略或为 FALSE 时,组合字符将被忽略。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
){string}
) strwidth(){string}
占用的显示单元数。制表符被计为一个单元,或者使用 strdisplaywidth()。当 {string}
包含具有东亚宽度类别的“不明确”字符时,此函数的返回值取决于 'ambiwidth'。错误时返回零。另请参阅 strlen()、strdisplaywidth() 和 strchars()。{string}
(字符串
)integer
){nr}
[, {list}
]) submatch() E935 仅适用于 :substitute 命令或 substitute() 函数中的表达式。返回匹配文本的第 {nr}
个子匹配项。当 {nr}
为 0 时,将返回整个匹配的文本。请注意,字符串中的 NL 可以代表多行匹配的换行符或文本中的 NUL 字符。另请参阅 sub-replace-expression。{list}
存在且非零,则 submatch() 将返回字符串列表,类似于带两个参数的 getline()。文本中的 NL 字符代表文本中的 NUL 字符。仅在 :substitute 中返回多个项目,在 substitute() 中,此列表将始终包含一个或零个项目,因为没有真正的换行符。s/\d\+/\=submatch(0) + 1/
echo substitute(text, '\d\+', '\=submatch(0) + 1', '')
{nr}
(整数
){list}
(nil?
)字符串
){string}
, {pat}
, {sub}
, {flags}
) substitute(){string}
的副本,其中 {pat}
的第一个匹配项被替换为 {sub}
。当 {flags}
为“g”时,{string}
中 {pat}
的所有匹配项都被替换。否则 {flags}
应为空字符串。{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, ",\\=[^,]*$", "", "")
echo substitute("testing", ".*", "\\U\\0", "")
{sub}
以“\=”开头时,剩余部分将被解释为表达式。请参阅 sub-replace-expression。示例echo substitute(s, '%\(\x\x\)',
\ '\=nr2char("0x" .. submatch(1))', 'g')
{sub}
是一个 Funcref 时,将调用该函数,并带有一个可选参数。示例echo substitute(s, '%\(\x\x\)', SubNr, 'g')
echo substitute(s, '%\(\x\x\)', {m -> '0x' .. m[1]}, 'g')
{string}
(字符串
){pat}
(string
){sub}
(string
){flags}
(string
)字符串
) 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
)任何
){buf}
) swapname(){buf}
的交换文件路径。有关 {buf}
的使用,请参阅上面的 bufname()。如果缓冲区 {buf}
是当前缓冲区,则结果等于 :swapname(除非没有交换文件)。如果缓冲区 {buf}
没有交换文件,则返回一个空字符串。{buf}
(integer|string
)字符串
){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
){synID}
, {what}
[, {mode}
]) synIDattr(){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")
echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")
{synID}
(integer
){what}
(string
){mode}
(string?
)字符串
){synID}
) synIDtrans(){synID}
的翻译后的语法 ID。这是用于突出显示字符的语法组 ID。使用“:highlight link”给出的突出显示链接将被跟踪。{synID}
(integer
)integer
){lnum}
, {col}
) synconcealed(){lnum}
和 {col}
处的字符不是可隐藏区域的一部分,为 1 表示是。{lnum}
的使用方法与 getline() 相同。2. 列表中的第二个项目是一个字符串。如果第一个项目为 1,则第二个项目包含将显示在隐藏文本位置的文本,具体取决于 'conceallevel' 和 'listchars' 的当前设置。3. 列表中的第三个也是最后一个项目是一个数字,表示在行中匹配的特定语法区域。当字符未被隐藏时,该值为零。如果存在两个具有相同替换字符的连续区域,这将允许检测新可隐藏区域的开始。例如,如果文本为“123456”,“23”和“45”都隐藏并被字符“X”替换,那么{lnum}
(integer
){col}
(integer
)[整数, 字符串, 整数]
){lnum}
, {col}
) synstack(){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[]
){cmd}
的输出作为 字符串 (systemlist() 返回一个 List) 并将 v:shell_error 设置为错误代码。 {cmd}
的处理方式与 jobstart() 中相同:如果 {cmd}
是一个 List,则直接运行(不使用 'shell')。 如果 {cmd}
是一个 String,则在 'shell' 中运行,例如call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}'])
<CR>
<NL>
被替换为 <NL>
echo system(['ls', expand('%:h')])
{input}
是一个字符串,它将被写入管道并作为 stdin 传递给命令。 字符串将按原样写入,行分隔符不会改变。 如果 {input}
是一个 List,它将以 writefile() 的方式写入管道,其中 {binary}
设置为 "b"(即在每个列表项之间使用换行符,并将列表项内部的换行符转换为 NUL)。 当 {input}
被给出并且是一个有效的缓冲区 ID 时,缓冲区的内容将逐行写入文件,每行以 NL 结尾(在文本包含 NL 的地方以 NUL 结尾)。 E5677echo system("cat - &", "foo")
$ echo foo | bash -c 'cat - &'
echo system('ls '..shellescape(expand('%:h')))
echo system('ls '..expand('%:h:S'))
{cmd}
(string|string[]
){input}
(字符串|字符串[]|整数?
)字符串
){cmd}
[, {input}
[, {keepempty}
]]) systemlist(){binary}
参数设置为 "b" 的输出相同,区别在于不保留最后的换行符,除非 {keepempty}
不为零。 请注意,在 MS-Windows 上,您可能会得到尾部的 CR 字符。echo split(system('echo hello'), '\n', 1)
{cmd}
(string|string[]
){input}
(字符串|字符串[]|整数?
){keepempty}
(整数?
)string[]
){arg}
]) tabpagebuflist(){arg}
指定要使用的标签页编号。 当省略时,使用当前标签页。 当 {arg}
无效时,将返回数字零。 要获取所有标签页中所有缓冲区的列表,请使用以下方法let buflist = []
for i in range(tabpagenr('$'))
call extend(buflist, tabpagebuflist(i + 1))
endfor
{arg}
(整数?
)任何
){arg}
支持以下值:$ 最后一个标签页的编号(标签页数量)。 # 上次访问的标签页的编号(g<Tab> 所在的标签页)。 如果没有以前的标签页,则返回 0。 此编号可与 :tab 命令一起使用。{arg}
('$'|'#'?
)integer
){tabarg}
[, {arg}
]) tabpagewinnr(){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
)string[]
){expr}
中使用锚点 '^' 和 '$'。 这也使函数运行得更快。 有关标签搜索正则表达式模式的更多信息,请参阅 tag-regexp。{expr}
(any
){filename}
(字符串?
)任何
){expr}
) tan(){expr}
的正切值(以弧度为单位),以 Float 格式表示,范围为 [-inf, inf]。 {expr}
必须计算为 Float 或 Number。 如果 {expr}
不是 Float 或 Number,则返回 0.0。 例如echo tan(10)
echo tan(-4.01)
{expr}
(number
)number
){expr}
) tanh(){expr}
的双曲正切值,以 Float 格式表示,范围为 [-1, 1]。 {expr}
必须计算为 Float 或 Number。 如果 {expr}
不是 Float 或 Number,则返回 0.0。 例如echo tanh(0.5)
echo tanh(-1)
{expr}
(number
)number
)let tmpfile = tempname()
exe "redir > " .. tmpfile
字符串
){cmd}
[, {opts}
]) termopen(){cmd}
。 参数和行为与 jobstart() 相同,但 "pty"、"width"、"height" 和 "TERM" 被忽略: "height" 和 "width" 取自当前窗口。 请注意,termopen() 意味着向 jobstart() 传递 "pty" 参数,因此具有在 jobstart() 中记录的含义。{cmd}
(string|string[]
){opts}
(table?
)任何
)任何
){id}
]) timer_info(){id}
时,仅返回有关此计时器的信息。 当计时器 {id}
不存在时,将返回一个空列表。 当省略 {id}
时,将返回有关所有计时器的信息。{id}
(integer?
)任何
){timer}
, {paused}
) timer_pause(){paused}
计算为非零 Number 或非空 String,则暂停计时器,否则取消暂停计时器。 请参阅 non-zero-arg。{timer}
(整数
){paused}
(布尔值
)任何
){time}
是以毫秒为单位的等待时间。这是调用回调函数前的最小时间。当系统繁忙或 Vim 不等待输入时,时间会更长。零可以用来在 Vim 恢复到主循环时执行回调函数。{callback}
是要调用的函数。它可以是函数名或 Funcref。它被调用时带有一个参数,即计时器 ID。回调函数只有在 Vim 等待输入时才会被调用。{options}
是一个字典。支持的条目:"repeat" 回调函数重复的次数。-1 表示永远。默认值为 1。如果计时器连续三次发生错误,则重复将被取消。func MyHandler(timer)
echo 'Handler called'
endfunc
let timer = timer_start(500, 'MyHandler',
\ {'repeat': 3})
{time}
(number
){callback}
(string|function
){options}
(table?
)任何
){timer}
) timer_stop(){timer}
是 timer_start() 返回的 ID,因此它必须是数字。如果{timer}
不存在,则不会发生错误。{timer}
(整数
)任何
)任何
){expr}
(string
)字符串
){expr}
(string
)字符串
){src}
, {fromstr}
, {tostr}
) tr(){src}
字符串的副本,其中所有出现在{fromstr}
中的字符都被替换为{tostr}
字符串中该位置的字符。因此,{fromstr}
中的第一个字符将被转换为{tostr}
中的第一个字符,以此类推。就像 unix 的 "tr" 命令一样。此代码也正确地处理了多字节字符。echo tr("hello there", "ht", "HT")
echo tr("<blob>", "<>", "{}")
{src}
(string
){fromstr}
(string
){tostr}
(string
)字符串
){mask}
未给出或为空字符串,则{mask}
将是所有小于 0x20 的字符,包括 Tab、空格、NL 和 CR,以及不间断空格字符 0xa0。{dir}
参数指定删除字符的位置:0 从{text}
的开头和结尾删除 1 仅从{text}
的开头删除 2 仅从{text}
的结尾删除 如果省略,则修剪两端。echo trim(" some text ")
echo trim(" \r\t\t\r RESERVE \t\n\x0B\xA0") .. "_TAIL"
echo trim("rm<Xrm<>X>rrm", "rm<>")
echo trim(" vim ", " ", 2)
{text}
(string
){mask}
(string?
){dir}
(0|1|2?
)字符串
){expr}
) trunc(){expr}
的最大整数值作为 Float 返回(向零截断)。{expr}
必须计算为 Float 或 Number。如果{expr}
不是 Float 或 Number,则返回 0.0。示例echo trunc(1.456)
echo trunc(-5.456)
echo trunc(4.0)
{expr}
(number
)integer
){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:false 和 v: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
if exists('v:t_number') | endif
{expr}
(any
)integer
){name}
) undofile(){name}
的文件的撤销文件的名称。这将使用 'undodir' 选项,找到存在的目录。它不检查撤销文件是否存在。{name}
始终扩展为完整路径,因为这是内部使用的路径。如果{name}
为空,undofile() 将返回空字符串,因为没有文件名的缓冲区将不会写入撤销文件。与 :wundo 和 :rundo 结合使用很有用。{name}
(字符串
)字符串
){buf}
]) undotree(){buf}
,则返回特定缓冲区的撤销树的当前状态。结果是一个包含以下项目的字典:"seq_last" 使用的最高撤销序列号。"seq_cur" 撤销树中当前位置的序列号。当撤销了一些更改时,它与 "seq_last" 不同。"time_cur" 最后用于 :earlier 和相关命令的时间。使用 strftime() 转换为可读的内容。"save_last" 最后一次文件写入的编号。写入之前为零。"save_cur" 撤销树中当前位置的编号。"synced" 最后一个撤销块同步时为非零。当等待用户输入时会发生这种情况。参见 undo-blocks。"entries" 包含有关撤销块的信息的字典列表。{buf}
(整数|字符串?
)vim.fn.undotree.ret
){list}
[, {func}
[, {dict}
]]) uniq() E882 删除{list}
中重复相邻项目的第二个和后续副本(就地操作)。返回{list}
。如果您希望列表保持不变,请先复制一份let newlist = uniq(copy(mylist))
{list}
不是 List,则返回零。{list}
(any
){func}
(any?
){dict}
(任何?
)any[]|0
){string}
, {idx}
[, {countcc}
[, {charidx}
]]) utf16idx(){string}
中{idx}
处的字节的 UTF-16 代码单元索引(在将其转换为 UTF-16 后)。{charidx}
存在且为 TRUE 时,{idx}
被用作字符串{string}
中的字符索引,而不是字节索引。{string}
中 UTF-8 序列中间的{idx}
将向下舍入到该序列的开头。{string}
中的字节少于{idx}
个,则返回 -1。如果字节恰好为{idx}
个,则返回字符串在 UTF-16 代码单元中的长度。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
){dict}
) values(){dict}
中所有值的 List。该 List 的顺序是任意的。另请参见 items() 和 keys()。如果{dict}
不是 Dict,则返回零。{dict}
(any
)任何
){expr}
[, {list}
[, {winid}
]]) virtcol(){expr}
给出的文件位置的屏幕列。也就是说,当屏幕宽度无限时,该位置的字符占据的最后一个屏幕位置。当位置处有<Tab>
时,返回的数字将是<Tab>
结尾处的列。例如,对于列 1 中的<Tab>
,如果将 'ts' 设置为 8,则返回 8。忽略 conceal。对于字节位置,请使用 col()。{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
echo max(map(range(1, line('$')), "virtcol([v:val, '$'])"))
{expr}
(字符串|整数[]
){list}
(boolean?
){winid}
(integer?
)任何
){winid}
, {lnum}
, {col}
) virtcol2col(){winid}
中缓冲区行{lnum}
和虚拟列{col}
处的字符的字节索引。{lnum}
为空行,则返回 0。{col}
大于行 {lnum}
中最后一个虚拟列,则返回最后一个虚拟列字符的字节索引。{winid}
参数可以是窗口号或窗口 ID。如果为零,则使用当前窗口。{winid}
不存在,或者缓冲区行 {lnum}
或虚拟列 {col}
无效,则返回 -1。{winid}
(integer
){lnum}
(integer
){col}
(integer
)任何
){expr}
]) visualmode()CTRL-V
字符)。示例exe "normal " .. visualmode()
{expr}
并且它计算结果为非零数字或非空字符串,则将清除 Visual 模式,并返回旧值。请参阅 non-zero-arg。{expr}
(boolean?
)任何
){timeout}
, {condition}
[, {interval}
]) wait(){condition}
计算结果为 TRUE,其中 {condition}
是一个 Funcref 或包含表达式的 字符串。{timeout}
是以毫秒为单位的最大等待时间,-1 表示永远等待。{interval}
毫秒(默认值:200)时评估条件。{timeout}
(integer
){condition}
(any
){interval}
(number?
)任何
)<c-j>
在 wildmode 中像 <down>
一样工作,请使用cnoremap <expr> <C-j> wildmenumode() ? "\<Down>\<Tab>" : "\<c-j>"
任何
){id}
, {command}
[, {silent}
]) win_execute()execute()
相似,但在窗口 {id}
的上下文中。该窗口将暂时变为当前窗口,而不会触发自动命令或更改目录。执行 {command}
时,将触发自动命令,这可能产生意想不到的副作用。如果需要,请使用 :noautocmd
。示例call win_execute(winid, 'syntax enable')
setwinvar()
执行相同操作不会触发自动命令,也不会真正显示语法高亮显示。{id}
不存在时,不会给出错误,并返回一个空字符串。{id}
(整数
){command}
(string
){silent}
(boolean?
)任何
){bufnr}
(integer
)integer[]
){win}
[, {tab}
]]) win_getid(){win}
,则使用当前窗口。对于 {win}
,这是窗口号。最顶部的窗口的编号为 1。如果 {tab}
不存在,则使用当前标签页,否则使用编号为 {tab}
的标签页。第一个标签页的编号为 1。如果找不到窗口,则返回零。{win}
(整数?
){tab}
(integer?
)integer
){nr}
]) win_gettype(){nr}
未找到{nr}
(integer?
)'autocmd'|'command'|''|'loclist'|'popup'|'preview'|'quickfix'|'unknown'
){expr}
(integer
)0|1
){expr}
) win_id2tabwin(){expr}
的窗口的标签页号和窗口号的列表:[tabnr, winnr]。如果找不到窗口,则返回 [0, 0]。{expr}
(integer
)任何
){expr}
(integer
)任何
){nr}
, {offset}
) win_move_separator(){nr}
的垂直分隔线(即右边界)移动 {offset}
列,就像用鼠标拖动一样。{nr}
可以是窗口号或 窗口 ID。正数的 {offset}
向右移动,负数的 {offset}
向左移动。移动窗口的垂直分隔线将更改窗口的宽度以及与垂直分隔线相邻的其他窗口的宽度。移动的幅度可能小于指定的幅度(例如,由于要维护 'winminwidth')。如果找到窗口,则返回 TRUE,否则返回 FALSE。这对于最右边的窗口和全宽窗口将失败,因为它们在右侧没有分隔线。仅对当前标签页起作用。 E1308{nr}
(整数
){offset}
(integer
)任何
){nr}
, {offset}
) win_move_statusline(){nr}
的状态行(即底部边界)移动 {offset}
行,就像用鼠标拖动一样。{nr}
可以是窗口号或 窗口 ID。正数的 {offset}
向下移动,负数的 {offset}
向上移动。移动窗口的状态行将更改窗口的高度以及与状态行相邻的其他窗口的高度。移动的幅度可能小于指定的幅度(例如,由于要维护 'winminheight')。如果找到窗口,则返回 TRUE,否则返回 FALSE。仅对当前标签页起作用。{nr}
(整数
){offset}
(integer
)任何
){nr}
) win_screenpos(){nr}
的屏幕位置,这是一个包含两个数字的列表:[row, col]。第一个窗口的位置始终为 [1, 1],除非存在标签页线,否则为 [2, 1]。{nr}
可以是窗口号或 窗口 ID。对于当前窗口,请使用零。如果找不到窗口,则返回 [0, 0]。{nr}
(整数
)任何
){nr}
, {target}
[, {options}
]) win_splitmove(){target}
,然后将窗口 {nr}
移动到与 {target}
相邻的新分割处。与 :split 等命令不同,不会创建新的窗口(窗口 {nr}
的 窗口 ID 在移动后保持不变)。{options}
是一个包含以下可选条目的 字典:"vertical" 当为 TRUE 时,分割将垂直创建,就像使用 :vsplit 一样。"rightbelow" 当为 TRUE 时,分割将在下方或右侧(如果为垂直)创建。当为 FALSE 时,将在上方或左侧(如果为垂直)创建。如果不存在,则使用 'splitbelow' 和 'splitright' 的值。{nr}
(整数
){target}
(integer
){options}
(table?
)任何
){nr}
) winbufnr(){nr}
关联的缓冲区的编号。{nr}
可以是窗口号或 窗口 ID。当 {nr}
为零时,将返回当前窗口中缓冲区的编号。当窗口 {nr}
不存在时,将返回 -1。示例echo "The file in the current window is " .. bufname(winbufnr(0))
{nr}
(整数
)integer
)integer
)字符串
){nr}
) winheight(){nr}
的高度。{nr}
可以是窗口号或 窗口 ID。当 {nr}
为零时,将返回当前窗口的高度。当窗口 {nr}
不存在时,将返回 -1。现有的窗口始终具有零或更大的高度。这排除了任何窗口工具栏行。示例echo "The current window has " .. winheight(0) .. " lines."
{nr}
(整数
)integer
){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?
)任何
)integer
){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?
)任何
)let cmd = winrestcmd()
call MessWithWindowSizes()
exe cmd
任何
){dict}
) winrestview(){dict}
不必包含由 winsaveview() 返回的所有值。如果缺少值,则不会恢复这些设置。因此,您可以使用call winrestview({'curswant': 4})
{dict}
(vim.fn.winrestview.dict
)任何
)vim.fn.winsaveview.ret
){nr}
) winwidth(){nr}
的宽度。{nr}
可以是窗口编号或 窗口 ID。当 {nr}
为零时,返回当前窗口的宽度。当窗口 {nr}
不存在时,返回 -1。现有窗口的宽度始终为零或大于零。示例echo "The current window has " .. winwidth(0) .. " columns."
if winwidth(0) <= 50
50 wincmd |
endif
{nr}
(整数
)任何
)任何
){object}
, {fname}
[, {flags}
]) writefile(){object}
为 List 时,将其写入文件 {fname}
。每个列表项用 NL 分隔。每个列表项必须是字符串或数字。所有 NL 字符都将替换为 NUL 字符。在将 {list}
传递给 writefile() 之前,需要插入 CR 字符。{flags}
必须是字符串。识别以下字符call writefile(["foo"], "event.log", "a")
call writefile(["bar"], "event.log", "a")
defer delete({fname})
{flags}
不包含 "S" 或 "s" 时,如果设置了 'fsync' 选项,则会调用 fsync()。let fl = readfile("foo", "b")
call writefile(fl, "foocopy", "b")
{object}
(any
){fname}
(string
){flags}
(string?
)任何
){expr}
, {expr}
) xor()and()
和 or()
。示例let bits = xor(bits, 0x80)
{expr}
(number
){expr1}
(number
)任何
)let a = "aaaa\nxxxx"
echo matchstr(a, "..\n..")
" aa
" xx
echo matchstr(a, "a.x")
" a
" x
不要忘记 "^" 只匹配字符串的第一个字符,"$" 只匹配字符串的最后一个字符。它们不会匹配 "\n" 之后或之前。