<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
**Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*

- [15 Parameters](#15-parameters)
  - [15.1 Description](#151-description)
  - [15.2 Array Parameters](#152-array-parameters)
    - [15.2.1 Array Subscripts](#1521-array-subscripts)
    - [15.2.2 Array Element Assignment](#1522-array-element-assignment)
    - [15.2.3 Subscript Flags](#1523-subscript-flags)
    - [15.2.4 Subscript Parsing](#1524-subscript-parsing)
  - [15.3 Positional Parameters](#153-positional-parameters)
  - [15.4 Local Parameters](#154-local-parameters)
  - [15.5 Parameters Set By The Shell](#155-parameters-set-by-the-shell)
  - [15.6 Parameters Used By The Shell](#156-parameters-used-by-the-shell)

<!-- END doctoc generated TOC please keep comment here to allow auto update -->

<span id="Parameters"></span> <span id="Parameters-1"></span>

# 15 Parameters

<span id="index-parameters"></span> <span id="index-variables"></span>

-----

<span id="Description-5"></span>

## 15.1 Description

A parameter has a name, a value, and a number of attributes. A name may
be any sequence of alphanumeric characters and underscores, or the
single characters ‘`*`’, ‘`@`’, ‘`#`’, ‘`?`’, ‘`-`’, ‘`$`’, or ‘`!`’. A
parameter whose name begins with an alphanumeric or underscore is also
referred to as a *variable*.

<span id="index-scalar"></span>
<span id="index-parameters_002c-scalar"></span>
<span id="index-parameters_002c-array"></span>
<span id="index-parameters_002c-associative-array"></span>
<span id="index-hash"></span>

The attributes of a parameter determine the *type* of its value, often
referred to as the parameter type or variable type, and also control
other processing that may be applied to the value when it is referenced.
The value type may be a *scalar* (a string, an integer, or a floating
point number), an array (indexed numerically), or an *associative* array
(an unordered set of name-value pairs, indexed by name, also referred to
as a *hash*).

<span id="index-export"></span> <span id="index-environment"></span>
<span id="index-environment-variables"></span>
<span id="index-variables_002c-environment"></span>

Named scalar parameters may have the *exported*, `-x`, attribute, to
copy them into the process environment, which is then passed from the
shell to any new processes that it starts. Exported parameters are
called *environment variables*. The shell also *imports* environment
variables at startup time and automatically marks the corresponding
parameters as exported. Some environment variables are not imported for
reasons of security or because they would interfere with the correct
operation of other shell features.

<span id="index-special-parameters"></span>
<span id="index-parameters_002c-special"></span>

Parameters may also be *special*, that is, they have a predetermined
meaning to the shell. Special parameters cannot have their type changed
or their readonly attribute turned off, and if a special parameter is
unset, then later recreated, the special properties will be retained.

To declare the type of a parameter, or to assign a string or numeric
value to a scalar parameter, use the `typeset` builtin.
<span id="index-typeset_002c-use-of"></span>

The value of a scalar parameter may also be assigned by writing:
<span id="index-assignment"></span>

> `name``=``value`

In scalar assignment, `value` is expanded as a single string, in which
the elements of arrays are joined together; filename expansion is not
performed unless the option `GLOB_ASSIGN` is set.

When the integer attribute, `-i`, or a floating point attribute, `-E` or
`-F`, is set for `name`, the `value` is subject to arithmetic
evaluation. Furthermore, by replacing ‘`=`’ with ‘`+=`’, a parameter can
be incremented or appended to. See [Array Parameters](#Array-Parameters)
and [Arithmetic
Evaluation](Arithmetic-Evaluation.html#Arithmetic-Evaluation) for
additional forms of assignment.

Note that assignment may implicitly change the attributes of a
parameter. For example, assigning a number to a variable in arithmetic
evaluation may change its type to integer or float, and with
`GLOB_ASSIGN` assigning a pattern to a variable may change its type to
an array.

To reference the value of a parameter, write ‘`$``name`’ or
‘`${``name``}`’. See [Parameter
Expansion](Expansion.html#Parameter-Expansion) for complete details.
That section also explains the effect of the difference between scalar
and array assignment on parameter expansion.

-----

<span id="Array-Parameters"></span>
<span id="Array-Parameters-1"></span>

## 15.2 Array Parameters

To assign an array value, write one of:
<span id="index-set_002c-use-of"></span>
<span id="index-array-assignment"></span>

> `set -A` `name` `value` ...

> `name``=(``value` ...`)`

> `name``=(``[``key``]=``value` ...`)`

If no parameter `name` exists, an ordinary array parameter is created.
If the parameter `name` exists and is a scalar, it is replaced by a new
array.

In the third form, `key` is an expression that will be evaluated in
arithmetic context (in its simplest form, an integer) that gives the
index of the element to be assigned with `value`. In this form any
elements not explicitly mentioned that come before the largest index to
which a value is assigned are assigned an empty string. The indices may
be in any order. Note that this syntax is strict: `[` and `]=` must not
be quoted, and `key` may not consist of the unquoted string `]=`, but is
otherwise treated as a simple string. The enhanced forms of subscript
expression that may be used when directly subscripting a variable name,
described in the section Array Subscripts below, are not available.

The syntaxes with and without the explicit key may be mixed. An implicit
`key` is deduced by incrementing the index from the previously assigned
element. Note that it is not treated as an error if latter assignments
in this form overwrite earlier assignments.

For example, assuming the option `KSH_ARRAYS` is not set, the following:

<div class="example">

``` example
array=(one [3]=three four)
```

</div>

causes the array variable `array` to contain four elements `one`, an
empty string, `three` and `four`, in that order.

In the forms where only `value` is specified, full command line
expansion is performed.

In the `[``key``]=``value` form, both `key` and `value` undergo all
forms of expansion allowed for single word shell expansions (this does
not include filename generation); these are as performed by the
parameter expansion flag `(e)` as described in [Parameter
Expansion](Expansion.html#Parameter-Expansion). Nested parentheses may
surround `value` and are included as part of the value, which is joined
into a plain string; this differs from ksh which allows the values
themselves to be arrays. A future version of zsh may support that. To
cause the brackets to be interpreted as a character class for filename
generation, and therefore to treat the resulting list of files as a set
of values, quote the equal sign using any form of quoting. Example:

> `name``=(``[a-z]’=’*)`

To append to an array without changing the existing values, use one of
the following:

> `name``+=(``value` ...`)`

> `name``+=(``[``key``]=``value` ...`)`

In the second form `key` may specify an existing index as well as an
index off the end of the old array; any existing value is overwritten by
`value`. Also, it is possible to use `[``key``]+=``value` to append to
the existing value at that index.

Within the parentheses on the right hand side of either form of the
assignment, newlines and semicolons are treated the same as white space,
separating individual `value`s. Any consecutive sequence of such
characters has the same effect.

Ordinary array parameters may also be explicitly declared with:
<span id="index-typeset_002c-use-of-1"></span>

> `typeset -a` `name`

Associative arrays *must* be declared before assignment, by using:

> `typeset -A` `name`

When `name` refers to an associative array, the list in an assignment is
interpreted as alternating keys and values:

> `set -A` `name` `key` `value` ...

> `name``=(``key` `value` ...`)`

> `name``=(``[``key``]=``value` ...`)`

Note that only one of the two syntaxes above may be used in any given
assignment; the forms may not be mixed. This is unlike the case of
numerically indexed arrays.

Every `key` must have a `value` in this case. Note that this assigns to
the entire array, deleting any elements that do not appear in the list.
The append syntax may also be used with an associative array:

> `name``+=(``key` `value` ...`)`

> `name``+=(``[``key``]=``value` ...`)`

This adds a new key/value pair if the key is not already present, and
replaces the value for the existing key if it is. In the second form it
is also possible to use `[``key``]+=``value` to append to the existing
value at that key. Expansion is performed identically to the
corresponding forms for normal arrays, as described above.

To create an empty array (including associative arrays), use one of:

> `set -A` `name`

> `name``=()`

-----

<span id="Array-Subscripts"></span>

### 15.2.1 Array Subscripts

<span id="index-subscripts"></span>

Individual elements of an array may be selected using a subscript. A
subscript of the form ‘`[``exp``]`’ selects the single element `exp`,
where `exp` is an arithmetic expression which will be subject to
arithmetic expansion as if it were surrounded by ‘`$((`...`))`’. The
elements are numbered beginning with 1, unless the `KSH_ARRAYS` option
is set in which case they are numbered from zero.
<span id="index-KSH_005fARRAYS_002c-use-of"></span>

Subscripts may be used inside braces used to delimit a parameter name,
thus ‘`${foo[2]}`’ is equivalent to ‘`$foo[2]`’. If the `KSH_ARRAYS`
option is set, the braced form is the only one that works, as bracketed
expressions otherwise are not treated as subscripts.

If the `KSH_ARRAYS` option is not set, then by default accesses to an
array element with a subscript that evaluates to zero return an empty
string, while an attempt to write such an element is treated as an
error. For backward compatibility the `KSH_ZERO_SUBSCRIPT` option can be
set to cause subscript values 0 and 1 to be equivalent; see the
description of the option in [Description of
Options](Options.html#Description-of-Options).

The same subscripting syntax is used for associative arrays, except that
no arithmetic expansion is applied to `exp`. However, the parsing rules
for arithmetic expressions still apply, which affects the way that
certain special characters must be protected from interpretation. See
*Subscript Parsing* below for details.

A subscript of the form ‘`[*]`’ or ‘`[@]`’ evaluates to all elements of
an array; there is no difference between the two except when they appear
within double quotes. ‘`"$foo[*]"`’ evaluates to ‘` "$foo[1] $foo[2]
 `...`"`’, whereas ‘`"$foo[@]"`’ evaluates to ‘` "$foo[1]" "$foo[2]"
 `...’. For associative arrays, ‘`[*]`’ or ‘`[@]`’ evaluate to all the
values, in no particular order. Note that this does not substitute the
keys; see the documentation for the ‘`k`’ flag under [Parameter
Expansion](Expansion.html#Parameter-Expansion) for complete details.
When an array parameter is referenced as ‘`$``name`’ (with no subscript)
it evaluates to ‘`$``name``[*]`’, unless the `KSH_ARRAYS` option is set
in which case it evaluates to ‘`${``name``[0]}`’ (for an associative
array, this means the value of the key ‘`0`’, which may not exist even
if there are values for other keys).

A subscript of the form ‘`[``exp1``,``exp2``]`’ selects all elements in
the range `exp1` to `exp2`, inclusive. (Associative arrays are
unordered, and so do not support ranges.) If one of the subscripts
evaluates to a negative number, say `-``n`, then the `n`th element from
the end of the array is used. Thus ‘`$foo[-3]`’ is the third element
from the end of the array `foo`, and ‘`$foo[1,-1]`’ is the same as
‘`$foo[*]`’.

Subscripting may also be performed on non-array values, in which case
the subscripts specify a substring to be extracted. For example, if
`FOO` is set to ‘`foobar`’, then ‘`echo $FOO[2,5]`’ prints ‘`ooba`’.
Note that some forms of subscripting described below perform pattern
matching, and in that case the substring extends from the start of the
match of the first subscript to the end of the match of the second
subscript. For example,

<div class="example">

``` example
string="abcdefghijklm"
print ${string[(r)d?,(r)h?]}
```

</div>

prints ‘`defghi`’. This is an obvious generalisation of the rule for
single-character matches. For a single subscript, only a single
character is referenced (not the range of characters covered by the
match).

Note that in substring operations the second subscript is handled
differently by the `r` and `R` subscript flags: the former takes the
shortest match as the length and the latter the longest match. Hence in
the former case a `*` at the end is redundant while in the latter case
it matches the whole remainder of the string. This does not affect the
result of the single subscript case as here the length of the match is
irrelevant.

-----

<span id="Array-Element-Assignment"></span>

### 15.2.2 Array Element Assignment

A subscript may be used on the left side of an assignment like so:

> `name``[``exp``]=``value`

In this form of assignment the element or range specified by `exp` is
replaced by the expression on the right side. An array (but not an
associative array) may be created by assignment to a range or element.
Arrays do not nest, so assigning a parenthesized list of values to an
element or range changes the number of elements in the array, shifting
the other elements to accommodate the new values. (This is not supported
for associative arrays.)

This syntax also works as an argument to the `typeset` command:

> `typeset` `"``name``[``exp``]"=``value`

The `value` may *not* be a parenthesized list in this case; only
single-element assignments may be made with `typeset`. Note that quotes
are necessary in this case to prevent the brackets from being
interpreted as filename generation operators. The `noglob` precommand
modifier could be used instead.

To delete an element of an ordinary array, assign ‘`()`’ to that
element. To delete an element of an associative array, use the `unset`
command:

> `unset` `"``name``[``exp``]"`

-----

<span id="Subscript-Flags"></span>

### 15.2.3 Subscript Flags

<span id="index-subscript-flags"></span>

If the opening bracket, or the comma in a range, in any subscript
expression is directly followed by an opening parenthesis, the string up
to the matching closing one is considered to be a list of flags, as in
‘`name``[(``flags``)``exp``]`’.

The flags `s`, `n` and `b` take an argument; the delimiter is shown
below as ‘`:`’, but any character, or the matching pairs ‘`(`...`)`’,
‘`{`...`}`’, ‘`[`...`]`’, or ‘`<`...`>`’, may be used, but note that
‘`<`...`>`’ can only be used if the subscript is inside a double
quoted expression or a parameter substitution enclosed in braces as
otherwise the expression is interpreted as a redirection.

The flags currently understood are:

  - `w`  
    If the parameter subscripted is a scalar then this flag makes
    subscripting work on words instead of characters. The default word
    separator is whitespace. When combined with the `i` or `I` flag, the
    effect is to produce the index of the first character of the
    first/last word which matches the given pattern; note that a failed
    match in this case always yields 0.

  - `s:``string``:`  
    This gives the `string` that separates words (for use with the `w`
    flag). The delimiter character `:` is arbitrary; see above.

  - `p`  
    Recognize the same escape sequences as the `print` builtin in the
    string argument of a subsequent ‘`s`’ flag.

  - `f`  
    If the parameter subscripted is a scalar then this flag makes
    subscripting work on lines instead of characters, i.e. with elements
    separated by newlines. This is a shorthand for ‘`pws:\n:`’.

  - `r`  
    Reverse subscripting: if this flag is given, the `exp` is taken as a
    pattern and the result is the first matching array element,
    substring or word (if the parameter is an array, if it is a scalar,
    or if it is a scalar and the ‘`w`’ flag is given, respectively). The
    subscript used is the number of the matching element, so that pairs
    of subscripts such as ‘`$foo[(r)??,3]`’ and ‘`$foo[(r)??,(r)f*]`’
    are possible if the parameter is not an associative array. If the
    parameter is an associative array, only the value part of each pair
    is compared to the pattern, and the result is that value.
    
    If a search through an ordinary array failed, the search sets the
    subscript to one past the end of the array, and hence
    `${array[(r)``pattern``]}` will substitute the empty string. Thus
    the success of a search can be tested by using the `(i)` flag, for
    example (assuming the option `KSH_ARRAYS` is not in effect):
    
    <div class="example">
    
    ``` example
    [[ ${array[(i)pattern]} -le ${#array} ]]
    ```
    
    </div>
    
    If `KSH_ARRAYS` is in effect, the `-le` should be replaced by `-lt`.

  - `R`  
    Like ‘`r`’, but gives the last match. For associative arrays, gives
    all possible matches. May be used for assigning to ordinary array
    elements, but not for assigning to associative arrays. On failure,
    for normal arrays this has the effect of returning the element
    corresponding to subscript 0; this is empty unless one of the
    options `KSH_ARRAYS` or `KSH_ZERO_SUBSCRIPT` is in effect.
    
    Note that in subscripts with both ‘`r`’ and ‘`R`’ pattern characters
    are active even if they were substituted for a parameter (regardless
    of the setting of `GLOB_SUBST` which controls this feature in normal
    pattern matching). The flag ‘`e`’ can be added to inhibit pattern
    matching. As this flag does not inhibit other forms of substitution,
    care is still required; using a parameter to hold the key has the
    desired effect:
    
    <div class="example">
    
    ``` example
    key2='original key'
    print ${array[(Re)$key2]}
    ```
    
    </div>

  - `i`  
    Like ‘`r`’, but gives the index of the match instead; this may not
    be combined with a second argument. On the left side of an
    assignment, behaves like ‘`r`’. For associative arrays, the key part
    of each pair is compared to the pattern, and the first matching key
    found is the result. On failure substitutes the length of the array
    plus one, as discussed under the description of ‘`r`’, or the empty
    string for an associative array.

  - `I`  
    Like ‘`i`’, but gives the index of the last match, or all possible
    matching keys in an associative array. On failure substitutes 0, or
    the empty string for an associative array. This flag is best when
    testing for values or keys that do not exist.

  - `k`  
    If used in a subscript on an associative array, this flag causes the
    keys to be interpreted as patterns, and returns the value for the
    first key found where `exp` is matched by the key. Note this could
    be any such key as no ordering of associative arrays is defined.
    This flag does not work on the left side of an assignment to an
    associative array element. If used on another type of parameter,
    this behaves like ‘`r`’.

  - `K`  
    On an associative array this is like ‘`k`’ but returns all values
    where `exp` is matched by the keys. On other types of parameters
    this has the same effect as ‘`R`’.

  - `n:``expr``:`  
    If combined with ‘`r`’, ‘`R`’, ‘`i`’ or ‘`I`’, makes them give the
    `n`th or `n`th last match (if `expr` evaluates to `n`). This flag is
    ignored when the array is associative. The delimiter character `:`
    is arbitrary; see above.

  - `b:``expr``:`  
    If combined with ‘`r`’, ‘`R`’, ‘`i`’ or ‘`I`’, makes them begin at
    the `n`th or `n`th last element, word, or character (if `expr`
    evaluates to `n`). This flag is ignored when the array is
    associative. The delimiter character `:` is arbitrary; see above.

  - `e`  
    This flag causes any pattern matching that would be performed on the
    subscript to use plain string matching instead. Hence
    ‘`${array[(re)*]}`’ matches only the array element whose value is
    `*`. Note that other forms of substitution such as parameter
    substitution are not inhibited.
    
    This flag can also be used to force `*` or `@` to be interpreted as
    a single key rather than as a reference to all values. It may be
    used for either purpose on the left side of an assignment.

See *Parameter Expansion Flags* ([Parameter
Expansion](Expansion.html#Parameter-Expansion)) for additional ways to
manipulate the results of array subscripting.

-----

<span id="Subscript-Parsing"></span>

### 15.2.4 Subscript Parsing

This discussion applies mainly to associative array key strings and to
patterns used for reverse subscripting (the ‘`r`’, ‘`R`’, ‘`i`’, etc.
flags), but it may also affect parameter substitutions that appear as
part of an arithmetic expression in an ordinary subscript.

To avoid subscript parsing limitations in assignments to associative
array elements, use the append syntax:

<div class="example">

``` example
aa+=('key with "*strange*" characters' 'value string')
```

</div>

The basic rule to remember when writing a subscript expression is that
all text between the opening ‘`[`’ and the closing ‘`]`’ is interpreted
*as if* it were in double quotes
([Quoting](Shell-Grammar.html#Quoting)). However, unlike double quotes
which normally cannot nest, subscript expressions may appear inside
double-quoted strings or inside other subscript expressions (or both\!),
so the rules have two important differences.

The first difference is that brackets (‘`[`’ and ‘`]`’) must appear as
balanced pairs in a subscript expression unless they are preceded by a
backslash (‘`\`’). Therefore, within a subscript expression (and unlike
true double-quoting) the sequence ‘`\[`’ becomes ‘`[`’, and similarly
‘`\]`’ becomes ‘`]`’. This applies even in cases where a backslash is
not normally required; for example, the pattern ‘`[^[]`’ (to match any
character other than an open bracket) should be written ‘`[^\[]`’ in a
reverse-subscript pattern. However, note that ‘`\[^\[\]`’ and even
‘`\[^[]`’ mean the *same* thing, because backslashes are always
stripped when they appear before brackets\!

The same rule applies to parentheses (‘`(`’ and ‘`)`’) and braces (‘`{`’
and ‘`}`’): they must appear either in balanced pairs or preceded by a
backslash, and backslashes that protect parentheses or braces are
removed during parsing. This is because parameter expansions may be
surrounded by balanced braces, and subscript flags are introduced by
balanced parentheses.

The second difference is that a double-quote (‘`"`’) may appear as part
of a subscript expression without being preceded by a backslash, and
therefore that the two characters ‘`\"`’ remain as two characters in the
subscript (in true double-quoting, ‘`\"`’ becomes ‘`"`’). However,
because of the standard shell quoting rules, any double-quotes that
appear must occur in balanced pairs unless preceded by a backslash. This
makes it more difficult to write a subscript expression that contains an
odd number of double-quote characters, but the reason for this
difference is so that when a subscript expression appears inside true
double-quotes, one can still write ‘`\"`’ (rather than ‘`\\\"`’) for
‘`"`’.

To use an odd number of double quotes as a key in an assignment, use the
`typeset` builtin and an enclosing pair of double quotes; to refer to
the value of that key, again use double quotes:

<div class="example">

``` example
typeset -A aa
typeset "aa[one\"two\"three\"quotes]"=QQQ
print "$aa[one\"two\"three\"quotes]"
```

</div>

It is important to note that the quoting rules do not change when a
parameter expansion with a subscript is nested inside another subscript
expression. That is, it is not necessary to use additional backslashes
within the inner subscript expression; they are removed only once, from
the innermost subscript outwards. Parameters are also expanded from the
innermost subscript first, as each expansion is encountered left to
right in the outer expression.

A further complication arises from a way in which subscript parsing is
*not* different from double quote parsing. As in true double-quoting,
the sequences ‘`\*`’, and ‘`\@`’ remain as two characters when they
appear in a subscript expression. To use a literal ‘`*`’ or ‘`@`’ as an
associative array key, the ‘`e`’ flag must be used:

<div class="example">

``` example
typeset -A aa
aa[(e)*]=star
print $aa[(e)*]
```

</div>

A last detail must be considered when reverse subscripting is performed.
Parameters appearing in the subscript expression are first expanded and
then the complete expression is interpreted as a pattern. This has two
effects: first, parameters behave as if `GLOB_SUBST` were on (and it
cannot be turned off); second, backslashes are interpreted twice, once
when parsing the array subscript and again when parsing the pattern. In
a reverse subscript, it’s necessary to use *four* backslashes to cause a
single backslash to match literally in the pattern. For complex
patterns, it is often easiest to assign the desired pattern to a
parameter and then refer to that parameter in the subscript, because
then the backslashes, brackets, parentheses, etc., are seen only when
the complete expression is converted to a pattern. To match the value of
a parameter literally in a reverse subscript, rather than as a pattern,
use ‘`${(q``)``name``}`’ ([Parameter
Expansion](Expansion.html#Parameter-Expansion)) to quote the expanded
value.

Note that the ‘`k`’ and ‘`K`’ flags are reverse subscripting for an
ordinary array, but are *not* reverse subscripting for an associative
array\! (For an associative array, the keys in the array itself are
interpreted as patterns by those flags; the subscript is a plain string
in that case.)

One final note, not directly related to subscripting: the numeric names
of positional parameters ([Positional
Parameters](#Positional-Parameters)) are parsed specially, so for
example ‘`$2foo`’ is equivalent to ‘`${2}foo`’. Therefore, to use
subscript syntax to extract a substring from a positional parameter, the
expansion must be surrounded by braces; for example, ‘`${2[3,5]}`’
evaluates to the third through fifth characters of the second positional
parameter, but ‘`$2[3,5]`’ is the entire second parameter concatenated
with the filename generation pattern ‘`[3,5]`’.

-----

<span id="Positional-Parameters"></span>
<span id="Positional-Parameters-1"></span>

## 15.3 Positional Parameters

The positional parameters provide access to the command-line arguments
of a shell function, shell script, or the shell itself; see
[Invocation](Invocation.html#Invocation), and also
[Functions](Functions.html#Functions). The parameter `n`, where `n` is a
number, is the `n`th positional parameter. The parameter ‘`$0`’ is a
special case, see [Parameters Set By The
Shell](#Parameters-Set-By-The-Shell).

The parameters `*`, `@` and `argv` are arrays containing all the
positional parameters; thus ‘`$argv[``n``]`’, etc., is equivalent to
simply ‘`$``n`’. Note that the options `KSH_ARRAYS` or
`KSH_ZERO_SUBSCRIPT` apply to these arrays as well, so with either of
those options set, ‘`${argv[0]}`’ is equivalent to ‘`$1`’ and so on.

Positional parameters may be changed after the shell or function starts
by using the `set` builtin, by assigning to the `argv` array, or by
direct assignment of the form ‘`n``=``value`’ where `n` is the number of
the positional parameter to be changed. This also creates (with empty
values) any of the positions from 1 to `n` that do not already have
values. Note that, because the positional parameters form an array, an
array assignment of the form ‘`n``=(``value` ...`)`’ is allowed, and has
the effect of shifting all the values at positions greater than `n` by
as many positions as necessary to accommodate the new values.

-----

<span id="Local-Parameters"></span>
<span id="Local-Parameters-1"></span>

## 15.4 Local Parameters

Shell function executions delimit scopes for shell parameters.
(Parameters are dynamically scoped.) The `typeset` builtin, and its
alternative forms `declare`, `integer`, `local` and `readonly` (but not
`export`), can be used to declare a parameter as being local to the
innermost scope.

When a parameter is read or assigned to, the innermost existing
parameter of that name is used. (That is, the local parameter hides any
less-local parameter.) However, assigning to a non-existent parameter,
or declaring a new parameter with `export`, causes it to be created in
the *outer*most scope.

Local parameters disappear when their scope ends. `unset` can be used to
delete a parameter while it is still in scope; any outer parameter of
the same name remains hidden.

Special parameters may also be made local; they retain their special
attributes unless either the existing or the newly-created parameter has
the `-h` (hide) attribute. This may have unexpected effects: there is no
default value, so if there is no assignment at the point the variable is
made local, it will be set to an empty value (or zero in the case of
integers). The following:

<div class="example">

``` example
typeset PATH=/new/directory:$PATH
```

</div>

is valid for temporarily allowing the shell or programmes called from it
to find the programs in `/new/directory` inside a function.

Note that the restriction in older versions of zsh that local parameters
were never exported has been removed.

-----

<span id="Parameters-Set-By-The-Shell"></span>
<span id="Parameters-Set-By-The-Shell-1"></span>

## 15.5 Parameters Set By The Shell

In the parameter lists that follow, the mark ‘\<S\>’ indicates that the
parameter is special. ‘\<Z\>’ indicates that the parameter does not
exist when the shell initializes in `sh` or `ksh` emulation mode.

The following parameters are automatically set by the shell:

<span id="index-_0021"></span>

`!` \<S\>

The process ID of the last command started in the background with `&`,
put into the background with the `bg` builtin, or spawned with `coproc`.

<span id="index-_0023"></span>

`#` \<S\>

The number of positional parameters in decimal. Note that some confusion
may occur with the syntax `$#``param` which substitutes the length of
`param`. Use `${#}` to resolve ambiguities. In particular, the sequence
‘`$#-``...`’ in an arithmetic expression is interpreted as the length
of the parameter `-`, q.v.

<span id="index-ARGC"></span>

`ARGC` \<S\> \<Z\>

Same as `#`.

<span id="index-_0024"></span>

`$` \<S\>

The process ID of this shell. Note that this indicates the original
shell started by invoking `zsh`; all processes forked from the shells
without executing a new program, such as subshells started by
`(``...``)`, substitute the same value.

<span id="index-_002d-1"></span>

`-` \<S\>

Flags supplied to the shell on invocation or by the `set` or `setopt`
commands.

<span id="index-_002a"></span>

`*` \<S\>

An array containing the positional parameters.

<span id="index-argv"></span>

`argv` \<S\> \<Z\>

Same as `*`. Assigning to `argv` changes the local positional
parameters, but `argv` is *not* itself a local parameter. Deleting
`argv` with `unset` in any function deletes it everywhere, although only
the innermost positional parameter array is deleted (so `*` and `@` in
other scopes are not affected).

<span id="index-_0040"></span>

`@` \<S\>

Same as `argv[@]`, even when `argv` is not set.

<span id="index-_003f"></span>

`?` \<S\>

The exit status returned by the last command.

<span id="index-0"></span>

`0` \<S\>

The name used to invoke the current shell, or as set by the `-c` command
line option upon invocation. If the `FUNCTION_ARGZERO` option is set,
`$0` is set upon entry to a shell function to the name of the function,
and upon entry to a sourced script to the name of the script, and reset
to its previous value when the function or script returns.

<span id="index-status"></span>

`status` \<S\> \<Z\>

Same as `?`.

<span id="index-pipestatus"></span>

`pipestatus` \<S\> \<Z\>

An array containing the exit statuses returned by all commands in the
last pipeline.

<span id="index-_005f"></span>

`_` \<S\>

The last argument of the previous command. Also, this parameter is set
in the environment of every command executed to the full pathname of the
command.

<span id="index-CPUTYPE"></span>

`CPUTYPE`

The machine type (microprocessor class or machine model), as determined
at run time.

<span id="index-EGID"></span>

`EGID` \<S\>

The effective group ID of the shell process. If you have sufficient
privileges, you may change the effective group ID of the shell process
by assigning to this parameter. Also (assuming sufficient privileges),
you may start a single command with a different effective group ID by
‘`(EGID=``gid``; command)`’

If this is made local, it is not implicitly set to 0, but may be
explicitly set locally.

<span id="index-EUID"></span>

`EUID` \<S\>

The effective user ID of the shell process. If you have sufficient
privileges, you may change the effective user ID of the shell process by
assigning to this parameter. Also (assuming sufficient privileges), you
may start a single command with a different effective user ID by
‘`(EUID=``uid``; command)`’

If this is made local, it is not implicitly set to 0, but may be
explicitly set locally.

<span id="index-ERRNO"></span>

`ERRNO` \<S\>

The value of errno (see man page errno(3)) as set by the most recently
failed system call. This value is system dependent and is intended for
debugging purposes. It is also useful with the `zsh/system` module which
allows the number to be turned into a name or message.

<span id="index-FUNCNEST"></span>

`FUNCNEST` \<S\>

Integer. If greater than or equal to zero, the maximum nesting depth of
shell functions. When it is exceeded, an error is raised at the point
where a function is called. The default value is determined when the
shell is configured, but is typically 500. Increasing the value
increases the danger of a runaway function recursion causing the shell
to crash. Setting a negative value turns off the check.

<span id="index-GID"></span>

`GID` \<S\>

The real group ID of the shell process. If you have sufficient
privileges, you may change the group ID of the shell process by
assigning to this parameter. Also (assuming sufficient privileges), you
may start a single command under a different group ID by ‘`(GID=``gid``;
command)`’

If this is made local, it is not implicitly set to 0, but may be
explicitly set locally.

<span id="index-HISTCMD"></span>

`HISTCMD`

The current history event number in an interactive shell, in other words
the event number for the command that caused `$HISTCMD` to be read. If
the current history event modifies the history, `HISTCMD` changes to the
new maximum history event number.

<span id="index-HOST"></span>

`HOST`

The current hostname.

<span id="index-LINENO"></span>

`LINENO` \<S\>

The line number of the current line within the current script, sourced
file, or shell function being executed, whichever was started most
recently. Note that in the case of shell functions the line number
refers to the function as it appeared in the original definition, not
necessarily as displayed by the `functions` builtin.

<span id="index-LOGNAME"></span>

`LOGNAME`

If the corresponding variable is not set in the environment of the
shell, it is initialized to the login name corresponding to the current
login session. This parameter is exported by default but this can be
disabled using the `typeset` builtin. The value is set to the string
returned by the man page getlogin(3) system call if that is available.

<span id="index-MACHTYPE"></span>

`MACHTYPE`

The machine type (microprocessor class or machine model), as determined
at compile time.

<span id="index-OLDPWD"></span>

`OLDPWD`

The previous working directory. This is set when the shell initializes
and whenever the directory changes.

<span id="index-OPTARG"></span>

`OPTARG` \<S\>

The value of the last option argument processed by the `getopts`
command.

<span id="index-OPTIND"></span>

`OPTIND` \<S\>

The index of the last option argument processed by the `getopts`
command.

<span id="index-OSTYPE"></span>

`OSTYPE`

The operating system, as determined at compile time.

<span id="index-PPID"></span>

`PPID` \<S\>

The process ID of the parent of the shell. As for `$$`, the value
indicates the parent of the original shell and does not change in
subshells.

<span id="index-PWD"></span>

`PWD`

The present working directory. This is set when the shell initializes
and whenever the directory changes.

<span id="index-RANDOM"></span>

`RANDOM` \<S\>

A pseudo-random integer from 0 to 32767, newly generated each time this
parameter is referenced. The random number generator can be seeded by
assigning a numeric value to `RANDOM`.

sequence; subshells that reference `RANDOM` will result in identical
pseudo-random values unless the value of `RANDOM` is referenced or
seeded in the parent shell in between subshell invocations.

<span id="index-SECONDS"></span>

`SECONDS` \<S\>

The number of seconds since shell invocation. If this parameter is
assigned a value, then the value returned upon reference will be the
value that was assigned plus the number of seconds since the assignment.

Unlike other special parameters, the type of the `SECONDS` parameter can
be changed using the `typeset` command. Only integer and one of the
floating point types are allowed. For example, ‘`typeset -F SECONDS`’
causes the value to be reported as a floating point number. The value is
available to microsecond accuracy, although the shell may show more or
fewer digits depending on the use of `typeset`. See the documentation
for the builtin `typeset` in [Shell Builtin
Commands](Shell-Builtin-Commands.html#Shell-Builtin-Commands) for more
details.

<span id="index-SHLVL"></span>

`SHLVL` \<S\>

Incremented by one each time a new shell is started.

<span id="index-signals"></span>

`signals`

An array containing the names of the signals. Note that with the
standard zsh numbering of array indices, where the first element has
index 1, the signals are offset by 1 from the signal number used by the
operating system. For example, on typical Unix-like systems `HUP` is
signal number 1, but is referred to as `$signals[2]`. This is because of
`EXIT` at position 1 in the array, which is used internally by zsh but
is not known to the operating system.

<span id="index-TRY_005fBLOCK_005fERROR"></span>

`TRY_BLOCK_ERROR` \<S\>

In an `always` block, indicates whether the preceding list of code
caused an error. The value is 1 to indicate an error, 0 otherwise. It
may be reset, clearing the error condition. See [Complex
Commands](Shell-Grammar.html#Complex-Commands)

<span id="index-TRY_005fBLOCK_005fINTERRUPT"></span>

`TRY_BLOCK_INTERRUPT` \<S\>

This variable works in a similar way to `TRY_BLOCK_ERROR`, but
represents the status of an interrupt from the signal SIGINT, which
typically comes from the keyboard when the user types `^C`. If set to 0,
any such interrupt will be reset; otherwise, the interrupt is propagated
after the `always` block.

Note that it is possible that an interrupt arrives during the execution
of the `always` block; this interrupt is also propagated.

<span id="index-TTY"></span>

`TTY`

The name of the tty associated with the shell, if any.

<span id="index-TTYIDLE"></span>

`TTYIDLE` \<S\>

The idle time of the tty associated with the shell in seconds or -1 if
there is no such tty.

<span id="index-UID"></span>

`UID` \<S\>

The real user ID of the shell process. If you have sufficient
privileges, you may change the user ID of the shell by assigning to this
parameter. Also (assuming sufficient privileges), you may start a single
command under a different user ID by ‘`(UID=``uid``; command)`’

If this is made local, it is not implicitly set to 0, but may be
explicitly set locally.

<span id="index-USERNAME"></span>

`USERNAME` \<S\>

The username corresponding to the real user ID of the shell process. If
you have sufficient privileges, you may change the username (and also
the user ID and group ID) of the shell by assigning to this parameter.
Also (assuming sufficient privileges), you may start a single command
under a different username (and user ID and group ID) by
‘`(USERNAME=``username``; command)`’

<span id="index-VENDOR"></span>

`VENDOR`

The vendor, as determined at compile time.

<span id="index-zsh_005feval_005fcontext"></span>
<span id="index-ZSH_005fEVAL_005fCONTEXT"></span>

`zsh_eval_context` \<S\> \<Z\> (`ZSH_EVAL_CONTEXT` \<S\>)

An array (colon-separated list) indicating the context of shell code
that is being run. Each time a piece of shell code that is stored within
the shell is executed a string is temporarily appended to the array to
indicate the type of operation that is being performed. Read in order
the array gives an indication of the stack of operations being performed
with the most immediate context last.

Note that the variable does not give information on syntactic context
such as pipelines or subshells. Use `$ZSH_SUBSHELL` to detect subshells.

The context is one of the following:

  - `cmdarg`  
    Code specified by the `-c` option to the command line that invoked
    the shell.

  - `cmdsubst`  
    Command substitution using the `‘``...``‘` or `$(``...``)`
    construct.

  - `equalsubst`  
    File substitution using the `=(``...``)` construct.

  - `eval`  
    Code executed by the `eval` builtin.

  - `evalautofunc`  
    Code executed with the `KSH_AUTOLOAD` mechanism in order to define
    an autoloaded function.

  - `fc`  
    Code from the shell history executed by the `-e` option to the `fc`
    builtin.

  - `file`  
    Lines of code being read directly from a file, for example by the
    `source` builtin.

  - `filecode`  
    Lines of code being read from a `.zwc` file instead of directly from
    the source file.

  - `globqual`  
    Code executed by the `e` or `+` glob qualifier.

  - `globsort`  
    Code executed to order files by the `o` glob qualifier.

  - `insubst`  
    File substitution using the `<(``...``)` construct.

  - `loadautofunc`  
    Code read directly from a file to define an autoloaded function.

  - `outsubst`  
    File substitution using the `>(``...``)` construct.

  - `sched`  
    Code executed by the `sched` builtin.

  - `shfunc`  
    A shell function.

  - `stty`  
    Code passed to `stty` by the `STTY` environment variable. Normally
    this is passed directly to the system’s `stty` command, so this
    value is unlikely to be seen in practice.

  - `style`  
    Code executed as part of a style retrieved by the `zstyle` builtin
    from the `zsh/zutil` module.

  - `toplevel`  
    The highest execution level of a script or interactive shell.

  - `trap`  
    Code executed as a trap defined by the `trap` builtin. Traps defined
    as functions have the context `shfunc`. As traps are asynchronous
    they may have a different hierarchy from other code.

  - `zpty`  
    Code executed by the `zpty` builtin from the `zsh/zpty` module.

  - `zregexparse-guard`  
    Code executed as a guard by the `zregexparse` command from the
    `zsh/zutil` module.

  - `zregexparse-action`  
    Code executed as an action by the `zregexparse` command from the
    `zsh/zutil` module.

<span id="index-ZSH_005fARGZERO"></span>

`ZSH_ARGZERO`

If zsh was invoked to run a script, this is the name of the script.
Otherwise, it is the name used to invoke the current shell. This is the
same as the value of `$0` when the `POSIX_ARGZERO` option is set, but is
always available.

<span id="index-ZSH_005fEXECUTION_005fSTRING"></span>

`ZSH_EXECUTION_STRING`

If the shell was started with the option `-c`, this contains the
argument passed to the option. Otherwise it is not set.

<span id="index-ZSH_005fNAME"></span>

`ZSH_NAME`

Expands to the basename of the command used to invoke this instance of
zsh.

<span id="index-ZSH_005fPATCHLEVEL"></span>

`ZSH_PATCHLEVEL`

The output of ‘`git describe –tags –long`’ for the zsh repository used
to build the shell. This is most useful in order to keep track of
versions of the shell during development between releases; hence most
users should not use it and should instead rely on `$ZSH_VERSION`.

`zsh_scheduled_events`

See [The zsh/sched Module](Zsh-Modules.html#The-zsh_002fsched-Module).

<span id="index-ZSH_005fSCRIPT"></span>

`ZSH_SCRIPT`

If zsh was invoked to run a script, this is the name of the script,
otherwise it is unset.

<span id="index-ZSH_005fSUBSHELL-_003cS_003e"></span>

`ZSH_SUBSHELL`

Readonly integer. Initially zero, incremented each time the shell forks
to create a subshell for executing code. Hence ‘`(print $ZSH_SUBSHELL)`’
and ‘`print $(print $ZSH_SUBSHELL)`’ output 1, while ‘`( (print
$ZSH_SUBSHELL) )`’ outputs 2.

<span id="index-ZSH_005fVERSION"></span>

`ZSH_VERSION`

The version number of the release of zsh.

-----

<span id="Parameters-Used-By-The-Shell"></span>
<span id="Parameters-Used-By-The-Shell-1"></span>

## 15.6 Parameters Used By The Shell

The following parameters are used by the shell. Again, ‘\<S\>’ indicates
that the parameter is special and ‘\<Z\>’ indicates that the parameter
does not exist when the shell initializes in `sh` or `ksh` emulation
mode.

In cases where there are two parameters with an upper- and lowercase
form of the same name, such as `path` and `PATH`, the lowercase form is
an array and the uppercase form is a scalar with the elements of the
array joined together by colons. These are similar to tied parameters
created via ‘`typeset -T`’. The normal use for the colon-separated form
is for exporting to the environment, while the array form is easier to
manipulate within the shell. Note that unsetting either of the pair will
unset the other; they retain their special properties when recreated,
and recreating one of the pair will recreate the other.

<span id="index-ARGV0"></span>

`ARGV0`

If exported, its value is used as the `argv[0]` of external commands.
Usually used in constructs like ‘`ARGV0=emacs nethack`’.

<span id="index-editing-over-slow-connection"></span>
<span id="index-slow-connection_002c-editing-over"></span>
<span id="index-BAUD"></span>

`BAUD`

The rate in bits per second at which data reaches the terminal. The line
editor will use this value in order to compensate for a slow terminal by
delaying updates to the display until necessary. If the parameter is
unset or the value is zero the compensation mechanism is turned off. The
parameter is not set by default.

This parameter may be profitably set in some circumstances, e.g. for
slow modems dialing into a communications server, or on a slow wide area
network. It should be set to the baud rate of the slowest part of the
link for best performance.

<span id="index-cdpath"></span> <span id="index-CDPATH"></span>

`cdpath` \<S\> \<Z\> (`CDPATH` \<S\>)

An array (colon-separated list) of directories specifying the search
path for the `cd` command.

<span id="index-COLUMNS"></span>

`COLUMNS` \<S\>

The number of columns for this terminal session. Used for printing
select lists and for the line editor.

<span id="index-CORRECT_005fIGNORE"></span>

`CORRECT_IGNORE`

If set, is treated as a pattern during spelling correction. Any
potential correction that matches the pattern is ignored. For example,
if the value is ‘`_*`’ then completion functions (which, by convention,
have names beginning with ‘`_`’) will never be offered as spelling
corrections. The pattern does not apply to the correction of file names,
as applied by the `CORRECT_ALL` option (so with the example just given
files beginning with ‘`_`’ in the current directory would still be
completed).

<span id="index-CORRECT_005fIGNORE_005fFILE"></span>

`CORRECT_IGNORE_FILE`

If set, is treated as a pattern during spelling correction of file
names. Any file name that matches the pattern is never offered as a
correction. For example, if the value is ‘`.*`’ then dot file names will
never be offered as spelling corrections. This is useful with the
`CORRECT_ALL` option.

<span id="index-DIRSTACKSIZE"></span>

`DIRSTACKSIZE`

The maximum size of the directory stack, by default there is no limit.
If the stack gets larger than this, it will be truncated automatically.
This is useful with the `AUTO_PUSHD` option.
<span id="index-AUTO_005fPUSHD_002c-use-of"></span>

<span id="index-ENV"></span>

`ENV`

If the `ENV` environment variable is set when zsh is invoked as `sh` or
`ksh`, `$ENV` is sourced after the profile scripts. The value of `ENV`
is subjected to parameter expansion, command substitution, and
arithmetic expansion before being interpreted as a pathname. Note that
`ENV` is *not* used unless the shell is interactive and zsh is emulating
sh or ksh.

<span id="index-FCEDIT"></span>

`FCEDIT`

The default editor for the `fc` builtin. If `FCEDIT` is not set, the
parameter `EDITOR` is used; if that is not set either, a builtin
default, usually `vi`, is used.

<span id="index-fignore"></span> <span id="index-FIGNORE"></span>

`fignore` \<S\> \<Z\> (`FIGNORE` \<S\>)

An array (colon separated list) containing the suffixes of files to be
ignored during filename completion. However, if completion only
generates files with suffixes in this list, then these files are
completed anyway.

<span id="index-fpath"></span> <span id="index-FPATH"></span>

`fpath` \<S\> \<Z\> (`FPATH` \<S\>)

An array (colon separated list) of directories specifying the search
path for function definitions. This path is searched when a function
file is found, then it is read and executed in the current environment.

<span id="index-histchars"></span>

`histchars` \<S\>

Three characters used by the shell’s history and lexical analysis
mechanism. The first character signals the start of a history expansion
(default ‘`!`’). The second character signals the start of a quick
history substitution (default ‘`^`’). The third character is the comment
character (default ‘`#`’).

The characters must be in the ASCII character set; any attempt to set
`histchars` to characters with a locale-dependent meaning will be
rejected with an error message.

<span id="index-HISTCHARS"></span>

`HISTCHARS` \<S\> \<Z\>

Same as `histchars`. (Deprecated.)

<span id="index-HISTFILE"></span>

`HISTFILE`

The file to save the history in when an interactive shell exits. If
unset, the history is not saved.

<span id="index-HISTORY_005fIGNORE"></span>

`HISTORY_IGNORE`

If set, is treated as a pattern at the time history files are written.
Any potential history entry that matches the pattern is skipped. For
example, if the value is ‘`fc *`’ then commands that invoke the
interactive history editor are never written to the history file.

Note that `HISTORY_IGNORE` defines a single pattern: to specify
alternatives use the ‘`(``first``|``second``|``...``)`’ syntax.

Compare the `HIST_NO_STORE` option or the `zshaddhistory` hook, either
of which would prevent such commands from being added to the interactive
history at all. If you wish to use `HISTORY_IGNORE` to stop history
being added in the first place, you can define the following hook:

<div class="example">

``` example
zshaddhistory() {
  emulate -L zsh
  ## uncomment if HISTORY_IGNORE
  ## should use EXTENDED_GLOB syntax
  # setopt extendedglob
  [[ $1 != ${~HISTORY_IGNORE} ]]
}
```

</div>

<span id="index-HISTSIZE"></span>

`HISTSIZE` \<S\>

The maximum number of events stored in the internal history list. If you
use the `HIST_EXPIRE_DUPS_FIRST` option, setting this value larger than
the `SAVEHIST` size will give you the difference as a cushion for saving
duplicated history events.

If this is made local, it is not implicitly set to 0, but may be
explicitly set locally.

<span id="index-HOME"></span>

`HOME` \<S\>

The default argument for the `cd` command. This is not set automatically
by the shell in `sh`, `ksh` or `csh` emulation, but it is typically
present in the environment anyway, and if it becomes set it has its
usual special behaviour.

<span id="index-IFS"></span>

`IFS` \<S\>

Internal field separators (by default space, tab, newline and NUL), that
are used to separate words which result from command or parameter
expansion and words read by the `read` builtin. Any characters from the
set space, tab and newline that appear in the IFS are called *IFS white
space*. One or more IFS white space characters or one non-IFS white
space character together with any adjacent IFS white space character
delimit a field. If an IFS white space character appears twice
consecutively in the IFS, this character is treated as if it were not an
IFS white space character.

If the parameter is unset, the default is used. Note this has a
different effect from setting the parameter to an empty string.

<span id="index-KEYBOARD_005fHACK"></span>

`KEYBOARD_HACK`

This variable defines a character to be removed from the end of the
command line before interpreting it (interactive shells only). It is
intended to fix the problem with keys placed annoyingly close to return
and replaces the `SUNKEYBOARDHACK` option which did this for backquotes
only. Should the chosen character be one of singlequote, doublequote or
backquote, there must also be an odd number of them on the command line
for the last one to be removed.

For backward compatibility, if the `SUNKEYBOARDHACK` option is
explicitly set, the value of `KEYBOARD_HACK` reverts to backquote. If
the option is explicitly unset, this variable is set to empty.

<span id="index-KEYTIMEOUT"></span>

`KEYTIMEOUT`

The time the shell waits, in hundredths of seconds, for another key to
be pressed when reading bound multi-character sequences.

<span id="index-LANG"></span>

`LANG` \<S\>

This variable determines the locale category for any category not
specifically selected via a variable starting with ‘`LC_`’.

<span id="index-LC_005fALL"></span>

`LC_ALL` \<S\>

This variable overrides the value of the ‘`LANG`’ variable and the value
of any of the other variables starting with ‘`LC_`’.

<span id="index-LC_005fCOLLATE"></span>

`LC_COLLATE` \<S\>

This variable determines the locale category for character collation
information within ranges in glob brackets and for sorting.

<span id="index-LC_005fCTYPE"></span>

`LC_CTYPE` \<S\>

This variable determines the locale category for character handling
functions. If the `MULTIBYTE` option is in effect this variable or
`LANG` should contain a value that reflects the character set in use,
even if it is a single-byte character set, unless only the 7-bit subset
(ASCII) is used. For example, if the character set Linux distributions)
or `en_US.ISO8859-1` (MacOS).

<span id="index-LC_005fMESSAGES"></span>

`LC_MESSAGES` \<S\>

This variable determines the language in which messages should be
written. Note that zsh does not use message catalogs.

<span id="index-LC_005fNUMERIC"></span>

`LC_NUMERIC` \<S\>

This variable affects the decimal point character and thousands
separator character for the formatted input/output functions and string
conversion functions. Note that zsh ignores this setting when parsing
floating point mathematical expressions.

<span id="index-LC_005fTIME"></span>

`LC_TIME` \<S\>

This variable determines the locale category for date and time
formatting in prompt escape sequences.

<span id="index-LINES"></span>

`LINES` \<S\>

The number of lines for this terminal session. Used for printing select
lists and for the line editor.

<span id="index-LISTMAX"></span>

`LISTMAX`

In the line editor, the number of matches to list without asking first.
If the value is negative, the list will be shown if it spans at most as
many lines as given by the absolute value. If set to zero, the shell
asks only if the top of the listing would scroll off the screen.

<span id="index-LOGCHECK"></span>

`LOGCHECK`

The interval in seconds between checks for login/logout activity using
the `watch` parameter.

<span id="index-MAIL"></span>

`MAIL`

If this parameter is set and `mailpath` is not set, the shell looks for
mail in the specified file.

<span id="index-MAILCHECK"></span>

`MAILCHECK`

The interval in seconds between checks for new mail.

<span id="index-mailpath"></span> <span id="index-MAILPATH"></span>

`mailpath` \<S\> \<Z\> (`MAILPATH` \<S\>)

An array (colon-separated list) of filenames to check for new mail. Each
filename can be followed by a ‘`?`’ and a message that will be printed.
The message will undergo parameter expansion, command substitution and
arithmetic expansion with the variable `$_` defined as the name of the
file that has changed. The default message is ‘`You have new mail`’. If
an element is a directory instead of a file the shell will recursively
check every file in every subdirectory of the element.

<span id="index-manpath"></span> <span id="index-MANPATH"></span>

`manpath` \<S\> \<Z\> (`MANPATH` \<S\> \<Z\>)

An array (colon-separated list) whose value is not used by the shell.
The `manpath` array can be useful, however, since setting it also sets
`MANPATH`, and vice versa.

`match`

`mbegin`

`mend`

Arrays set by the shell when the `b` globbing flag is used in pattern
matches. See the subsection *Globbing flags* in [Filename
Generation](Expansion.html#Filename-Generation).

`MATCH`

`MBEGIN`

`MEND`

Set by the shell when the `m` globbing flag is used in pattern matches.
See the subsection *Globbing flags* in [Filename
Generation](Expansion.html#Filename-Generation).

<span id="index-module_005fpath"></span>
<span id="index-MODULE_005fPATH"></span>

`module_path` \<S\> \<Z\> (`MODULE_PATH` \<S\>)

An array (colon-separated list) of directories that `zmodload` searches
for dynamically loadable modules. This is initialized to a standard
pathname, usually ‘`/usr/local/lib/zsh/$ZSH_VERSION`’. (The
‘`/usr/local/lib`’ part varies from installation to installation.) For
security reasons, any value set in the environment when the shell is
started will be ignored.

These parameters only exist if the installation supports dynamic module
loading.

<span id="index-NULLCMD"></span>
<span id="index-null-command-style"></span>
<span id="index-csh_002c-null-command-style"></span>
<span id="index-ksh_002c-null-command-style"></span>

`NULLCMD` \<S\>

The command name to assume if a redirection is specified with no
command. Defaults to `cat`. For sh/ksh behavior, change this to `:`. For
csh-like behavior, unset this parameter; the shell will print an error
message if null commands are entered.

<span id="index-path"></span> <span id="index-PATH"></span>

`path` \<S\> \<Z\> (`PATH` \<S\>)

An array (colon-separated list) of directories to search for commands.
When this parameter is set, each directory is scanned

<span id="index-POSTEDIT"></span>

`POSTEDIT` \<S\>

This string is output whenever the line editor exits. It usually
contains termcap strings to reset the terminal.

<span id="index-PROMPT"></span>

`PROMPT` \<S\> \<Z\>

<span id="index-PROMPT2"></span>

`PROMPT2` \<S\> \<Z\>

<span id="index-PROMPT3"></span>

`PROMPT3` \<S\> \<Z\>

<span id="index-PROMPT4"></span>

`PROMPT4` \<S\> \<Z\>

Same as `PS1`, `PS2`, `PS3` and `PS4`, respectively.

<span id="index-prompt"></span>

`prompt` \<S\> \<Z\>

Same as `PS1`.

<span id="index-PROMPT_005fEOL_005fMARK"></span>

`PROMPT_EOL_MARK`

When the `PROMPT_CR` and `PROMPT_SP` options are set, the
`PROMPT_EOL_MARK` parameter can be used to customize how the end of
partial lines are shown. This parameter undergoes prompt expansion, with
the `PROMPT_PERCENT` option set. If not set, the default behavior is
equivalent to the value ‘`%B%S%#%s%b`’.

<span id="index-PS1"></span>

`PS1` \<S\>

The primary prompt string, printed before a command is read. It
undergoes a special form of expansion before being displayed; see
[Prompt Expansion](Prompt-Expansion.html#Prompt-Expansion). The default
is ‘` %m%#  `’.

<span id="index-PS2"></span>

`PS2` \<S\>

The secondary prompt, printed when the shell needs more information to
complete a command. It is expanded in the same way as `PS1`. The default
is ‘` %_>  `’, which displays any shell constructs or quotation marks
which are currently being processed.

<span id="index-PS3"></span>

`PS3` \<S\>

Selection prompt used within a `select` loop. It is expanded in the same
way as `PS1`. The default is ‘` ?#  `’.

<span id="index-PS4"></span>

`PS4` \<S\>

The execution trace prompt. Default is ‘` +%N:%i>  `’, which displays
the name of the current shell structure and the line number within it.
In sh or ksh emulation, the default is ‘` +  `’.

<span id="index-psvar"></span> <span id="index-PSVAR"></span>

`psvar` \<S\> \<Z\> (`PSVAR` \<S\>)

An array (colon-separated list) whose elements can be used in `PROMPT`
strings. Setting `psvar` also sets `PSVAR`, and vice versa.

<span id="index-READNULLCMD"></span>

`READNULLCMD` \<S\>

The command name to assume if a single input redirection is specified
with no command. Defaults to `more`.

<span id="index-REPORTMEMORY"></span>

`REPORTMEMORY`

If nonnegative, commands whose maximum resident set size (roughly
speaking, main memory usage) in kilobytes is greater than this value
have timing statistics reported. The format used to output statistics is
the value of the `TIMEFMT` parameter, which is the same as for the
`REPORTTIME` variable and the `time` builtin; note that by default this
does not output memory usage. Appending `" max RSS %M"` to the value of
`TIMEFMT` causes it to output the value that triggered the report. If
`REPORTTIME` is also in use, at most a single report is printed for both
triggers. This feature requires the `getrusage()` system call, commonly
supported by modern Unix-like systems.

<span id="index-REPORTTIME"></span>

`REPORTTIME`

If nonnegative, commands whose combined user and system execution times
(measured in seconds) are greater than this value have timing statistics
printed for them. Output is suppressed for commands executed within the
line editor, including completion; commands explicitly marked with the
`time` keyword still cause the summary to be printed in this case.

<span id="index-REPLY"></span>

`REPLY`

This parameter is reserved by convention to pass string values between
shell scripts and shell builtins in situations where a function call or
redirection are impossible or undesirable. The `read` builtin and the
`select` complex command may set `REPLY`, and filename generation both
sets and examines its value when evaluating certain expressions. Some
modules also employ `REPLY` for similar purposes.

<span id="index-reply"></span>

`reply`

As `REPLY`, but for array values rather than strings.

<span id="index-RPROMPT"></span>

`RPROMPT` \<S\>

<span id="index-RPS1"></span>

`RPS1` \<S\>

This prompt is displayed on the right-hand side of the screen when the
primary prompt is being displayed on the left. This does not work if the
`SINGLE_LINE_ZLE` option is set. It is expanded in the same way as
`PS1`.

<span id="index-RPROMPT2"></span>

`RPROMPT2` \<S\>

<span id="index-RPS2"></span>

`RPS2` \<S\>

This prompt is displayed on the right-hand side of the screen when the
secondary prompt is being displayed on the left. This does not work if
the `SINGLE_LINE_ZLE` option is set. It is expanded in the same way as
`PS2`.

<span id="index-SAVEHIST"></span>

`SAVEHIST`

The maximum number of history events to save in the history file.

If this is made local, it is not implicitly set to 0, but may be
explicitly set locally.

<span id="index-SPROMPT"></span>

`SPROMPT` \<S\>

The prompt used for spelling correction. The sequence ‘`%R`’ expands to
the string which presumably needs spelling correction, and ‘`%r`’
expands to the proposed correction. All other prompt escapes are also
allowed.

The actions available at the prompt are `[nyae]`:

  - `n` (‘no’) (default)  
    Discard the correction and run the command.

  - `y` (‘yes’)  
    Make the correction and run the command.

  - `a` (‘abort’)  
    Discard the entire command line without running it.

  - `e` (‘edit’)  
    Resume editing the command line.

<span id="index-STTY"></span>

`STTY`

If this parameter is set in a command’s environment, the shell runs the
`stty` command with the value of this parameter as arguments in order to
set up the terminal before executing the command. The modes apply only
to the command, and are reset when it finishes or is suspended. If the
command is suspended and continued later with the `fg` or `wait`
builtins it will see the modes specified by `STTY`, as if it were not
suspended. This (intentionally) does not apply if the command is
continued via ‘`kill -CONT`’. `STTY` is ignored if the command is run in
the background, or if it is in the environment of the shell but not
explicitly assigned to in the input line. This avoids running stty at
every external command by accidentally exporting it. Also note that
`STTY` should not be used for window size specifications; these will not
be local to the command.

<span id="index-TERM"></span>

`TERM` \<S\>

The type of terminal in use. This is used when looking up termcap
sequences. An assignment to `TERM` causes zsh to re-initialize the
terminal, even if the value does not change (e.g., ‘`TERM=$TERM`’). It
is necessary to make such an assignment upon any change to the terminal
definition database or terminal type in order for the new settings to
take effect.

<span id="index-TERMINFO"></span>

`TERMINFO` \<S\>

A reference to your terminfo database, used by the ‘terminfo’ library
when the system has it; see man page terminfo(5). If set, this causes
the shell to reinitialise the terminal, making the workaround
‘`TERM=$TERM`’ unnecessary.

<span id="index-TERMINFO_005fDIRS"></span>

`TERMINFO_DIRS` \<S\>

A colon-seprarated list of terminfo databases, used by the ‘terminfo’
library when the system has it; see man page terminfo(5). This variable
is only used by certain terminal libraries, in particular ncurses; see
man page terminfo(5) to check support on your system. If set, this
causes the shell to reinitialise the terminal, making the workaround
‘`TERM=$TERM`’ unnecessary. Note that unlike other colon-separated
arrays this is not tied to a zsh array.

<span id="index-TIMEFMT"></span>

`TIMEFMT`

The format of process time reports with the `time` keyword. The default
is ‘`%J %U user %S system %P cpu %*E total`’. Recognizes the following
escape sequences, although not all may be available on all systems, and
some that are available may not be useful:

  - `%%`  
    A ‘`%`’.

  - `%U`  
    CPU seconds spent in user mode.

  - `%S`  
    CPU seconds spent in kernel mode.

  - `%E`  
    Elapsed time in seconds.

  - `%P`  
    The CPU percentage, computed as 100\*(`%U`+`%S`)/`%E`.

  - `%W`  
    Number of times the process was swapped.

  - `%X`  
    The average amount in (shared) text space used in kilobytes.

  - `%D`  
    The average amount in (unshared) data/stack space used in kilobytes.

  - `%K`  
    The total space used (`%X`+`%D`) in kilobytes.

  - `%M`  
    The maximum memory the process had in use at any time in kilobytes.

  - `%F`  
    The number of major page faults (page needed to be brought from
    disk).

  - `%R`  
    The number of minor page faults.

  - `%I`  
    The number of input operations.

  - `%O`  
    The number of output operations.

  - `%r`  
    The number of socket messages received.

  - `%s`  
    The number of socket messages sent.

  - `%k`  
    The number of signals received.

  - `%w`  
    Number of voluntary context switches (waits).

  - `%c`  
    Number of involuntary context switches.

  - `%J`  
    The name of this job.

A star may be inserted between the percent sign and flags printing time
(e.g., ‘`%*E`’); this causes the time to be printed in
‘`hh``:``mm``:``ss``.``ttt`’ format (hours and minutes are only
printed if they are not zero). Alternatively, ‘`m`’ or ‘`u`’ may be used
(e.g., ‘`%mE`’) to produce time output in milliseconds or microseconds,
respectively.

<span id="index-TMOUT"></span>

`TMOUT`

If this parameter is nonzero, the shell will receive an `ALRM` signal if
a command is not entered within the specified number of seconds after
issuing a prompt. If there is a trap on `SIGALRM`, it will be executed
and a new alarm is scheduled using the value of the `TMOUT` parameter
after executing the trap. If no trap is set, and the idle time of the
terminal is not less than the value of the `TMOUT` parameter, zsh
terminates. Otherwise a new alarm is scheduled to `TMOUT` seconds after
the last keypress.

<span id="index-TMPPREFIX"></span>

`TMPPREFIX`

A pathname prefix which the shell will use for all temporary files. Note
that this should include an initial part for the file name as well as
any directory names. The default is ‘`/tmp/zsh`’.

<span id="index-TMPSUFFIX"></span>

`TMPSUFFIX`

A filename suffix which the shell will use for temporary files created
by process substitutions (e.g., ‘`=(list)`’). Note that the value should
include a leading dot ‘`.`’ if intended to be interpreted as a file
extension. The default is not to append any suffix, thus this parameter
should be assigned only when needed and then unset again.

<span id="index-watch"></span> <span id="index-WATCH"></span>

`watch` \<S\> \<Z\> (`WATCH` \<S\>)

An array (colon-separated list) of login/logout events to report.

If it contains the single word ‘`all`’, then all login/logout events are
reported. If it contains the single word ‘`notme`’, then all events are
reported as with ‘`all`’ except `$USERNAME`.

An entry in this list may consist of a username, an ‘`@`’ followed by a
remote hostname, and a ‘`%`’ followed by a line (tty). Any of these may
be a pattern (be sure to quote this during the assignment to `watch` so
that it does not immediately perform file generation); the setting of
the `EXTENDED_GLOB` option is respected. Any or all of these components
may be present in an entry; if a login/logout event matches all of them,
it is reported.

For example, with the `EXTENDED_GLOB` option set, the following:

<div class="example">

``` example
watch=('^(pws|barts)')
```

</div>

causes reports for activity associated with any user other than `pws` or
`barts`.

<span id="index-WATCHFMT"></span>

`WATCHFMT`

The format of login/logout reports if the `watch` parameter is set.
Default is ‘`%n has %a %l from %m`’. Recognizes the following escape
sequences:

  - `%n`  
    The name of the user that logged in/out.

  - `%a`  
    The observed action, i.e. "logged on" or "logged off".

  - `%l`  
    The line (tty) the user is logged in on.

  - `%M`  
    The full hostname of the remote host.

  - `%m`  
    The hostname up to the first ‘`.`’. If only the IP address is
    available or the utmp field contains the name of an X-windows
    display, the whole name is printed.
    
    *NOTE:* The ‘`%m`’ and ‘`%M`’ escapes will work only if there is a
    host name field in the utmp on your machine. Otherwise they are
    treated as ordinary strings.

  - `%S` (`%s`)  
    Start (stop) standout mode.

  - `%U` (`%u`)  
    Start (stop) underline mode.

  - `%B` (`%b`)  
    Start (stop) boldface mode.

  - `%t`  
    `%@`  
    The time, in 12-hour, am/pm format.

  - `%T`  
    The time, in 24-hour format.

  - `%w`  
    The date in ‘`day``-``dd`’ format.

  - `%W`  
    The date in ‘`mm``/``dd``/``yy`’ format.

  - `%D`  
    The date in ‘`yy``-``mm``-``dd`’ format.

  - `%D{``string``}`  
    The date formatted as `string` using the `strftime` function, with
    zsh extensions as described by [Prompt
    Expansion](Prompt-Expansion.html#Prompt-Expansion).

  - `%(``x``:``true-text``:``false-text``)`  
    Specifies a ternary expression. The character following the `x` is
    arbitrary; the same character is used to separate the text for the
    "true" result from that for the "false" result. Both the separator
    and the right parenthesis may be escaped with a backslash. Ternary
    expressions may be nested.
    
    The test character `x` may be any one of ‘`l`’, ‘`n`’, ‘`m`’ or
    ‘`M`’, which indicate a ‘true’ result if the corresponding
    escape sequence would return a non-empty value; or it may be ‘`a`’,
    which indicates a ‘true’ result if the watched user has logged in,
    or ‘false’ if he has logged out. Other characters evaluate to
    neither true nor false; the entire expression is omitted in this
    case.
    
    If the result is ‘true’, then the `true-text` is formatted according
    to the rules above and printed, and the `false-text` is skipped. If
    ‘false’, the `true-text` is skipped and the `false-text` is
    formatted and printed. Either or both of the branches may be empty,
    but both separators must be present in any case.

<span id="index-WORDCHARS"></span>

`WORDCHARS` \<S\>

A list of non-alphanumeric characters considered part of a word by the
line editor.

<span id="index-ZBEEP"></span>

`ZBEEP`

If set, this gives a string of characters, which can use all the same
codes as the `bindkey` command as described in [The zsh/zle
Module](Zsh-Modules.html#The-zsh_002fzle-Module), that will be output to
the terminal instead of beeping. This may have a visible instead of an
audible effect; for example, the string ‘`\e[?5h\e[?5l`’ on a vt100 or
xterm will have the effect of flashing reverse video on and off (if you
usually use reverse video, you should use the string ‘`\e[?5l\e[?5h`’
instead). This takes precedence over the `NOBEEP` option.

<span id="index-ZDOTDIR"></span>

`ZDOTDIR`

The directory to search for shell startup files (.zshrc, etc), if not
`$HOME`.

<span id="index-zle_005fbracketed_005fpaste"></span>
<span id="index-bracketed-paste"></span>
<span id="index-enabling-bracketed-paste"></span>

`zle_bracketed_paste`

Many terminal emulators have a feature that allows applications to
identify when text is pasted into the terminal rather than being typed
normally. For ZLE, this means that special characters such as tabs and
newlines can be inserted instead of invoking editor commands.
Furthermore, pasted text forms a single undo event and if the region is
active, pasted text will replace the region.

This two-element array contains the terminal escape sequences for
enabling and disabling the feature. These escape sequences are used to
enable bracketed paste when ZLE is active and disable it at other times.
Unsetting the parameter has the effect of ensuring that bracketed paste
remains disabled.

<span id="index-zle_005fhighlight"></span>

`zle_highlight`

An array describing contexts in which ZLE should highlight the input
text. See [Character
Highlighting](Zsh-Line-Editor.html#Character-Highlighting).

<span id="index-ZLE_005fLINE_005fABORTED"></span>

`ZLE_LINE_ABORTED`

This parameter is set by the line editor when an error occurs. It
contains the line that was being edited at the point of the error.
‘`print -zr – $ZLE_LINE_ABORTED`’ can be used to recover the line.
Only the most recent line of this kind is remembered.

<span id="index-ZLE_005fREMOVE_005fSUFFIX_005fCHARS"></span>
<span id="index-ZLE_005fSPACE_005fSUFFIX_005fCHARS"></span>

`ZLE_REMOVE_SUFFIX_CHARS`

`ZLE_SPACE_SUFFIX_CHARS`

These parameters are used by the line editor. In certain circumstances
suffixes (typically space or slash) added by the completion system will
be removed automatically, either because the next editing command as
requiring the suffix to be removed.

These variables can contain the sets of characters that will cause the
suffix to be removed. If `ZLE_REMOVE_SUFFIX_CHARS` is set, those
characters will cause the suffix to be removed; if
`ZLE_SPACE_SUFFIX_CHARS` is set, those characters will cause the suffix
to be removed and replaced by a space.

If `ZLE_REMOVE_SUFFIX_CHARS` is not set, the default behaviour is
equivalent to:

<div class="example">

``` example
ZLE_REMOVE_SUFFIX_CHARS=$' \t\n;&|'
```

</div>

If `ZLE_REMOVE_SUFFIX_CHARS` is set but is empty, no characters have
this behaviour. `ZLE_SPACE_SUFFIX_CHARS` takes precedence, so that the
following:

<div class="example">

``` example
ZLE_SPACE_SUFFIX_CHARS=$'&|'
```

</div>

causes the characters ‘`&`’ and ‘`|`’ to remove the suffix but to
replace it with a space.

To illustrate the difference, suppose that the option
`AUTO_REMOVE_SLASH` is in effect and the directory `DIR` has just been
completed, with an appended `/`, following which the user types ‘`&`’.
The default result is ‘`DIR&`’. With `ZLE_REMOVE_SUFFIX_CHARS` set but
without including ‘`&`’ the result is ‘`DIR/&`’. With
`ZLE_SPACE_SUFFIX_CHARS` set to include ‘`&`’ the result is ‘`DIR &`’.

Note that certain completions may provide their own suffix removal or
replacement behaviour which overrides the values described here. See the
completion system documentation in [Completion
System](Completion-System.html#Completion-System).

<span id="index-ZLE_005fRPROMPT_005fINDENT"></span>

`ZLE_RPROMPT_INDENT` \<S\>

If set, used to give the indentation between the right hand side of the
right prompt in the line editor as given by `RPS1` or `RPROMPT` and the
right hand side of the screen. If not set, the value 1 is used.

Typically this will be used to set the value to 0 so that the prompt
appears flush with the right hand side of the screen. This is not the
default as many terminals do not handle this correctly, in particular
when the prompt appears at the extreme bottom right of the screen.
Recent virtual terminals are more likely to handle this case correctly.
Some experimentation is necessary.

-----

This document was generated on *February 15, 2020* using
[*texi2html 5.0*](http://www.nongnu.org/texi2html/).  
Zsh version 5.8, released on February 14, 2020.
