0
0
mirror of https://github.com/vim/vim.git synced 2025-07-04 23:07:33 -04:00
vim/runtime/doc/usr_41.txt

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1944 lines
65 KiB
Plaintext
Raw Normal View History

*usr_41.txt* For Vim version 9.1. Last change: 2024 Dec 30
2004-06-13 20:20:40 +00:00
VIM USER MANUAL - by Bram Moolenaar
Write a Vim script
The Vim script language is used for the startup vimrc file, syntax files, and
many other things. This chapter explains the items that can be used in a Vim
2022-06-03 21:59:47 +01:00
script. There are a lot of them, therefore this is a long chapter.
2004-06-13 20:20:40 +00:00
|41.1| Introduction
|41.2| Variables
|41.3| Expressions
|41.4| Conditionals
|41.5| Executing an expression
|41.6| Using functions
|41.7| Defining a function
2005-02-07 22:01:03 +00:00
|41.8| Lists and Dictionaries
2022-06-09 20:45:54 +01:00
|41.9| White space
|41.10| Line continuation
|41.11| Comments
|41.12| Fileformat
2004-06-13 20:20:40 +00:00
Next chapter: |usr_42.txt| Add new menus
Previous chapter: |usr_40.txt| Make new commands
Table of contents: |usr_toc.txt|
==============================================================================
2005-01-25 21:57:23 +00:00
*41.1* Introduction *vim-script-intro* *script*
2004-06-13 20:20:40 +00:00
Let's start with some nomenclature. A Vim script is any file that Vim can
interpret and execute. This includes files written in Vim's scripting language
like for example .vim files or configuration files like .vimrc and .gvimrc.
These scripts may define functions, commands and settings that Vim uses to
customize and extend its behavior.
With a slight abuse of nomenclature, we will use "Vim script" to refer to the
Vim scripting language throughout this documentation. This shorthand helps to
streamline explanations and discussions about scripting with Vim.
A Vim plugin is a collection of one or more Vim scripts, along with additional
files like help documentation, configuration files, and other resources,
designed to add specific features or functionalities to Vim. A plugin can
provide new commands, enhance existing capabilities, and integrate external
tools or services into the Vim environment.
2004-06-13 20:20:40 +00:00
Your first experience with Vim scripts is the vimrc file. Vim reads it when
2022-06-03 21:59:47 +01:00
it starts up and executes the commands. You can set options to the values you
prefer, define mappings, select plugins and much more. You can use any colon
command in it (commands that start with a ":"; these are sometimes referred to
as Ex commands or command-line commands).
2021-12-30 20:24:12 +00:00
Syntax files are also Vim scripts. As are files that set options for a
2004-06-13 20:20:40 +00:00
specific file type. A complicated macro can be defined by a separate Vim
script file. You can think of other uses yourself.
2021-12-30 20:24:12 +00:00
Vim script comes in two flavors: legacy and |Vim9|. Since this help file is
for new users, we'll teach you the newer and more convenient |Vim9| syntax.
2022-06-03 21:59:47 +01:00
While legacy script is particularly for Vim, |Vim9| script looks more like
other languages, such as JavaScript and TypeScript.
2021-12-30 20:24:12 +00:00
To try out Vim script the best way is to edit a script file and source it.
Basically: >
:edit test.vim
[insert the script lines you want]
:w
:source %
2004-06-13 20:20:40 +00:00
Let's start with a simple example: >
2021-12-30 20:24:12 +00:00
vim9script
var i = 1
while i < 5
echo "count is" i
i += 1
endwhile
2004-06-13 20:20:40 +00:00
<
2005-02-07 22:01:03 +00:00
The output of the example code is:
count is 1 ~
count is 2 ~
count is 3 ~
count is 4 ~
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
In the first line the `vim9script` command makes clear this is a new, |Vim9|
2022-06-06 20:52:59 +01:00
script file. That matters for how the rest of the file is used. It is
recommended to put it in the very first line, before any comments.
2022-06-03 21:59:47 +01:00
*vim9-declarations*
2021-12-30 20:24:12 +00:00
The `var i = 1` command declares the "i" variable and initializes it. The
2005-02-07 22:01:03 +00:00
generic form is: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
var {name} = {expression}
2004-06-13 20:20:40 +00:00
In this case the variable name is "i" and the expression is a simple value,
the number one.
2021-12-30 20:24:12 +00:00
The `while` command starts a loop. The generic form is: >
while {condition}
{statements}
endwhile
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
The statements until the matching `endwhile` are executed for as long as the
2004-06-13 20:20:40 +00:00
condition is true. The condition used here is the expression "i < 5". This
is true when the variable i is smaller than five.
2005-02-07 22:01:03 +00:00
Note:
If you happen to write a while loop that keeps on running, you can
interrupt it by pressing CTRL-C (CTRL-Break on MS-Windows).
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
The `echo` command prints its arguments. In this case the string "count is"
2005-02-07 22:01:03 +00:00
and the value of the variable i. Since i is one, this will print:
2004-06-13 20:20:40 +00:00
count is 1 ~
2021-12-30 20:24:12 +00:00
Then there is the `i += 1` command. This does the same thing as "i = i + 1",
it adds one to the variable i and assigns the new value to the same variable.
2004-06-13 20:20:40 +00:00
2005-02-07 22:01:03 +00:00
The example was given to explain the commands, but would you really want to
2017-03-05 17:04:09 +01:00
make such a loop, it can be written much more compact: >
2005-01-17 22:11:23 +00:00
2021-12-30 20:24:12 +00:00
for i in range(1, 4)
2022-06-03 21:59:47 +01:00
echo $"count is {i}"
2021-12-30 20:24:12 +00:00
endfor
2005-01-17 22:11:23 +00:00
2022-06-03 21:59:47 +01:00
We won't explain how `for`, `range()`and `$"string"` work until later. Follow
the links if you are impatient.
TRYING OUT EXAMPLES
You can easily try out most examples in these help files without saving the
2022-06-09 20:45:54 +01:00
commands to a file. For example, to try out the "for" loop above do this:
2022-06-03 21:59:47 +01:00
1. position the cursor on the "for"
2. start Visual mode with "v"
3. move down to the "endfor"
4. press colon, then "so" and Enter
After pressing colon you will see ":'<,'>", which is the range of the Visually
selected text.
For some commands it matters they are executed as in |Vim9| script. But typed
commands normally use legacy script syntax, such as the example below that
causes the E1004 error. For that use this fourth step:
4. press colon, then "vim9 so" and Enter
"vim9" is short for `vim9cmd`, which is a command modifier to execute the
following command in |Vim9| syntax.
Note that this won't work for examples that require a script context.
2005-01-17 22:11:23 +00:00
2004-06-13 20:20:40 +00:00
2019-05-31 21:41:05 +02:00
FOUR KINDS OF NUMBERS
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
Numbers can be decimal, hexadecimal, octal and binary.
2021-04-21 18:09:37 +02:00
A hexadecimal number starts with "0x" or "0X". For example "0x1f" is decimal
2022-11-09 21:21:04 +00:00
31 and "0x1234" is decimal 4660.
2021-04-21 18:09:37 +02:00
2021-12-30 20:24:12 +00:00
An octal number starts with "0o", "0O". "0o17" is decimal 15.
2021-04-21 18:09:37 +02:00
A binary number starts with "0b" or "0B". For example "0b101" is decimal 5.
2021-12-30 20:24:12 +00:00
A decimal number is just digits. Careful: In legacy script don't put a zero
2022-06-03 21:59:47 +01:00
before a decimal number, it will be interpreted as an octal number! That's
one reason to use |Vim9| script.
2021-04-21 18:09:37 +02:00
2022-06-03 21:59:47 +01:00
The `echo` command evaluates its argument and when it is a number always
prints the decimal form. Example: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
echo 0x7f 0o36
2004-06-13 20:20:40 +00:00
< 127 30 ~
2019-05-31 21:41:05 +02:00
A number is made negative with a minus sign. This also works for hexadecimal,
2021-12-30 20:24:12 +00:00
octal and binary numbers: >
echo -0x7f
< -127 ~
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
A minus sign is also used for subtraction. This can sometimes lead to
confusion. If we put a minus sign before both numbers we get an error: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
echo -0x7f -0o36
< E1004: White space required before and after '-' at "-0o36" ~
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
Note: if you are not using a |Vim9| script to try out these commands but type
them directly, they will be executed as legacy script. Then the echo command
sees the second minus sign as subtraction. To get the error, prefix the
command with `vim9cmd`: >
vim9cmd echo -0x7f -0o36
< E1004: White space required before and after '-' at "-0o36" ~
White space in an expression is often required to make sure it is easy to read
and avoid errors. Such as thinking that the "-0o36" above makes the number
negative, while it is actually seen as a subtraction.
To actually have the minus sign be used for negation, you can put the second
2022-02-20 19:48:20 +00:00
expression in parentheses: >
2021-12-30 20:24:12 +00:00
echo -0x7f (-0o36)
2022-06-03 21:59:47 +01:00
< -127 -30 ~
2004-06-13 20:20:40 +00:00
==============================================================================
*41.2* Variables
A variable name consists of ASCII letters, digits and the underscore. It
cannot start with a digit. Valid variable names are:
counter
_aap3
very_long_variable_name_with_underscores
2022-06-03 21:59:47 +01:00
CamelCaseName
2004-06-13 20:20:40 +00:00
LENGTH
2022-06-09 20:45:54 +01:00
Invalid names are "foo.bar" and "6var".
2021-12-30 20:24:12 +00:00
Some variables are global. To see a list of currently defined global
variables type this command: >
2004-06-13 20:20:40 +00:00
:let
2022-06-03 21:59:47 +01:00
You can use global variables everywhere. However, it is too easy to use the
same name in two unrelated scripts. Therefore variables declared in a script
are local to that script. For example, if you have this in "script1.vim": >
2021-12-30 20:24:12 +00:00
vim9script
var counter = 5
echo counter
< 5 ~
And you try to use the variable in "script2.vim": >
vim9script
echo counter
< E121: Undefined variable: counter ~
Using a script-local variable means you can be sure that it is only changed in
that script and not elsewhere.
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
If you do want to share variables between scripts, use the "g:" prefix and
2022-06-03 21:59:47 +01:00
assign the value directly, do not use `var`. And use a specific name to avoid
mistakes. Thus in "script1.vim": >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
vim9script
2022-06-03 21:59:47 +01:00
g:mash_counter = 5
echo g:mash_counter
2021-12-30 20:24:12 +00:00
< 5 ~
And then in "script2.vim": >
vim9script
2022-06-03 21:59:47 +01:00
echo g:mash_counter
2021-12-30 20:24:12 +00:00
< 5 ~
2022-06-03 21:59:47 +01:00
Global variables can also be accessed on the command line, E.g. typing this: >
echo g:mash_counter
That will not work for a script-local variable.
2021-12-30 20:24:12 +00:00
More about script-local variables here: |script-variable|.
2004-06-13 20:20:40 +00:00
There are more kinds of variables, see |internal-variables|. The most often
used ones are:
b:name variable local to a buffer
w:name variable local to a window
g:name global variable (also in a function)
v:name variable predefined by Vim
DELETING VARIABLES
2021-12-30 20:24:12 +00:00
Variables take up memory and show up in the output of the `let` command. To
delete a global variable use the `unlet` command. Example: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
unlet g:counter
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
This deletes the global variable "g:counter" to free up the memory it uses.
If you are not sure if the variable exists, and don't want an error message
when it doesn't, append !: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
unlet! g:counter
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
You cannot `unlet` script-local variables in |Vim9| script, only in legacy
2021-12-30 20:24:12 +00:00
script.
2004-06-13 20:20:40 +00:00
2022-08-08 15:42:38 +01:00
When a script has been processed to the end, the local variables declared
there will not be deleted. Functions defined in the script can use them.
Example:
2021-12-30 20:24:12 +00:00
>
vim9script
var counter = 0
def g:GetCount(): number
2022-08-08 15:42:38 +01:00
counter += 1
return counter
2021-12-30 20:24:12 +00:00
enddef
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
Every time you call the function it will return the next count: >
:echo g:GetCount()
< 1 ~
>
:echo g:GetCount()
< 2 ~
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
If you are worried a script-local variable is consuming too much memory, set
it to an empty or null value after you no longer need it. Example: >
var lines = readfile(...)
...
lines = []
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
Note: below we'll leave out the `vim9script` line from examples, so we can
concentrate on the relevant commands, but you'll still need to put it at the
top of your script file.
2004-06-13 20:20:40 +00:00
STRING VARIABLES AND CONSTANTS
So far only numbers were used for the variable value. Strings can be used as
2005-02-07 22:01:03 +00:00
well. Numbers and strings are the basic types of variables that Vim supports.
2021-12-30 20:24:12 +00:00
Example: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
var name = "Peter"
echo name
2022-01-08 21:51:59 +00:00
< Peter ~
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
Every variable has a type. Very often, as in this example, the type is
defined by assigning a value. This is called type inference. If you do not
want to give the variable a value yet, you need to specify the type: >
var name: string
var age: number
2022-06-03 21:59:47 +01:00
if male
name = "Peter"
age = 42
else
name = "Elisa"
age = 45
endif
2021-12-30 20:24:12 +00:00
If you make a mistake and try to assign the wrong type of value you'll get an
error: >
2022-06-26 12:21:15 +01:00
2021-12-30 20:24:12 +00:00
age = "Peter"
< E1012: Type mismatch; expected number but got string ~
More about types in |41.8|.
2022-06-03 21:59:47 +01:00
To assign a string value to a variable, you can use a string constant. There
are two types of these. First the string in double quotes, as we used
2021-12-30 20:24:12 +00:00
already. If you want to include a double quote inside the string, put a
backslash in front of it: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
var name = "he is \"Peter\""
echo name
< he is "Peter" ~
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
To avoid the need for backslashes, you can use a string in single quotes: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
var name = 'he is "Peter"'
echo name
< he is "Peter" ~
2004-06-13 20:20:40 +00:00
2005-02-07 22:01:03 +00:00
Inside a single-quote string all the characters are as they are. Only the
single quote itself is special: you need to use two to get one. A backslash
is taken literally, thus you can't use it to change the meaning of the
2021-12-30 20:24:12 +00:00
character after it: >
var name = 'P\e''ter'''
echo name
< P\e'ter' ~
In double-quote strings it is possible to use special characters. Here are a
few useful ones:
2004-06-13 20:20:40 +00:00
\t <Tab>
\n <NL>, line break
\r <CR>, <Enter>
\e <Esc>
\b <BS>, backspace
\" "
\\ \, backslash
\<Esc> <Esc>
\<C-W> CTRL-W
The last two are just examples. The "\<name>" form can be used to include
the special key "name".
2021-12-30 20:24:12 +00:00
See |expr-quote| for the full list of special items in a string.
2004-06-13 20:20:40 +00:00
==============================================================================
*41.3* Expressions
2021-12-30 20:24:12 +00:00
Vim has a fairly standard way to handle expressions. You can read the
2004-06-13 20:20:40 +00:00
definition here: |expression-syntax|. Here we will show the most common
items.
2021-12-30 20:24:12 +00:00
The numbers, strings and variables mentioned above are expressions by
2004-06-13 20:20:40 +00:00
themselves. Thus everywhere an expression is expected, you can use a number,
string or variable. Other basic items in an expression are:
$NAME environment variable
2022-06-03 21:59:47 +01:00
&name option value
@r register contents
2004-06-13 20:20:40 +00:00
Examples: >
2021-12-30 20:24:12 +00:00
echo "The value of 'tabstop' is" &ts
echo "Your home directory is" $HOME
if @a == 'text'
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
The &name form can also be used to set an option value, do something and
restore the old value. Example: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
var save_ic = &ic
set noic
s/The Start/The Beginning/
&ic = save_ic
2004-06-13 20:20:40 +00:00
This makes sure the "The Start" pattern is used with the 'ignorecase' option
2005-02-07 22:01:03 +00:00
off. Still, it keeps the value that the user had set. (Another way to do
this would be to add "\C" to the pattern, see |/\C|.)
2004-06-13 20:20:40 +00:00
MATHEMATICS
It becomes more interesting if we combine these basic items. Let's start with
mathematics on numbers:
a + b add
a - b subtract
a * b multiply
a / b divide
a % b modulo
The usual precedence is used. Example: >
2021-12-30 20:24:12 +00:00
echo 10 + 5 * 2
2004-06-13 20:20:40 +00:00
< 20 ~
2011-02-25 14:42:19 +01:00
Grouping is done with parentheses. No surprises here. Example: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
echo (10 + 5) * 2
2004-06-13 20:20:40 +00:00
< 30 ~
2022-06-03 21:59:47 +01:00
OTHERS
2020-09-07 22:18:52 +02:00
Strings can be concatenated with ".." (see |expr6|). Example: >
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
echo "Name: " .. name
Name: Peter
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
When the "echo" command gets multiple arguments, it separates them with a
2004-06-13 20:20:40 +00:00
space. In the example the argument is a single expression, thus no space is
inserted.
2022-06-03 21:59:47 +01:00
If you don't like the concatenation you can use the $"string" form, which
accepts an expression in curly braces: >
echo $"Name: {name}"
2022-11-23 23:46:31 +00:00
See |interpolated-string| for more information.
2022-06-03 21:59:47 +01:00
2021-12-30 20:24:12 +00:00
Borrowed from the C language is the conditional expression: >
2004-06-13 20:20:40 +00:00
a ? b : c
If "a" evaluates to true "b" is used, otherwise "c" is used. Example: >
2021-12-30 20:24:12 +00:00
var nr = 4
echo nr > 5 ? "nr is big" : "nr is small"
< nr is small ~
2004-06-13 20:20:40 +00:00
The three parts of the constructs are always evaluated first, thus you could
2021-12-30 20:24:12 +00:00
see it works as: >
2004-06-13 20:20:40 +00:00
(a) ? (b) : (c)
2022-06-03 21:59:47 +01:00
There is also the falsy operator: >
echo name ?? "No name given"
See |??|.
2004-06-13 20:20:40 +00:00
==============================================================================
*41.4* Conditionals
2021-12-30 20:24:12 +00:00
The `if` commands executes the following statements, until the matching
`endif`, only when a condition is met. The generic form is:
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
if {condition}
2004-06-13 20:20:40 +00:00
{statements}
2021-12-30 20:24:12 +00:00
endif
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
Only when the expression {condition} evaluates to true or one will the
{statements} be executed. If they are not executed they must still be valid
commands. If they contain garbage, Vim won't be able to find the matching
`endif`.
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
You can also use `else`. The generic form for this is:
if {condition}
2004-06-13 20:20:40 +00:00
{statements}
2021-12-30 20:24:12 +00:00
else
2004-06-13 20:20:40 +00:00
{statements}
2021-12-30 20:24:12 +00:00
endif
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
The second {statements} block is only executed if the first one isn't.
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
Finally, there is `elseif`
if {condition}
2004-06-13 20:20:40 +00:00
{statements}
2021-12-30 20:24:12 +00:00
elseif {condition}
2004-06-13 20:20:40 +00:00
{statements}
2021-12-30 20:24:12 +00:00
endif
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
This works just like using `else` and then `if`, but without the need for an
extra `endif`.
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
A useful example for your vimrc file is checking the 'term' option and doing
something depending upon its value: >
if &term == "xterm"
# Do stuff for xterm
elseif &term == "vt100"
# Do stuff for a vt100 terminal
else
# Do something for other terminals
endif
This uses "#" to start a comment, more about that later.
2004-06-13 20:20:40 +00:00
LOGIC OPERATIONS
We already used some of them in the examples. These are the most often used
ones:
a == b equal to
a != b not equal to
a > b greater than
a >= b greater than or equal to
a < b less than
a <= b less than or equal to
2021-12-30 20:24:12 +00:00
The result is true if the condition is met and false otherwise. An example: >
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
if v:version >= 800
2021-12-30 20:24:12 +00:00
echo "congratulations"
else
echo "you are using an old version, upgrade!"
endif
2004-06-13 20:20:40 +00:00
Here "v:version" is a variable defined by Vim, which has the value of the Vim
2022-06-03 21:59:47 +01:00
version. 800 is for version 8.0, version 8.1 has the value 801. This is
useful to write a script that works with multiple versions of Vim.
See |v:version|. You can also check for a specific feature with `has()` or a
specific patch, see |has-patch|.
2004-06-13 20:20:40 +00:00
The logic operators work both for numbers and strings. When comparing two
strings, the mathematical difference is used. This compares byte values,
which may not be right for some languages.
2021-12-30 20:24:12 +00:00
If you try to compare a string with a number you will get an error.
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
For strings there are two more useful items:
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
str =~ pat matches with
str !~ pat does not match with
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
The left item "str" is used as a string. The right item "pat" is used as a
2004-06-13 20:20:40 +00:00
pattern, like what's used for searching. Example: >
2021-12-30 20:24:12 +00:00
if str =~ " "
echo "str contains a space"
endif
if str !~ '\.$'
echo "str does not end in a full stop"
endif
2004-06-13 20:20:40 +00:00
Notice the use of a single-quote string for the pattern. This is useful,
2022-06-03 21:59:47 +01:00
because patterns tend to contain many backslashes and backslashes need to be
doubled in a double-quote string.
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
The match is not anchored, if you want to match the whole string start with
"^" and end with "$".
The 'ignorecase' option is not used when comparing strings. When you do want
to ignore case append "?". Thus "==?" compares two strings to be equal while
ignoring case. For the full table see |expr-==|.
2004-06-13 20:20:40 +00:00
MORE LOOPING
2021-12-30 20:24:12 +00:00
The `while` command was already mentioned. Two more statements can be used in
between the `while` and the `endwhile`:
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
continue Jump back to the start of the while loop; the
2004-06-13 20:20:40 +00:00
loop continues.
2021-12-30 20:24:12 +00:00
break Jump forward to the `endwhile`; the loop is
2004-06-13 20:20:40 +00:00
discontinued.
Example: >
2022-01-08 21:51:59 +00:00
var counter = 1
2021-12-30 20:24:12 +00:00
while counter < 40
2022-01-08 21:51:59 +00:00
if skip_number(counter)
2021-12-30 20:24:12 +00:00
continue
endif
2022-01-08 21:51:59 +00:00
if last_number(counter)
2021-12-30 20:24:12 +00:00
break
endif
sleep 50m
2022-01-08 21:51:59 +00:00
++counter
2021-12-30 20:24:12 +00:00
endwhile
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
The `sleep` command makes Vim take a nap. The "50m" specifies fifty
milliseconds. Another example is `sleep 4`, which sleeps for four seconds.
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
`continue` and `break` can also be used in between `for` and `endfor`.
2021-12-30 20:24:12 +00:00
Even more looping can be done with the `for` command, see below in |41.8|.
2005-02-07 22:01:03 +00:00
2004-06-13 20:20:40 +00:00
==============================================================================
*41.5* Executing an expression
So far the commands in the script were executed by Vim directly. The
2021-12-30 20:24:12 +00:00
`execute` command allows executing the result of an expression. This is a
2004-06-13 20:20:40 +00:00
very powerful way to build commands and execute them.
2021-12-30 20:24:12 +00:00
An example is to jump to a tag, which is contained in a variable: >
execute "tag " .. tag_name
2004-06-13 20:20:40 +00:00
2020-09-07 22:18:52 +02:00
The ".." is used to concatenate the string "tag " with the value of variable
2004-06-13 20:20:40 +00:00
"tag_name". Suppose "tag_name" has the value "get_cmd", then the command that
will be executed is: >
2021-12-30 20:24:12 +00:00
tag get_cmd
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
The `execute` command can only execute Ex commands. The `normal` command
2004-06-13 20:20:40 +00:00
executes Normal mode commands. However, its argument is not an expression but
the literal command characters. Example: >
2021-12-30 20:24:12 +00:00
normal gg=G
This jumps to the first line with "gg" and formats all lines with the "="
operator and the "G" movement.
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
To make `normal` work with an expression, combine `execute` with it.
2004-06-13 20:20:40 +00:00
Example: >
2021-12-30 20:24:12 +00:00
execute "normal " .. count .. "j"
This will move the cursor "count" lines down.
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
Make sure that the argument for `normal` is a complete command. Otherwise
2022-06-03 21:59:47 +01:00
Vim will run into the end of the argument and silently abort the command. For
example, if you start the delete operator, you must give the movement command
also. This works: >
2022-06-26 12:21:15 +01:00
2021-12-30 20:24:12 +00:00
normal d$
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
This does nothing: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
normal d
If you start Insert mode and do not end it with Esc, it will end anyway. This
works to insert "new text": >
execute "normal inew text"
If you want to do something after inserting text you do need to end Insert
mode: >
execute "normal inew text\<Esc>b"
This inserts "new text" and puts the cursor on the first letter of "text".
Notice the use of the special key "\<Esc>". This avoids having to enter a
real <Esc> character in your script. That is where `execute` with a
double-quote string comes in handy.
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
If you don't want to execute a string as a command but evaluate it to get the
result of the expression, you can use the eval() function: >
2005-02-07 22:01:03 +00:00
2021-12-30 20:24:12 +00:00
var optname = "path"
var optvalue = eval('&' .. optname)
2005-02-07 22:01:03 +00:00
A "&" character is prepended to "path", thus the argument to eval() is
"&path". The result will then be the value of the 'path' option.
2004-06-13 20:20:40 +00:00
==============================================================================
*41.6* Using functions
Vim defines many functions and provides a large amount of functionality that
way. A few examples will be given in this section. You can find the whole
2021-12-30 20:24:12 +00:00
list below: |function-list|.
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
A function is called with the parameters in between parentheses, separated by
commas. Example: >
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
search("Date: ", "W")
2004-06-13 20:20:40 +00:00
This calls the search() function, with arguments "Date: " and "W". The
search() function uses its first argument as a search pattern and the second
one as flags. The "W" flag means the search doesn't wrap around the end of
the file.
2022-11-09 21:21:04 +00:00
Using the `call` command is optional in |Vim9| script. It is required in
2022-06-09 20:45:54 +01:00
legacy script and on the command line: >
2021-12-30 20:24:12 +00:00
2022-06-03 21:59:47 +01:00
call search("Date: ", "W")
2021-12-30 20:24:12 +00:00
2004-06-13 20:20:40 +00:00
A function can be called in an expression. Example: >
2021-12-30 20:24:12 +00:00
var line = getline(".")
var repl = substitute(line, '\a', "*", "g")
setline(".", repl)
2004-06-13 20:20:40 +00:00
2005-02-07 22:01:03 +00:00
The getline() function obtains a line from the current buffer. Its argument
is a specification of the line number. In this case "." is used, which means
the line where the cursor is.
2021-12-30 20:24:12 +00:00
2022-06-03 21:59:47 +01:00
The substitute() function does something similar to the `:substitute` command.
The first argument "line" is the string on which to perform the substitution.
The second argument '\a' is the pattern, the third "*" is the replacement
string. Finally, the last argument "g" is the flags.
2021-12-30 20:24:12 +00:00
The setline() function sets the line, specified by the first argument, to a
2004-06-13 20:20:40 +00:00
new string, the second argument. In this example the line under the cursor is
replaced with the result of the substitute(). Thus the effect of the three
statements is equal to: >
:substitute/\a/*/g
2022-06-09 20:45:54 +01:00
Using the functions becomes interesting when you do more work before and
2004-06-13 20:20:40 +00:00
after the substitute() call.
FUNCTIONS *function-list*
There are many functions. We will mention them here, grouped by what they are
2021-12-30 20:24:12 +00:00
used for. You can find an alphabetical list here: |builtin-function-list|.
Use CTRL-] on the function name to jump to detailed help on it.
2004-06-13 20:20:40 +00:00
String manipulation: *string-functions*
nr2char() get a character by its number value
list2str() get a character string from a list of numbers
char2nr() get number value of a character
str2list() get list of numbers from a string
2008-06-24 21:16:56 +00:00
str2nr() convert a string to a Number
str2float() convert a string to a Float
2006-04-09 21:54:49 +00:00
printf() format a string according to % items
2004-06-13 20:20:40 +00:00
escape() escape characters in a string with a '\'
2008-06-24 21:16:56 +00:00
shellescape() escape a string for use with a shell command
fnameescape() escape a file name for use with a Vim command
2006-04-09 21:54:49 +00:00
tr() translate characters from one set to another
2004-06-13 20:20:40 +00:00
strtrans() translate a string to make it printable
2022-09-12 15:16:29 +01:00
keytrans() translate internal keycodes to a form that
can be used by |:map|
2004-06-13 20:20:40 +00:00
tolower() turn a string to lowercase
toupper() turn a string to uppercase
charclass() class of a character
2004-06-13 20:20:40 +00:00
match() position where a pattern matches in a string
matchbufline() all the matches of a pattern in a buffer
2004-06-13 20:20:40 +00:00
matchend() position where a pattern match ends in a string
matchfuzzy() fuzzy matches a string in a list of strings
matchfuzzypos() fuzzy matches a string in a list of strings
2004-06-13 20:20:40 +00:00
matchstr() match of a pattern in a string
matchstrlist() all the matches of a pattern in a List of
strings
2016-07-24 14:12:38 +02:00
matchstrpos() match and positions of a pattern in a string
2006-04-09 21:54:49 +00:00
matchlist() like matchstr() and also return submatches
2004-06-13 20:20:40 +00:00
stridx() first index of a short string in a long string
strridx() last index of a short string in a long string
2014-01-23 14:24:41 +01:00
strlen() length of a string in bytes
strcharlen() length of a string in characters
strchars() number of characters in a string
strutf16len() number of UTF-16 code units in a string
2014-01-23 14:24:41 +01:00
strwidth() size of string when displayed
strdisplaywidth() size of string when displayed, deals with tabs
setcellwidths() set character cell width overrides
getcellwidths() get character cell width overrides
getcellpixels() get character cell pixel size
reverse() reverse the order of characters in a string
2004-06-13 20:20:40 +00:00
substitute() substitute a pattern match with a string
2011-06-19 05:09:16 +02:00
submatch() get a specific match in ":s" and substitute()
2016-06-12 23:01:46 +02:00
strpart() get part of a string using byte index
strcharpart() get part of a string using char index
slice() take a slice of a string, using char index in
Vim9 script
2016-06-12 23:01:46 +02:00
strgetchar() get character from a string using char index
2004-06-13 20:20:40 +00:00
expand() expand special keywords
expandcmd() expand a command like done for `:edit`
2004-06-13 20:20:40 +00:00
iconv() convert text from one encoding to another
2006-04-09 21:54:49 +00:00
byteidx() byte index of a character in a string
2014-01-23 14:24:41 +01:00
byteidxcomp() like byteidx() but count composing characters
charidx() character index of a byte in a string
utf16idx() UTF-16 index of a byte in a string
2006-04-09 21:54:49 +00:00
repeat() repeat a string multiple times
eval() evaluate a string expression
2016-07-09 20:21:48 +02:00
execute() execute an Ex command and get the output
2019-05-31 21:41:05 +02:00
win_execute() like execute() but in a specified window
2018-11-25 03:56:26 +01:00
trim() trim characters from a string
bindtextdomain() set message lookup translation base path
gettext() lookup message translation
2004-06-13 20:20:40 +00:00
List manipulation: *list-functions*
2005-01-17 22:11:23 +00:00
get() get an item without error for wrong index
len() number of items in a List
empty() check if List is empty
insert() insert an item somewhere in a List
add() append an item to a List
extend() append a List to a List
extendnew() make a new List and append items
2005-01-17 22:11:23 +00:00
remove() remove one or more items from a List
copy() make a shallow copy of a List
deepcopy() make a full copy of a List
filter() remove selected items from a List
map() change each List item
mapnew() make a new List with changed items
foreach() apply function to List items
reduce() reduce a List to a value
slice() take a slice of a List
2005-01-17 22:11:23 +00:00
sort() sort a List
reverse() reverse the order of items in a List
2014-03-27 22:30:07 +01:00
uniq() remove copies of repeated adjacent items
2005-01-17 22:11:23 +00:00
split() split a String into a List
join() join List items into a String
2006-04-09 21:54:49 +00:00
range() return a List with a sequence of numbers
2005-01-17 22:11:23 +00:00
string() String representation of a List
call() call a function with List as arguments
index() index of a value in a List or Blob
indexof() index in a List or Blob where an expression
2022-11-23 23:46:31 +00:00
evaluates to true
2005-01-17 22:11:23 +00:00
max() maximum value in a List
min() minimum value in a List
count() count number of times a value appears in a List
2006-04-09 21:54:49 +00:00
repeat() repeat a List multiple times
flatten() flatten a List
flattennew() flatten a copy of a List
2005-01-17 22:11:23 +00:00
Dictionary manipulation: *dict-functions*
2005-06-13 22:28:56 +00:00
get() get an entry without an error for a wrong key
2005-01-17 22:11:23 +00:00
len() number of entries in a Dictionary
has_key() check whether a key appears in a Dictionary
empty() check if Dictionary is empty
remove() remove an entry from a Dictionary
extend() add entries from one Dictionary to another
extendnew() make a new Dictionary and append items
2005-01-17 22:11:23 +00:00
filter() remove selected entries from a Dictionary
map() change each Dictionary entry
mapnew() make a new Dictionary with changed items
foreach() apply function to Dictionary items
2005-01-17 22:11:23 +00:00
keys() get List of Dictionary keys
values() get List of Dictionary values
items() get List of Dictionary key-value pairs
copy() make a shallow copy of a Dictionary
deepcopy() make a full copy of a Dictionary
string() String representation of a Dictionary
max() maximum value in a Dictionary
min() minimum value in a Dictionary
count() count number of times a value appears
Floating point computation: *float-functions*
2008-06-24 21:16:56 +00:00
float2nr() convert Float to Number
abs() absolute value (also works for Number)
round() round off
ceil() round up
floor() round down
trunc() remove value after decimal point
2014-01-23 14:24:41 +01:00
fmod() remainder of division
exp() exponential
log() natural logarithm (logarithm to base e)
2008-06-24 21:16:56 +00:00
log10() logarithm to base 10
pow() value of x to the exponent y
sqrt() square root
sin() sine
cos() cosine
2011-03-22 14:05:35 +01:00
tan() tangent
asin() arc sine
acos() arc cosine
2008-06-24 21:16:56 +00:00
atan() arc tangent
2011-03-22 14:05:35 +01:00
atan2() arc tangent
sinh() hyperbolic sine
cosh() hyperbolic cosine
tanh() hyperbolic tangent
isinf() check for infinity
2016-06-12 23:01:46 +02:00
isnan() check for not a number
2008-06-24 21:16:56 +00:00
Blob manipulation: *blob-functions*
blob2list() get a list of numbers from a blob
list2blob() get a blob from a list of numbers
reverse() reverse the order of numbers in a blob
2011-12-30 13:11:27 +01:00
Other computation: *bitwise-function*
and() bitwise AND
invert() bitwise invert
or() bitwise OR
xor() bitwise XOR
2014-01-23 14:24:41 +01:00
sha256() SHA-256 hash
rand() get a pseudo-random number
srand() initialize seed used by rand()
2011-12-30 13:11:27 +01:00
Variables: *var-functions*
instanceof() check if a variable is an instance of a given
class
type() type of a variable as a number
typename() type of a variable as text
2006-04-09 21:54:49 +00:00
islocked() check if a variable is locked
2017-03-05 17:04:09 +01:00
funcref() get a Funcref for a function reference
2006-04-09 21:54:49 +00:00
function() get a Funcref for a function name
getbufvar() get a variable value from a specific buffer
setbufvar() set a variable in a specific buffer
2006-04-15 20:25:09 +00:00
getwinvar() get a variable from specific window
gettabvar() get a variable from specific tab page
2006-04-15 20:25:09 +00:00
gettabwinvar() get a variable from specific window & tab page
2006-04-09 21:54:49 +00:00
setwinvar() set a variable in a specific window
settabvar() set a variable in a specific tab page
2006-04-15 20:25:09 +00:00
settabwinvar() set a variable in a specific window & tab page
2006-04-09 21:54:49 +00:00
garbagecollect() possibly free memory
Cursor and mark position: *cursor-functions* *mark-functions*
2004-06-13 20:20:40 +00:00
col() column number of the cursor or a mark
virtcol() screen column of the cursor or a mark
line() line number of the cursor or mark
wincol() window column number of the cursor
winline() window line number of the cursor
cursor() position the cursor at a line/column
2014-01-23 14:24:41 +01:00
screencol() get screen column of the cursor
screenrow() get screen row of the cursor
screenpos() screen row and col of a text character
virtcol2col() byte index of a text character on screen
2014-06-12 21:46:14 +02:00
getcurpos() get position of the cursor
2006-04-09 21:54:49 +00:00
getpos() get position of cursor, mark, etc.
setpos() set position of cursor, mark, etc.
getmarklist() list of global/local marks
2006-04-09 21:54:49 +00:00
byte2line() get line number at a specific byte count
line2byte() byte count at a specific line
diff_filler() get the number of filler lines above a line
2014-01-23 14:24:41 +01:00
screenattr() get attribute at a screen line/row
screenchar() get character code at a screen line/row
screenchars() get character codes at a screen line/row
screenstring() get string of characters at a screen line/row
charcol() character number of the cursor or a mark
getcharpos() get character position of cursor, mark, etc.
setcharpos() set character position of cursor, mark, etc.
getcursorcharpos() get character position of the cursor
setcursorcharpos() set character position of the cursor
2006-04-09 21:54:49 +00:00
Working with text in the current buffer: *text-functions*
2005-02-07 22:01:03 +00:00
getline() get a line or list of lines from the buffer
getregion() get a region of text from the buffer
getregionpos() get a list of positions for a region
2004-06-13 20:20:40 +00:00
setline() replace a line in the buffer
2005-02-07 22:01:03 +00:00
append() append line or list of lines in the buffer
2004-06-13 20:20:40 +00:00
indent() indent of a specific line
cindent() indent according to C indenting
lispindent() indent according to Lisp indenting
nextnonblank() find next non-blank line
prevnonblank() find previous non-blank line
search() find a match for a pattern
2006-02-14 22:29:30 +00:00
searchpos() find a match for a pattern
searchcount() get number of matches before/after the cursor
2004-06-13 20:20:40 +00:00
searchpair() find the other end of a start/skip/end
2006-02-14 22:29:30 +00:00
searchpairpos() find the other end of a start/skip/end
2006-04-09 21:54:49 +00:00
searchdecl() search for the declaration of a name
2016-06-12 23:01:46 +02:00
getcharsearch() return character search information
setcharsearch() set character search information
2004-06-13 20:20:40 +00:00
Working with text in another buffer:
getbufline() get a list of lines from the specified buffer
getbufoneline() get a one line from the specified buffer
setbufline() replace a line in the specified buffer
appendbufline() append a list of lines in the specified buffer
deletebufline() delete lines from a specified buffer
*system-functions* *file-functions*
2004-06-13 20:20:40 +00:00
System functions and manipulation of files:
glob() expand wildcards
globpath() expand wildcards in a number of directories
2016-06-12 23:01:46 +02:00
glob2regpat() convert a glob pattern into a search pattern
2006-04-09 21:54:49 +00:00
findfile() find a file in a list of directories
finddir() find a directory in a list of directories
2004-06-13 20:20:40 +00:00
resolve() find out where a shortcut points to
fnamemodify() modify a file name
2006-04-09 21:54:49 +00:00
pathshorten() shorten directory names in a path
simplify() simplify a path without changing its meaning
2004-06-13 20:20:40 +00:00
executable() check if an executable program exists
2014-04-05 22:55:53 +02:00
exepath() full path of an executable program
2004-06-13 20:20:40 +00:00
filereadable() check if a file can be read
filewritable() check if a file can be written to
2006-04-09 21:54:49 +00:00
getfperm() get the permissions of a file
2016-06-12 23:01:46 +02:00
setfperm() set the permissions of a file
2006-04-09 21:54:49 +00:00
getftype() get the kind of a file
isabsolutepath() check if a path is absolute
2004-06-13 20:20:40 +00:00
isdirectory() check if a directory exists
getfsize() get the size of a file
2006-04-09 21:54:49 +00:00
getcwd() get the current working directory
haslocaldir() check if current window used |:lcd| or |:tcd|
2004-06-13 20:20:40 +00:00
tempname() get the name of a temporary file
2006-04-09 21:54:49 +00:00
mkdir() create a new directory
chdir() change current working directory
2004-06-13 20:20:40 +00:00
delete() delete a file
rename() rename a file
2014-04-05 22:55:53 +02:00
system() get the result of a shell command as a string
systemlist() get the result of a shell command as a list
environ() get all environment variables
getenv() get one environment variable
setenv() set an environment variable
2004-06-13 20:20:40 +00:00
hostname() name of the system
2005-02-05 21:39:53 +00:00
readfile() read a file into a List of lines
readblob() read a file into a Blob
2019-04-08 16:25:07 +02:00
readdir() get a List of file names in a directory
readdirex() get a List of file information in a directory
2019-02-03 15:27:20 +01:00
writefile() write a List of lines or Blob into a file
filecopy() copy a file {from} to {to}
2004-06-13 20:20:40 +00:00
Date and Time: *date-functions* *time-functions*
2006-04-09 21:54:49 +00:00
getftime() get last modification time of a file
localtime() get current time in seconds
strftime() convert time to a string
strptime() convert a date/time string to time
2006-04-09 21:54:49 +00:00
reltime() get the current or elapsed time accurately
reltimestr() convert reltime() result to a string
2016-04-12 21:07:15 +02:00
reltimefloat() convert reltime() result to a Float
2006-04-09 21:54:49 +00:00
Autocmds: *autocmd-functions*
autocmd_add() add a list of autocmds and groups
autocmd_delete() delete a list of autocmds and groups
autocmd_get() return a list of autocmds
*buffer-functions* *window-functions* *arg-functions*
2004-06-13 20:20:40 +00:00
Buffers, windows and the argument list:
argc() number of entries in the argument list
argidx() current position in the argument list
arglistid() get id of the argument list
2004-06-13 20:20:40 +00:00
argv() get one entry from the argument list
bufadd() add a file to the list of buffers
2004-06-13 20:20:40 +00:00
bufexists() check if a buffer exists
buflisted() check if a buffer exists and is listed
bufload() ensure a buffer is loaded
2004-06-13 20:20:40 +00:00
bufloaded() check if a buffer exists and is loaded
bufname() get the name of a specific buffer
bufnr() get the buffer number of a specific buffer
2006-04-09 21:54:49 +00:00
tabpagebuflist() return List of buffers in a tab page
tabpagenr() get the number of a tab page
tabpagewinnr() like winnr() for a specified tab page
2004-06-13 20:20:40 +00:00
winnr() get the window number for the current window
2016-06-04 20:20:29 +02:00
bufwinid() get the window ID of a specific buffer
2004-06-13 20:20:40 +00:00
bufwinnr() get the window number of a specific buffer
winbufnr() get the buffer number of a specific window
listener_add() add a callback to listen to changes
2019-05-26 21:33:31 +02:00
listener_flush() invoke listener callbacks
listener_remove() remove a listener callback
2016-06-12 23:01:46 +02:00
win_findbuf() find windows containing a buffer
win_getid() get window ID of a window
win_gettype() get type of window
2016-06-12 23:01:46 +02:00
win_gotoid() go to window with ID
win_id2tabwin() get tab and window nr from window ID
win_id2win() get window nr from window ID
win_move_separator() move window vertical separator
win_move_statusline() move window status line
win_splitmove() move window to a split of another window
getbufinfo() get a list with buffer information
gettabinfo() get a list with tab page information
getwininfo() get a list with window information
getchangelist() get a list of change list entries
getjumplist() get a list of jump list entries
swapfilelist() list of existing swap files in 'directory'
2018-08-28 22:58:02 +02:00
swapinfo() information about a swap file
2018-11-25 03:56:26 +01:00
swapname() get the swap file path of a buffer
2006-04-09 21:54:49 +00:00
Command line: *command-line-functions*
getcmdcomplpat() get completion pattern of the current command
line
getcmdcompltype() get the type of the current command line
completion
getcmdline() get the current command line input
getcmdprompt() get the current command line prompt
2006-04-09 21:54:49 +00:00
getcmdpos() get position of the cursor in the command line
getcmdscreenpos() get screen position of the cursor in the
command line
setcmdline() set the current command line
2006-04-09 21:54:49 +00:00
setcmdpos() set position of the cursor in the command line
getcmdtype() return the current command-line type
2014-08-22 19:21:47 +02:00
getcmdwintype() return the current command-line window type
2016-07-24 14:12:38 +02:00
getcompletion() list of command-line completion matches
fullcommand() get full command name
2006-04-09 21:54:49 +00:00
Quickfix and location lists: *quickfix-functions*
2006-04-09 21:54:49 +00:00
getqflist() list of quickfix errors
setqflist() modify a quickfix list
getloclist() list of location list items
setloclist() modify a location list
Insert mode completion: *completion-functions*
2006-04-09 21:54:49 +00:00
complete() set found matches
complete_add() add to found matches
complete_check() check if completion should be aborted
complete_info() get current completion information
2006-04-09 21:54:49 +00:00
pumvisible() check if the popup menu is displayed
2019-09-27 19:34:08 +02:00
pum_getpos() position and size of popup menu if visible
2004-06-13 20:20:40 +00:00
Folding: *folding-functions*
2004-06-13 20:20:40 +00:00
foldclosed() check for a closed fold at a specific line
foldclosedend() like foldclosed() but return the last line
foldlevel() check for the fold level at a specific line
foldtext() generate the line displayed for a closed fold
2006-04-09 21:54:49 +00:00
foldtextresult() get the text displayed for a closed fold
2004-06-13 20:20:40 +00:00
Syntax and highlighting: *syntax-functions* *highlighting-functions*
2007-07-26 20:58:42 +00:00
clearmatches() clear all matches defined by |matchadd()| and
the |:match| commands
getmatches() get all matches defined by |matchadd()| and
the |:match| commands
2004-06-13 20:20:40 +00:00
hlexists() check if a highlight group exists
hlget() get highlight group attributes
hlset() set highlight group attributes
2004-06-13 20:20:40 +00:00
hlID() get ID of a highlight group
synID() get syntax ID at a specific position
synIDattr() get a specific attribute of a syntax ID
synIDtrans() get translated syntax ID
2010-11-16 20:34:40 +01:00
synstack() get list of syntax IDs at a specific position
synconcealed() get info about (syntax) concealing
2006-04-09 21:54:49 +00:00
diff_hlID() get highlight ID for diff mode at a position
2007-07-26 20:58:42 +00:00
matchadd() define a pattern to highlight (a "match")
matchaddpos() define a list of positions to highlight
2006-04-09 21:54:49 +00:00
matcharg() get info about |:match| arguments
2007-07-26 20:58:42 +00:00
matchdelete() delete a match defined by |matchadd()| or a
|:match| command
setmatches() restore a list of matches saved by
|getmatches()|
2006-04-09 21:54:49 +00:00
Spelling: *spell-functions*
2006-04-09 21:54:49 +00:00
spellbadword() locate badly spelled word at or after cursor
spellsuggest() return suggested spelling corrections
soundfold() return the sound-a-like equivalent of a word
2004-06-13 20:20:40 +00:00
History: *history-functions*
2004-06-13 20:20:40 +00:00
histadd() add an item to a history
histdel() delete an item from a history
histget() get an item from a history
histnr() get highest index of a history list
Interactive: *interactive-functions*
2006-04-09 21:54:49 +00:00
browse() put up a file requester
browsedir() put up a directory requester
2004-06-13 20:20:40 +00:00
confirm() let the user make a choice
getchar() get a character from the user
getcharstr() get a character from the user as a string
2004-06-13 20:20:40 +00:00
getcharmod() get modifiers for the last typed character
2019-11-17 15:55:14 +01:00
getmousepos() get last known mouse position
getmouseshape() get name of the current mouse shape
echoraw() output characters as-is
2008-06-24 21:16:56 +00:00
feedkeys() put characters in the typeahead queue
2004-06-13 20:20:40 +00:00
input() get a line from the user
2006-04-09 21:54:49 +00:00
inputlist() let the user pick an entry from a list
2004-06-13 20:20:40 +00:00
inputsecret() get a line from the user without showing it
inputdialog() get a line from the user in a dialog
2005-03-25 21:53:48 +00:00
inputsave() save and clear typeahead
2004-06-13 20:20:40 +00:00
inputrestore() restore typeahead
GUI: *gui-functions*
2006-04-09 21:54:49 +00:00
getfontname() get name of current font being used
2018-03-09 22:22:21 +01:00
getwinpos() position of the Vim window
getwinposx() X position of the Vim window
getwinposy() Y position of the Vim window
2017-03-05 17:04:09 +01:00
balloon_show() set the balloon content
2017-11-21 23:09:50 +01:00
balloon_split() split a message for a balloon
balloon_gettext() get the text in the balloon
2006-04-09 21:54:49 +00:00
Vim server: *server-functions*
2004-06-13 20:20:40 +00:00
serverlist() return the list of server names
2017-11-02 22:58:42 +01:00
remote_startserver() run a server
2004-06-13 20:20:40 +00:00
remote_send() send command characters to a Vim server
remote_expr() evaluate an expression in a Vim server
server2client() send a reply to a client of a Vim server
remote_peek() check if there is a reply from a Vim server
remote_read() read a reply from a Vim server
foreground() move the Vim window to the foreground
remote_foreground() move the Vim server window to the foreground
Window size and position: *window-size-functions*
2006-04-09 21:54:49 +00:00
winheight() get height of a specific window
winwidth() get width of a specific window
2017-12-17 17:17:07 +01:00
win_screenpos() get screen position of a window
2018-11-25 03:56:26 +01:00
winlayout() get layout of windows in a tab page
2006-04-09 21:54:49 +00:00
winrestcmd() return command to restore window sizes
winsaveview() get view of current window
winrestview() restore saved view of current window
Mappings and Menus: *mapping-functions*
digraph_get() get |digraph|
digraph_getlist() get all |digraph|s
digraph_set() register |digraph|
digraph_setlist() register multiple |digraph|s
2004-06-13 20:20:40 +00:00
hasmapto() check if a mapping exists
mapcheck() check if a matching mapping exists
maparg() get rhs of a mapping
maplist() get list of all mappings
mapset() restore a mapping
menu_info() get information about a menu item
2013-02-20 21:26:00 +01:00
wildmenumode() check if the wildmode is active
Testing: *test-functions*
2016-03-20 21:08:34 +01:00
assert_equal() assert that two expressions values are equal
2018-11-25 03:56:26 +01:00
assert_equalfile() assert that two file contents are equal
2016-04-12 21:07:15 +02:00
assert_notequal() assert that two expressions values are not equal
2016-07-24 14:12:38 +02:00
assert_inrange() assert that an expression is inside a range
2016-03-29 23:12:46 +02:00
assert_match() assert that a pattern matches the value
2016-04-12 21:07:15 +02:00
assert_notmatch() assert that a pattern does not match the value
assert_false() assert that an expression is false
assert_true() assert that an expression is true
2016-03-20 21:08:34 +01:00
assert_exception() assert that a command throws an exception
assert_beeps() assert that a command beeps
assert_nobeep() assert that a command does not cause a beep
assert_fails() assert that a command fails
assert_report() report a test failure
2016-06-12 23:01:46 +02:00
test_alloc_fail() make memory allocation fail
2016-07-24 14:12:38 +02:00
test_autochdir() enable 'autochdir' during startup
2017-03-16 17:41:02 +01:00
test_override() test with Vim internal overrides
test_garbagecollect_now() free memory right now
test_garbagecollect_soon() set a flag to free memory soon
2019-05-26 21:33:31 +02:00
test_getvalue() get value of an internal variable
test_gui_event() generate a GUI event for testing
2017-03-05 17:04:09 +01:00
test_ignore_error() ignore a specific error message
test_mswin_event() generate an MS-Windows event
2019-02-03 15:27:20 +01:00
test_null_blob() return a null Blob
2016-06-12 23:01:46 +02:00
test_null_channel() return a null Channel
test_null_dict() return a null Dict
test_null_function() return a null Funcref
2016-06-12 23:01:46 +02:00
test_null_job() return a null Job
test_null_list() return a null List
test_null_partial() return a null Partial function
test_null_string() return a null String
2017-03-05 17:04:09 +01:00
test_settime() set the time Vim uses internally
test_setmouse() set the mouse position
2018-11-25 03:56:26 +01:00
test_feedinput() add key sequence to input buffer
test_option_not_set() reset flag indicating option was set
test_refcount() return an expression's reference count
test_srand_seed() set the seed value for srand()
test_unknown() return a value with unknown type
test_void() return a value with void type
2016-06-12 23:01:46 +02:00
Inter-process communication: *channel-functions*
ch_canread() check if there is something to read
2016-02-04 20:57:07 +01:00
ch_open() open a channel
ch_close() close a channel
2016-09-06 22:12:34 +02:00
ch_close_in() close the in part of a channel
2016-06-12 23:01:46 +02:00
ch_read() read a message from a channel
2019-01-17 16:07:22 +01:00
ch_readblob() read a Blob from a channel
2016-06-12 23:01:46 +02:00
ch_readraw() read a raw message from a channel
2016-02-04 20:57:07 +01:00
ch_sendexpr() send a JSON message over a channel
ch_sendraw() send a raw message over a channel
ch_evalexpr() evaluate an expression over channel
ch_evalraw() evaluate a raw string over channel
2016-06-12 23:01:46 +02:00
ch_status() get status of a channel
ch_getbufnr() get the buffer number of a channel
ch_getjob() get the job associated with a channel
ch_info() get channel information
ch_log() write a message in the channel log file
ch_logfile() set the channel log file
ch_setoptions() set the options for a channel
2016-06-17 12:48:11 +02:00
json_encode() encode an expression to a JSON string
json_decode() decode a JSON string to Vim types
2016-06-12 23:01:46 +02:00
js_encode() encode an expression to a JSON string
js_decode() decode a JSON string to Vim types
base64_encode() encode a blob into a base64 string
base64_decode() decode a base64 string into a blob
err_teapot() give error 418 or 503
2016-06-12 23:01:46 +02:00
Jobs: *job-functions*
2016-06-12 23:01:46 +02:00
job_start() start a job
job_stop() stop a job
job_status() get the status of a job
job_getchannel() get the channel used by a job
job_info() get information about a job
job_setoptions() set options for a job
Signs: *sign-functions*
sign_define() define or update a sign
sign_getdefined() get a list of defined signs
sign_getplaced() get a list of placed signs
sign_jump() jump to a sign
sign_place() place a sign
sign_placelist() place a list of signs
sign_undefine() undefine a sign
sign_unplace() unplace a sign
sign_unplacelist() unplace a list of signs
2017-08-27 16:52:01 +02:00
Terminal window: *terminal-functions*
term_start() open a terminal window and run a job
term_list() get the list of terminal buffers
term_sendkeys() send keystrokes to a terminal
term_wait() wait for screen to be updated
term_getjob() get the job associated with a terminal
term_scrape() get row of a terminal screen
term_getline() get a line of text from a terminal
term_getattr() get the value of attribute {what}
term_getcursor() get the cursor position of a terminal
term_getscrolled() get the scroll count of a terminal
term_getaltscreen() get the alternate screen flag
term_getsize() get the size of a terminal
term_getstatus() get the status of a terminal
term_gettitle() get the title of a terminal
term_gettty() get the tty name of a terminal
2018-04-20 22:36:41 +02:00
term_setansicolors() set 16 ANSI colors, used for GUI
term_getansicolors() get 16 ANSI colors, used for GUI
2018-11-25 03:56:26 +01:00
term_dumpdiff() display difference between two screen dumps
term_dumpload() load a terminal screen dump in a window
term_dumpwrite() dump contents of a terminal screen to a file
term_setkill() set signal to stop job in a terminal
term_setrestore() set command to restore a terminal
term_setsize() set the size of a terminal
term_setapi() set terminal JSON API function name prefix
2017-08-27 16:52:01 +02:00
Popup window: *popup-window-functions*
popup_create() create popup centered in the screen
popup_atcursor() create popup just above the cursor position,
closes when the cursor moves away
popup_beval() at the position indicated by v:beval_
variables, closes when the mouse moves away
popup_notification() show a notification for three seconds
popup_dialog() create popup centered with padding and border
popup_menu() prompt for selecting an item from a list
popup_hide() hide a popup temporarily
popup_show() show a previously hidden popup
popup_move() change the position and size of a popup
popup_setoptions() override options of a popup
popup_settext() replace the popup buffer contents
popup_setbuf() set the popup buffer
popup_close() close one popup
popup_clear() close all popups
popup_filter_menu() select from a list of items
popup_filter_yesno() block until 'y' or 'n' is pressed
popup_getoptions() get current options for a popup
popup_getpos() get actual position and size of a popup
popup_findecho() get window ID for popup used for `:echowindow`
popup_findinfo() get window ID for popup info window
popup_findpreview() get window ID for popup preview window
popup_list() get list of all popup window IDs
popup_locate() get popup window ID from its screen position
2016-06-12 23:01:46 +02:00
Timers: *timer-functions*
timer_start() create a timer
timer_pause() pause or unpause a timer
2016-06-12 23:01:46 +02:00
timer_stop() stop a timer
timer_stopall() stop all timers
timer_info() get information about timers
2016-01-28 22:38:53 +01:00
2018-11-25 03:56:26 +01:00
Tags: *tag-functions*
taglist() get list of matching tags
tagfiles() get a list of tags files
gettagstack() get the tag stack of a window
settagstack() modify the tag stack of a window
Prompt Buffer: *promptbuffer-functions*
prompt_getprompt() get the effective prompt text for a buffer
2018-11-25 03:56:26 +01:00
prompt_setcallback() set prompt callback for a buffer
prompt_setinterrupt() set interrupt callback for a buffer
prompt_setprompt() set the prompt text for a buffer
Registers: *register-functions*
getreg() get contents of a register
getreginfo() get information about a register
getregtype() get type of a register
setreg() set contents and type of a register
reg_executing() return the name of the register being executed
reg_recording() return the name of the register being recorded
Text Properties: *text-property-functions*
prop_add() attach a property at a position
prop_add_list() attach a property at multiple positions
prop_clear() remove all properties from a line or lines
prop_find() search for a property
prop_list() return a list of all properties in a line
prop_remove() remove a property from a line
prop_type_add() add/define a property type
prop_type_change() change properties of a type
prop_type_delete() remove a text property type
prop_type_get() return the properties of a type
prop_type_list() return a list of all property types
Sound: *sound-functions*
sound_clear() stop playing all sounds
sound_playevent() play an event's sound
sound_playfile() play a sound file
sound_stop() stop playing a sound
2013-02-20 21:26:00 +01:00
Various: *various-functions*
mode() get current editing mode
state() get current busy state
2013-02-20 21:26:00 +01:00
visualmode() last visual mode used
2004-06-13 20:20:40 +00:00
exists() check if a variable, function, etc. exists
exists_compiled() like exists() but check at compile time
2004-06-13 20:20:40 +00:00
has() check if a feature is supported in Vim
2006-04-09 21:54:49 +00:00
changenr() return number of most recent change
2004-06-13 20:20:40 +00:00
cscope_connection() check if a cscope connection exists
did_filetype() check if a FileType autocommand was used
diff() diff two Lists of strings
2004-06-13 20:20:40 +00:00
eventhandler() check if invoked by an event handler
getcellpixels() get List of cell pixel size
2008-06-24 21:16:56 +00:00
getpid() get process ID of Vim
2022-08-24 18:30:14 +01:00
getscriptinfo() get list of sourced vim scripts
getimstatus() check if IME status is active
interrupt() interrupt script execution
windowsversion() get MS-Windows version
terminalprops() properties of the terminal
2006-04-09 21:54:49 +00:00
2004-06-13 20:20:40 +00:00
libcall() call a function in an external library
libcallnr() idem, returning a number
2006-04-09 21:54:49 +00:00
2014-01-23 14:24:41 +01:00
undofile() get the name of the undo file
undotree() return the state of the undo tree for a buffer
2014-01-23 14:24:41 +01:00
shiftwidth() effective value of 'shiftwidth'
2016-07-09 20:21:48 +02:00
wordcount() get byte/word/char count of buffer
id() get unique string for item to use as a key
luaeval() evaluate |Lua| expression
mzeval() evaluate |MzScheme| expression
perleval() evaluate Perl expression (|+perl|)
2014-01-23 14:24:41 +01:00
py3eval() evaluate Python expression (|+python3|)
pyeval() evaluate Python expression (|+python|)
2017-01-28 18:34:47 +01:00
pyxeval() evaluate |python_x| expression
rubyeval() evaluate |Ruby| expression
2018-12-18 21:41:50 +01:00
debugbreak() interrupt a program being debugged
2004-06-13 20:20:40 +00:00
==============================================================================
*41.7* Defining a function
Vim enables you to define your own functions. The basic function declaration
begins as follows: >
2021-12-30 20:24:12 +00:00
def {name}({var1}, {var2}, ...): return-type
{body}
enddef
2004-06-13 20:20:40 +00:00
<
Note:
Function names must begin with a capital letter.
Let's define a short function to return the smaller of two numbers. It starts
with this line: >
2021-12-30 20:24:12 +00:00
def Min(num1: number, num2: number): number
This tells Vim that the function is named "Min", it takes two arguments that
are numbers: "num1" and "num2" and returns a number.
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
The first thing you need to do is to check to see which number is smaller:
2004-06-13 20:20:40 +00:00
>
2021-12-30 20:24:12 +00:00
if num1 < num2
2004-06-13 20:20:40 +00:00
Let's assign the variable "smaller" the value of the smallest number: >
2021-12-30 20:24:12 +00:00
var smaller: number
if num1 < num2
smaller = num1
else
smaller = num2
endif
2004-06-13 20:20:40 +00:00
2022-06-09 20:45:54 +01:00
The variable "smaller" is a local variable. It is declared to be a number,
that way Vim can warn you for any mistakes. Variables used inside a function
are local unless prefixed by something like "g:", "w:", or "b:".
2004-06-13 20:20:40 +00:00
Note:
To access a global variable from inside a function you must prepend
2008-06-24 21:16:56 +00:00
"g:" to it. Thus "g:today" inside a function is used for the global
variable "today", and "today" is another variable, local to the
2021-12-30 20:24:12 +00:00
function or the script.
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
You now use the `return` statement to return the smallest number to the user.
2004-06-13 20:20:40 +00:00
Finally, you end the function: >
2021-12-30 20:24:12 +00:00
return smaller
enddef
2004-06-13 20:20:40 +00:00
The complete function definition is as follows: >
2021-12-30 20:24:12 +00:00
def Min(num1: number, num2: number): number
var smaller: number
if num1 < num2
smaller = num1
else
smaller = num2
endif
return smaller
enddef
Obviously this is a verbose example. You can make it shorter by using two
return commands: >
def Min(num1: number, num2: number): number
if num1 < num2
return num1
endif
return num2
enddef
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
And if you remember the conditional expression, you need only one line: >
2005-02-07 22:01:03 +00:00
2021-12-30 20:24:12 +00:00
def Min(num1: number, num2: number): number
return num1 < num2 ? num1 : num2
enddef
2005-02-07 22:01:03 +00:00
2006-02-22 21:25:37 +00:00
A user defined function is called in exactly the same way as a built-in
2004-06-13 20:20:40 +00:00
function. Only the name is different. The Min function can be used like
this: >
2021-12-30 20:24:12 +00:00
echo Min(5, 8)
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
Only now will the function be executed and the lines be parsed by Vim.
2004-06-13 20:20:40 +00:00
If there are mistakes, like using an undefined variable or function, you will
now get an error message. When defining the function these errors are not
2021-12-30 20:24:12 +00:00
detected. To get the errors sooner you can tell Vim to compile all the
functions in the script: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
defcompile
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
Compiling functions takes a little time, but does report errors early. You
could use `:defcompile` at the end of your script while working on it, and
comment it out when everything is fine.
For a function that does not return anything simply leave out the return type: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
def SayIt(text: string)
echo text
enddef
2004-06-13 20:20:40 +00:00
2022-06-09 20:45:54 +01:00
If you want to return any kind of value, you can use the "any" return type: >
def GetValue(): any
This disables type checking for the return value, use only when needed.
2021-12-30 20:24:12 +00:00
It is also possible to define a legacy function with `function` and
2022-06-03 21:59:47 +01:00
`endfunction`. These do not have types and are not compiled. Therefore they
execute much slower.
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
USING A RANGE
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
A line range can be used with a function call. The function will be called
once for every line in the range, with the cursor in that line. Example: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
def Number()
echo "line " .. line(".") .. " contains: " .. getline(".")
enddef
2004-06-13 20:20:40 +00:00
If you call this function with: >
2022-06-09 20:45:54 +01:00
:10,15Number()
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
The function will be called six times, starting on line 10 and ending on line
15.
2004-06-13 20:20:40 +00:00
LISTING FUNCTIONS
2021-12-30 20:24:12 +00:00
The `function` command lists the names and arguments of all user-defined
2004-06-13 20:20:40 +00:00
functions: >
:function
2021-12-30 20:24:12 +00:00
< def <SNR>86_Show(start: string, ...items: list<string>) ~
2004-06-13 20:20:40 +00:00
function GetVimIndent() ~
function SetSyn(name) ~
2021-12-30 20:24:12 +00:00
The "<SNR>" prefix means that a function is script-local. |Vim9| functions
2022-06-12 22:15:57 +01:00
will start with "def" and include argument and return types. Legacy functions
2021-12-30 20:24:12 +00:00
are listed with "function".
To see what a function does, use its name as an argument for `function`: >
2004-06-13 20:20:40 +00:00
:function SetSyn
< 1 if &syntax == '' ~
2 let &syntax = a:name ~
3 endif ~
endfunction ~
2022-06-03 21:59:47 +01:00
To see the "Show" function you need to include the script prefix, since
multiple "Show" functions can be defined in different scripts. To find
2021-12-30 20:24:12 +00:00
the exact name you can use `function`, but the result may be a very long list.
To only get the functions matching a pattern you can use the `filter` prefix:
>
:filter Show function
< def <SNR>86_Show(start: string, ...items: list<string>) ~
>
:function <SNR>86_Show
< 1 echohl Title ~
2 echo "start is " .. start ~
etc.
2004-06-13 20:20:40 +00:00
DEBUGGING
The line number is useful for when you get an error message or when debugging.
See |debug-scripts| about debugging mode.
2021-12-30 20:24:12 +00:00
You can also set the 'verbose' option to 12 or higher to see all function
2004-06-13 20:20:40 +00:00
calls. Set it to 15 or higher to see every executed line.
DELETING A FUNCTION
2021-12-30 20:24:12 +00:00
To delete the SetSyn() function: >
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
:delfunction SetSyn
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
Deleting only works for global functions and functions in legacy script, not
for functions defined in a |Vim9| script.
You get an error when the function doesn't exist or cannot be deleted.
2004-06-13 20:20:40 +00:00
2005-02-07 22:01:03 +00:00
FUNCTION REFERENCES
Sometimes it can be useful to have a variable point to one function or
2022-06-03 21:59:47 +01:00
another. You can do it with a function reference variable. Often shortened
to "funcref". Example: >
2021-12-30 20:24:12 +00:00
2022-06-03 21:59:47 +01:00
def Right(): string
2021-12-30 20:24:12 +00:00
return 'Right!'
enddef
2022-06-03 21:59:47 +01:00
def Wrong(): string
2021-12-30 20:24:12 +00:00
return 'Wrong!'
enddef
2022-06-26 12:21:15 +01:00
2021-12-30 20:24:12 +00:00
var Afunc = g:result == 1 ? Right : Wrong
2022-06-03 21:59:47 +01:00
echo Afunc()
2005-02-07 22:01:03 +00:00
< Wrong! ~
2022-06-03 21:59:47 +01:00
This assumes "g:result" is not one. See |Funcref| for details.
2021-12-30 20:24:12 +00:00
2005-02-07 22:01:03 +00:00
Note that the name of a variable that holds a function reference must start
with a capital. Otherwise it could be confused with the name of a builtin
function.
2022-06-09 20:45:54 +01:00
FURTHER READING
Using a variable number of arguments is introduced in section |50.2|.
More information about defining your own functions here: |user-functions|.
2005-02-07 22:01:03 +00:00
==============================================================================
*41.8* Lists and Dictionaries
So far we have used the basic types String and Number. Vim also supports two
composite types: List and Dictionary.
2021-12-30 20:24:12 +00:00
A List is an ordered sequence of items. The items can be any kind of value,
2005-02-07 22:01:03 +00:00
thus you can make a List of numbers, a List of Lists and even a List of mixed
items. To create a List with three strings: >
2022-06-03 21:59:47 +01:00
var alist = ['aap', 'noot', 'mies']
2005-02-07 22:01:03 +00:00
The List items are enclosed in square brackets and separated by commas. To
create an empty List: >
2021-12-30 20:24:12 +00:00
var alist = []
2005-02-07 22:01:03 +00:00
You can add items to a List with the add() function: >
2021-12-30 20:24:12 +00:00
var alist = []
add(alist, 'foo')
add(alist, 'bar')
echo alist
2005-02-07 22:01:03 +00:00
< ['foo', 'bar'] ~
List concatenation is done with +: >
2021-12-30 20:24:12 +00:00
var alist = ['foo', 'bar']
alist = alist + ['and', 'more']
echo alist
< ['foo', 'bar', 'and', 'more'] ~
2005-02-07 22:01:03 +00:00
2022-06-03 21:59:47 +01:00
Or, if you want to extend a List with a function, use `extend()`: >
2005-02-07 22:01:03 +00:00
2021-12-30 20:24:12 +00:00
var alist = ['one']
extend(alist, ['two', 'three'])
echo alist
2005-02-07 22:01:03 +00:00
< ['one', 'two', 'three'] ~
2022-06-03 21:59:47 +01:00
Notice that using `add()` will have a different effect than `extend()`: >
2005-02-07 22:01:03 +00:00
2021-12-30 20:24:12 +00:00
var alist = ['one']
add(alist, ['two', 'three'])
echo alist
2005-02-07 22:01:03 +00:00
< ['one', ['two', 'three']] ~
2021-12-30 20:24:12 +00:00
The second argument of add() is added as an item, now you have a nested list.
2005-02-07 22:01:03 +00:00
FOR LOOP
One of the nice things you can do with a List is iterate over it: >
2021-12-30 20:24:12 +00:00
var alist = ['one', 'two', 'three']
for n in alist
echo n
endfor
2005-02-07 22:01:03 +00:00
< one ~
two ~
three ~
2021-12-30 20:24:12 +00:00
This will loop over each element in List "alist", assigning each value to
2005-02-07 22:01:03 +00:00
variable "n". The generic form of a for loop is: >
2022-06-03 21:59:47 +01:00
for {varname} in {list-expression}
2021-12-30 20:24:12 +00:00
{commands}
endfor
2005-02-07 22:01:03 +00:00
To loop a certain number of times you need a List of a specific length. The
range() function creates one for you: >
2021-12-30 20:24:12 +00:00
for a in range(3)
echo a
endfor
2005-02-07 22:01:03 +00:00
< 0 ~
1 ~
2 ~
Notice that the first item of the List that range() produces is zero, thus the
2022-06-03 21:59:47 +01:00
last item is one less than the length of the list. Detail: Internally range()
does not actually create the list, so that a large range used in a for loop
works efficiently. When used elsewhere, the range is turned into an actual
2022-06-12 22:15:57 +01:00
list, which takes more time for a long list.
2005-02-07 22:01:03 +00:00
2021-12-30 20:24:12 +00:00
You can also specify the maximum value, the stride and even go backwards: >
for a in range(8, 4, -2)
echo a
endfor
2005-02-07 22:01:03 +00:00
< 8 ~
6 ~
4 ~
2022-06-03 21:59:47 +01:00
A more useful example, looping over all the lines in the buffer: >
2005-02-07 22:01:03 +00:00
2022-06-03 21:59:47 +01:00
for line in getline(1, 50)
2021-12-30 20:24:12 +00:00
if line =~ "Date: "
echo line
endif
endfor
2005-02-07 22:01:03 +00:00
2022-06-03 21:59:47 +01:00
This looks into lines 1 to 50 (inclusive) and echoes any date found in there.
For further reading see |Lists|.
2005-02-07 22:01:03 +00:00
DICTIONARIES
A Dictionary stores key-value pairs. You can quickly lookup a value if you
know the key. A Dictionary is created with curly braces: >
2006-04-30 18:54:39 +00:00
2021-12-30 20:24:12 +00:00
var uk2nl = {one: 'een', two: 'twee', three: 'drie'}
2005-02-07 22:01:03 +00:00
2005-02-12 14:29:27 +00:00
Now you can lookup words by putting the key in square brackets: >
2005-02-07 22:01:03 +00:00
2021-12-30 20:24:12 +00:00
echo uk2nl['two']
< twee ~
If the key does not have special characters, you can use the dot notation: >
echo uk2nl.two
2005-02-07 22:01:03 +00:00
< twee ~
The generic form for defining a Dictionary is: >
{<key> : <value>, ...}
An empty Dictionary is one without any keys: >
{}
The possibilities with Dictionaries are numerous. There are various functions
for them as well. For example, you can obtain a list of the keys and loop
over them: >
2021-12-30 20:24:12 +00:00
for key in keys(uk2nl)
echo key
endfor
2005-02-07 22:01:03 +00:00
< three ~
one ~
two ~
2008-06-24 21:16:56 +00:00
You will notice the keys are not ordered. You can sort the list to get a
2005-02-07 22:01:03 +00:00
specific order: >
2021-12-30 20:24:12 +00:00
for key in sort(keys(uk2nl))
echo key
endfor
2005-02-07 22:01:03 +00:00
< one ~
three ~
two ~
But you can never get back the order in which items are defined. For that you
need to use a List, it stores items in an ordered sequence.
2022-06-03 21:59:47 +01:00
For further reading see |Dictionaries|.
2005-02-07 22:01:03 +00:00
2004-06-13 20:20:40 +00:00
==============================================================================
2022-06-09 20:45:54 +01:00
*41.9* White space
2004-06-13 20:20:40 +00:00
2022-06-23 13:04:20 +01:00
Blank lines are allowed in a script and ignored.
2004-06-13 20:20:40 +00:00
2022-06-23 13:04:20 +01:00
Leading whitespace characters (blanks and TABs) are ignored, except when using
|:let-heredoc| without "trim".
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
Trailing whitespace is often ignored, but not always. One command that
2022-06-09 20:45:54 +01:00
includes it is `map`. You have to watch out for that, it can cause hard to
understand mistakes. A generic solution is to never use trailing white space,
unless you really need it.
2004-06-13 20:20:40 +00:00
To include a whitespace character in the value of an option, it must be
escaped by a "\" (backslash) as in the following example: >
:set tags=my\ nice\ file
2022-06-03 21:59:47 +01:00
If it would be written as: >
2004-06-13 20:20:40 +00:00
:set tags=my nice file
2022-06-03 21:59:47 +01:00
This will issue an error, because it is interpreted as: >
2004-06-13 20:20:40 +00:00
:set tags=my
:set nice
:set file
2021-12-30 20:24:12 +00:00
|Vim9| script is very picky when it comes to white space. This was done
intentionally to make sure scripts are easy to read and to avoid mistakes.
2022-06-03 21:59:47 +01:00
If you use white space sensibly it will just work. When not you will get an
error message telling you where white space is missing or should be removed.
2021-12-30 20:24:12 +00:00
2022-06-09 20:45:54 +01:00
==============================================================================
*41.10* Line continuation
In legacy Vim script line continuation is done by preceding a continuation
line with a backslash: >
let mylist = [
\ 'one',
\ 'two',
\ ]
This requires the 'cpo' option to exclude the "C" flag. Normally this is done
by putting this at the start of the script: >
let s:save_cpo = &cpo
set cpo&vim
And restore the option at the end of the script: >
let &cpo = s:save_cpo
unlet s:save_cpo
A few more details can be found here: |line-continuation|.
In |Vim9| script the backslash can still be used, but in most places it is not
needed: >
var mylist = [
'one',
'two',
]
Also, the 'cpo' option does not need to be changed. See
|vim9-line-continuation| for details.
2004-06-13 20:20:40 +00:00
2022-06-09 20:45:54 +01:00
==============================================================================
*41.11* Comments
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
In |Vim9| script the character # starts a comment. That character and
everything after it until the end-of-line is considered a comment and
2004-06-13 20:20:40 +00:00
is ignored, except for commands that don't consider comments, as shown in
2021-12-30 20:24:12 +00:00
examples below. A comment can start on any character position on the line,
2022-06-03 21:59:47 +01:00
but not when it is part of the command, e.g. inside a string.
2021-12-30 20:24:12 +00:00
2022-06-26 12:21:15 +01:00
The character " (the double quote mark) starts a comment in legacy script.
2022-06-03 21:59:47 +01:00
This involves some cleverness to make sure double quoted strings are not
recognized as comments (just one reason to prefer |Vim9| script).
2004-06-13 20:20:40 +00:00
There is a little "catch" with comments for some commands. Examples: >
2021-12-30 20:24:12 +00:00
abbrev dev development # shorthand
map <F3> o#include # insert include
execute cmd # do it
!ls *.c # list C files
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
- The abbreviation 'dev' will be expanded to 'development # shorthand'.
- The mapping of <F3> will actually be the whole line after the 'o# ....'
including the '# insert include'.
- The `execute` command will give an error.
- The `!` command will send everything after it to the shell, most likely
causing an error.
2004-06-13 20:20:40 +00:00
2021-12-30 20:24:12 +00:00
There can be no comment after `map`, `abbreviate`, `execute` and `!` commands
(there are a few more commands with this restriction). For the `map`,
`abbreviate` and `execute` commands there is a trick: >
abbrev dev development|# shorthand
map <F3> o#include|# insert include
execute '!ls *.c' |# do it
2004-06-13 20:20:40 +00:00
With the '|' character the command is separated from the next one. And that
2021-12-30 20:24:12 +00:00
next command is only a comment. The last command, using `execute` is a
general solution, it works for all commands that do not accept a comment or a
'|' to separate the next command.
2004-06-13 20:20:40 +00:00
Notice that there is no white space before the '|' in the abbreviation and
mapping. For these commands, any character until the end-of-line or '|' is
included. As a consequence of this behavior, you don't always see that
trailing whitespace is included: >
2021-12-30 20:24:12 +00:00
map <F4> o#include
2004-06-13 20:20:40 +00:00
2022-06-03 21:59:47 +01:00
Here it is intended, in other cases it might be accidental. To spot these
problems, you can highlight trailing spaces: >
2021-12-30 20:24:12 +00:00
match Search /\s\+$/
2004-06-13 20:20:40 +00:00
2007-05-06 12:51:41 +00:00
For Unix there is one special way to comment a line, that allows making a Vim
2021-12-30 20:24:12 +00:00
script executable, and it also works in legacy script: >
2007-05-06 12:51:41 +00:00
#!/usr/bin/env vim -S
echo "this is a Vim script"
quit
2022-06-09 20:45:54 +01:00
==============================================================================
*41.12* Fileformat
2004-06-13 20:20:40 +00:00
2022-06-09 20:45:54 +01:00
The end-of-line character depends on the system. For Vim scripts it is
2022-06-23 13:04:20 +01:00
recommended to always use the Unix fileformat. Lines are then separated with
the Newline character. This also works on any other system. That way you can
copy your Vim scripts from MS-Windows to Unix and they still work. See
|:source_crnl|. To be sure it is set right, do this before writing the file:
>
2022-06-09 20:45:54 +01:00
:setlocal fileformat=unix
2022-05-21 13:08:16 +01:00
2022-06-23 13:04:20 +01:00
When using "dos" fileformat, lines are separated with CR-NL, two characters.
The CR character causes various problems, better avoid this.
2004-06-13 20:20:40 +00:00
==============================================================================
2022-06-09 20:45:54 +01:00
Advance information about writing Vim script is in |usr_50.txt|.
2004-06-13 20:20:40 +00:00
Next chapter: |usr_42.txt| Add new menus
2018-08-11 18:00:22 +02:00
Copyright: see |manual-copyright| vim:tw=78:ts=8:noet:ft=help:norl: