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

script.  There are a lot of them, thus this is a long chapter.


|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

|41.8| Lists and Dictionaries

|41.9| Exceptions

|41.10| Various remarks

|41.11| Writing a plugin

|41.12| Writing a filetype plugin

|41.13| Writing a compiler plugin

|41.14| Writing a plugin that loads quickly

|41.15| Writing library scripts

|41.16| Distributing Vim scripts


     Next chapter: |usr_42.txt|  Add new menus

 Previous chapter: |usr_40.txt|  Make new commands

Table of contents: |usr_toc.txt|




*41.1* Introduction *vim-script-intro* *script*


Your first experience with Vim scripts is the vimrc file.  Vim reads it when

it starts up and executes the commands.  You can set options to values you

prefer.  And 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).

   Syntax files are also Vim scripts.  As are files that set options for a

specific file type.  A complicated macro can be defined by a separate Vim

script file.  You can think of other uses yourself.


Let's start with a simple example:


:let i = 1

:while i < 5

:  echo "count is" i

:  let i += 1




The ":" characters are not really needed here.  You only need to use

them when you type a command.  In a Vim script file they can be left

out.  We will use them here anyway to make clear these are colon

commands and make them stand out from Normal mode commands.


You can try out the examples by yanking the lines from the text here

and executing them with :@"


The output of the example code is:


count is 1 

count is 2 

count is 3 

count is 4 


In the first line the ":let" command assigns a value to a variable.  The

generic form is:


:let {variable} = {expression}


In this case the variable name is "i" and the expression is a simple value,

the number one.

   The ":while" command starts a loop.  The generic form is:


:while {condition}

:  {statements}



The statements until the matching ":endwhile" are executed for as long as the

condition is true.  The condition used here is the expression "i < 5".  This

is true when the variable i is smaller than five.


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).


The ":echo" command prints its arguments.  In this case the string "count is"

and the value of the variable i.  Since i is one, this will print:


count is 1 


Then there is the ":let i += 1" command.  This does the same thing as

":let i = i + 1".  This adds one to the variable i and assigns the new value

to the same variable.


The example was given to explain the commands, but would you really want to

make such a loop it can be written much more compact:


:for i in range(1, 4)

:  echo "count is" i



We won't explain how |:for| and |range()| work until later.  Follow the links

if you are impatient.





Numbers can be decimal, hexadecimal or octal.  A hexadecimal number starts

with "0x" or "0X".  For example "0x1f" is decimal 31.  An octal number starts

with a zero.  "017" is decimal 15.  Careful: don't put a zero before a decimal

number, it will be interpreted as an octal number!

   The ":echo" command always prints decimal numbers.  Example:


:echo 0x7f 036

  127 30 


A number is made negative with a minus sign.  This also works for hexadecimal

and octal numbers.   A minus sign is also used for subtraction.  Compare this

with the previous example:


:echo 0x7f -036



White space in an expression is ignored.  However, it's recommended to use it

for separating items, to make the expression easier to read.  For example, to

avoid the confusion with a negative number above, put a space between the

minus sign and the following number:


:echo 0x7f - 036




*41.2* Variables


A variable name consists of ASCII letters, digits and the underscore.  It

cannot start with a digit.  Valid variable names are:








Invalid names are "foo+bar" and "6var".

   These variables are global.  To see a list of currently defined variables

use this command:




You can use global variables everywhere.  This also means that when the

variable "count" is used in one script file, it might also be used in another

file.  This leads to confusion at least, and real problems at worst.  To avoid

this, you can use a variable local to a script file by prepending "s:".  For

example, one script contains this code:


:let s:count = 1

:while s:count < 5

:  source other.vim

:  let s:count += 1



Since "s:count" is local to this script, you can be sure that sourcing the

"other.vim" script will not change this variable.  If "other.vim" also uses an

"s:count" variable, it will be a different copy, local to that script.  More

about script-local variables here: |script-variable|.


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





Variables take up memory and show up in the output of the ":let" command.  To

delete a variable use the ":unlet" command.  Example:


:unlet s:count


This deletes the script-local variable "s:count" 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 !:


:unlet! s:count


When a script finishes, the local variables used there will not be

automatically freed.  The next time the script executes, it can still use the

old value.  Example:


:if !exists("s:call_count")

