Lua

Lua engine Lua

INTRODUCTION  介绍 lua-intro

The Lua 5.1 script engine is builtin and always available. Try this command to get an idea of what lurks beneath:
Lua 5.1 脚本引擎是内置的，并且始终可用。尝试此命令 了解下面潜伏着什么：

:lua vim.print(package.loaded)

Nvim includes a "standard library" lua-stdlib for Lua. It complements the "editor stdlib" (vimscript-functions + Ex-commands) and the API, all of which can be used from Lua code (lua-vimscript vim.api). These three namespaces form the Nvim programming interface.
Nvim 包括一个用于 Lua 的 “标准库” lua-stdlib。 它补充了 “editor stdlib” （vimscript-functions + Ex-commands） 和 API，所有这些都可以从 Lua 代码 （lua-vimscriptvim.api） 中使用。这三个 命名空间构成了 Nvim 编程接口。

Lua plugins and user config are automatically discovered and loaded, just like Vimscript. See lua-guide for practical guidance.
Lua 插件和用户配置会自动发现和加载，就像 Vimscript 一样。有关实用指南，请参阅 lua-guide。

You can also run Lua scripts from your shell using the -l argument:
您还可以使用 -l 参数从 shell 运行 Lua 脚本：

nvim -l foo.lua [args...]

lua-compat  lua-compat 公司
Lua 5.1 is the permanent interface for Nvim Lua. Plugins should target Lua 5.1 as specified in luaref; later versions (which are essentially different, incompatible, dialects) are not supported. This includes extensions such as goto that some Lua 5.1 interpreters like LuaJIT may support.
Lua 5.1 是 Nvim Lua 的永久接口。插件应以 Lua 5.1 为目标 如 luaref 中指定;更高版本（本质上不同， 不兼容、方言）的 S 的 Quinect S S 的 Dialect 的这包括 goto 一些 Lua 5.1 解释器（如 LuaJIT）可能支持。

lua-luajit
While Nvim officially only requires Lua 5.1 support, it should be built with LuaJIT or a compatible fork on supported platforms for performance reasons. LuaJIT also comes with useful extensions such as ffi, lua-profile, and enhanced standard library functions; these cannot be assumed to be available, and Lua code in init.lua or plugins should check the jit global variable before using them:
虽然 Nvim 官方只需要 Lua 5.1 支持，但它应该使用 LuaJIT 或受支持平台上的兼容 fork。 LuaJIT 还附带了有用的扩展，例如 ffi、lua-profile 和增强的标准库函数;这些不能假设是可用的，init.lua 或插件中的 Lua 代码应该在使用它们之前检查 jit 全局变量：

if jit then
  -- code for luajit
else
  -- code for plain lua 5.1
end

lua-bit
One exception is the LuaJIT bit extension, which is always available: when built with PUC Lua, Nvim includes a fallback implementation which provides require("bit").
一个例外是 LuaJIT 位扩展，它始终可用：当 Nvim 使用 PUC Lua 构建，包括一个回退实现，它提供 require（“bit”）的

lua-profile  lua-配置文件
If Nvim is built with LuaJIT, Lua code can be profiled via
如果 Nvim 是使用 LuaJIT 构建的，则可以通过以下方式分析 Lua 代码

-- Start a profiling session:
require('jit.p').start('ri1', '/tmp/profile')
-- Perform arbitrary tasks (use plugins, scripts, etc.) ...
-- Stop the session. Profile is written to /tmp/profile.
require('jit.p').stop()

See https://luajit.org/ext_profiler.html or the p.lua source for details:
有关详细信息，请参阅 https://luajit.org/ext_profiler.html 或 p.lua 源：

:lua vim.cmd.edit(package.searchpath('jit.p', package.path))

LUA CONCEPTS AND IDIOMS  LUA 概念和习语 lua-concepts

Lua is very simple, and _consistent_: while there are some quirks, once you internalize those quirks, everything works the same everywhere. Scopes (closures) in particular are very consistent, unlike JavaScript or most other languages.
Lua 非常简单，而且 _consistent_： 虽然有一些怪癖，但一旦你内化了这些怪癖，一切都在任何地方都是一样的。特别是 scopes（闭包）非常一致，这与 JavaScript 或大多数其他语言不同。

Lua has three fundamental mechanisms—one for "each major aspect of programming": tables, closures, and coroutines. https://www.lua.org/doc/cacm2018.pdf
Lua 有三个基本机制 — 一个用于“每个主要方面 programming“：表、闭包和协程。 https://www.lua.org/doc/cacm2018.pdf

lua-error-handling  lua-错误处理
Lua functions may throw lua-errors for exceptional (unexpected) failures, which you can handle with pcall().
Lua 函数可能会因异常（意外）故障而引发 lua-errors，您可以使用 pcall（） 处理。lua-result-or-message
When failure is normal and expected, it's idiomatic to return nil which signals to the caller that failure is not "exceptional" and must be handled. This "result-or-message" pattern is expressed as the multi-value return type any|nil,nil|string, or in LuaLS notation:
当失败是正常且预期的时，惯用的返回 nil 是惯用的，它 向调用者发出信号，表明失败不是 “异常” 的，必须进行处理。 这种 “result-or-message” 模式表示为多值返回类型 any|nil，nil|string，或者以 LuaLS 表示法表示：

---@return any|nil    # result on success, nil on failure.
---@return nil|string # nil on success, error message on failure.

Examples of the "result-or-message" pattern:
“result-or-message” 模式的示例：

When a caller can't proceed on failure, it's idiomatic to assert() the "result-or-message" result:
当调用者在失败时无法继续时，惯用的 assert（） “result-or-message” 结果是惯用的：

local value = assert(fn())

Guidance: use the "result-or-message" pattern for...
指导：将 “result-or-message” 模式用于...

iterator  迭 代
An iterator is just a function that can be called repeatedly to get the "next" value of a collection (or any other iterable). This interface is expected by for-in loops, produced by pairs(), supported by vim.iter, etc. https://www.lua.org/pil/7.1.html
迭代器只是一个可以重复调用以获得“下一个”的函数 值（或任何其他可迭代对象）。此接口由 for-in 循环，由 pairs（） 生成，由 vim.iter 支持，等等。 https://www.lua.org/pil/7.1.html

iterable  可迭代
An "iterable" is anything that vim.iter() can consume: tables, dicts, lists, iterator functions, tables implementing the __call() metamethod, and vim.iter() objects.
“可迭代对象” 是 vim.iter（） 可以使用的任何东西：表、字典、列表、迭代器函数、实现 __call（） 元方法的表，以及 vim.iter（） 对象。

list-iterator  列表迭代器
Iterators on lua-list tables have a "middle" and "end", whereas iterators in general may be logically infinite. Therefore some vim.iter operations (e.g. Iter:rev()) make sense only on list-like tables (which are finite by definition).
lua-list 表上的迭代器有 “middle” 和 “end”，而迭代器通常在逻辑上可能是无限的。因此，一些 vim.iter 操作（例如 iter：rev（））仅在类似列表的表（其有限 定义）。

lua-function-call  lua 函数调用
Lua functions can be called in multiple ways. Consider the function:
可以通过多种方式调用 Lua 函数。考虑函数：

local foo = function(a, b)
    print("A: ", a)
    print("B: ", b)
end

The first way to call this function is:
调用此函数的第一种方法是：

foo(1, 2)
-- ==== Result ====
-- A: 1
-- B: 2

This way of calling a function is familiar from most scripting languages. In Lua, any missing arguments are passed as nil, and extra parameters are silently discarded. Example:
这种调用函数的方式在大多数脚本语言中都很常见。在 Lua，则任何缺失的参数都将作为 nil 传递，额外的参数将被静默丢弃。例：

foo(1)
-- ==== Result ====
-- A: 1
-- B: nil

kwargs  夸格斯
When calling a function, you can omit the parentheses if the function takes exactly one string literal ("foo") or table literal ({1,2,3}). The latter is often used to mimic "named parameters" ("kwargs" or "keyword args") as in languages like Python and C#. Example:
调用函数时，如果函数采用 恰好是一个字符串文本 （“foo”） 或表文本 （{1,2,3}）。后者通常用于模拟 Python 和 C# 等语言中的“命名参数”（“kwargs”或“keyword args”）。例：

local func_with_opts = function(opts)
    local will_do_foo = opts.foo
    local filename = opts.filename
    -- ...
end
func_with_opts { foo = true, filename = "hello.world" }

There's nothing special going on here except that parentheses are implicitly added. But visually, this small bit of sugar gets reasonably close to a "keyword args" interface.
除了隐式添加括号外，这里没有什么特别之处。但从视觉上看，这小点糖相当接近 “keyword args” 界面。

lua-regex  lua-正则表达式
Lua intentionally does not support regular expressions, instead it has limited lua-patterns which avoid the performance pitfalls of extended regex. Lua scripts can also use Vim regex via vim.regex().
Lua 故意不支持正则表达式，而是将 lua-patterns 避免了扩展正则表达式的性能陷阱。Lua 脚本也可以通过 vim.regex（） 使用 Vim 正则表达式。

Examples:  例子：

print(string.match("foo123bar123", "%d+"))
-- 123
print(string.match("foo123bar123", "[^%d]+"))
-- foo
print(string.match("foo123bar123", "[abc]+"))
-- ba
print(string.match("foo.bar", "%.bar"))
-- .bar

IMPORTING LUA MODULES  导入 LUA 模块 lua-module-load  lua-module-load 模块

Modules are searched for under the directories specified in 'runtimepath', in the order they appear. Any "." in the module name is treated as a directory separator when searching. For a module foo.bar, each directory is searched for lua/foo/bar.lua, then lua/foo/bar/init.lua. If no files are found, the directories are searched again for a shared library with a name matching lua/foo/bar.?, where ? is a list of suffixes (such as so or dll) derived from the initial value of package.cpath. If still no files are found, Nvim falls back to Lua's default search mechanism. The first script found is run and require() returns the value returned by the script if any, else true.
按照模块出现的顺序在 'runtimepath' 中指定的目录下搜索模块。搜索时，模块名称中的任何 “.” 都被视为目录分隔符。对于模块 foo.bar，每个目录都会搜索 lua/foo/bar.lua，然后搜索 lua/foo/bar/init.lua。 如果未找到文件，则 将再次搜索目录以查找名称匹配的共享库 lua/foo/bar.？，其中 ？是从 package.cpath 的初始值派生的后缀（例如 so 或 dll）列表。如果仍然没有找到文件，Nvim 会失败 回到 Lua 的默认搜索机制。找到的第一个脚本是 run 和 require（） 返回脚本返回的值（如果有），否则为 true。

The return value is cached after the first call to require() for each module, with subsequent calls returning the cached value without searching for, or executing any script. For further details see require().
返回值在每个模块第一次调用 require（） 后缓存，后续调用返回缓存的值，而不搜索或执行任何脚本。有关更多详细信息，请参阅 require（）。

