Nvim:help pages,generated fromsource using thetree-sitter-vimdoc parser.
:map <F2> a<C-R>=strftime("%c")<CR><Esc>This appends the current date and time after the cursor (in <> notation<>).{lhs}{rhs}mapmode-nvo:map{lhs}{rhs}mapmode-n:nm:nmap:vm[ap]{lhs}{rhs}mapmode-v:vm:vmap:xm[ap]{lhs}{rhs}mapmode-x:xm:xmap:smap{lhs}{rhs}mapmode-s:smap{lhs}{rhs}mapmode-o:om:omap:map!{lhs}{rhs}mapmode-ic:map!{lhs}{rhs}mapmode-i:im:imap:lm[ap]{lhs}{rhs}mapmode-l:lm:lma:lmap:cm[ap]{lhs}{rhs}mapmode-c:cm:cmap:tma[p]{lhs}{rhs}mapmode-t:tma:tmapMap the key sequence{lhs} to{rhs} for the modeswhere the map command applies. The result, including{rhs}, is then further scanned for mappings. Thisallows for nested and recursive use of mappings.Note: Trailing spaces are included in the{rhs},because space is a valid Normal mode command.Seemap-trailing-white.{lhs}{rhs}mapmode-nvo:no:noremap:nor:nn[oremap]{lhs}{rhs}mapmode-n:nn:nnoremap:vn[oremap]{lhs}{rhs}mapmode-v:vn:vnoremap:xn[oremap]{lhs}{rhs}mapmode-x:xn:xnoremap:snor[emap]{lhs}{rhs}mapmode-s:snor:snore:snoremap:ono[remap]{lhs}{rhs}mapmode-o:ono:onoremap:no[remap]!{lhs}{rhs}mapmode-ic:no!:noremap!:ino[remap]{lhs}{rhs}mapmode-i:ino:inor:inoremap:ln[oremap]{lhs}{rhs}mapmode-l:ln:lnoremap:cno[remap]{lhs}{rhs}mapmode-c:cno:cnor:cnoremap:tno[remap]{lhs}{rhs}mapmode-t:tno:tnoremapMap the key sequence{lhs} to{rhs} for the modeswhere the map command applies. Disallow mapping of{rhs}, to avoid nested and recursive mappings. Oftenused to redefine a command.Note: Keys in{rhs} also won't trigger abbreviation,with the exception ofi_CTRL-] andc_CTRL-].Note: When<Plug> appears in the{rhs} this part isalways applied even if remapping is disallowed.{lhs}mapmode-nvo:unm:unmap:nun[map]{lhs}mapmode-n:nun:nunmap:vu[nmap]{lhs}mapmode-v:vu:vunmap:xu[nmap]{lhs}mapmode-x:xu:xunmap:sunm[ap]{lhs}mapmode-s:sunm:sunmap:ou[nmap]{lhs}mapmode-o:ou:ounmap:unm[ap]!{lhs}mapmode-ic:unm!:unmap!:iu[nmap]{lhs}mapmode-i:iu:iunmap:lu[nmap]{lhs}mapmode-l:lu:lunmap:cu[nmap]{lhs}mapmode-c:cu:cun:cunmap:tunma[p]{lhs}mapmode-t:tunma:tunmapRemove the mapping of{lhs} for the modes where themap command applies. The mapping may remain definedfor other modes where it applies.It also works when{lhs} matches the{rhs} of amapping. This is for when an abbreviation applied.Note: Trailing spaces are included in the{lhs}.Seemap-trailing-white.<buffer> argument to remove buffer-localmappings:map-<buffer>Warning: This also removes thedefault-mappings.{lhs}mapmode-nvo:map_l{lhs}mapmode-n:nmap_l{lhs}mapmode-v:vmap_l{lhs}mapmode-x:xmap_l{lhs}mapmode-s:smap_l{lhs}mapmode-o:omap_l{lhs}mapmode-ic:map_l!{lhs}mapmode-i:imap_l{lhs}mapmode-l:lmap_l{lhs}mapmode-c:cmap_l{lhs}mapmode-t:tmap_l{lhs} in the modes where the map command applies.:imap aa foo:imap aaa barWhen Vim has read "aa", it will need to get another character to be able todecide if "aa" or "aaa" should be mapped. This means that after typing "aa"that mapping won't get expanded yet, Vim is waiting for another character.If you type a space, then "foo" will get inserted, plus the space. If youtype "a", then "bar" will get inserted.
:map @@ foo:unmap @@ | printBecause it tries to unmap "@@ ", including the white space before the commandseparator "|". Other examples with trailing white space:
unmap @@ unmap @@ " commentAn error will be issued, which is very hard to identify, because the endingwhitespace character in
unmap @@ is not visible.unmap @@| " comment
:map <buffer> ,w /[.,;]<CR>Then you can map ",w" to something else in another buffer:
:map <buffer> ,w /[#&!]<CR>The local buffer mappings are used before the global ones. See
<nowait> belowto make a short local mapping not taking effect when a longer global oneexists.The "<buffer>" argument can also be used to clear mappings::unmap <buffer> ,w:mapclear <buffer>Local mappings are also cleared when a buffer is deleted, but not when it isunloaded. Just like local option values.Also seemap-precedence.
<nowait> argument. Then the mapping will be used when it matches, Vim doesnot wait for more characters to be typed. However, if the characters werealready typed they are used.Note that this works when the<nowait> mapping fully matches and is foundbefore any partial matches. This works when::map <silent> ,h /Header<CR>The search string will not be echoed when using this mapping. Messages fromthe executed command are still given though. To shut them up too, add a":silent" in the executed command:
:map <silent> ,h :exe ":silent normal /Header\r"<CR>Note that the effect of a command might also be silenced, e.g., when themapping selects another entry for command line completion it won't bedisplayed.Prompts will still be given, e.g., for inputdialog().Using "<silent>" for an abbreviation is possible, but will cause redrawing ofthe command line to fail.
{rhs} using mappings that were defined local to a script, starting with"<SID>". This can be used to avoid that mappings from outside a scriptinterfere (e.g., whenCTRL-V is remapped in mswin.vim), but do use othermappings defined in the script.Note: ":map<script>" and ":noremap<script>" do the same thing. The"<script>" overrules the command name. Using ":noremap<script>" ispreferred, because it's clearer that remapping is (mostly) disabled.:map <unique> ,w /[#&!]<CR>When defining a local mapping, there will also be a check if a global mapalready exists which is equal.Example of what will fail:
:map ,w /[#&!]<CR>:map <buffer> <unique> ,w /[.,;]<CR>If you want to map a key and then have it do what it was originally mapped to,have a look atmaparg().
{rhs} that is used. Example::inoremap <expr> . <SID>InsertDot()The result of the s:InsertDot() function will be inserted. It could check thetext before the cursor and start omni completion when some condition is met.Using a script-local function is preferred, to avoid polluting the globalnamespace. Use
<SID> in the RHS so that the script that the mapping wasdefined in can be found.{lhs}. Youshould not either insert or change the v:char.func StoreColumn() let g:column = col('.') return 'x'endfuncnnoremap <expr> x StoreColumn()nmap ! f!xYou will notice that g:column has the value from before executing "f!",because "x" is evaluated before "f!" is executed.This can be solved by inserting<Ignore> before the character that isexpression-mapped:nmap ! f!<Ignore>xBe very careful about side effects! The expression is evaluated whileobtaining characters, you may very well make the command dysfunctional.Therefore the following is blocked for
<expr> mappings:inoremap <expr> <C-L> nr2char(getchar())inoremap <expr> <C-L>x "foo"If you now type
CTRL-L nothing happens yet, Vim needs the next character todecide what mapping to use. If you type 'x' the second mapping is used and"foo" is inserted. If you type any other key the first mapping is used,getchar() gets the typed key and returns it.let counter = 0inoremap <expr> <C-L> ListItem()inoremap <expr> <C-R> ListReset()func ListItem() let g:counter += 1 return g:counter .. '. 'endfuncfunc ListReset() let g:counter = 0 return ''endfuncCTRL-L inserts the next number,
CTRL-R resets the count.CTRL-R returns anempty string, so that nothing is inserted.<Cmd> pseudokey begins a "command mapping", which executes the commanddirectly without changing modes. Where you might use ":...<CR>" in the{rhs} of a mapping, you can instead use "<Cmd>...<CR>".Example:noremap x <Cmd>echo mode(1)<CR>
:<C-U> in Visual and Operator-pending mode, or<C-O>: in Insert mode, because the commands are executed directly in thecurrent mode, instead of always going to Normal mode. Visual mode ispreserved, so tricks withgv are not needed. Commands can be invokeddirectly in Command-line mode (which would otherwise require timer hacks).Example of using<Cmd> halfway Insert mode:nnoremap <F3> aText <Cmd>echo mode(1)<CR> Added<Esc>Unlike
<expr> mappings, there are no special restrictions on the<Cmd>command: it is executed as if an (unrestricted)autocommand was invokedor an async event was processed.<Cmd> avoids mode-changes (unlike ":") it does not triggerCmdlineEnter andCmdlineLeave events. This helps performance.<silent>.{rhs} is not subject to abbreviations nor to other mappings, even if the mapping is recursive.line('v') andcol('v') to get one end of the Visual area, the cursor is at the other end.<Cmd> commands must terminate, that is, they must be followed by<CR> in the{rhs} of the mapping definition.Command-line mode is never entered. To usea literal<CR> in the{rhs}, use<lt>.:omap { wmakes "y{" work like "yw" and "d{" like "dw".onoremap <silent> F :<C-U>normal! 0f(hviw<CR>The
CTRL-U (<C-U>) is used to remove the range that Vim may insert. TheNormal mode commands find the first '(' character and select the first wordbefore it. That usually is the function name.:map xx something-difficult:ounmap xxLikewise for a mapping for Visual and Operator-pending mode or Normal andOperator-pending mode.
CTRL-^ commandi_CTRL-^c_CTRL-^. These commands change the value ofthe'iminsert' option. When starting to enter a normal command line (not asearch pattern) the mappings are disabled until aCTRL-^ is typed. The statelast used is remembered for Insert mode and Search patterns separately. Thestate for Insert mode is also used when typing a character as an argument tocommand like "f" or "t". Language mappings will never be applied to already mapped characters. Theyare only used for typed characters. This assumes that the language mappingwas already done when typing the mapping. Correspondingly, language mappingsare applied when recording macros, rather than when applying them.<Space>Normal, Visual, Select and Operator-pendingnNormalvVisual and SelectsSelectxVisualoOperator-pending!Insert and Command-lineiInsertl":lmap" mappings for Insert, Command-line and Lang-ArgcCommand-linetTerminal-Job{rhs} a special character can appear:*indicates that it is not remappable&indicates that only script-local mappings are remappable@indicates a buffer-local mapping{lhs} up to the end of the line(or '|') is considered to be part of{rhs}. This allows the{rhs} to endwith a space.{lhs} and{rhs} in the raw form. If adescription was added usingnvim_set_keymap() ornvim_buf_set_keymap()then the pattern is also matched against it.:verbose map <C-W>*n <C-W>* * <C-W><C-S>* Last set from ~/.config/nvim/init.vimSee:verbose-cmd for more information.
CTRL-K and then hit the function key, or use the form "<F2>", "<F10>","<Up>", "<S-Down>", "<S-F7>", etc. (see table of keyskey-notation, all keysfrom<Up> can be used).CTRL-V is mentioned here as a special character for mappingsand abbreviations. When'cpoptions' does not contain 'B', a backslash canalso be used likeCTRL-V. The <> notation can be fully used then<>. Butyou cannot use "<C-V>" likeCTRL-V to escape the special meaning of whatfollows.{rhs}, the specialsequence "<Bslash>" can be used. This avoids the need to double backslasheswhen using nested mappings.CTRL-C in the{lhs} is possible, but it will only work when Vim iswaiting for a key, not when Vim is busy with something. When Vim is busyCTRL-C interrupts/breaks the command.When using the GUI version on MS-WindowsCTRL-C can be mapped to allow a Copycommand to the clipboard. UseCTRL-Break to interrupt Vim.{lhs} precede it with aCTRL-V (type twoCTRL-Vs foreach space).map_space_in_rhsmap-space_in_rhsIf you want a{rhs} that starts with a space, use "<Space>". To be fully Vicompatible (but unreadable) don't use the<> notation, precede{rhs} with asingleCTRL-V (you have to typeCTRL-V two times).map_empty_rhsmap-empty-rhsYou can create an empty{rhs} by typing nothing after a singleCTRL-V (youhave to typeCTRL-V two times). Unfortunately, you cannot do this in a vimrcfile.<Nop> An easier way to get a mapping that doesn't produce anything, is to use"<Nop>" for the{rhs}. For example, to disable function key 8::map <F8> <Nop>:map! <F8> <Nop>
:set encoding=latin1:imap <M-C> foo:set encoding=utf-8The mapping for
<M-C> is defined with the latin1 encoding, resulting in a 0xc3byte. If you type the character á (0xe1<M-a>) in UTF-8 encoding this is thetwo bytes 0xc3 0xa1. You don't want the 0xc3 byte to be mapped then orotherwise it would be impossible to type the á character.map <Leader>A oanother line<Esc>Works like:
map \A oanother line<Esc>But after:
let mapleader = ","It works like:
map ,A oanother line<Esc>Note that the value of "g:mapleader" is used at the moment the mapping isdefined. Changing "g:mapleader" after that has no effect for already definedmappings.
<LocalLeader> is just like<Leader>, except that it uses "maplocalleader"instead of "mapleader".<LocalLeader> is to be used for mappings which arelocal to a buffer. Example::map <buffer> <LocalLeader>A oanother line<Esc>
<Leader> should be used and in a filetype plugin<LocalLeader>. "mapleader" and "maplocalleader" can be equal. Although, ifyou make them different, there is a smaller chance of mappings from globalplugins to clash with mappings for filetype plugins. For example, you couldkeep "mapleader" at the default backslash, and set "maplocalleader" to anunderscore.<Char>construct can be used:<Char-123>character 123<Char-033>character 27<Char-0x7f>character 127<S-Char-114> character 114 ('r') shifted ('R')This is useful to specify a (multibyte) character in a'keymap' file.Upper and lowercase differences are ignored."character is considered to be part of the{lhs} or{rhs}. However, one canuse|", since this starts a new, empty command with a comment.{rhs}.There are three methods:<Bar> always :map _l :!ls<Bar> more^M \| 'b' is not in'cpoptions' :map _l :!ls \| more^M ^V| always :map _l :!ls ^V| more^MCTRL-V; to get oneCTRL-V you have to type it twice; youcannot use the <> notation "<C-V>" here).<CR> is recommended forthis (see<>). Example::map _ls :!ls -l %:S<CR>:echo "the end"<CR>To avoid mapping of the characters you type in insert or Command-line mode,type a
CTRL-V first.map-errorCTRL-X is not mapped. This was done to be able to use all the namedregisters and marks, even when the command with the same name has beenmapped.{lhs}. You will have to avoid keys that are used for Vim commands,otherwise you would not be able to use those commands anymore. Here are a fewsuggestions:<F2>,<F3>, etc.. Also the shifted function keys<S-F1>,<S-F2>, etc. Note that<F1> is already used for the help command.CTRL-P andCTRL-N. Use an extra character to allow more mappings.<Leader> and one or more other keys. This is especially useful in scripts.mapleader{key}^D" to find out ifa key is used for some command. ({key} is the specific key you want to findout about, ^D isCTRL-D).:map <F3> o#include:map <M-g> /foo<CR>cwbar<Esc>:map _x d/END/e<CR>:map! qq quadrillion questionsMultiplying a count
{lhs}. For example, with this mapping::map <F4> 3wTyping 2<F4> will result in "23w". Thus not moving 2 * 3 words but 23 words.If you want to multiply counts use the expression register:
:map <F4> @='3w'<CR>The part between quotes is the expression being executed.@=
<nowait>, even if a longer mappinghas the same prefix. For example, given the following two mappings::map <buffer> <nowait> \a :echo "Local \a"<CR>:map \abc :echo "Global \abc"<CR>When typing \a the buffer-local mapping will be used immediately. Vim willnot wait for more characters to see if the user might be typing \abc.
<F1> to<F4> the actual key code generated may correspond to<xF1> to<xF4>. There are mappings from<xF1> to<F1>,<xF2> to<F2>, etc., but these are not recognized after another half a mapping. Make sure the key codes for<F1> to<F4> are correct::set <F1>=<type CTRL-V><type F1>
<F1> as four characters. The part after the "=" must be done with the actual keys, not the literal text.Another solution is to use the actual key code in the mapping for the secondspecial key::map <F1><Esc>OP :echo "yes"<CR>Don't type a real
<Esc>, Vim will recognize the key code and replace it with<F1> anyway.{lhs} in the{rhs} you have a recursive mapping. When{lhs} is typed, it will be replaced with{rhs}. When the{lhs} which isincluded in{rhs} is encountered it will be replaced with{rhs}, and so on.This makes it possible to repeat a command an infinite number of times. Theonly problem is that the only way to stop this is by causing an error. Themacros to solve a maze uses this, look there for an example. There is oneexception: If the{rhs} starts with{lhs}, the first character is not mappedagain (this is Vi compatible).For example::map ab abcdwill execute the "a" command and insert "bcd" in the text. The "ab" in the
{rhs} will not be mapped again.:noremap k j:noremap j kThis will exchange the cursor up and down commands.
{lhs}. For example, if you use::map x y:map y xVim will replace x with y, and then y with x, etc. When this has happened'maxmapdepth' times (default 1000), Vim will give the error message"recursive mapping".
<A-k> form can be used. Note that<A-k>and<A-K> are different, the latter will use an upper case letter. Actually,<A-K> and<A-S-K> are the same. Instead of "A" you can use "M". If you havean actual Meta modifier key, please see:map-meta-keys.{key} within'ttimeoutlen'milliseconds, the ESC is interpreted as: <ALT-{key}>otherwise it is interpreted as two key presses:<ESC>{key}<M-a> actually is for using the Alt key. That can beconfusing! It cannot be changed, it would not be backwards compatible.:imap <T-b> terrible1.12 MAPPING SUPER-KEYS or COMMAND-KEYS:map-super-keys:map-cmd-key
:imap <D-b> barritone
{motion} command. To define your own operatoryou must create a mapping that first sets the'operatorfunc' option and theninvoke theg@ operator. After the user types the{motion} command thespecified function will be called.{motion}, the '] mark on the lastcharacter of the text.The function is called with one String argument: "line"{motion} waslinewise "char"{motion} wascharwise "block"{motion} wasblockwise-visualThe type can be forced, seeforced-motion.<F4>:nnoremap <expr> <F4> CountSpaces()xnoremap <expr> <F4> CountSpaces()" doubling <F4> works on a linennoremap <expr> <F4><F4> CountSpaces() .. '_'function CountSpaces(context = {}, type = '') abort if a:type == '' let context = #{ \ dot_command: v:false, \ extend_block: '', \ virtualedit: [&l:virtualedit, &g:virtualedit], \ } let &operatorfunc = function('CountSpaces', [context]) set virtualedit=block return 'g@' endif let save = #{ \ clipboard: &clipboard, \ selection: &selection, \ virtualedit: [&l:virtualedit, &g:virtualedit], \ register: getreginfo('"'), \ visual_marks: [getpos("'<"), getpos("'>")], \ } try set clipboard= selection=inclusive virtualedit= let commands = #{ \ line: "'[V']", \ char: "`[v`]", \ block: "`[\<C-V>`]", \ }[a:type] let [_, _, col, off] = getpos("']") if off != 0 let vcol = getline("'[")->strpart(0, col + off)->strdisplaywidth() if vcol >= [line("'["), '$']->virtcol() - 1 let a:context.extend_block = '$' else let a:context.extend_block = vcol .. '|' endif endif if a:context.extend_block != '' let commands ..= 'oO' .. a:context.extend_block endif let commands ..= 'y' execute 'silent noautocmd keepjumps normal! ' .. commands echomsg getreg('"')->count(' ') finally call setreg('"', save.register) call setpos("'<", save.visual_marks[0]) call setpos("'>", save.visual_marks[1]) let &clipboard = save.clipboard let &selection = save.selection let [&l:virtualedit, &g:virtualedit] = get(a:context.dot_command ? save : a:context, 'virtualedit') let a:context.dot_command = v:true endtryendfunctionAn<expr> mapping is used to be able to fetch any prefixed count and register.This also avoids using a command line, which would trigger CmdlineEnter andCmdlineLeave autocommands."* or"+ registers, if its value contains the itemunnamedorunnamedplus.mode() function will return the state as it will be after applying theoperator.nnoremap <F4> <Cmd>let &opfunc='{t -> \ getline(".") \ ->split("\\zs") \ ->insert("\"", col("'']")) \ ->insert("\"", col("''[") - 1) \ ->join("") \ ->setline(".")}'<CR>g@<Esc> that ends Insert mode or the<CR> that ends acommand. The non-keyword character which ends the abbreviation is insertedafter the expanded abbreviation. An exception to this is the character<C-]>,which is used to expand an abbreviation without inserting any extracharacters.:ab hhhello
{CURSOR} is where you type a non-keyword character):ab foo four old otters
:ab #i #include
:ab ;; <endofline>
<endofline>"CTRL-V before the characterthat would trigger the abbreviation. E.g.CTRL-V<Space>. Or type part ofthe abbreviation, exit insert mode with<Esc>, re-enter insert mode with "a"and type the rest.CTRL-V twice somewhere inthe abbreviation to avoid it to be replaced. ACTRL-V in front of a normalcharacter is mostly ignored otherwise.:iab if if ()<Left>You can even do more complicated things. For example, to consume the spacetyped after an abbreviation:
func Eatchar(pat) let c = nr2char(getchar(0)) return (c =~ a:pat) ? '' : cendfunciabbr <silent> if if ()<Left><C-R>=Eatchar('\s')<CR>There are no default abbreviations.:abb <buffer> FF for (i = 0; i < ; ++i)
:verbose abbreviate! teh the Last set from /home/abcd/vim/abbr.vimSee:verbose-cmd for more information.
{lhs}list the abbreviations that start with{lhs}You may need to insert aCTRL-V (type it twice) toavoid that a typed{lhs} is expanded, sincecommand-line abbreviations apply here.<expr>] [<buffer>]{lhs}{rhs}add abbreviation for{lhs} to{rhs}. If{lhs} alreadyexisted it is replaced with the new{rhs}.{rhs} maycontain spaces.See:map-<expr> for the optional<expr> argument.See:map-<buffer> for the optional<buffer> argument.<buffer>]{lhs}Remove abbreviation for{lhs} from the list. If noneis found, remove abbreviations in which{lhs} matcheswith the{rhs}. This is done so that you can evenremove abbreviations after expansion. To avoidexpansion insert aCTRL-V (type it twice).<expr>] [<buffer>] [lhs] [rhs]same as ":ab", but no remapping for this{rhs}<expr>] [<buffer>] [lhs] [rhs]same as ":ab", but for Command-line mode only.<expr>] [<buffer>] [lhs] [rhs]same as ":ab", but for Command-line mode only and noremapping for this{rhs}<expr>] [<buffer>] [lhs] [rhs]same as ":ab", but for Insert mode only and noremapping for this{rhs}CTRL-Vs need to be typed depends on how you enter theabbreviation. This also applies to mappings. Let's use an example here.<Esc> character. When youtype the ":ab" command in Vim, you have to enter this: (here ^V is aCTRL-Vand ^[ is<Esc>)<SNR>, followed by a number that's unique for the script, and anunderscore. Example::map <SID>Addwould define a mapping "<SNR>23_Add".
<SID> cannot be correctlyexpanded, use the expand() function:let &includexpr = expand('<SID>') .. 'My_includeexpr()'Otherwise, using "<SID>" outside of a script context is an error.func s:ScriptNumber() return matchstr(expand('<SID>'), '<SNR>\zs\d\+\ze_')endfuncThe "<SNR>" will be shown when listing functions and mappings. This is usefulto find out what they are defined to.<SNR> number is.:command Rename ...:command Renumber ...:Rena" Means "Rename":Renu" Means "Renumber":Ren" Error - ambiguous:command Paste ...It is recommended that full names for user-defined commands are used inscripts.
filter Pyth command:com[mand]
{cmd}List the user-defined commands that start with{cmd}:verbose command TOhtml
<line1>,<line2>){attr}...]{cmd}{repl}Define a user command. The name of the command is{cmd} and its replacement text is{repl}. Thecommand's attributes (see below) are{attr}. If thecommand already exists, an error is reported, unless a! is specified, in which case the command isredefined. There is one exception: When sourcing ascript again, a command that was previously defined inthat script will be silently replaced.{cmd}E1237{cmd} that was definedfor the current buffer.:let s:error = "None":command -nargs=1 Error echoerr <args>
:source script1.vim:let s:error = "Wrong!":Error s:errorExecuting script2.vim will result in "None" being echoed. Not what youintended! Calling a function may be an alternative.
CTRL-D is hit-complete=useruser names-complete=varuser variables-complete=custom,{func} custom completion, defined via{func}-complete=customlist,{func} custom completion, defined via{func}{func}"or the "customlist,{func}" completion argument. The{func} part should be afunction with the following signature::function {func}(ArgLead, CmdLine, CursorPos)The function need not use all these arguments. The function should provide thecompletion candidates as the return value.:com -complete=custom,ListUsers -nargs=1 Finger !finger <args>:fun ListUsers(A,L,P): return system("cut -d: -f1 /etc/passwd"):endfunThe following example completes filenames from the directories specified inthe'path' option::com -nargs=1 -bang -complete=customlist,EditFileComplete \ EditFile edit<bang> <args>:fun EditFileComplete(A,L,P): return split(globpath(&path, a:A), "\n"):endfun
.,$ or%which by default correspond to the current line, last line and the wholebuffer, relate to arguments, (loaded) buffers, windows or tab pages.{nvim-api}Commands can show an'inccommand' (as-you-type) preview by defining a previewhandler (only from Lua, seenvim_create_user_command()).function cmdpreview(opts, ns, buf)
-- If invoked as a preview callback, performs 'inccommand' preview by-- highlighting trailing whitespace in the current buffer.local function trim_space_preview(opts, preview_ns, preview_buf) vim.cmd('hi clear Whitespace') local line1 = opts.line1 local line2 = opts.line2 local buf = vim.api.nvim_get_current_buf() local lines = vim.api.nvim_buf_get_lines(buf, line1 - 1, line2, false) local preview_buf_line = 0 for i, line in ipairs(lines) do local start_idx, end_idx = string.find(line, '%s+$') if start_idx then -- Highlight the match vim.hl.range( buf, preview_ns, 'Substitute', {line1 + i - 2, start_idx - 1}, {line1 + i - 2, end_idx}, ) -- Add lines and set highlights in the preview buffer -- if inccommand=split if preview_buf then local prefix = string.format('|%d| ', line1 + i - 1) vim.api.nvim_buf_set_lines( preview_buf, preview_buf_line, preview_buf_line, false, { prefix .. line } ) vim.hl.range( preview_buf, preview_ns, 'Substitute', {preview_buf_line, #prefix + start_idx - 1}, {preview_buf_line, #prefix + end_idx}, ) preview_buf_line = preview_buf_line + 1 end end end -- Return the value of the preview type return 2end-- Trims all trailing whitespace in the current buffer.local function trim_space(opts) local line1 = opts.line1 local line2 = opts.line2 local buf = vim.api.nvim_get_current_buf() local lines = vim.api.nvim_buf_get_lines(buf, line1 - 1, line2, false) local new_lines = {} for i, line in ipairs(lines) do new_lines[i] = string.gsub(line, '%s+$', '') end vim.api.nvim_buf_set_lines(buf, line1 - 1, line2, false, new_lines)end-- Create the user commandvim.api.nvim_create_user_command( 'TrimTrailingWhitespace', trim_space, { nargs = '?', range = '%', addr = 'lines', preview = trim_space_preview }){repl} for a user defined command is scanned for specialescape sequences, using <...> notation. Escape sequences are replaced withvalues from the entered command line, and all other text is copied unchanged.The resulting string is executed as an Ex command. To avoid the replacementuse<lt> in place of the initial <. Thus to include "<bang>" literally use"<lt>bang>".<line1>The starting line of the command range.<line2><line2>The final line of the command range.<range><range> The number of items in the command range: 0, 1 or 2<count><count>Any count supplied (as described for the '-range'and '-count' attributes).<bang><bang>(See the '-bang' attribute) Expands to a ! if thecommand was executed with a ! modifier, otherwiseexpands to nothing.<mods><q-mods>:command-modifiers<mods> The command modifiers, if specified. Otherwise, expands tonothing. Supported modifiers are:aboveleft,:belowright,:botright,:browse,:confirm,:hide,:horizontal,:keepalt,:keepjumps,:keepmarks,:keeppatterns,:leftabove,:lockmarks,:noautocmd,:noswapfile,:rightbelow,:sandbox,:silent,:tab,:topleft,:unsilent,:verbose, and:vertical.Note that:filter is not supported.Examples:command! -nargs=+ -complete=file MyEdit \ for f in expand(<q-args>, 0, 1) | \ exe '<mods> split ' .. f | \ endforfunction! SpecialEdit(files, mods) for f in expand(a:files, 0, 1) exe a:mods .. ' split ' .. f endforendfunctioncommand! -nargs=+ -complete=file Sedit \ call SpecialEdit(<q-args>, <q-mods>)
<reg>(See the '-register' attribute) The optional register,if specified. Otherwise, expands to nothing.<register>is a synonym for this.<args><args>The command arguments, exactly as supplied (but asnoted above, any count or register can consume someof the arguments, which are then not part of<args>).<lt>A single '<' (Less-Than) character. This is needed if youwant to get a literal copy of one of these escape sequencesinto the expansion - for example, to get<bang>, use<lt>bang>.<q-args>) then the value is quoted in such a way as to make it a valid valuefor use in an expression. This uses the argument as one single value.When there is no argument<q-args> is an empty string. See theq-args-example below.<f-args><f-args> ("function args"). This splits the commandarguments at spaces and tabs, quotes each argument individually, and the<f-args> sequence is replaced by the comma-separated list of quoted arguments.See the Mycmd example below. If no arguments are given<f-args> is removed. To embed whitespace into an argument of<f-args>, prepend a backslash.<f-args> replaces every pair of backslashes (\\) with one backslash. Abackslash followed by a character other than white space or a backslashremains unmodified. Also seef-args-example below. Overview:<f-args>" Delete everything after here to the end:com Ddel +,$d" Rename the current buffer:com -nargs=1 -bang -complete=file Ren f <args>|w<bang>" Replace a range with the contents of a file" (Enter this all as one line):com -range -nargs=1 -complete=file Replace <line1>-pu_|<line1>,<line2>d|r <args>|<line1>d" Count the number of lines in the range:com! -range -nargs=0 Lines echo <line2> - <line1> + 1 "lines"
<f-args>):com -nargs=* Mycmd call Myfunc(<f-args>)When executed as:
:Mycmd arg1 arg2This will invoke:
:call Myfunc("arg1","arg2"):function Allargs(command): let i = 0: while i < argc(): if filereadable(argv(i)): execute "e " .. argv(i): execute a:command: endif: let i = i + 1: endwhile:endfunction:command -nargs=+ -complete=command Allargs call Allargs(<q-args>)The command Allargs takes any Vim command(s) as argument and executes it on allfiles in the argument list. Usage example (note use of the "e" flag to ignoreerrors and the "update" command to write modified buffers):
:Allargs %s/foo/bar/ge|updateThis will invoke:
:call Allargs("%s/foo/bar/ge|update")