:  let s:call_count = 0


:let s:call_count = s:call_count + 1

:echo "called" s:call_count "times"


The "exists()" function checks if a variable has already been defined.  Its

argument is the name of the variable you want to check.  Not the variable

itself!  If you would do this:


:if !exists(s:call_count)


Then the value of s:call_count will be used as the name of the variable that

exists() checks.  That's not what you want.

   The exclamation mark ! negates a value.  When the value was true, it

becomes false.  When it was false, it becomes true.  You can read it as "not".

Thus "if !exists()" can be read as "if not exists()".

   What Vim calls true is anything that is not zero.  Zero is false.


Vim automatically converts a string to a number when it is looking for

a number.  When using a string that doesn't start with a digit the

resulting number is zero.  Thus look out for this:

:if "true"

  The "true" will be interpreted as a zero, thus as false!





So far only numbers were used for the variable value.  Strings can be used as

well.  Numbers and strings are the basic types of variables that Vim supports.

The type is dynamic, it is set each time when assigning a value to the

variable with ":let".  More about types in |41.8|.

   To assign a string value to a variable, you need to use a string constant.

There are two types of these.  First the string in double quotes:


:let name = "peter"

:echo name



If you want to include a double quote inside the string, put a backslash in

front of it:


:let name = "\"peter\""

:echo name



To avoid the need for a backslash, you can use a string in single quotes:


:let name = '"peter"'

:echo name



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

character after it.

   In double-quote strings it is possible to use special characters.  Here are

a few useful ones:


\t <Tab>

\n <NL>, line break

\r <CR>, <Enter>

\e <Esc>

\b <BS>, backspace

\" "

\\ \, backslash

\<Esc> <Esc>



The last two are just examples.  The  "\<name>" form can be used to include

the special key "name".

   See |expr-quote| for the full list of special items in a string.




*41.3* Expressions


Vim has a rich, yet simple way to handle expressions.  You can read the

definition here: |expression-syntax|.  Here we will show the most common


   The numbers, strings and variables mentioned above are expressions by

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

&name option

@r register




:echo "The value of 'tabstop' is" &ts

:echo "Your home directory is" $HOME

:if @a > 5


The &name form can be used to save an option value, set it to a new value,

do something and restore the old value.  Example:


:let save_ic = &ic

:set noic

:/The Start/,$delete

:let &ic = save_ic


This makes sure the "The Start" pattern is used with the 'ignorecase' option

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|.)





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:


:echo 10 + 5 * 2



Grouping is done with parentheses.  No surprises here.  Example:


:echo (10 + 5) * 2



Strings can be concatenated with ".".  Example:


:echo "foo" . "bar"



When the ":echo" command gets multiple arguments, it separates them with a

space.  In the example the argument is a single expression, thus no space is



Borrowed from the C language is the conditional expression:


a ? b : c


If "a" evaluates to true "b" is used, otherwise "c" is used.  Example:


:let i = 4

:echo i > 5 ? "i is big" : "i is small"

  i is small 


The three parts of the constructs are always evaluated first, thus you could

see it work as:


(a) ? (b) : (c)




*41.4* Conditionals


The ":if" commands executes the following statements, until the matching

":endif", only when a condition is met.  The generic form is:


:if {condition}




Only when the expression {condition} evaluates to true (non-zero) will the

{statements} be executed.  These must still be valid commands.  If they

contain garbage, Vim won't be able to find the ":endif".

   You can also use ":else".  The generic form for this is:


:if {condition}






The second {statements} is only executed if the first one isn't.

   Finally, there is ":elseif":


:if {condition}


:elseif {condition}




This works just like using ":else" and then "if", but without the need for an

extra ":endif".

   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


:  " Do something for other terminals






We already used some of them in the examples.  These are the most often used



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


The result is one if the condition is met and zero otherwise.  An example:


:if v:version >= 700

:  echo "congratulations"


:  echo "you are using an old version, upgrade!"



Here "v:version" is a variable defined by Vim, which has the value of the Vim

version.  600 is for version 6.0.  Version 6.1 has the value 601.  This is

very useful to write a script that works with multiple versions of Vim.



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.

   When comparing a string with a number, the string is first converted to a

number.  This is a bit tricky, because when a string doesn't look like a

number, the number zero is used.  Example:


