The zsh/param/private module is used to create parameters whose scope
is limited to the current function body, and not to other functions
called by the current function.
This module provides a single autoloaded builtin:
private [ {+|-}AHUahlmrtux ] [ {+|-}EFLRZi [ n ] ] [ name[=value] ... ]The private builtin accepts all the same options and arguments as local
(Shell Builtin Commands) except
for the ‘-T’ option. Tied parameters may not be made private.
The ‘-p’ option is presently a no-op because the state of
private parameters cannot reliably be reloaded. This also applies
to printing private parameters with ‘typeset -p’.
If used at the top level (outside a function scope), private creates a
normal parameter in the same manner as declare or typeset. A
warning about this is printed if WARN_CREATE_GLOBAL is set
(Options). Used inside a
function scope, private creates a local parameter similar to one
declared with local, except having special properties noted below.
Special parameters which expose or manipulate internal shell state, such
as ARGC, argv, COLUMNS, LINES, UID, EUID, IFS,
PROMPT, RANDOM, SECONDS, etc., cannot be made private unless
the ‘-h’ option is used to hide the special meaning of the
parameter. This may change in the future.
As with other typeset equivalents, private is both a builtin and a
reserved word, so arrays may be assigned with parenthesized word list
name=(value...) syntax. However, the reserved
word ‘private’ is not available until zsh/param/private is loaded,
so care must be taken with order of execution and parsing for function
definitions which use private. To compensate for this, the module
also adds the option ‘-P’ to the ‘local’ builtin to declare private
parameters.
For example, this construction fails if zsh/param/private has not yet
been loaded when ‘bad_declaration’ is defined:
bad_declaration() {
zmodload zsh/param/private
private array=( one two three )
}
This construction works because local is already a keyword, and the
module is loaded before the statement is executed:
good_declaration() {
zmodload zsh/param/private
local -P array=( one two three )
}
The following is usable in scripts but may have trouble with autoload:
zmodload zsh/param/private
iffy_declaration() {
private array=( one two three )
}
The private builtin may always be used with scalar assignments and
for declarations without assignments.
Parameters declared with private have the following properties:
Note that this differs from the static scope defined by compiled languages
derived from C, in that the a new call to the same function creates a new
scope, i.e., the parameter is still associated with the call stack rather
than with the function definition. It differs from ksh ‘typeset -S’
because the syntax used to define the function has no bearing on whether
the parameter scope is respected.