For example, if 'runtimepath' is foo,bar and package.cpath was ./?.so;./?.dll at startup, require('mod') searches these paths in order and loads the first module found ("first wins"):
例如，如果 'runtimepath' 是 foo，bar 并且 package.cpath 是 ./？.所以;。/?.dll 启动时，require（'mod'） 按顺序搜索这些路径并加载找到的第一个模块 （“first wins”）：

foo/lua/mod.lua
foo/lua/mod/init.lua
bar/lua/mod.lua
bar/lua/mod/init.lua
foo/lua/mod.so
foo/lua/mod.dll
bar/lua/mod.so
bar/lua/mod.dll

lua-package-path
Nvim automatically adjusts package.path and package.cpath according to the effective 'runtimepath' value. Adjustment happens whenever 'runtimepath' is changed. package.path is adjusted by simply appending /lua/?.lua and /lua/?/init.lua to each directory from 'runtimepath' (/ is actually the first character of package.config).
Nvim 根据有效的 'runtimepath' 值自动调整 package.path 和 package.cpath。每当 'runtimepath' 发生更改时，都会进行调整。package.path 可以通过简单地附加 /lua/？来调整。lua 和 /lua/？/init.lua 到 'runtimepath' 的每个目录（/ 实际上是 package.config 的第一个字符）。

Similarly to package.path, modified directories from 'runtimepath' are also added to package.cpath. In this case, instead of appending /lua/?.lua and /lua/?/init.lua to each runtimepath, all unique ?-containing suffixes of the existing package.cpath are used. Example:
与 package.path 类似，从 'runtimepath' 修改的目录也会添加到 package.cpath 中。在这种情况下，而不是附加 /lua/？。lua 和 /lua/？/init.lua 添加到每个运行时路径，都是唯一的 ？-包含现有 package.cpath 的后缀。例：

The result will look like this:

/foo/bar,/xxx;yyy/baz,/abc ('runtimepath')
× ./?.so;/def/ghi/a?d/j/g.elf;/def/?.so (package.cpath)
= /foo/bar/lua/?.so;/foo/bar/lua/a?d/j/g.elf;/abc/lua/?.so;/abc/lua/a?d/j/g.elf;./?.so;/def/ghi/a?d/j/g.elf;/def/?.so

Note:
结果将如下所示：注意：

COMMANDS  命令 lua-commands  lua 命令

These commands execute a Lua chunk from either the command line (:lua, :luado) or a file (:luafile) on the given line [range]. As always in Lua, each chunk has its own scope (closure), so only global variables are shared between command calls. The lua-stdlib modules, user modules, and anything else on package.path are available.
这些命令从命令行 （：lua， ：luado） 或给定行 [range] 上的文件 （：luafile） 执行 Lua 块。与 Lua 一样，每个 chunk 都有自己的范围（闭包），因此在命令调用之间只有全局变量共享。lua-stdlib 模块、用户模块以及 package.path 可用。

The Lua print() function redirects its output to the Nvim message area, with arguments separated by " " (space) instead of "\t" (tab).
Lua print（） 函数将其输出重定向到 Nvim 消息区域，参数用“ ”（空格）而不是 “\t” （制表符）分隔。

:lua= :lua :lua {chunk} Executes Lua chunk {chunk}. If {chunk} starts with "=" the rest of the chunk is evaluated as an expression and printed. :lua =expr and :=expr are equivalent to :lua vim.print(expr).
：lua=：lua ：lua {chunk} 执行 Lua chunk {chunk}。如果 {chunk} 以 “=” 开头，则 chunk 的其余部分将作为表达式计算并打印。：lua =expr 和 ：=expr 等价于 ：lua vim.print（expr）。

Examples:  例子：

:lua vim.api.nvim_command('echo "Hello, Nvim!"')

To see the Lua version:
要查看 Lua 版本：

:lua print(_VERSION)

To see the LuaJIT version:
要查看 LuaJIT 版本：

:lua =jit.version

:{range}lua Executes buffer lines in {range} as Lua code. Unlike :source, this always treats the lines as Lua code.
：{range}lua 将 {range} 中的缓冲区行作为 Lua 代码执行。与 ：source 不同，它总是将这些行视为 Lua 代码。

Example: select the following code and type ":lua<Enter>" to execute it:
示例：选择以下代码并键入 “：lua<Enter>” 来执行它：

print(string.format(
    'unix time: %s', os.time()))

:lua-heredoc  ：lua-heredoc
:lua << [trim] [{endmarker}] {script} {endmarker} Executes Lua script {script} from within Vimscript. You can omit [endmarker] after the "<<" and use a dot "." after {script} (similar to :append, :insert). Refer to :let-heredoc for more information.
：lua << [修剪] [{endmarker}] {script}{endmarker} 从 Vimscript 中执行 Lua 脚本 {script}。您可以省略 [endmarker]，并在 {script} 后使用点 “.”（类似于 ：append， ：insert） 的有关更多信息，请参阅 ：let-heredoc。

Example:  例：