:if 0 == "one"

:  echo "yes"



This will echo "yes", because "one" doesn't look like a number, thus it is

converted to the number zero.


For strings there are two more items:


a =~ b matches with

a !~ b does not match with


The left item "a" is used as a string.  The right item "b" is used as a

pattern, like what's used for searching.  Example:


:if str =~ " "

:  echo "str contains a space"


:if str !~ '\.$'

:  echo "str does not end in a full stop"



Notice the use of a single-quote string for the pattern.  This is useful,

because backslashes would need to be doubled in a double-quote string and

patterns tend to contain many backslashes.


The 'ignorecase' option is used when comparing strings.  When you don't want

that, append "#" to match case and "?" to ignore case.  Thus "==?" compares

two strings to be equal while ignoring case.  And "!~#" checks if a pattern

doesn't match, also checking the case of letters.  For the full table see






The ":while" command was already mentioned.  Two more statements can be used

in between the ":while" and the ":endwhile":


:continue Jump back to the start of the while loop; the

loop continues.

:break Jump forward to the ":endwhile"; the loop is





:while counter < 40

:  call do_something()

:  if skip_flag

:    continue

:  endif

:  if finished_flag

:    break

:  endif

:  sleep 50m



The ":sleep" command makes Vim take a nap.  The "50m" specifies fifty

milliseconds.  Another example is ":sleep 4", which sleeps for four seconds.


Even more looping can be done with the ":for" command, see below in |41.8|.




*41.5* Executing an expression


So far the commands in the script were executed by Vim directly.  The

":execute" command allows executing the result of an expression.  This is a

very powerful way to build commands and execute them.

   An example is to jump to a tag, which is contained in a variable:


:execute "tag " . tag_name


The "." is used to concatenate the string "tag " with the value of variable

"tag_name".  Suppose "tag_name" has the value "get_cmd", then the command that

will be executed is:


:tag get_cmd


The ":execute" command can only execute colon commands.  The ":normal" command

executes Normal mode commands.  However, its argument is not an expression but

the literal command characters.  Example:


:normal gg=G


This jumps to the first line and formats all lines with the "=" operator.

   To make ":normal" work with an expression, combine ":execute" with it.



:execute "normal " . normal_commands


The variable "normal_commands" must contain the Normal mode commands.

   Make sure that the argument for ":normal" is a complete command.  Otherwise

Vim will run into the end of the argument and abort the command.  For example,

if you start Insert mode, you must leave Insert mode as well.  This works:


:execute "normal Inew text \<Esc>"


This inserts "new text " in the current line.  Notice the use of the special

key "\<Esc>".  This avoids having to enter a real <Esc> character in your



If you don't want to execute a string but evaluate it to get its expression

value, you can use the eval() function:


:let optname = "path"

:let optval = eval('&' . optname)


A "&" character is prepended to "path", thus the argument to eval() is

"&path".  The result will then be the value of the 'path' option.

   The same thing can be done with:

:exe 'let optval = &' . optname




*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

list here: |functions|.


A function is called with the ":call" command.  The parameters are passed in

between parentheses separated by commas.  Example:


:call search("Date: ", "W")


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.


A function can be called in an expression.  Example:


:let line = getline(".")

:let repl = substitute(line, '\a', "*", "g")

:call setline(".", repl)


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.

   The substitute() function does something similar to the ":substitute"

command.  The first argument is the string on which to perform the

substitution.  The second argument is the pattern, the third the replacement

string.  Finally, the last arguments are the flags.

   The setline() function sets the line, specified by the first argument, to a

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:




Using the functions becomes more interesting when you do more work before and

after the substitute() call.




FUNCTIONS *function-list*


There are many functions.  We will mention them here, grouped by what they are

used for.  You can find an alphabetical list here: |functions|.  Use CTRL-] on

the function name to jump to detailed help on it.



String manipulation: *string-functions*

nr2char() get a character by its ASCII value

char2nr() get ASCII value of a character

str2nr() convert a string to a Number

str2float() convert a string to a Float

printf() format a string according to % items

escape() escape characters in a string with a '\'

shellescape() escape a string for use with a shell command

fnameescape() escape a file name for use with a Vim command

tr() translate characters from one set to another

strtrans() translate a string to make it printable

tolower() turn a string to lowercase

