代码拉取完成，页面将自动刷新
VSCode Neovim Integration
Neovim is a fork of Vim to allow greater extensibility and integration. This extension uses a fully embedded Neovim instance, no more half-complete Vim emulation! VSCode's native functionality is used for insert mode and VSCode commands, making the best use of both editors.
![github-actions[bot]-](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAAAXNSR0IArs4c6QAAAARzQklUCAgICHwIZIgAAADUSURBVDhPY1Rfl/CfgYqAcdRAikNzNAxRg1CcQ5ChRCeUwUxUg4GTmZ3hwrs7DF2XVzLc+fwMZ1jjDENWRmaG9c5NDAdeXGRYdGcXw9c/PxgMhJQZ7MT1GNovLyfdQGsxbYYi7VCG4P0NJMU8TheGKdgzmIpoMJSemQk2sM80k8FLxozhw68vDBZbc6njQi5gOO7z6CHPQPQwfP/zM4M6vyzDbOsiBsuteaS7EKQDFsvmopoMXCzsDNc+PGKYdG0dw5m3t8gzkKTYgCoezXrkhBqqHgAoYGglOfP1xQAAAABJRU5ErkJggg==){kind=small}
init.lua and most Nvim plugins.Table of Contents
Install the vscode-neovim extension.
Install Neovim 0.10.0 or greater.
Note: Though the extension strives to be as compatible as possible with older versions of Neovim, some older versions may have quirks that are not present anymore. In light of this, certain configuration settings are recommended in some older versions for the best experience. These can be found on the wiki.
[Optional] Set the Neovim path in the extension settings under
"vscode-neovim.neovimExecutablePaths.win32/linux/darwin", respective to your system. For example,
"C:\Neovim\bin\nvim.exe" or "/usr/local/bin/nvim".
WSL Users: If you want to use Neovim from WSL, set the
useWSLconfiguration toggle and specify the Linux path to the nvim binary.wsl.exeWindows binary andwslpathLinux binary are required for this.wslpathmust be available through$PATHLinux env setting. Usewsl --listto check for the correct default Linux distribution.Snap Users: If you want to use Neovim from Snap, the Neovim path must be resolved to the snap binary location. On some systems it might be "
/snap/nvim/current/usr/bin/nvim". To check if you're running as a snap package, see ifwhich nvimresolves to/usr/bin/snap.
Since many Vim plugins can cause issues in VSCode, it is recommended to start from an empty init.vim. For a guide for
which types of plugins are supported, see troubleshooting.
Before creating an issue on Github, make sure you can reproduce the problem with an empty init.vim and no VSCode
extensions.
To determine if Neovim is running in VSCode, add to your init.vim:
if exists('g:vscode')
" VSCode extension
else
" ordinary Neovim
endif
In lua:
if vim.g.vscode then
-- VSCode extension
else
-- ordinary Neovim
end
To conditionally activate plugins, the best solution is to use the
LazyVim VSCode extra. However, packer.nvim and lazy.nvim have built-in
support for cond = vim.g.vscode and vim-plug has a
few solutions. See
plugins in the wiki for tips on configuring Vim plugins.
You can view all available settings and commands by opening the vscode-neovim extension details pane, and navigating to the features tab.
:e/:q/:vsplit/:tabnext/etc are mapped to corresponding VSCode
commands and behavior may be different (see below).
:e in scripts/keybindings, they won't work. If you're using them in some custom
commands/mappings, you might need to rebind them to call VSCode commands from Neovim with
require('vscode').call() (see API).:w, :wa and :sav commands are supported and no longer alias to VSCode commands. You
can use them as you would in Neovim.abc<cursor> in insert mode, then move the cursor to a<cursor>bc and type 1 here
the repeat sequence would be 1. However, in VSCode, it would be a1bc. Another difference is that when you delete
some text in insert mode, dot repeat only works from right to left, meaning it will treat Del key as
BS keys when running dot repeat.Output: Focus on Output View and select vscode-neovim logs.
Debug, then click it again and choose
Set As Default.vscode-neovim.neovimClean in VSCode settings, which starts Nvim without your plugins (nvim --clean). Nvim
plugins can do anything. Visual effects in particular can cause visual artifacts. vscode-neovim does its best to
merge the visual effects of Nvim and VSCode, but it's far from perfect. You may need to disable some Nvim plugins that
cause visual effects.Unable to init vscode-neovim: command 'type' already exists message, uninstall other VSCode
extensions that use registerTextEditorCommand("type", …) (like
VSCodeVim or
Overtype).defaults write com.microsoft.VSCode ApplePressAndHoldEnabled -bool false."keyboard.dispatch": "keyCode".Developer: Toggle Keyboard Shortcuts Troubleshooting for tracing VSCode emitted keypresses and their processing
via defined keybindings.Developer: Inspect Key Mapping for getting the recognized mappings for the current keyboard layout inside
VSCode.If you have any performance problems (cursor jitter usually) make sure you're not using vim plugins that increase latency and cause performance problems.
Make sure to disable unneeded plugins, as many of them don't make sense with VSCode. Specifically, you don't need any code highlighting, completion, LSP plugins, or plugins that spawn windows/buffers (nerdtree , fuzzy-finders, etc). Most navigation/textobject/editing plugins should be fine.
For example, make sure you're not using anything that renders decorators very often:
If you're not sure, disable all other extensions, reload VSCode window, and see if the problem persists before reporting it.
Set with compositeKeys and tweak with compositeTimeout.
Examples: add to your settings.json:
jj to escape
{
"vscode-neovim.compositeKeys": {
"jj": {
"command": "vscode-neovim.escape",
},
},
}
jk to escape and save
{
"vscode-neovim.compositeKeys": {
"jk": {
// Use lua to execute any logic
"command": "vscode-neovim.lua",
"args": [
[
"local code = require('vscode')",
"code.action('vscode-neovim.escape')",
"code.action('workbench.action.files.save')",
],
],
},
},
}
VSCode's jumplist is used instead of Neovim's. This is to make VSCode native navigation (mouse click, jump to definition, etc) navigable through the jumplist.
Make sure to bind to workbench.action.navigateBack / workbench.action.navigateForward if you're using custom
mappings. Marks (both upper & lowercased) should work fine.
Multiple cursors work in:
To spawn multiple cursors from visual line/block modes type ma/mA or mi/mI (by default). The effect differs:
See gif in action:
Note: The built-in multi-cursor support may not meet your needs. Please refer to the plugin vscode-multi-cursor.nvim for more multi-cursor features
We intend to use vscode-neovim as a UI extension, so when you're using remote development, vscode-neovim is enabled in the Local Extension Host, and it should work out of the box.
If you prefer to use the remote environment's copy of Neovim, rather than the locally installed one, vscode-neovim
should be installed in the Remote Extension Host. You can set the following in your VSCode settings.json:
{
"remote.extensionKind": {
"asvetliakov.vscode-neovim": ["workspace"]
}
}
Note: You will need to install neovim in the remote environment.
For more information:
Load the module:
local vscode = require('vscode')
[!TIP] The previously used module named "vscode-neovim" is now deprecated, so don't be confused if "vscode-neovim" is used in old discussions or other resources.
vscode.action(): asynchronously executes a vscode command.vscode.call(): synchronously executes a vscode command.vscode.on(): defines a handler for some Nvim UI events.vscode.has_config(): checks if a vscode setting exists.vscode.get_config(): gets a vscode setting value.vscode.update_config(): sets a vscode setting.vscode.notify(): shows a vscode message (see also Nvim's vim.notify).vscode.to_op(): A helper for map-operator. See code_actions.lua for the
usageg:vscode_clipboard: Clipboard provider using VSCode's clipboard API. Used by default when in WSL. See
:h g:clipboard for more details. Usage: vim.g.clipboard = vim.g.vscode_clipboardvscode.eval(): evaluate javascript synchronously in vscode and return the resultvscode.eval_async(): evaluate javascript asynchronously in vscodevscode.with_insert(): perform operations in insert mode.Asynchronously executes a vscode command.
Parameters:
name (string): The name of the action, generally a vscode command.opts (table): Map of optional parameters:
args (table): List of arguments passed to the vscode command. If the command only requires a single object
parameter, you can directly pass in a map-like table.
action('foo', { args = { 'foo', 'bar', … } })action('foo', { args = { foo = bar, … } })range (table): Specific range for the action. Implicitly passed in visual mode. Has three possible forms (all
values are 0-indexed):
[start_line, end_line][start_line, start_character, end_line, end_character]{start = { line = start_line, character = start_character}, end = { line = end_line, character = end_character}}restore_selection (boolean): Whether to preserve the current selection. Only valid when range is specified.
Defaults to true.callback: Function to handle the action result. Must have this signature: function(err: string|nil, ret: any):
err is the error message, if anyret is the resultExample: open definition aside (default binding):
nnoremap <C-w>gd <Cmd>lua require('vscode').action('editor.action.revealDefinitionAside')<CR>
Example: find in files for word under cursor (see the vscode command definition for the expected parameter format):
nnoremap ? <Cmd>lua require('vscode').action('workbench.action.findInFiles', { args = { query = vim.fn.expand('<cword>') } })<CR>
Example: use in lua script:
-- Format current document
vscode.action("editor.action.formatDocument")
do -- Comment the three lines below the cursor
local curr_line = vim.fn.line(".") - 1 -- 0-indexed
vscode.action("editor.action.commentLine", {
range = { curr_line + 1, curr_line + 3 },
})
end
do -- Comment the previous line
local curr_line = vim.fn.line(".") - 1 -- 0-indexed
local prev_line = curr_line - 1
if prev_line >= 0 then
vscode.action("editor.action.commentLine", {
range = { prev_line , prev_line },
})
end
end
do -- Find in files for word under cursor
vscode.action("workbench.action.findInFiles", {
args = { query = vim.fn.expand('<cword>') }
})
end
Currently, two built-in actions are provided for testing purposes:
_ping returns "pong"_wait waits for the specified milliseconds and then returns "ok"do -- Execute _ping asynchronously and print the result
vscode.action("_ping", {
callback = function(err, res)
if err == nil then
print(res) -- outputs: pong
end
end,
})
end
Synchronously executes a vscode command.
Parameters:
name (string): The name of the action, generally a vscode command.opts (table): Same as vscode.action().timeout (number): Timeout in milliseconds. The default value is -1, which means there is no timeout.Returns: the result of the action
Example: format selection (default binding):
xnoremap = <Cmd>lua require('vscode').call('editor.action.formatSelection')<CR>
nnoremap = <Cmd>lua require('vscode').call('editor.action.formatSelection')<CR><Esc>
nnoremap == <Cmd>lua require('vscode').call('editor.action.formatSelection')<CR>
Example: use in lua script:
-- Execute _ping synchronously and print the result
print(vscode.call("_ping")) -- outputs: pong
-- Wait for 1 second and print the return value 'ok'
print(vscode.call("_wait", { args = { 1000 } })) -- outputs: ok
-- Wait for 2 seconds with a timeout of 1 second
print(vscode.call("_wait", { args = { 2000 } }), 1000)
-- error: Call '_wait' timed out
Currently no available events for user use.
Check if configuration has a certain value.
Parameters:
name (string|string[]): The configuration name or an array of configuration names.Returns:
boolean|boolean[]: Returns true if the configuration has a certain value, false otherwise. If name is an
array, returns an array of booleans indicating whether each configuration has a certain value or not.Examples:
-- Check if the configuration "not.exist" exists
print(vscode.has_config("not.exist"))
-- Should return: false
-- Check multiple configurations
vim.print(vscode.has_config({ "not.exist", "existing.config" }))
-- Should return: { false, true }
Get configuration value.
Parameters:
name (string|string[]): The configuration name or an array of configuration names.Returns:
unknown|unknown[]: The value of the configuration. If name is an array, returns an array of values corresponding
to each configuration.Examples:
-- Get the value of "editor.tabSize"
print(vscode.get_config("editor.tabSize")) -- a number
-- Get multiple configurations
vim.print(vscode.get_config({ "editor.fontFamily", "editor.tabSize" }))
-- Should return: { "the font family", "the editor tabSizse" }
Update configuration value.
Parameters:
name (string|string[]): The configuration name or an array of configuration names.value (unknown|unknown[]): The new value for the configuration.target ("global"|"workspace"|"workspace_folder"): The configuration target. Optional, defaults to
"workspace_folder".Examples:
-- Update the value of "editor.tabSize"
vscode.update_config("editor.tabSize", 16, "global")
-- Update multiple configurations
vscode.update_config({ "editor.fontFamily", "editor.tabSize" }, { "Fira Code", 14 })
Show a vscode notification
You can set vscode.notify as your default notify function.
vim.notify = vscode.notify
Evaluate javascript inside vscode and return the result. The code is executed in an async function context (so await
can be used). Use a return statement to return a value back to lua. Arguments passed from lua are available as the
args variable. The evaluated code has access to the
VSCode API through the vscode global.
Tips:
await on asynchronous functions when accessing the API.logger (e.g. logger.info(...)) to log messages to the output of vscode-neovim.globalThis['some_name'] = ... can be used to persist values between calls.Parameters:
code (string): The javascript to execute.opts (table): Map of optional parameters:
args (any): a value to make available as the args variable in javascript. Can be a single value such as a
string or a table of multiple values.timeout (number): The number of milliseconds to wait for the evaluation to complete before cancelling. By default
there is no timeout.Returns:
Examples:
local current_file = vscode.eval("return vscode.window.activeTextEditor.document.fileName")
local current_tab_is_pinned = vscode.eval("return vscode.window.tabGroups.activeTabGroup.activeTab.isPinned")
vscode.eval("await vscode.env.clipboard.writeText(args.text)", { args = { text = "some text" } })
Like vscode.eval() but returns immediately and evaluates in the background instead.
Parameters:
code (string): The javascript to execute.opts (table): Map of optional parameters:
args (any): a value to make available as the args variable in javascript. Can be a single value such as a
string or a table of multiple values.callback: Function to handle the eval result. Must have this signature: function(err: string|nil, ret: any):
err is the error message, if anyret is the resultPerform operations in insert mode. If in visual mode, this function will preserve the selection after switching to insert mode.
Parameters:
callback (function): Callback function to run after switching to insert modems (number, optional): Milliseconds to defer the callback. Defaults to 30.Example: make editor.action.addSelectionToNextFindMatch work correctly in any mode.
vim.keymap.set({ "n", "x", "i" }, "<C-d>", function()
vscode.with_insert(function()
vscode.action("editor.action.addSelectionToNextFindMatch")
end)
end)
Example: make "editor.action.refactor" work correctly on the selection and support snippet manipulation after entering VSCode snippet mode.
vim.keymap.set({ "n", "x" }, "<leader>r", function()
vscode.with_insert(function()
vscode.action("editor.action.refactor")
end)
end)
vim.ui: use VSCode's UI components.vim.lsp.buf: execute corresponding VSCode LSP commands.Note: Since 1.0.0, vimscript functions are deprecated. Use the Lua api instead.
VSCodeNotify()/VSCodeCall(): deprecated, use Lua require('vscode').call() instead.VSCodeNotifyRange()/VSCodeCallRange(): deprecated, use Lua
require('vscode').call(…, {range:…}) instead.VSCodeNotifyRangePos()/VSCodeCallRangePos(): deprecated, use Lua
require('vscode').call(…, {range:…}) instead.You can also use v:lua.require("vscode") to access the API from VimScript.
There are three types of default/user keybindings:
init.vim file. These provide code navigation, buffer management, and other neovim-specific overrides.package.json or the user's
keybindings.json file. These provide the ability to interact with VSCode's built-in features, and are used to make
VSCode more Vim-like.package.json or
the user's keybindings.json file, but simply pass the keypress through to Neovim. These are used to allow Neovim to
handle certain keypresses that would otherwise be handled by VSCode.This document only mentions some special cases, it is not an exhaustive list of keybindings and commands. Use VSCode and Nvim features to see documentation and all defined shortcuts:
Preferences: Open Keyboard Shortcuts vscode command and search for "neovim" to see all vscode and
passthrough keybindings.:help command to see the documentation for a given neovim command or keybinding. For example try
:help :split or :help zo.
:help for <C-…> bindings is spelled CTRL-…. For example to see the help for <c-w>, run
:help CTRL-W.Every special (control/alt/non-alphanumerical) keyboard shortcut must be explicitly defined in VSCode to send to neovim. By default, only bindings that are used by Neovim by default are sent.
Note: if you want to pass additional control keys without adding a custom passthrough, see below.
To add a custom passthrough, for example A-h in normal mode, add to your keybindings.json:
{
"command": "vscode-neovim.send",
// Invoke the binding with this key sequence.
"key": "alt+h",
// Don't activate during insert mode.
// Docs for "when": https://code.visualstudio.com/api/references/when-clause-contexts
"when": "editorTextFocus && neovim.mode != insert",
// Send this input to Neovim.
"args": "<A-h>",
}
Set by vscode-neovim.ctrlKeysForInsertMode.
Default: ["a", "d", "h", "j", "m", "o", "r", "t", "u", "w"]
Set by ctrlKeysForNormalMode.
Default:
["a", "b", "d", "e", "f", "h", "i", "j", "k", "l", "m", "o", "r", "t", "u", "v", "w", "x", "y", "z", "/", "]"]
Always enabled.
<C-h> <C-w> <C-u> <C-n> <C-p> <C-l> <C-g> <C-t><C-r> prefixed keysSet by editorLangIdExclusions.
Disable keybindings defined by this extension in certain filetypes. Please note that this will not affect all keybindings.
If the above configuration flags do not provide enough control, you can remove the keybindings by editing your
keybindings.json or using the VSCode keybindings editor:
| Key | VSCode Command |
|---|---|
| = / == | editor.action.formatSelection |
| gh / K | editor.action.showHover |
| gd / C-] | editor.action.revealDefinition Also works in vim help. |
| gf | editor.action.revealDeclaration |
| gH | editor.action.referenceSearch.trigger |
| gO | workbench.action.gotoSymbol |
| C-w gd / C-w gf | editor.action.revealDefinitionAside |
| gD | editor.action.peekDefinition |
| gF | editor.action.peekDeclaration |
| Tab | togglePeekWidgetFocus Switch between peek editor and reference list. |
| C-n / C-p | Navigate lists, parameter hints, suggestions, quick-open, cmdline history, peek reference list |
💡 To specify the default peek mode, modify
editor.peekWidgetDefaultFocusin your settings.
| Key | VSCode Command |
|---|---|
| j or k | list.focusDown/Up |
| h or l | list.collapse/select |
| Enter | list.select |
| gg | list.focusFirst |
| G | list.focusLast |
| o | list.toggleExpand |
| C-u or C-d | list.focusPageUp/Down |
| zo or zO | list.expand |
| zc | list.collapse |
| zC | list.collapseAllToFocus |
| za or zA | list.toggleExpand |
| zm or zM | list.collapseAll |
| / or Escape | list.toggleKeyboardNavigation |
| Key | VSCode Command |
|---|---|
| r | renameFile |
| d | deleteFile |
| y | filesExplorer.copy |
| x | filesExplorer.cut |
| p | filesExplorer.paste |
| v | explorer.openToSide |
| a | explorer.newFile |
| A | explorer.newFolder |
| R | workbench.files.action.refreshFilesExplorer |
| Key | VSCode Command |
|---|---|
| K | editor.action.showHover |
| h | editor.action.scrollLeftHover |
| j | editor.action.scrollDownHover |
| k | editor.action.scrollUpHover |
| l | editor.action.scrollRightHover |
| gg | editor.action.goToTopHover |
| G | editor.action.goToBottomHover |
| C-f | editor.action.pageDownHover |
| C-b | editor.action.pageUpHover |
Default commands and bindings are available for file/scroll/window/tab management.
See vscode-file-commands.vim for file commands reference.
The extension aliases various Nvim commands (:edit, :enew, :find, :quit, etc.) to equivalent vscode commands.
Also their normal-mode equivalents (where applicable) such as C-w q, etc.
See vscode-tab-commands.vim for tab commands reference.
The extension aliases various Nvim tab commands (:tabedit, :tabnew, :tabfind, :tabclose, :tabnext,
:tabprevious, :tabfirst, :tablast) to equivalent vscode commands. Also their normal-mode equivalents (where
applicable) such as gt, etc.
See vscode-window-commands.vim for file commands reference.
The extension aliases various Nvim buffer/window commands (:split, :vsplit, :new, :vnew, :only) to equivalent
vscode commands. Also their normal-mode equivalents (where applicable) such as C-w s, etc.
💡 Split size distribution is controlled by
workbench.editor.splitSizingsetting. By default, it'sdistribute, which is equal to vim'sequalalwaysandeadirection = 'both'(default).
To use VSCode command 'Increase/decrease current view size' instead of separate bindings for width and height:
workbench.action.increaseViewSizeworkbench.action.decreaseViewSizefunction! s:manageEditorSize(...)
let count = a:1
let to = a:2
for i in range(1, count ? count : 1)
call VSCodeNotify(to ==# 'increase' ? 'workbench.action.increaseViewSize' : 'workbench.action.decreaseViewSize')
endfor
endfunction
" Sample keybindings. Note these override default keybindings mentioned above.
nnoremap <C-w>> <Cmd>call <SID>manageEditorSize(v:count, 'increase')<CR>
xnoremap <C-w>> <Cmd>call <SID>manageEditorSize(v:count, 'increase')<CR>
nnoremap <C-w>+ <Cmd>call <SID>manageEditorSize(v:count, 'increase')<CR>
xnoremap <C-w>+ <Cmd>call <SID>manageEditorSize(v:count, 'increase')<CR>
nnoremap <C-w>< <Cmd>call <SID>manageEditorSize(v:count, 'decrease')<CR>
xnoremap <C-w>< <Cmd>call <SID>manageEditorSize(v:count, 'decrease')<CR>
nnoremap <C-w>- <Cmd>call <SID>manageEditorSize(v:count, 'decrease')<CR>
xnoremap <C-w>- <Cmd>call <SID>manageEditorSize(v:count, 'decrease')<CR>
There are two ways to customize highlight colors:
Set colors in nvim
Note: Due to the support for the syntax option requiring processing of syntax highlights, all built-in
highlight groups may be overridden or cleared. Therefore, please do not link any highlights to the built-in
highlight groups.
Set colors in vscode
Please see CONTRIBUTING.md for details on how to contribute to this project.
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
马建仓 AI 助手