function! CurrentLineInfo()
lua << EOF
local linenr = vim.api.nvim_win_get_cursor(0)[1]
local curline = vim.api.nvim_buf_get_lines(0, linenr - 1, linenr, false)[1]
print(string.format('Line [%d] has %d bytes', linenr, #curline))
EOF
endfunction

Note that the local variables will disappear when the block finishes. But not globals.
请注意，当模块完成时，局部变量将消失。但不是 globals。

:luado  ：卢阿多
:[range]luado {body} Executes Lua chunk "function(line, linenr) {body} end" for each buffer line in [range], where line is the current line text (without <EOL>), and linenr is the current line number. If the function returns a string that becomes the text of the corresponding buffer line. Default [range] is the whole file: "1,$".
：[range]luado {body} 为每个缓冲区执行 Lua 块 “function（line， linenr） {body} end” line in [range]，其中 line 是当前行文本（不含 <EOL>）， linenr 是当前行号。如果函数返回字符串 这将成为相应缓冲区行的文本。默认值 [range] 为 整个文件：“1，$”。

Examples:  例子：

:luado return string.format("%s\t%d", line:reverse(), #line)
:lua require"lpeg"
:lua -- balanced parenthesis grammar:
:lua bp = lpeg.P{ "(" * ((1 - lpeg.S"()") + lpeg.V(1))^0 * ")" }
:luado if bp:match(line) then return "=>\t" .. line end

:luafile  ：lua文件
:luafile {file} Execute Lua script in {file}. The whole argument is used as the filename (like :edit), spaces do not need to be escaped. Alternatively you can :source Lua files.
：luafile {文件} 在 {file} 中执行 Lua 脚本。 整个参数用作文件名（如 ：edit），空格则不 需要被转义。或者，你可以 ：source Lua 文件。

Examples:  例子：

:luafile script.lua
:luafile %

luaeval()  卢阿瓦尔（） lua-eval

The (dual) equivalent of "vim.eval" for passing Lua values to Nvim is "luaeval". "luaeval" takes an expression string and an optional argument used for _A inside expression and returns the result of the expression. It is semantically equivalent in Lua to:
将 Lua 值传递给 Nvim 的 “vim.eval” 的（双重）等价物是 “卢阿瓦尔”。“luaeval” 接受一个表达式字符串和一个使用的可选参数 for _A 表达式中，并返回表达式的结果。是的 在 Lua 中语义上等同于：

local chunkheader = "local _A = select(1, ...) return "
function luaeval (expstr, arg)
    local chunk = assert(loadstring(chunkheader .. expstr, "luaeval"))
    return chunk(arg) -- return typval
end

Lua nils, numbers, strings, tables and booleans are converted to their respective Vimscript types. If a Lua string contains a NUL byte, it will be converted to a Blob. Conversion of other Lua types is an error.
Lua nils、数字、字符串、表格和布尔值被转换为它们各自的 Vimscript 类型。如果 Lua 字符串包含 NUL 字节，它将被转换为 Blob。其他 Lua 类型的转换是一个错误。

The magic global "_A" contains the second argument to luaeval().
魔术全局 “_A” 包含 luaeval（） 的第二个参数。

Example:  例：

:echo luaeval('_A[1] + _A[2]', [40, 2])
" 42
:echo luaeval('string.match(_A, "[a-z]+")', 'XYXfoo123')
" foo

lua-table-ambiguous
Lua tables are used as both dictionaries and lists, so it is impossible to decide whether empty table is a list or a dict. Also Lua does not have integer numbers. To disambiguate these cases, we define:
Lua 表既用作字典又用作列表，因此不可能 确定 Empty Table 是 List 还是 Dict。此外，Lua 没有整数 数字。为了消除这些情况的歧义，我们定义了：lua-list
0. Empty table is a list. Use vim.empty_dict() to represent empty dict. 1. Table with N consecutive (no nil values, aka "holes") integer keys 1…N is a list. See also list-iterator.
0. 空表是一个列表。使用 vim.empty_dict（） 表示空字典。具有 N 个连续（无 nil 值，又名“holes”）整数键 1...N 是 一个列表。另请参见 list-iterator。lua-dict  lua-dict 命令
2. Table with string keys, none of which contains NUL byte, is a dict. 3. Table with string keys, at least one of which contains NUL byte, is also considered to be a dictionary, but this time it is converted to a msgpack-special-map.
2. 带有字符串键的表，其中不包含 NUL 字节，是一个字典。 3. 带有字符串键的表，其中至少有一个包含 NUL 字节，也是 被认为是一个字典，但这次它被转换为 一个 msgpack-special-map 的 map。lua-special-tbl
4. Table with vim.type_idx key may be a dictionary, a list or floating-point value:
4. 带vim.type_idx键的表格可以是字典、列表或浮点 价值：

Examples:  例子：

:echo luaeval('math.pi')
:function Rand(x,y) " random uniform between x and y
:  return luaeval('(_A.y-_A.x)*math.random()+_A.x', {'x':a:x,'y':a:y})
:  endfunction
:echo Rand(1,10)

Note: Second argument to luaeval is converted ("marshalled") from Vimscript to Lua, so changes to Lua containers do not affect values in Vimscript. Return value is also always converted. When converting, msgpack-special-dicts are treated specially.
注意：luaeval 的第二个参数从 Vimscript 转换（“编组”）为 Lua，因此对 Lua 容器的更改不会影响 Vimscript 中的值。返回值也始终进行转换。在转换时，msgpack-special-dicts 会被特殊处理。

Vimscript v:lua interface  Vimscript v：lua 接口 v:lua-call  v：lua-call

From Vimscript the special v:lua prefix can be used to call Lua functions which are global or accessible from global tables. The expression
在 Vimscript 中，特殊的 v：lua 前缀可用于调用全局或可从全局表访问的 Lua 函数。表达式

call v:lua.func(arg1, arg2)

is equivalent to the Lua chunk
等同于 Lua 块

return func(...)

where the args are converted to Lua values. The expression
其中 args 转换为 Lua 值。表达式

call v:lua.somemod.func(args)

is equivalent to the Lua chunk
等同于 Lua 块

return somemod.func(...)

In addition, functions of packages can be accessed like
此外，还可以访问包的功能，例如

call v:lua.require'mypack'.func(arg1, arg2)
call v:lua.require'mypack.submod'.func(arg1, arg2)

Note: Only single quote form without parens is allowed. Using require"mypack" or require('mypack') as prefixes do NOT work (the latter is still valid as a function call of itself, in case require returns a useful value).
注意：只允许没有括号的单引号格式。用 require“mypack” 或 require（'mypack'） 作为前缀不起作用（后者 仍然有效，以防 require 返回一个有用的 值）。

The v:lua prefix may be used to call Lua functions as methods. For example:
v：lua 前缀可用于将 Lua 函数作为方法s 调用。例如：

:eval arg1->v:lua.somemod.func(arg2)

You can use v:lua in "func" options like 'tagfunc', 'omnifunc', etc. For example consider the following Lua omnifunc handler:
你可以在 'tagfunc'、'omnifunc' 等 “func” 选项中使用 v：lua。例如，考虑以下 Lua omnifunc 处理程序：

function mymod.omnifunc(findstart, base)
  if findstart == 1 then
    return 0
  else
    return {'stuff', 'steam', 'strange things'}
  end
end
vim.bo[buf].omnifunc = 'v:lua.mymod.omnifunc'

Note: The module ("mymod" in the above example) must either be a Lua global, or use require() as shown above to access it from a package.
注意：模块（上面例子中的“mymod”）必须是 Lua 全局变量， 或者使用上面所示的 require（） 从包中访问它。

Note: v:lua without a call is not allowed in a Vimscript expression: Funcrefs cannot represent Lua functions. The following are errors:
注意：在 Vimscript 表达式中不允许不带调用的 v：lua： Funcref不能表示 Lua 函数。以下是错误：

let g:Myvar = v:lua.myfunc        " Error
call SomeFunc(v:lua.mycallback)   " Error
let g:foo = v:lua                 " Error
let g:foo = v:['lua']             " Error

Lua standard modules  Lua 标准模块 lua-stdlib

The Nvim Lua "standard library" (stdlib) is the vim module, which exposes various functions and sub-modules. It is always loaded, thus require("vim") is unnecessary.
Nvim Lua“标准库”（stdlib）是 vim 模块，它暴露了各种函数和子模块。它总是被加载的，因此 require（“vim”） 是不必要的。

You can peek at the module properties:
您可以查看模块属性：

:lua vim.print(vim)

Result is something like this:

{
  _os_proc_children = <function 1>,
  _os_proc_info = <function 2>,
  ...
  api = {
    nvim__id = <function 5>,
    nvim__id_array = <function 6>,
    ...
  },
  deepcopy = <function 106>,
  gsplit = <function 107>,
  ...
}

To find documentation on e.g. the "deepcopy" function:
Result 是这样的： 要查找有关 “deepcopy” 函数的文档：

:help vim.deepcopy()

Note that underscore-prefixed functions (e.g. "_os_proc_children") are internal/private and must not be used by plugins.
请注意，以下划线为前缀的函数（例如“_os_proc_children”）是 internal/private 的，并且不得件使用。

VIM.UV lua-loop vim.uv

vim.uv exposes the "luv" Lua bindings for the libUV library that Nvim uses for networking, filesystem, and process management, see luvref.txt. In particular, it allows interacting with the main Nvim luv-event-loop.
vim.uv 公开了 nvim 用于网络、文件系统和进程管理的 libUV 库的 “luv” Lua 绑定，请参见luvref.txt。特别是，它允许与主 Nvim luv-event-loop 交互。

E5560 lua-loop-callbacks It is an error to directly invoke vim.api functions (except api-fast) in vim.uv callbacks. For example, this is an error:
E5560lua-loop-callbacks 在 vim.uv 回调。例如，这是一个错误：

local timer = vim.uv.new_timer()
timer:start(1000, 0, function()
  vim.api.nvim_command('echomsg "test"')
end)

To avoid the error use vim.schedule_wrap() to defer the callback:
为避免此错误，请使用 vim.schedule_wrap（） 延迟回调：

local timer = vim.uv.new_timer()
timer:start(1000, 0, vim.schedule_wrap(function()
  vim.api.nvim_command('echomsg "test"')
end))

(For one-shot timers, see vim.defer_fn(), which automatically adds the wrapping.)
（对于一次性计时器，请参阅 vim.defer_fn（），它会自动添加换行。

Example: repeating timer 1. Save this code to a file. 2. Execute it with ":luafile %".
示例：重复计时器 1. 将此代码保存到文件中。 2. 用 “：luafile %” 执行它。

-- Create a timer handle (implementation detail: uv_timer_t).
local timer = vim.uv.new_timer()
local i = 0
-- Waits 1000ms, then repeats every 750ms until timer:close().
timer:start(1000, 750, function()
  print('timer invoked! i='..tostring(i))
  if i > 4 then
    timer:close()  -- Always close handles to avoid leaks.
  end
  i = i + 1
end)
print('sleeping');

Example: File-change detection
示例：文件更改检测watch-file  监视文件
1. Save this code to a file. 2. Execute it with ":luafile %". 3. Use ":Watch %" to watch any file. 4. Try editing the file from another text editor. 5. Observe that the file reloads in Nvim (because on_change() calls :checktime).
1. 将此代码保存到文件中。 2. 用 “：luafile %” 执行它。 3. 使用 “：watch %” 来监视任何文件。 4. 尝试从其他文本编辑器编辑文件。 5. 观察文件在 Nvim 中重新加载（因为 on_change（） 调用 ：checktime 的 S T

local w = vim.uv.new_fs_event()
local function on_change(err, fname, status)
  -- Do work...
  vim.api.nvim_command('checktime')
  -- Debounce: stop/start.
  w:stop()
  watch_file(fname)
end
function watch_file(fname)
  local fullpath = vim.api.nvim_call_function(
    'fnamemodify', {fname, ':p'})
  w:start(fullpath, {}, vim.schedule_wrap(function(...)
    on_change(...) end))
end
vim.api.nvim_command(
  "command! -nargs=1 Watch call luaeval('watch_file(_A)', expand('<args>'))")

inotify-limitations  inotify-限制
When on Linux you may need to increase the maximum number of inotify watches and queued events as the default limit can be too low. To increase the limit, run:
在 Linux 上时，您可能需要增加 inotify 监视和排队事件的最大数量，因为默认限制可能太低。要提高限制，请运行：

sysctl fs.inotify.max_user_watches=494462

This will increase the limit to 494462 watches and queued events. These lines can be added to /etc/sysctl.conf to make the changes persistent.
这将增加对 494462 个监视和排队事件的限制。可以将这些行添加到 /etc/sysctl.conf 中，以使更改持久化。

Note that each watch is a structure in the Kernel, thus available memory is also a bottleneck for using inotify. In fact, a watch can take up to 1KB of space. This means a million watches could result in 1GB of extra RAM usage.
请注意，每个 watch 都是 Kernel 中的一个结构，因此可用内存也是使用 inotify 的瓶颈。事实上，一只手表最多可以占用 1KB 的空间。这意味着 100 万只手表可能会导致 1GB 的额外 RAM 使用量。

Example: TCP echo-server   示例：TCP echo-servertcp-server  tcp 服务器
1. Save this code to a file. 2. Execute it with ":luafile %". 3. Note the port number. 4. Connect from any TCP client (e.g. "nc 0.0.0.0 36795"):
1. 将此代码保存到文件中。 2. 用 “：luafile %” 执行它。 3. 记下端口号。 4. 从任何 TCP 客户端连接（例如“nc 0.0.0.0 36795”）：

local function create_server(host, port, on_connect)
  local server = vim.uv.new_tcp()
  server:bind(host, port)
  server:listen(128, function(err)
    assert(not err, err)  -- Check for errors.
    local sock = vim.uv.new_tcp()
    server:accept(sock)  -- Accept client connection.
    on_connect(sock)  -- Start reading messages.
  end)
  return server
end
local server = create_server('0.0.0.0', 0, function(sock)
  sock:read_start(function(err, chunk)
    assert(not err, err)  -- Check for errors.
    if chunk then
      sock:write(chunk)  -- Echo received messages to the channel.
    else  -- EOF (stream closed).
      sock:close()  -- Always close handles to avoid leaks.
    end
  end)
end)
print('TCP echo-server listening on port: '..server:getsockname().port)

Multithreading   多线程lua-loop-threading

Plugins can perform work in separate (os-level) threads using the threading APIs in luv, for instance vim.uv.new_thread. Each thread has its own separate Lua interpreter state, with no access to Lua globals on the main thread. Neither can the editor state (buffers, windows, etc) be directly accessed from threads.
插件可以使用 luv 中的线程 API 在单独的（操作系统级）线程中执行工作，例如 vim.uv.new_thread。每个线程都有自己单独的 Lua 解释器状态，无法访问主线程上的 Lua 全局变量。编辑器状态（缓冲区、窗口等）也不能直接从线程访问。

A subset of the vim.* stdlib is available in threads, including:
vim.* stdlib 的子集在线程中可用，包括：

VIM.HL vim.hl

vim.hl.on_yank({opts})
vim.hl.on_yank（{opts}）vim.hl.on_yank()  vim.hl.on_yank（）
Highlight the yanked text during a TextYankPost event.
在 TextYankPost 事件期间突出显示被拉取的文本。

Add the following to your init.vim:
将以下内容添加到您的 init.vim 中：

autocmd TextYankPost * silent! lua vim.hl.on_yank {higroup='Visual', timeout=300}

vim.hl.priorities   vim.hl.priorities 的vim.hl.priorities  vim.hl.priorities 的
Table with default priorities used for highlighting:
用于突出显示的默认优先级的表：

vim.hl.range()  vim.hl.range（）
vim.hl.range({bufnr}, {ns}, {higroup}, {start}, {finish}, {opts}) Apply highlight group to range of text.
vim.hl.range（{bufnr}， {ns}， {higroup}， {start}， {finish}， {opts}） 将高亮组应用于文本范围。

VIM.DIFF  VIM.DIFF （英文） vim.diff  vim.diff 中

vim.diff({a}, {b}, {opts})
vim.diff（{a}， {b}， {opts}）vim.diff()  vim.diff（） 文件
Run diff on strings {a} and {b}. Any indices returned by this function, either directly or via callback arguments, are 1-based.
对字符串 {a} 和 {b} 运行 diff。此函数返回的任何索引 直接或通过 callback 参数，都是从 1 开始的。

Examples:  例子：

vim.diff('a\n', 'b\nc\n')
-- =>
-- @@ -1 +1,2 @@
-- -a
-- +b
-- +c
vim.diff('a\n', 'b\nc\n', {result_type = 'indices'})
-- =>
-- {
--   {1, 1, 1, 2}
-- }

(string|integer[][]?) See {opts.result_type}. nil if {opts.on_hunk} is given.
（字符串|整数[][]？）参见 {opts.result_type}。如果 nil {opts.on_hunk} 给出。

VIM.MPACK  维姆.MPACK vim.mpack

This module provides encoding and decoding of Lua objects to and from msgpack-encoded strings. Supports vim.NIL and vim.empty_dict().
该模块提供 Lua 对象与 msgpack 编码字符串之间的编码和解码。支持 vim.NIL 和 vim.empty_dict（）。

vim.mpack.decode({str})
vim.mpack.decode（{str}）vim.mpack.decode()  vim.mpack.decode（）
Decodes (or "unpacks") the msgpack-encoded {str} to a Lua object.
将 msgpack 编码的 {str} 解码（或“解包”）为 Lua 对象。

(any)   （任意）

vim.mpack.encode({obj})
vim.mpack.encode（{obj}）vim.mpack.encode()  vim.mpack.encode（）
Encodes (or "packs") Lua object {obj} as msgpack in a Lua string.
将 Lua 对象 {obj} 编码（或“打包”）为 Lua 字符串中的 msgpack。

(string)   （字符串）

VIM.JSON vim.json

This module provides encoding and decoding of Lua objects to and from JSON-encoded strings. Supports vim.NIL and vim.empty_dict().
此模块提供 Lua 对象与 JSON 编码字符串之间的编码和解码。支持 vim.NIL 和 vim.empty_dict（）。

vim.json.decode({str}, {opts})
vim.json.decode（{str}， {opts}）vim.json.decode()  vim.json.decode（）
Decodes (or "unpacks") the JSON-encoded {str} to a Lua object.
将 JSON 编码的 {str} 解码（或“解包”）为 Lua 对象。

Example:  例：

vim.print(vim.json.decode('{"bar":[],"foo":{},"zub":null}'))
-- { bar = {}, foo = vim.empty_dict(), zub = vim.NIL }

(any)   （任意）

vim.json.encode({obj}, {opts})
vim.json.encode（{obj}， {opts}）vim.json.encode()  vim.json.encode（）
Encodes (or "packs") Lua object {obj} as JSON in a Lua string.
将 Lua 对象 {obj} 编码（或“打包”）为 Lua 字符串中的 JSON。

(string)   （字符串）

VIM.BASE64 vim.base64  vim.base64 的

vim.base64.decode({str})
vim.base64.decode（{str}）vim.base64.decode()  vim.base64.decode（）
Decode a Base64 encoded string.
解码 Base64 编码的字符串。

(string) Decoded string
（字符串）解码字符串

vim.base64.encode({str})
vim.base64.encode（{str}）vim.base64.encode()  vim.base64.encode（）
Encode {str} using Base64.
使用 Base64 对 {str} 进行编码。

(string) Encoded string
（字符串）编码字符串

VIM.SPELL vim.spell  vim.spell 命令

vim.spell.check({str})
vim.spell.check（{str}）vim.spell.check()  vim.spell.check（）
Check {str} for spelling errors. Similar to the Vimscript function spellbadword().
检查 {str} 是否有拼写错误。与 Vimscript 函数类似 spellbadword（） 的

Note: The behaviour of this function is dependent on: 'spelllang', 'spellfile', 'spellcapcheck' and 'spelloptions' which can all be local to the buffer. Consider calling this with nvim_buf_call().
注意：这个函数的行为取决于： 'spelllang'， 'spellfile'、'spellcapcheck' 和 'spelloptions' 都可以是缓冲区的本地。考虑使用 nvim_buf_call（） 调用此函数。

Example:  例：

vim.spell.check("the quik brown fox")
-- =>
-- {
--     {'quik', 'bad', 5}
-- }

([string, 'bad'|'rare'|'local'|'caps', integer][]) List of tuples with three items:
（ [string, 'bad'|'rare'|'local'|'caps', integer][] ） 元组列表 包含三项：

VIM vim.builtin  vim.内置

vim.api.{func}({...})
vim.api 的 API 中。{func}（{...}）vim.api
Invokes Nvim API function {func} with arguments {...}. Example: call the "nvim_get_current_line()" API function:
使用参数 {...} 调用 Nvim API 函数 {func}。 示例：调用 nvim_get_current_line（）） API 函数：

print(tostring(vim.api.nvim_get_current_line()))

vim.NIL vim.NIL
Special value representing NIL in RPC and v:null in Vimscript conversion, and similar cases. Lua nil cannot be used as part of a Lua table representing a Dictionary or Array, because it is treated as missing: {"foo", nil} is the same as {"foo"}.
在 RPC 中表示 NIL 和 Vimscript 中表示 v：null 的特殊值 conversion 和类似情况。Lua nil 不能用作 Lua 的一部分 table 表示 Dictionary 或 Array，因为它被视为 missing： {“foo”， nil} 与 {“foo”} 相同。

vim.type_idx vim.type_idx
Type index for use in lua-special-tbl. Specifying one of the values from vim.types allows typing the empty table (it is unclear whether empty Lua table represents empty list or empty array) and forcing integral numbers to be Float. See lua-special-tbl for more details.
键入 index 以在 lua-special-tbl 中使用。从 vim.types 允许输入空表（目前尚不清楚空 Lua table 表示空列表或空数组）并强制整数 设置为 Float。有关更多详细信息，请参阅 lua-special-tbl。

vim.val_idx vim.val_idx
Value index for tables representing Floats. A table representing floating-point value 1.0 looks like this:
表示 Float的表的值索引。表示 浮点值 1.0 如下所示：

{
  [vim.type_idx] = vim.types.float,
  [vim.val_idx] = 1.0,
}

See also vim.type_idx and lua-special-tbl.
另请参见 vim.type_idx 和 lua-special-tbl。

vim.types vim.types
Table with possible values for vim.type_idx. Contains two sets of key-value pairs: first maps possible values for vim.type_idx to human-readable strings, second maps human-readable type names to values for vim.type_idx. Currently contains pairs for float, array and dictionary types.
包含vim.type_idx的可能值的表。包含两组 键值对：首先将 vim.type_idx 的可能值映射到 人类可读的字符串，第二个将人类可读的类型名称映射到值 vim.type_idx。当前包含 float、array 和 dictionary 类型。

Note: One must expect that values corresponding to vim.types.float, vim.types.array and vim.types.dictionary fall under only two following assumptions: 1. Value may serve both as a key and as a value in a table. Given the properties of Lua tables this basically means “value is not nil”. 2. For each value in vim.types table vim.types[vim.types[value]] is the same as value. No other restrictions are put on types, and it is not guaranteed that values corresponding to vim.types.float, vim.types.array and vim.types.dictionary will not change or that vim.types table will only contain values for these three types.
注意：必须期望对应于 vim.types.float 的值， vim.types.array 和 vim.types.dictionary 仅属于以下两个假设：1. Value 在表中既可以用作键，也可以用作 value。考虑到 Lua 表的属性，这基本上意味着 “value is not nil”。2. 对于 vim.types 表中的每个值，vim.types[vim.types[value]] 与 value 相同。对类型没有其他限制，并且不能保证对应于 vim.types.float、vim.types.array 和 vim.types.dictionary 不会改变，或者 vim.types 表将只包含这三种类型的值。

log_levels vim.log.levels Log levels are one of the values defined in vim.log.levels:
log_levelsvim.log.levels 日志级别是 vim.log.levels 中定义的值之一：

vim.log.levels.DEBUG vim.log.levels.ERROR vim.log.levels.INFO vim.log.levels.TRACE vim.log.levels.WARN vim.log.levels.OFF

vim.empty_dict()   vim.empty_dict（）vim.empty_dict()  vim.empty_dict（）
Creates a special empty table (marked with a metatable), which Nvim converts to an empty dictionary when translating Lua values to Vimscript or API types. Nvim by default converts an empty table {} without this metatable to an list/array.
创建一个特殊的空表（用元表标记），该 Nvim 将 Lua 值转换为 Vimscript 时转换为空字典 或 API 类型。默认情况下，Nvim 会转换一个空表 {}，而不需要这个 metatable 转换为列表/数组。

Note: If numeric keys are present in the table, Nvim ignores the metatable marker and converts the dict to a list/array anyway.
注意：如果表中存在数字键，Nvim 会忽略元表标记并将 dict 转换为列表/数组。

(table)   （表）

vim.iconv({str}, {from}, {to})
vim.iconv（{str}， {from}， {to}）vim.iconv()  vim.iconv（）
The result is a String, which is the text {str} converted from encoding {from} to encoding {to}. When the conversion fails nil is returned. When some characters could not be converted they are replaced with "?". The encoding names are whatever the iconv() library function can accept, see ":Man 3 iconv".
结果是一个 String，它是从编码转换而来的文本 {str} {from} 进行编码 {to}。转换失败时，将返回 nil。什么时候 有些字符无法转换，它们被替换为 “？”。这 编码名称是 iconv（） 库函数可以接受的任何名称，请参阅 “：Man 3 iconv”.

(string?) Converted string if conversion succeeds, nil otherwise.
（字符串？如果转换成功，则转换字符串，否则为 nil。

vim.in_fast_event()   vim.in_fast_event（）vim.in_fast_event()  vim.in_fast_event（）
Returns true if the code is executing as part of a "fast" event handler, where most of the API is disabled. These are low-level events (e.g. lua-loop-callbacks) which can be invoked whenever Nvim polls for input. When this is false most API functions are callable (but may be subject to other restrictions such as textlock).
如果代码作为 “fast” 事件处理程序的一部分执行，则返回 true， 其中大多数 API 被禁用。这些是低级事件（例如 lua-loop-callbacks）每当 Nvim 轮询输入时都可以调用它。 当此值为 false 时，大多数 API 函数都是可调用的（但可能会受制于 更改为其他限制，例如 Textlock）。

vim.rpcnotify({channel}, {method}, {...})
vim.rpcnotify（{channel}， {method}， {...}）vim.rpcnotify()  vim.rpcnotify（）
Sends {event} to {channel} via RPC and returns immediately. If {channel} is 0, the event is broadcast to all channels.
通过 RPC 将 {event} 发送到 {channel} 并立即返回。如果 {channel} 为 0，则事件将广播到所有频道。

This function also works in a fast callback lua-loop-callbacks.
此函数也适用于快速回调 lua-loop-callbacks。

vim.rpcrequest({channel}, {method}, {...})
vim.rpcrequest（{channel}， {method}， {...}）vim.rpcrequest()  vim.rpcrequest（）
Sends a request to {channel} to invoke {method} via RPC and blocks until a response is received.
向 {channel} 发送请求，通过 RPC 调用 {method} 并阻塞，直到 收到响应。

Note: NIL values as part of the return value is represented as vim.NIL special value
注意：作为返回值一部分的 NIL 值表示为 vim.NIL 特殊值

vim.schedule({fn})
vim.schedule（{fn}）vim.schedule()  vim.schedule（）
Schedules {fn} to be invoked soon by the main event-loop. Useful to avoid textlock or other temporary restrictions.
安排 {fn} 很快由主事件循环调用。有助于避免 textlock 或其他临时限制。

vim.str_utf_end({str}, {index})
vim.str_utf_end（{str}， {index}）vim.str_utf_end()  vim.str_utf_end（）
Gets the distance (in bytes) from the last byte of the codepoint (character) that {index} points to.
获取距代码点最后一个字节的距离（以字节为单位） {index} 指向的 （字符） 的 intent 的

Examples:  例子：

-- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)
-- Returns 0 because the index is pointing at the last byte of a character
vim.str_utf_end('æ', 2)
-- Returns 1 because the index is pointing at the penultimate byte of a character
vim.str_utf_end('æ', 1)

(integer)   （整数）

vim.str_utf_pos({str})
vim.str_utf_pos（{str}）vim.str_utf_pos()  vim.str_utf_pos（）
Gets a list of the starting byte positions of each UTF-8 codepoint in the given string.
获取 given 字符串。

Embedded NUL bytes are treated as terminating the string.
嵌入的 NUL 字节被视为终止字符串。

(integer[])   （整数[]）

vim.str_utf_start({str}, {index})
vim.str_utf_start（{str}， {index}）vim.str_utf_start()  vim.str_utf_start（）
Gets the distance (in bytes) from the starting byte of the codepoint (character) that {index} points to.
获取距代码点起始字节的距离（以字节为单位） {index} 指向的 （字符） 的 intent 的

The result can be added to {index} to get the starting byte of a character.
可以将结果添加到 {index} 以获取字符的起始字节。

Examples:  例子：

-- The character 'æ' is stored as the bytes '\xc3\xa6' (using UTF-8)
-- Returns 0 because the index is pointing at the first byte of a character
vim.str_utf_start('æ', 1)
-- Returns -1 because the index is pointing at the second byte of a character
vim.str_utf_start('æ', 2)

(integer)   （整数）

vim.stricmp({a}, {b})
vim.stricmp（{a}， {b}）vim.stricmp()  vim.stricmp（）
Compares strings case-insensitively.
比较不区分大小写的字符串。

(0|1|-1) if strings are equal, {a} is greater than {b} or {a} is lesser than {b}, respectively.
（0|1|-1） 如果字符串相等，则 {a} 大于 {b} 或 {a} 为 小于 {b}。

vim.ui_attach({ns}, {options}, {callback})
vim.ui_attach（{ns}， {options}， {callback}）vim.ui_attach()  vim.ui_attach（）
WARNING: This feature is experimental/unstable.
警告：此功能是实验性的/不稳定的。

Attach to ui-events, similar to nvim_ui_attach() but receive events as Lua callback. Can be used to implement screen elements like popupmenu or message handling in Lua.
附加到 ui-events，类似于 nvim_ui_attach（），但作为 Lua 回调接收事件。可用于在 Lua 中实现 popupmenu 或消息处理等屏幕元素。

{options} should be a dictionary-like table, where ext_... options should be set to true to receive events for the respective external element.
{options} 应该是一个类似字典的表格，其中 ext_... options 应该设置为 true 来接收相应 external 元素的事件。

{callback} receives event name plus additional parameters. See ui-popupmenu and the sections below for event format for respective events.
{callback} 接收事件名称和其他参数。看 ui-popup菜单和以下部分，了解相应事件的事件格式。

Callbacks for msg_show events are executed in api-fast context; showing the message should be scheduled.
msg_show 事件的回调在 api-fast 上下文中执行;应安排显示消息。

Excessive errors inside the callback will result in forced detachment.
回调中的错误过多将导致强制分离。

WARNING: This api is considered experimental. Usability will vary for different screen elements. In particular ext_messages behavior is subject to further changes and usability improvements. This is expected to be used to handle messages when setting 'cmdheight' to zero (which is likewise experimental).
警告：此 api 被视为实验性 API。可用性会因不同的屏幕元素而异。特别是ext_messages行为可能会进一步更改和可用性改进。当将 'cmdheight' 设为 0 时，这应该被用来处理消息（这同样是实验性的）。

Example (stub for a ui-popupmenu implementation):
示例（ui-popupmenu 实现的存根）：

ns = vim.api.nvim_create_namespace('my_fancy_pum')
vim.ui_attach(ns, {ext_popupmenu=true}, function(event, ...)
  if event == "popupmenu_show" then
    local items, selected, row, col, grid = ...
    print("display pum ", #items)
  elseif event == "popupmenu_select" then
    local selected = ...
    print("selected", selected)
  elseif event == "popupmenu_hide" then
    print("FIN")
  end
end)

vim.ui_detach({ns})
vim.ui_detach（{ns}）vim.ui_detach()  vim.ui_detach（）
Detach a callback previously attached with vim.ui_attach() for the given namespace {ns}.
分离之前使用 vim.ui_attach（） 为给定 命名空间 {ns} 中。

vim.wait({time}, {callback}, {interval}, {fast_only})
vim.wait（{时间}， {回调}， {间隔}， {fast_only}）vim.wait()  vim.wait（）
Wait for {time} in milliseconds until {callback} returns true.
等待 {time} （以毫秒为单位），直到 {callback} 返回 true。

Executes {callback} immediately and at approximately {interval} milliseconds (default 200). Nvim still processes other events during this time.
立即执行 {callback}，大约每 {interval} 毫秒（默认为 200）。在此期间，Nvim 仍会处理其他事件。

Cannot be called while in an api-fast event.
在 api-fast 事件中无法调用。

Examples:  例子：

---
-- Wait for 100 ms, allowing other events to process
vim.wait(100, function() end)
---
-- Wait for 100 ms or until global variable set.
vim.wait(100, function() return vim.g.waiting_for_var end)
---
-- Wait for 1 second or until global variable set, checking every ~500 ms
vim.wait(1000, function() return vim.g.waiting_for_var end, 500)
---
-- Schedule a function to set a value in 100ms
vim.defer_fn(function() vim.g.timer_result = true end, 100)
-- Would wait ten seconds if results blocked. Actually only waits  100 ms
if vim.wait(10000, function() return vim.g.timer_result end) then
  print('Only waiting a little bit of time!')
end

(boolean) (-1|-2?)
（布尔值） （-1|-2？）

LUA-VIMSCRIPT BRIDGE  LUA-VIMSCRIPT 桥 lua-vimscript  lua-vimscript 文件

Nvim Lua provides an interface or "bridge" to Vimscript variables and functions, and editor commands and options.
Nvim Lua 为 Vimscript 变量和函数以及编辑器命令和选项提供了一个接口或“桥梁”。

Objects passed over this bridge are COPIED (marshalled): there are no "references". lua-guide-variables For example, using vim.fn.remove() on a Lua list copies the list object to Vimscript and does NOT modify the Lua list:
通过此网桥传递的对象将 COPYED（编组）：没有 “参考资料”。lua-guide-变量例如，在 Lua 列表上使用 vim.fn.remove（） 会将列表对象复制到 Vimscript，并且不会修改 Lua 列表：

local list = { 1, 2, 3 }
vim.fn.remove(list, 0)
vim.print(list)  --> "{ 1, 2, 3 }"

vim.call({func}, {...})
vim.call（{func}， {...}）vim.call()  vim.call（）
Invokes vim-function or user-function {func} with arguments {...}. See also vim.fn. Equivalent to:
调用带有参数 {...} 的 vim-function 或 user-function{func}。 另请参见 vim.fn。 相当于：

vim.fn[func]({...})

vim.cmd({command}) See vim.cmd().
vim.cmd（{command}） 参见 vim.cmd（）。

vim.fn.{func}({...})
vim.fn 的{func}（{...}）vim.fn
Invokes vim-function or user-function {func} with arguments {...}. To call autoload functions, use the syntax:
调用带有参数 {...} 的 vim-function 或 user-function{func}。 要调用 autoload 函数，请使用以下语法：

vim.fn['some#function']({...})

Unlike vim.api.|nvim_call_function()| this converts directly between Vim objects and Lua objects. If the Vim function returns a float, it will be represented directly as a Lua number. Empty lists and dictionaries both are represented by an empty table.
与 vim.api.|nvim_call_function（）|这会直接在 Vim 对象和 Lua 对象之间转换。如果 Vim 函数返回一个浮点数，它将直接表示为 Lua 数字。空列表和字典都由空表表示。

Note: v:null values as part of the return value is represented as vim.NIL special value
注意：v：null 值作为返回值的一部分表示为 vim.NIL 特殊值

Note: vim.fn keys are generated lazily, thus pairs(vim.fn) only enumerates functions that were called at least once.
注意： vim.fn 键是懒惰生成的，因此 pairs（vim.fn） 只枚举至少被调用过一次的函数。

Note: The majority of functions cannot run in api-fast callbacks with some undocumented exceptions which are allowed.
注意：大多数函数无法在 api-fast 回调中运行，但允许一些未记录的异常。

lua-vim-variables  lua-vim-变量
The Vim editor global dictionaries g: w: b: t: v: can be accessed from Lua conveniently and idiomatically by referencing the vim.* Lua tables described below. In this way you can easily read and modify global Vimscript variables from Lua.
Vim 编辑器全局词典 g：w：b：t：v： 可以通过引用 vim.* Lua 表格，方便、地道地从 Lua 访问 如下所述。通过这种方式，您可以轻松读取和修改全局 Vimscript 变量。

Example:  例：

vim.g.foo = 5     -- Set the g:foo Vimscript variable.
print(vim.g.foo)  -- Get and print the g:foo Vimscript variable.
vim.g.foo = nil   -- Delete (:unlet) the Vimscript variable.
vim.b[2].foo = 6  -- Set b:foo for buffer 2

Note that setting dictionary fields directly will not write them back into Nvim. This is because the index into the namespace simply returns a copy. Instead the whole dictionary must be written as one. This can be achieved by creating a short-lived temporary.
请注意，直接设置字典字段不会将它们写回 Nvim。这是因为命名空间的索引只返回一个副本。相反，整个词典必须写成一个。这可以通过创建一个短期临时变量来实现。

Example:  例：

vim.g.my_dict.field1 = 'value'  -- Does not work
local my_dict = vim.g.my_dict   --
my_dict.field1 = 'value'        -- Instead do
vim.g.my_dict = my_dict         --

vim.g vim.g
Global (g:) editor variables. Key with no value returns nil.
全局 （g：） 编辑器变量。 没有值的 Key 返回 nil。

vim.b vim.b
Buffer-scoped (b:) variables for the current buffer. Invalid or unset key returns nil. Can be indexed with an integer to access variables for a specific buffer.
当前缓冲区的缓冲区范围 （b：） 变量。 无效或未设置的键返回 nil。可以使用 一个整数，用于访问特定缓冲区的变量。

vim.w vim.w
Window-scoped (w:) variables for the current window. Invalid or unset key returns nil. Can be indexed with an integer to access variables for a specific window.
当前窗口的窗口范围 （w：） 变量。 无效或未设置的键返回 nil。可以使用 一个整数，用于访问特定窗口的变量。

vim.t vim.t
Tabpage-scoped (t:) variables for the current tabpage. Invalid or unset key returns nil. Can be indexed with an integer to access variables for a specific tabpage.
当前标签页的 Tabpage 范围 （t：） 变量。 无效或未设置的键返回 nil。可以使用 一个整数，用于访问特定标签页的变量。

vim.v vim.v
v: variables. Invalid or unset key returns nil.
v：变量。 无效或未设置的键返回 nil。

lua-options  lua-选项
lua-vim-options  lua-vim-选项
lua-vim-set  lua-vim-集
lua-vim-setlocal  lua-vim-set本地

Vim options can be accessed through vim.o, which behaves like Vimscript :set.
Vim 选项可以通过 vim.o 访问，它的行为类似于 Vimscript ：set 的

To set a boolean toggle: Vimscript: set number Lua: vim.o.number = true
设置布尔值切换： Vimscript： set number Lua： vim.o.number = true

To set a string value: Vimscript: set wildignore=*.o,*.a,__pycache__ Lua: vim.o.wildignore = '*.o,*.a,__pycache__'
设置字符串值： Vimscript： set wildignore=*.o,*.a,__pycache__ Lua： vim.o.wildignore = '*.o,*.a,__pycache__'

Similarly, there is vim.bo and vim.wo for setting buffer-scoped and window-scoped options. Note that this must NOT be confused with local-options and :setlocal. There is also vim.go that only accesses the global value of a global-local option, see :setglobal.
同样，有 vim.bo 和 vim.wo 用于设置 buffer-scoped 和 窗口范围的选项。请注意，这不能与 local-options 和 ：setlocal 的还有 vim.go 只访问 global-local 选项的 global 值，参见 ：setglobal。

vim.opt_local
vim.opt_global
vim.opt

A special interface vim.opt exists for conveniently interacting with list- and map-style options from Lua: It allows accessing them as Lua tables and offers object-oriented method for adding and removing entries.
存在一个特殊的接口 vim.opt，可以方便地与 Lua 中的列表和映射样式选项进行交互：它允许以 Lua 表格的形式访问它们，并提供面向对象的方法来添加和删除条目。

The following methods of setting a list-style option are equivalent: In Vimscript:
以下设置 list-style 选项的方法等效： 在 Vimscript 中：

set wildignore=*.o,*.a,__pycache__

In Lua using vim.o:
在 Lua 中使用 vim.o：

vim.o.wildignore = '*.o,*.a,__pycache__'

In Lua using vim.opt:
在 Lua 中使用 vim.opt：

vim.opt.wildignore = { '*.o', '*.a', '__pycache__' }

To replicate the behavior of :set+=, use:
要复制 ：set+= 的行为，请使用：

vim.opt.wildignore:append { "*.pyc", "node_modules" }

To replicate the behavior of :set^=, use:
要复制 ：set^= 的行为，请使用：

vim.opt.wildignore:prepend { "new_first_value" }

To replicate the behavior of :set-=, use:
要复制 ：set-= 的行为，请使用：

vim.opt.wildignore:remove { "node_modules" }

The following methods of setting a map-style option are equivalent: In Vimscript:
以下设置地图样式选项的方法等效： 在 Vimscript 中：

set listchars=space:_,tab:>~

In Lua using vim.o:
在 Lua 中使用 vim.o：

vim.o.listchars = 'space:_,tab:>~'

In Lua using vim.opt:
在 Lua 中使用 vim.opt：

vim.opt.listchars = { space = '_', tab = '>~' }

Note that vim.opt returns an Option object, not the value of the option, which is accessed through vim.opt:get():
请注意，vim.opt 返回一个 Option 对象，而不是 option 的值，可通过 vim.opt：get（） 访问：

The following methods of getting a list-style option are equivalent: In Vimscript:
以下获取列表样式选项的方法等效： 在 Vimscript 中：

echo wildignore

In Lua using vim.o:
在 Lua 中使用 vim.o：

print(vim.o.wildignore)

In Lua using vim.opt:
在 Lua 中使用 vim.opt：

vim.print(vim.opt.wildignore:get())

In any of the above examples, to replicate the behavior :setlocal, use vim.opt_local. Additionally, to replicate the behavior of :setglobal, use vim.opt_global.
在上述任何示例中，要复制行为 ：setlocal，请使用 vim.opt_local。此外，要复制 ：setglobal 的行为，请使用 vim.opt_global。

Option:append({value})
选项：append（{value}）vim.opt:append()  vim.opt：append（）
Append a value to string-style options. See :set+=
将值附加到字符串样式选项。参见 ：set+=

These are equivalent:  这些是等效的：

vim.opt.formatoptions:append('j')
vim.opt.formatoptions = vim.opt.formatoptions + 'j'

Option:get()   选项：get（）vim.opt:get()  vim.opt：get（）
Returns a Lua-representation of the option. Boolean, number and string values will be returned in exactly the same fashion.
返回选项的 Lua 表示形式。布尔值、数字和字符串 值将以完全相同的方式返回。

For values that are comma-separated lists, an array will be returned with the values as entries in the array:
对于逗号分隔列表的值，将返回一个数组，其中包含 值作为数组中的条目：

vim.cmd [[set wildignore=*.pyc,*.o]]
vim.print(vim.opt.wildignore:get())
-- { "*.pyc", "*.o", }
for _, ignore_pattern in ipairs(vim.opt.wildignore:get()) do
    print("Will ignore:", ignore_pattern)
end
-- Will ignore: *.pyc
-- Will ignore: *.o

For values that are comma-separated maps, a table will be returned with the names as keys and the values as entries:
对于逗号分隔的映射值，将返回一个表格，其中包含 名称作为键，值作为条目：

vim.cmd [[set listchars=space:_,tab:>~]]
vim.print(vim.opt.listchars:get())
--  { space = "_", tab = ">~", }
for char, representation in pairs(vim.opt.listchars:get()) do
    print(char, "=>", representation)
end

For values that are lists of flags, a set will be returned with the flags as keys and true as entries.
对于作为标志列表的值，将返回一个包含标志的集合 作为键，true 作为条目。

vim.cmd [[set formatoptions=njtcroql]]
vim.print(vim.opt.formatoptions:get())
-- { n = true, j = true, c = true, ... }
local format_opts = vim.opt.formatoptions:get()
if format_opts.j then
    print("J is enabled!")
end

(string|integer|boolean?) value of option
（字符串|整数|布尔值？）期权价值

Option:prepend({value})
Option：prepend（{value}）vim.opt:prepend()  vim.opt：prepend（）
Prepend a value to string-style options. See :set^=
在字符串样式选项前面加上一个值。参见 ：set^=

These are equivalent:  这些是等效的：

vim.opt.wildignore:prepend('*.o')
vim.opt.wildignore = vim.opt.wildignore ^ '*.o'

Option:remove({value})
选项：remove（{value}）vim.opt:remove()  vim.opt：remove（）
Remove a value from string-style options. See :set-=
从 string-style 选项中删除值。参见 ：set-=

These are equivalent:  这些是等效的：

vim.opt.wildignore:remove('*.pyc')
vim.opt.wildignore = vim.opt.wildignore - '*.pyc'

vim.bo[{bufnr}] vim.bo
Get or set buffer-scoped options for the buffer with number {bufnr}. Like :setlocal. If {bufnr} is omitted then the current buffer is used. Invalid {bufnr} or key is an error.
为编号为 {bufnr} 的缓冲区获取或设置缓冲区范围的选项。 就像 ：setlocal 一样。如果省略 {bufnr}，则使用当前缓冲区。 无效的 {bufnr} 或 key 是错误。

Example:  例：

local bufnr = vim.api.nvim_get_current_buf()
vim.bo[bufnr].buflisted = true    -- same as vim.bo.buflisted = true
print(vim.bo.comments)
print(vim.bo.baz)                 -- error: invalid key

vim.env   vim.env 中vim.env  vim.env 中
Environment variables defined in the editor session. See expand-env and :let-environment for the Vimscript behavior. Invalid or unset key returns nil.
在 Editor 会话中定义的环境变量。请参阅 expand-env 和 ：let-environment 的 Vimscript 行为。键无效或未设置 返回 nil。

Example:  例：

vim.env.FOO = 'bar'
print(vim.env.TERM)

vim.go vim.go
Get or set global options. Like :setglobal. Invalid key is an error.
获取或设置全局选项。就像 ：setglobal 一样。无效的密钥是错误的。

Note: this is different from vim.o because this accesses the global option value and thus is mostly useful for use with global-local options.
注意：这与 vim.o 不同，因为它会访问全局选项值，因此在与 global-local 一起使用时非常有用 选项。

Example:  例：

vim.go.cmdheight = 4
print(vim.go.columns)
print(vim.go.bar)     -- error: invalid key

vim.o vim.o
Get or set options. Works like :set, so buffer/window-scoped options target the current buffer/window. Invalid key is an error.
获取或设置选项。工作方式类似于 ：set，因此 buffer/window 范围的选项 以当前缓冲区/窗口为目标。无效的密钥是错误的。

Example:  例：

vim.o.cmdheight = 4
print(vim.o.columns)
print(vim.o.foo)     -- error: invalid key

vim.wo[{winid}][{bufnr}] vim.wo
Get or set window-scoped options for the window with handle {winid} and buffer with number {bufnr}. Like :setlocal if setting a global-local option or if {bufnr} is provided, like :set otherwise. If {winid} is omitted then the current window is used. Invalid {winid}, {bufnr} or key is an error.
获取或设置具有句柄 {winid} 和 编号为 {bufnr} 的缓冲区。就像 ：setlocal 如果设置 global-local 选项，或者如果提供了 {bufnr}，则否则为 ：set。如果 {winid} 为 省略，则使用当前窗口。无效的 {winid}、{bufnr} 或密钥 是一个错误。

Note: only {bufnr} with value 0 (the current buffer in the window) is supported.
注意：仅支持值为 0 （窗口中的当前缓冲区） 的 {bufnr}。

Example:  例：

local winid = vim.api.nvim_get_current_win()
vim.wo[winid].number = true    -- same as vim.wo.number = true
print(vim.wo.foldmarker)
print(vim.wo.quux)             -- error: invalid key
vim.wo[winid][0].spell = false -- like ':setlocal nospell'

Lua module: vim  Lua 模块：vim lua-vim

vim.cmd({command})
vim.cmd（{command}）vim.cmd()  vim.cmd（）
Executes Vimscript (Ex-commands).
执行 Vimscript （Ex-commands）。

Note that vim.cmd can be indexed with a command name to return a callable function to the command.
请注意，可以使用命令名称对 vim.cmd 进行索引，以将可调用函数返回给命令。

Example:  例：

vim.cmd('echo 42')
vim.cmd([[
  augroup My_group
    autocmd!
    autocmd FileType c setlocal cindent
  augroup END
]])
-- Ex command :echo "foo"
-- Note string literals need to be double quoted.
vim.cmd('echo "foo"')
vim.cmd { cmd = 'echo', args = { '"foo"' } }
vim.cmd.echo({ args = { '"foo"' } })
vim.cmd.echo('"foo"')
-- Ex command :write! myfile.txt
vim.cmd('write! myfile.txt')
vim.cmd { cmd = 'write', args = { "myfile.txt" }, bang = true }
vim.cmd.write { args = { "myfile.txt" }, bang = true }
vim.cmd.write { "myfile.txt", bang = true }
-- Ex command :colorscheme blue
vim.cmd('colorscheme blue')
vim.cmd.colorscheme('blue')

vim.defer_fn({fn}, {timeout})
vim.defer_fn（{fn}， {timeout}）vim.defer_fn()  vim.defer_fn（）
Defers calling {fn} until {timeout} ms passes.
推迟调用 {fn}，直到 {timeout} 毫秒过去。

Use to do a one-shot timer that calls {fn} Note: The {fn} is vim.schedule_wrap()ped automatically, so API functions are safe to call.
用于执行调用 {fn} 的一次性计时器 注意：{fn} 是 vim.schedule_wrap（）ped 的 API 函数，因此可以安全地调用 API 函数。

(table) timer luv timer object
（表） 计时器 LUV 计时器对象

vim.deprecate()  vim.deprecate（）
vim.deprecate({name}, {alternative}, {version}, {plugin}, {backtrace}) Shows a deprecation message to the user.
vim.deprecate（{名称}， {alternative}， {版本}， {plugin}， {backtrace}） 向用户显示弃用消息。

(string?) Deprecated message, or nil if no message was shown.
（字符串？ 已弃用的消息，如果未显示任何消息，则为 nil。

vim.inspect()   vim.inspect（）vim.inspect()  vim.inspect（）
Gets a human-readable representation of the given object.
获取给定对象的人类可读表示形式。

(string)   （字符串）

vim.keycode({str})
vim.keycode（{str}）vim.keycode()  vim.keycode（）
Translates keycodes.   翻译键码。

Example:  例：

local k = vim.keycode
vim.g.mapleader = k'<bs>'

(string)   （字符串）

vim.lua_omnifunc({find_start})
vim.lua_omnifunc（{find_start}）vim.lua_omnifunc()  vim.lua_omnifunc（）
Omnifunc for completing Lua values from the runtime Lua interpreter, similar to the builtin completion for the :lua command.
Omnifunc 用于从运行时 Lua 解释器完成 Lua 值， 类似于 ：lua 命令的内置补全。

Activate using set omnifunc=v:lua.vim.lua_omnifunc in a Lua buffer.
在 Lua 缓冲区中激活 using set omnifunc=v:lua.vim.lua_omnifunc 。

vim.notify({msg}, {level}, {opts})
vim.notify（{msg}， {level}， {opts}）vim.notify()  vim.notify（）
Displays a notification to the user.
向用户显示通知。

This function can be overridden by plugins to display notifications using a custom provider (such as the system notification provider). By default, writes to :messages.
插件可以覆盖此函数，以使用自定义提供程序（例如系统通知提供程序）显示通知。默认情况下，写入 ：messages。

vim.notify_once({msg}, {level}, {opts})
vim.notify_once（{msg}， {level}， {opts}）vim.notify_once()  vim.notify_once（）
Displays a notification only one time.
通知仅显示一次。

Like vim.notify(), but subsequent calls with the same message will not display a notification.
与 vim.notify（） 类似，但具有相同消息的后续调用不会显示通知。

(boolean) true if message was displayed, else false
（布尔值）如果显示消息，则为 true，否则为 false

vim.on_key({fn}, {ns_id}, {opts})
vim.on_key（{fn}， {ns_id}， {opts}）vim.on_key()  vim.on_key（）
Adds Lua function {fn} with namespace id {ns_id} as a listener to every, yes every, input key.
将命名空间 ID 为 {ns_id} 的 Lua 函数 {fn} 添加为每个 是的，每个，输入键。

The Nvim command-line option -w is related but does not support callbacks and cannot be toggled dynamically.
Nvim 命令行选项 -w 是相关的，但不支持回调，也无法动态切换。

(integer) Namespace id associated with {fn}. Or count of all callbacks if on_key() is called without arguments.
（整数）与 {fn} 关联的命名空间 ID。或 count of all callbacks （如果 on_key（） 被调用时不带参数）。

vim.paste({lines}, {phase})
vim.paste（{行}， {phase}）vim.paste()  vim.paste（）
Paste handler, invoked by nvim_paste().
Paste 处理程序，由 nvim_paste（） 调用。

Note: This is provided only as a "hook", don't call it directly; call nvim_paste() instead, which arranges redo (dot-repeat) and invokes vim.paste.
注意：这仅作为 “钩子” 提供，不要直接调用它;叫 nvim_paste（） 来代替它，它安排重做（点重复）并调用 vim.paste 中。

Example: To remove ANSI color codes when pasting:
示例：要在粘贴时删除 ANSI 颜色代码：

vim.paste = (function(overridden)
  return function(lines, phase)
    for i,line in ipairs(lines) do
      -- Scrub ANSI color codes from paste input.
      lines[i] = line:gsub('\27%[[0-9;mK]+', '')
    end
    return overridden(lines, phase)
  end
end)(vim.paste)

(boolean) result false if client should cancel the paste.
（boolean） 结果 如果客户端应取消粘贴，则为 false。

vim.print({...})
vim.print（{...}）vim.print()  vim.print（）
"Pretty prints" the given arguments and returns them unmodified.
“Pretty 打印” 给定的参数并返回它们。

Example:  例：

local hl_normal = vim.print(vim.api.nvim_get_hl(0, { name = 'Normal' }))

(any) given arguments.
（any） 给定的参数。

vim.schedule_wrap({fn})
vim.schedule_wrap（{fn}）vim.schedule_wrap()  vim.schedule_wrap（）
Returns a function which calls {fn} via vim.schedule().
返回一个通过 vim.schedule（） 调用 {fn} 的函数。

The returned function passes all arguments to {fn}.
返回的函数将所有参数传递给 {fn}。

Example:  例：

function notify_readable(_err, readable)
  vim.notify("readable? " .. tostring(readable))
end
vim.uv.fs_access(vim.fn.stdpath("config"), "R", vim.schedule_wrap(notify_readable))

(function)   （功能）

vim.str_byteindex()  vim.str_byteindex（）
vim.str_byteindex({s}, {encoding}, {index}, {strict_indexing}) Convert UTF-32, UTF-16 or UTF-8 {index} to byte index. If {strict_indexing} is false then then an out of range index will return byte length instead of throwing an error.
vim.str_byteindex（{s}， {encoding}， {index}， {strict_indexing}） 将 UTF-32、UTF-16 或 UTF-8 {index} 转换为字节索引。如果 {strict_indexing} 为 false，则超出范围的索引将返回 字节长度，而不是引发错误。

Invalid UTF-8 and NUL is treated like in vim.str_utfindex(). An {index} in the middle of a UTF-16 sequence is rounded upwards to the end of that sequence.
无效的 UTF-8 和 NUL 的处理方式与 vim.str_utfindex（） 中的处理方式相同。UTF-16 序列中间的 {index} 向上舍入到该序列的末尾。

(integer)   （整数）

vim.str_utfindex()  vim.str_utfindex（）
vim.str_utfindex({s}, {encoding}, {index}, {strict_indexing}) Convert byte index to UTF-32, UTF-16 or UTF-8 indices. If {index} is not supplied, the length of the string is used. All indices are zero-based.
vim.str_utfindex（{s}， {encoding}， {index}， {strict_indexing}） 将字节索引转换为 UTF-32、UTF-16 或 UTF-8 索引。如果 {index} 不是 提供字符串的长度。所有索引都从零开始。

If {strict_indexing} is false then an out of range index will return string length instead of throwing an error. Invalid UTF-8 bytes, and embedded surrogates are counted as one code point each. An {index} in the middle of a UTF-8 sequence is rounded upwards to the end of that sequence.
如果 {strict_indexing} 为 false，则超出范围的索引将返回字符串长度，而不是引发错误。无效的 UTF-8 字节和嵌入的代理项各计为 1 个码位。UTF-8 序列中间的 {index} 向上舍入到该序列的末尾。

(integer)   （整数）

vim.system({cmd}, {opts}, {on_exit})
vim.system（{cmd}， {opts}， {on_exit}）vim.system()  vim.system（）
Runs a system command or throws an error if {cmd} cannot be run.
运行系统命令，如果 {cmd} 无法运行，则引发错误。

Examples:  例子：

local on_exit = function(obj)
  print(obj.code)
  print(obj.signal)
  print(obj.stdout)
  print(obj.stderr)
end
-- Runs asynchronously:
vim.system({'echo', 'hello'}, { text = true }, on_exit)
-- Runs synchronously:
local obj = vim.system({'echo', 'hello'}, { text = true }):wait()
-- { code = 0, signal = 0, stdout = 'hello\n', stderr = '' }

See uv.spawn() for more details. Note: unlike uv.spawn(), vim.system throws an error if {cmd} cannot be run.
有关更多详细信息，请参阅 uv.spawn（） 。 注意：与 uv.spawn（） 不同，如果 {cmd} 无法运行，vim.system 会抛出错误。

(vim.SystemObj) Object with the fields:
（vim.SystemObj）Object 的字段：

Lua module: vim.inspector  Lua 模块：vim.inspector vim.inspector  vim.inspector 命令

vim.inspect_pos({bufnr}, {row}, {col}, {filter})
vim.inspect_pos（{bufnr}， {row}， {col}， {filter}）vim.inspect_pos()  vim.inspect_pos（）
Get all the items at a given buffer position.
获取给定缓冲区位置的所有项目。

Can also be pretty-printed with :Inspect!.
也可以使用 ：Inspect！ 进行漂亮打印。:Inspect!  ：检查！

Since: 0.9.0   从：0.9.0 开始

(table) a table with the following key-value pairs. Items are in "traversal order":
（table） 一个包含以下键值对的表。项目在 “遍历顺序”：

vim.show_pos({bufnr}, {row}, {col}, {filter})
vim.show_pos（{bufnr}， {row}， {col}， {filter}）vim.show_pos()  vim.show_pos（）
Show all the items at a given buffer position.
显示给定缓冲区位置的所有项目。

Can also be shown with :Inspect.
也可以用 ：Inspect 显示。:Inspect  ：检查

Example: To bind this function to the vim-scriptease inspired zS in Normal mode:
示例：若要将此函数绑定到 vim-scriptease 启发的 zS 正常模式：

vim.keymap.set('n', 'zS', vim.show_pos)

Since: 0.9.0   从：0.9.0 开始

vim.Ringbuf

Ringbuf:clear()   Ringbuf：clear（）Ringbuf:clear()  Ringbuf：clear（）
Clear all items   清除所有项目

Ringbuf:peek()   Ringbuf：peek（）Ringbuf:peek()  Ringbuf：peek（）
Returns the first unread item without removing it
返回第一个未读项目，而不将其删除

(any?)   （任何？

Ringbuf:pop()   ringbuf：pop（）Ringbuf:pop()  ringbuf：pop（）
Removes and returns the first unread item
删除并返回第一个未读项目

(any?)   （任何？

Ringbuf:push({item})
Ringbuf：push（{item}）Ringbuf:push()  ringbuf：push（）
Adds an item, overriding the oldest item if the buffer is full.
添加一个项，如果缓冲区已满，则覆盖最早的项。

vim.deep_equal({a}, {b})
vim.deep_equal（{a}， {b}）vim.deep_equal()  vim.deep_equal（）
Deep compare values for equality
深度比较相等值

Tables are compared recursively unless they both provide the eq metamethod. All other types are compared using the equality == operator.
表以递归方式进行比较，除非它们都提供 eq 元方法。使用相等 == 运算符比较所有其他类型。

(boolean) true if values are equals, else false
（布尔值）如果值等于，则为 true，否则为 false

vim.deepcopy({orig}, {noref})
vim.deepcopy（{orig}， {noref}）vim.deepcopy()  vim.deepcopy（）
Returns a deep copy of the given object. Non-table objects are copied as in a typical Lua assignment, whereas table objects are copied recursively. Functions are naively copied, so functions in the copied table point to the same functions as those in the input table. Userdata and threads are not copied and will throw an error.
返回给定对象的深层副本。非表对象将复制为 在典型的 Lua 赋值中，而 table 对象是递归复制的。 函数是天真地复制的，因此复制的表中的函数指向 与 Input Table 中的功能相同。Userdata 和 threads 是 未复制，将引发错误。

Note: noref=true is much more performant on tables with unique table fields, while noref=false is more performant on tables that reuse table fields.
注意：noref=true 在具有唯一表字段的表上性能要高得多，而 noref=false 在重用表字段的表上性能更高。

(table) Table of copied keys and (nested) values.
（表）复制的键和（嵌套）值的表。

vim.defaulttable({createfn})
vim.defaulttable（{createfn}）vim.defaulttable()  vim.defaulttable（）
Creates a table whose missing keys are provided by {createfn} (like Python's "defaultdict").
创建一个表，其缺失的键由 {createfn} 提供（如 Python 的 “defaultdict” 的 “defaultdict” 的

If {createfn} is nil it defaults to defaulttable() itself, so accessing nested keys creates nested tables:
如果 {createfn} 为 nil，则默认为 defaulttable（） 本身，因此访问 嵌套键创建嵌套表：

local a = vim.defaulttable()
a.b.c = 1

(table) Empty table with __index metamethod.
（表）带有 __index metamethod 的空表。

vim.endswith({s}, {suffix})
vim.endswith（{s}， {后缀}）vim.endswith()  vim.endswith（）
Tests if s ends with suffix.
测试 s 是否以 suffix 结尾。

(boolean) true if suffix is a suffix of s
（布尔值）如果 suffix 是 s 的后缀，则为 true

vim.gsplit({s}, {sep}, {opts})
vim.gsplit（{s}， {sep}， {opts}）vim.gsplit()  vim.gsplit（）
Gets an iterator that splits a string at each instance of a separator, in "lazy" fashion (as opposed to vim.split() which is "eager").
获取一个迭代器，该迭代器在分隔符的每个实例处拆分字符串， 以 “懒惰” 的方式（而不是 “eager” 的 vim.split（） ）。

Example:  例：

for s in vim.gsplit(':aa::b:', ':', {plain=true}) do
  print(s)
end

If you want to also inspect the separator itself (instead of discarding it), use string.gmatch(). Example:
如果您还想检查分隔符本身（而不是丢弃 it），请使用 string.gmatch（）。例：

for word, num in ('foo111bar222'):gmatch('([^0-9]*)(%d*)') do
  print(('word: %s num: %s'):format(word, num))
end

(fun():string?) Iterator over the split components
（fun（）：string？）拆分组件上的 Iterator

vim.is_callable({f})
vim.is_callable（{f}）vim.is_callable()  vim.is_callable（）
Returns true if object f can be called as a function.
如果对象 f 可以作为函数调用，则返回 true。

(boolean) true if f is callable, else false
（布尔值）如果 f 是可调用的，则为 true，否则为 false

vim.isarray({t})
vim.isarray（{t}）vim.isarray()  vim.isarray（）
Tests if t is an "array": a table indexed only by integers (potentially non-contiguous).
测试 t 是否为“数组”：仅由整数索引的表（可能 non-contiguous） 的 Package。

If the indexes start from 1 and are contiguous then the array is also a list. vim.islist()
如果索引从 1 开始并且是连续的，则数组也是一个列表。vim.islist（）

Empty table {} is an array, unless it was created by vim.empty_dict() or returned as a dict-like API or Vimscript result, for example from rpcrequest() or vim.fn.
空表 {} 是一个数组，除非它是由 vim.empty_dict（） 创建的或作为类似 dict 的 API 或 Vimscript 结果返回的，例如从 rpcrequest（） 或 vim.fn 的

(boolean) true if array-like table, else false.
（布尔值）如果是类似数组的表，则为 true，否则为 false。

vim.islist({t})   vim.islist（{t}）vim.islist()  vim.islist（）
Tests if t is a "list": a table indexed only by contiguous integers starting from 1 (what lua-length calls a "regular array").
测试 t 是否为 “list”：仅由连续整数索引的表 从 1 开始（Lua-Length 称为 “常规数组”）。

Empty table {} is a list, unless it was created by vim.empty_dict() or returned as a dict-like API or Vimscript result, for example from rpcrequest() or vim.fn.
空表 {} 是一个列表，除非它是由 vim.empty_dict（） 创建的或作为类似 dict 的 API 或 Vimscript 结果返回的，例如 rpcrequest（） 或 vim.fn 的

(boolean) true if list-like table, else false.
（布尔值）如果是类似列表的表，则为 true，否则为 false。

vim.list_contains({t}, {value})
vim.list_contains（{t}， {value}）vim.list_contains()  vim.list_contains（）
Checks if a list-like table (integer keys without gaps) contains value.
检查列表状表（无间隙的整数键）是否包含 value。

(boolean) true if t contains value
（布尔值）如果 t 包含值，则为 true

vim.list_extend({dst}, {src}, {start}, {finish})
vim.list_extend（{dst}， {src}， {start}， {finish}）vim.list_extend()  vim.list_extend（）
Extends a list-like table with the values of another list-like table.
使用另一个类似列表的表的值扩展一个类似列表的表。

NOTE: This mutates dst!
注意：这会改变 dst！

(table) dst   （表） DST

vim.list_slice({list}, {start}, {finish})
vim.list_slice（{list}， {start}， {finish}）vim.list_slice()  vim.list_slice（）
Creates a copy of a table containing only elements from start to end (inclusive)
创建仅包含从头到尾元素的表的副本 （含）

(any[]) Copy of table sliced from start to finish (inclusive)
（任何[]）从头到尾（含）切片的表副本

vim.pesc({s})   vim.pesc（{s}）vim.pesc()  vim.pesc（）
Escapes magic chars in lua-patterns.
转义 lua 模式中的 magic chars。

(string) %-escaped pattern string
（string） % 转义的模式字符串

vim.ringbuf({size})
vim.ringbuf（{大小}）vim.ringbuf()  vim.ringbuf（）
Create a ring buffer limited to a maximal number of items. Once the buffer is full, adding a new entry overrides the oldest entry.
创建一个限制为最大项目数的环形缓冲区。一旦缓冲区 已满，则添加新条目将覆盖最早的条目。

local ringbuf = vim.ringbuf(4)
ringbuf:push("a")
ringbuf:push("b")
ringbuf:push("c")
ringbuf:push("d")
ringbuf:push("e")    -- overrides "a"
print(ringbuf:pop()) -- returns "b"
print(ringbuf:pop()) -- returns "c"
-- Can be used as iterator. Pops remaining items:
for val in ringbuf do
  print(val)
end

Returns a Ringbuf instance with the following methods:
返回一个 Ringbuf 实例，方法如下：

(vim.Ringbuf) ringbuf See vim.Ringbuf.
（vim.Ringbuf） ringbuf 参见 vim.Ringbuf.

vim.spairs({t})   vim.spairs（{t}）vim.spairs()  vim.spairs（）
Enumerates key-value pairs of a table, ordered by key.
枚举表的键值对，按键排序。

(fun(table: table<K, V>, index?: K):K, V) for-in iterator over sorted keys and their values (table)
（ fun(table: table<K, V>, index?: K):K, V ） for-in 迭代器 over 排序的 Key 及其值 （表）

vim.split({s}, {sep}, {opts})
vim.split（{s}， {sep}， {opts}）vim.split()  vim.split（）
Splits a string at each instance of a separator and returns the result as a table (unlike vim.gsplit()).
在分隔符的每个实例处拆分字符串，并将结果返回为 一个表（与 vim.gsplit（） 不同）。

Examples:  例子：

split(":aa::b:", ":")                   --> {'','aa','','b',''}
split("axaby", "ab?")                   --> {'','x','y'}
split("x*yz*o", "*", {plain=true})      --> {'x','yz','o'}
split("|x|y|z|", "|", {trimempty=true}) --> {'x', 'y', 'z'}

(string[]) List of split components
（字符串[]）拆分组件列表

vim.startswith({s}, {prefix})
vim.startswith（{s}， {prefix}）vim.startswith()  vim.startswith（）
Tests if s starts with prefix.
测试 s 是否以 prefix 开头。

(boolean) true if prefix is a prefix of s
（布尔值）如果 prefix 是 s 的前缀，则为 true