toupper() turn a string to uppercase

match() position where a pattern matches in a string

matchend() position where a pattern match ends in a string

matchstr() match of a pattern in a string

matchlist() like matchstr() and also return submatches

stridx() first index of a short string in a long string

strridx() last index of a short string in a long string

strlen() length of a string

substitute() substitute a pattern match with a string

submatch() get a specific match in a ":substitute"

strpart() get part of a string

expand() expand special keywords

iconv() convert text from one encoding to another

byteidx() byte index of a character in a string

repeat() repeat a string multiple times

eval() evaluate a string expression



List manipulation: *list-functions*

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

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

sort() sort a List

reverse() reverse the order of a List

split() split a String into a List

join() join List items into a String

range() return a List with a sequence of numbers

string() String representation of a List

call() call a function with List as arguments

index() index of a value in a List

max() maximum value in a List

min() minimum value in a List

count() count number of times a value appears in a List

repeat() repeat a List multiple times



Dictionary manipulation: *dict-functions*

get() get an entry without an error for a wrong key

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

filter() remove selected entries from a Dictionary

map() change each Dictionary entry

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*

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

log10() logarithm to base 10

pow() value of x to the exponent y

sqrt() square root

sin() sine

cos() cosine

tan() tangent

asin() arc sine

acos() arc cosine

atan() arc tangent

atan2() arc tangent

sinh() hyperbolic sine

cosh() hyperbolic cosine

tanh() hyperbolic tangent



Variables: *var-functions*

type() type of a variable

islocked() check if a variable is locked

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

getwinvar() get a variable from specific window

gettabvar() get a variable from specific tab page

gettabwinvar() get a variable from specific window & tab page

setwinvar() set a variable in a specific window

settabvar() set a variable in a specific tab page

settabwinvar() set a variable in a specific window & tab page

garbagecollect() possibly free memory



Cursor and mark position: *cursor-functions* *mark-functions*

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

getpos() get position of cursor, mark, etc.

setpos() set position of cursor, mark, etc.

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



Working with text in the current buffer: *text-functions*

getline() get a line or list of lines from the buffer

setline() replace a line in the buffer

append() append line or list of lines in the buffer

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

searchpos() find a match for a pattern

searchpair() find the other end of a start/skip/end

searchpairpos() find the other end of a start/skip/end

searchdecl() search for the declaration of a name



*system-functions* *file-functions*

System functions and manipulation of files:

glob() expand wildcards

globpath() expand wildcards in a number of directories

findfile() find a file in a list of directories

finddir() find a directory in a list of directories

resolve() find out where a shortcut points to

fnamemodify() modify a file name

pathshorten() shorten directory names in a path

simplify() simplify a path without changing its meaning

executable() check if an executable program exists

filereadable() check if a file can be read

filewritable() check if a file can be written to

getfperm() get the permissions of a file

getftype() get the kind of a file

isdirectory() check if a directory exists

getfsize() get the size of a file

getcwd() get the current working directory

haslocaldir() check if current window used |:lcd|

tempname() get the name of a temporary file

mkdir() create a new directory

delete() delete a file

rename() rename a file

system() get the result of a shell command

hostname() name of the system

readfile() read a file into a List of lines

writefile() write a List of lines into a file



Date and Time: *date-functions* *time-functions*

getftime() get last modification time of a file

localtime() get current time in seconds

strftime() convert time to a string

reltime() get the current or elapsed time accurately

reltimestr() convert reltime() result to a string



*buffer-functions* *window-functions* *arg-functions*

Buffers, windows and the argument list:

argc() number of entries in the argument list

argidx() current position in the argument list

argv() get one entry from the argument list

bufexists() check if a buffer exists

buflisted() check if a buffer exists and is listed

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

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

winnr() get the window number for the current window

bufwinnr() get the window number of a specific buffer

winbufnr() get the buffer number of a specific window

getbufline() get a list of lines from the specified buffer



Command line: *command-line-functions*

getcmdline() get the current command line

getcmdpos() get position of the cursor in the command line

setcmdpos() set position of the cursor in the command line

getcmdtype() return the current command-line type



Quickfix and location lists: *quickfix-functions*

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*

complete() set found matches

complete_add() add to found matches

complete_check() check if completion should be aborted

pumvisible() check if the popup menu is displayed



