Shell functions are defined with the function reserved word or the special syntax `funcname ()'. Shell functions are read in and stored internally. Alias names are resolved when the function is read. Functions are executed like commands with the arguments passed as positional parameters. (See section Command Execution.)
Functions execute in the same process as the caller and share all files and present working directory with the caller. A trap on EXIT set inside a function is executed after the function completes in the environment of the caller.
The return builtin is used to return from function calls.
Function identifiers can be listed with the functions builtin. Functions can be undefined with the unfunction builtin.
A function can be marked as undefined using the autoload builtin (or `functions -u' or `typeset -fu'). Such a function has no body. When the function is first executed, the shell searches for its definition using the elements of the fpath variable. Thus to define functions for autoloading, a typical sequence is:
fpath=(~/myfuncs $fpath) autoload myfunc1 myfunc2 ...
The usual alias expansion during reading will be suppressed if the autoload builtin or its equivalent is given the option -U. For functions precompiled with the zcompile builtin command, this has to be decided when creating the file; this is recommended for the use of functions supplied with the zsh distribution.
For each element in fpath, the shell looks for three files, the newest of which is used to load the definition for the function:
If the KSH_AUTOLOAD option is set, or the file contains only a simple definition of the function, the file's contents will be executed. This will normally define the function in question, but may also perform initialization; such initialization is executed in the context of the function execution, and may therefore define local parameters. It is an error if the function is not defined by loading the file.
Otherwise, the function is defined such that its body is the complete contents of the file. This form allows the file to be used directly as an executable shell script. If processing of the file results in the function being re-defined, the function itself is not re-executed. To force the function to perform initialization and be called, the file should contain initialization code (which will be discarded) in addition to a complete function definition (which will be retained for subsequent calls to the function), and a call to the shell function at the end.
For example, suppose the autoload file func contains
func() { print This is func; } print func is initialized
then `func; func' with KSH_AUTOLOAD set will produce both messages on the first call, and just the message `This is func' on the second and any subsequent calls. Without KSH_AUTOLOAD set, it will produce the initialization message on the first call, and the other message on the second and subsequent calls.
It is also possible to create a function that is not marked autoloaded, yet loads its own definition by searching fpath: `autoload -X', when called from within a shell function myfunc, is equivalent to:
unfunction myfunc autoload myfunc myfunc "$@"
In fact, the functions command outputs `builtin autoload -X' as the body of an autoloaded function. A true autoloaded function can be identified by the presence of the comment `# undefined' in the body, because all comments are discarded from defined functions. This is done so that
eval "$(functions)"
produces a reasonable result.
To load the definition of an autoloaded function myfunc without executing myfunc, use:
autoload +X myfunc
The following functions, if defined, have special meaning to the shell:
The functions beginning `TRAP' may alternatively be defined with the trap builtin: this may be preferable for some uses, as they are then run in the environment of the calling process, rather than in their own function environment.
Go to the first, previous, next, last section, table of contents.