Current File : //usr/local/share/zsh/5.8/help/float
typeset [ {+|-}AHUaghlmrtux ] [ {+|-}EFLRZip [ n ] ]
[ + ] [ name[=value] ... ]
typeset -T [ {+|-}Uglrux ] [ {+|-}LRZp [ n ] ]
[ + | SCALAR[=value] array[=(value ...)] [ sep ] ]
typeset -f [ {+|-}TUkmtuz ] [ + ] [ name ... ]
Set or display attributes and values for shell parameters.
Except as noted below for control flags that change the behavior,
a parameter is created for each name that does not already refer
to one. When inside a function, a new parameter is created for
every name (even those that already exist), and is unset again
when the function completes. See `Local Parameters' in
zshparam(1). The same rules apply to special shell parameters,
which retain their special attributes when made local.
For each name=value assignment, the parameter name is set to
value.
If the shell option TYPESET_SILENT is not set, for each remaining
name that refers to a parameter that is already set, the name and
value of the parameter are printed in the form of an assignment.
Nothing is printed for newly-created parameters, or when any
attribute flags listed below are given along with the name. Using
`+' instead of minus to introduce an attribute turns it off.
If no name is present, the names and values of all parameters are
printed. In this case the attribute flags restrict the display to
only those parameters that have the specified attributes, and
using `+' rather than `-' to introduce the flag suppresses
printing of the values of parameters when there is no parameter
name.
All forms of the command handle scalar assignment. Array
assignment is possible if any of the reserved words declare,
export, float, integer, local, readonly or typeset is matched when
the line is parsed (N.B. not when it is executed). In this case
the arguments are parsed as assignments, except that the `+='
syntax and the GLOB_ASSIGN option are not supported, and scalar
values after = are not split further into words, even if expanded
(regardless of the setting of the KSH_TYPESET option; this option
is obsolete).
Examples of the differences between command and reserved word
parsing:
# Reserved word parsing
typeset svar=$(echo one word) avar=(several words)
The above creates a scalar parameter svar and an array parameter
avar as if the assignments had been
svar="one word"
avar=(several words)
On the other hand:
# Normal builtin interface
builtin typeset svar=$(echo two words)
The builtin keyword causes the above to use the standard builtin
interface to typeset in which argument parsing is performed in the
same way as for other commands. This example creates a scalar
svar containing the value two and another scalar parameter words
with no value. An array value in this case would either cause an
error or be treated as an obscure set of glob qualifiers.
Arbitrary arguments are allowed if they take the form of
assignments after command line expansion; however, these only
perform scalar assignment:
var='svar=val'
typeset $var
The above sets the scalar parameter svar to the value val.
Parentheses around the value within var would not cause array
assignment as they will be treated as ordinary characters when
$var is substituted. Any non-trivial expansion in the name part
of the assignment causes the argument to be treated in this
fashion:
typeset {var1,var2,var3}=name
The above syntax is valid, and has the expected effect of setting
the three parameters to the same value, but the command line is
parsed as a set of three normal command line arguments to typeset
after expansion. Hence it is not possible to assign to multiple
arrays by this means.
Note that each interface to any of the commands my be disabled
separately. For example, `disable -r typeset' disables the
reserved word interface to typeset, exposing the builtin
interface, while `disable typeset' disables the builtin. Note
that disabling the reserved word interface for typeset may cause
problems with the output of `typeset -p', which assumes the
reserved word interface is available in order to restore array and
associative array values.
Unlike parameter assignment statements, typeset's exit status on
an assignment that involves a command substitution does not
reflect the exit status of the command substitution. Therefore,
to test for an error in a command substitution, separate the
declaration of the parameter from its initialization:
# WRONG
typeset var1=$(exit 1) || echo "Trouble with var1"
# RIGHT
typeset var1 && var1=$(exit 1) || echo "Trouble with var1"
To initialize a parameter param to a command output and mark it
readonly, use typeset -r param or readonly param after the
parameter assignment statement.
If no attribute flags are given, and either no name arguments are
present or the flag +m is used, then each parameter name printed
is preceded by a list of the attributes of that parameter (array,
association, exported, float, integer, readonly, or undefined for
autoloaded parameters not yet loaded). If +m is used with
attribute flags, and all those flags are introduced with +, the
matching parameter names are printed but their values are not.
The following control flags change the behavior of typeset:
+ If `+' appears by itself in a separate word as the last
option, then the names of all parameters (functions with
-f) are printed, but the values (function bodies) are not.
No name arguments may appear, and it is an error for any
other options to follow `+'. The effect of `+' is as if
all attribute flags which precede it were given with a `+'
prefix. For example, `typeset -U +' is equivalent to
`typeset +U' and displays the names of all arrays having
the uniqueness attribute, whereas `typeset -f -U +'
displays the names of all autoloadable functions. If + is
the only option, then type information (array, readonly,
etc.) is also printed for each parameter, in the same
manner as `typeset +m "*"'.
-g The -g (global) means that any resulting parameter will not
be restricted to local scope. Note that this does not
necessarily mean that the parameter will be global, as the
flag will apply to any existing parameter (even if unset)
from an enclosing function. This flag does not affect the
parameter after creation, hence it has no effect when
listing existing parameters, nor does the flag +g have any
effect except in combination with -m (see below).
-m If the -m flag is given the name arguments are taken as
patterns (use quoting to prevent these from being
interpreted as file patterns). With no attribute flags,
all parameters (or functions with the -f flag) with
matching names are printed (the shell option TYPESET_SILENT
is not used in this case).
If the +g flag is combined with -m, a new local parameter
is created for every matching parameter that is not already
local. Otherwise -m applies all other flags or assignments
to the existing parameters.
Except when assignments are made with name=value, using +m
forces the matching parameters and their attributes to be
printed, even inside a function. Note that -m is ignored
if no patterns are given, so `typeset -m' displays
attributes but `typeset -a +m' does not.
-p [ n ]
If the -p option is given, parameters and values are
printed in the form of a typeset command with an
assignment, regardless of other flags and options. Note
that the -H flag on parameters is respected; no value will
be shown for these parameters.
-p may be followed by an optional integer argument.
Currently only the value 1 is supported. In this case
arrays and associative arrays are printed with newlines
between indented elements for readability.
-T [ scalar[=value] array[=(value ...)] [ sep ] ]
This flag has a different meaning when used with -f; see
below. Otherwise the -T option requires zero, two, or
three arguments to be present. With no arguments, the list
of parameters created in this fashion is shown. With two
or three arguments, the first two are the name of a scalar
and of an array parameter (in that order) that will be tied
together in the manner of $PATH and $path. The optional
third argument is a single-character separator which will
be used to join the elements of the array to form the
scalar; if absent, a colon is used, as with $PATH. Only
the first character of the separator is significant; any
remaining characters are ignored. Multibyte characters are
not yet supported.
Only one of the scalar and array parameters may be assigned
an initial value (the restrictions on assignment forms
described above also apply).
Both the scalar and the array may be manipulated as normal.
If one is unset, the other will automatically be unset too.
There is no way of untying the variables without unsetting
them, nor of converting the type of one of them with
another typeset command; +T does not work, assigning an
array to scalar is an error, and assigning a scalar to
array sets it to be a single-element array.
Note that both `typeset -xT ...' and `export -T ...' work,
but only the scalar will be marked for export. Setting the
value using the scalar version causes a split on all
separators (which cannot be quoted). It is possible to
apply -T to two previously tied variables but with a
different separator character, in which case the variables
remain joined as before but the separator is changed.
When an existing scalar is tied to a new array, the value
of the scalar is preserved but no attribute other than
export will be preserved.
Attribute flags that transform the final value (-L, -R, -Z, -l,
-u) are only applied to the expanded value at the point of a
parameter expansion expression using `$'. They are not applied
when a parameter is retrieved internally by the shell for any
purpose.
The following attribute flags may be specified:
-A The names refer to associative array parameters; see `Array
Parameters' in zshparam(1).
-L [ n ]
Left justify and remove leading blanks from the value when
the parameter is expanded. If n is nonzero, it defines the
width of the field. If n is zero, the width is determined
by the width of the value of the first assignment. In the
case of numeric parameters, the length of the complete
value assigned to the parameter is used to determine the
width, not the value that would be output.
The width is the count of characters, which may be
multibyte characters if the MULTIBYTE option is in effect.
Note that the screen width of the character is not taken
into account; if this is required, use padding with
parameter expansion flags ${(ml...)...} as described in
`Parameter Expansion Flags' in zshexpn(1).
When the parameter is expanded, it is filled on the right
with blanks or truncated if necessary to fit the field.
Note truncation can lead to unexpected results with numeric
parameters. Leading zeros are removed if the -Z flag is
also set.
-R [ n ]
Similar to -L, except that right justification is used;
when the parameter is expanded, the field is left filled
with blanks or truncated from the end. May not be combined
with the -Z flag.
-U For arrays (but not for associative arrays), keep only the
first occurrence of each duplicated value. This may also
be set for tied parameters (see -T) or colon-separated
special parameters like PATH or FIGNORE, etc. Note the
flag takes effect on assignment, and the type of the
variable being assigned to is determinative; for variables
with shared values it is therefore recommended to set the
flag for all interfaces, e.g. `typeset -U PATH path'.
This flag has a different meaning when used with -f; see
below.
-Z [ n ]
Specially handled if set along with the -L flag.
Otherwise, similar to -R, except that leading zeros are
used for padding instead of blanks if the first non-blank
character is a digit. Numeric parameters are specially
handled: they are always eligible for padding with zeroes,
and the zeroes are inserted at an appropriate place in the
output.
-a The names refer to array parameters. An array parameter
may be created this way, but it may be assigned to in the
typeset statement only if the reserved word form of typeset
is enabled (as it is by default). When displaying, both
normal and associative arrays are shown.
-f The names refer to functions rather than parameters. No
assignments can be made, and the only other valid flags are
-t, -T, -k, -u, -U and -z. The flag -t turns on execution
tracing for this function; the flag -T does the same, but
turns off tracing for any named (not anonymous) function
called from the present one, unless that function also has
the -t or -T flag. The -u and -U flags cause the function
to be marked for autoloading; -U also causes alias
expansion to be suppressed when the function is loaded.
See the description of the `autoload' builtin for details.
Note that the builtin functions provides the same basic
capabilities as typeset -f but gives access to a few extra
options; autoload gives further additional options for the
case typeset -fu and typeset -fU.
-h Hide: only useful for special parameters (those marked
`<S>' in the table in zshparam(1)), and for local
parameters with the same name as a special parameter,
though harmless for others. A special parameter with this
attribute will not retain its special effect when made
local. Thus after `typeset -h PATH', a function containing
`typeset PATH' will create an ordinary local parameter
without the usual behaviour of PATH. Alternatively, the
local parameter may itself be given this attribute; hence
inside a function `typeset -h PATH' creates an ordinary
local parameter and the special PATH parameter is not
altered in any way. It is also possible to create a local
parameter using `typeset +h special', where the local copy
of special will retain its special properties regardless of
having the -h attribute. Global special parameters loaded
from shell modules (currently those in zsh/mapfile and
zsh/parameter) are automatically given the -h attribute to
avoid name clashes.
-H Hide value: specifies that typeset will not display the
value of the parameter when listing parameters; the display
for such parameters is always as if the `+' flag had been
given. Use of the parameter is in other respects normal,
and the option does not apply if the parameter is specified
by name, or by pattern with the -m option. This is on by
default for the parameters in the zsh/parameter and
zsh/mapfile modules. Note, however, that unlike the -h
flag this is also useful for non-special parameters.
-i [ n ]
Use an internal integer representation. If n is nonzero it
defines the output arithmetic base, otherwise it is
determined by the first assignment. Bases from 2 to 36
inclusive are allowed.
-E [ n ]
Use an internal double-precision floating point
representation. On output the variable will be converted
to scientific notation. If n is nonzero it defines the
number of significant figures to display; the default is
ten.
-F [ n ]
Use an internal double-precision floating point
representation. On output the variable will be converted
to fixed-point decimal notation. If n is nonzero it
defines the number of digits to display after the decimal
point; the default is ten.
-l Convert the result to lower case whenever the parameter is
expanded. The value is not converted when assigned.
-r The given names are marked readonly. Note that if name is
a special parameter, the readonly attribute can be turned
on, but cannot then be turned off.
If the POSIX_BUILTINS option is set, the readonly attribute
is more restrictive: unset variables can be marked readonly
and cannot then be set; furthermore, the readonly attribute
cannot be removed from any variable.
It is still possible to change other attributes of the
variable though, some of which like -U or -Z would affect
the value. More generally, the readonly attribute should
not be relied on as a security mechanism.
Note that in zsh (like in pdksh but unlike most other
shells) it is still possible to create a local variable of
the same name as this is considered a different variable
(though this variable, too, can be marked readonly).
Special variables that have been made readonly retain their
value and readonly attribute when made local.
-t Tags the named parameters. Tags have no special meaning to
the shell. This flag has a different meaning when used
with -f; see above.
-u Convert the result to upper case whenever the parameter is
expanded. The value is not converted when assigned. This
flag has a different meaning when used with -f; see above.
-x Mark for automatic export to the environment of
subsequently executed commands. If the option
GLOBAL_EXPORT is set, this implies the option -g, unless +g
is also explicitly given; in other words the parameter is
not made local to the enclosing function. This is for
compatibility with previous versions of zsh.
declare
Same as typeset.
float [ {+|-}Hghlprtux ] [ {+|-}EFLRZ [ n ] ] [ name[=value] ... ]
Equivalent to typeset -E, except that options irrelevant to
floating point numbers are not permitted.
integer [ {+|-}Hghlprtux ] [ {+|-}LRZi [ n ] ] [ name[=value] ... ]
Equivalent to typeset -i, except that options irrelevant to
integers are not permitted.
local [ {+|-}AHUahlprtux ] [ {+|-}EFLRZi [ n ] ] [ name[=value] ... ]
Same as typeset, except that the options -g, and -f are not
permitted. In this case the -x option does not force the use of
-g, i.e. exported variables will be local to functions.
readonly
Same as typeset -r. With the POSIX_BUILTINS option set, same as
typeset -gr.
Mini Shell