Folding: *folding-functions*

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

foldtextresult() get the text displayed for a closed fold



Syntax and highlighting:  *syntax-functions* *highlighting-functions*

clearmatches() clear all matches defined by |matchadd()| and

the |:match| commands

getmatches() get all matches defined by |matchadd()| and

the |:match| commands

hlexists() check if a highlight group exists

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

synstack() get list of syntax IDs at a specific position

synconcealed() get info about concealing

diff_hlID() get highlight ID for diff mode at a position

matchadd() define a pattern to highlight (a "match")

matcharg() get info about |:match| arguments

matchdelete() delete a match defined by |matchadd()| or a

|:match| command

setmatches() restore a list of matches saved by




Spelling: *spell-functions*

spellbadword() locate badly spelled word at or after cursor

spellsuggest() return suggested spelling corrections

soundfold() return the sound-a-like equivalent of a word



History: *history-functions*

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*

browse() put up a file requester

browsedir() put up a directory requester

confirm() let the user make a choice

getchar() get a character from the user

getcharmod() get modifiers for the last typed character

feedkeys() put characters in the typeahead queue

input() get a line from the user

inputlist() let the user pick an entry from a list

inputsecret() get a line from the user without showing it

inputdialog() get a line from the user in a dialog

inputsave() save and clear typeahead

inputrestore() restore typeahead



GUI: *gui-functions*

getfontname() get name of current font being used

getwinposx() X position of the GUI Vim window

getwinposy() Y position of the GUI Vim window



Vim server: *server-functions*

serverlist() return the list of server names

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*

winheight() get height of a specific window

winwidth() get width of a specific window

winrestcmd() return command to restore window sizes

winsaveview() get view of current window

winrestview() restore saved view of current window



Various: *various-functions*

mode() get current editing mode

visualmode() last visual mode used

hasmapto() check if a mapping exists

mapcheck() check if a matching mapping exists

maparg() get rhs of a mapping

exists() check if a variable, function, etc. exists

has() check if a feature is supported in Vim

changenr() return number of most recent change

cscope_connection() check if a cscope connection exists

did_filetype() check if a FileType autocommand was used

eventhandler() check if invoked by an event handler

getpid() get process ID of Vim


libcall() call a function in an external library

libcallnr() idem, returning a number


getreg() get contents of a register

getregtype() get type of a register

setreg() set contents and type of a register


taglist() get list of matching tags

tagfiles() get a list of tags files


mzeval() evaluate |MzScheme| expression




*41.7* Defining a function


Vim enables you to define your own functions.  The basic function declaration

begins as follows:


:function {name}({var1}, {var2}, ...)

:  {body}




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:


:function Min(num1, num2)


This tells Vim that the function is named "Min" and it takes two arguments:

"num1" and "num2".

   The first thing you need to do is to check to see which number is smaller:


:  if a:num1 < a:num2


The special prefix "a:" tells Vim that the variable is a function argument.

Let's assign the variable "smaller" the value of the smallest number:


:  if a:num1 < a:num2

:    let smaller = a:num1

:  else

:    let smaller = a:num2

:  endif


The variable "smaller" is a local variable.  Variables used inside a function

are local unless prefixed by something like "g:", "a:", or "s:".



To access a global variable from inside a function you must prepend

"g:" to it.  Thus "g:today" inside a function is used for the global

variable "today", and "today" is another variable, local to the



You now use the ":return" statement to return the smallest number to the user.

Finally, you end the function:


:  return smaller



The complete function definition is as follows:


:function Min(num1, num2)

:  if a:num1 < a:num2

:    let smaller = a:num1

:  else

:    let smaller = a:num2

:  endif

:  return smaller



For people who like short functions, this does the same thing:


:function Min(num1, num2)

:  if a:num1 < a:num2

:    return a:num1

:  endif

:  return a:num2



A user defined function is called in exactly the same way as a built-in

function.  Only the name is different.  The Min function can be used like



:echo Min(5, 8)


Only now will the function be executed and the lines be interpreted by Vim.

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



When a function reaches ":endfunction" or ":return" is used without an

argument, the function returns zero.


To redefine a function that already exists, use the ! for the ":function"



:function!  Min(num1, num2, num3)





The ":call" command can be given a line rang


댓글 본문
graphittie 자세히 보기