Diff for "BashFAQ/083"

Differences between revisions 17 and 22 (spanning 5 versions)

How do I determine whether a variable is already defined? Or a function?

There are several ways to test for a defined or non-empty variable or function depending upon the requirements.

Contents

How do I determine whether a variable is already defined? Or a function?

"Declared", "Defined", and "Undefined"

Like in many languages, declaration and definition can be independent steps. To declare an object is to give it a name and datatype, whereas a definition associates it with a value, which may be empty. In Unix shell terminology, "unset", "set", and "null" are often used to mean "undefined", "defined", and "empty" respectively. Since "string" is very nearly the only common datatype, "null" usually means the empty string. With arrays, things become less consistent between shells.

Testing for a defined, non-empty variable / parameter.

Since the most common goal is to distinguish between an empty and non-empty variable or parameter, we'll discuss it first. These are the most common solutions arranged from most to least portable.

`test x"$var" != x`	Only needed for ancient Bourne shells. Don't use this in modern scripts.
`test -n "$var"`	POSIX sh plus some older Bourne shells which lacked `[`.
`[ -n "$var" ]`	POSIX sh and most Bourne shells including Heirloom. Best overall choice for new scripts requiring POSIX compatibility.
`test "$var"`	POSIX sh. POSIX specifies that for one argument, non-null is always true while null is always false.
`[ "$var" ]`	POSIX sh. As above. Still very portable.
`[[ -n $var ]]`	Here and below is Bash/Ksh/Zsh only. This is compatible with some buggy shell versions which didn't process the implicit -n correctly.
`[[ $var ]]`	Best overall choice for Bash/Ksh where POSIX isn't a requirement. Usually best performance. This won't work in Zsh.
`(( ${#var} ))`	About as portable as the above. Almost always slower. Don't use this to test for empty strings.

To check the converse, whether a variable is empty (unset or zero-length), invert the above logic.

test x"$var" = x
test -z "$var"
[ -z "$var" ]
test ! "$var"
[ ! "$var" ]
[[ -z $var ]]
[[ ! $var ]] # Also won't work in Zsh in any emulate mode. If such portability is needed, adjust solutions on this page to use -z or -n explicitly.

Testing that a variable has been declared

Distinguishing between a variable that is undefined and one that is defined but empty is somewhat trickier, but possible.

# POSIX. Not Bourne-compatible.
! ${var+false} # Usually fastest and cleanest.
[ "$((${var+1}))" -ne 0 ]

# Bourne / POSIX
${var+:} false
[ -n "${var+_}" ]
[ "${var+_}" ]

Which of the above performs best varies from shell to shell. If POSIX isn't a requirement, the following [[ solution usually performs best.

# Bash/ksh
[[ ${var+_} ]]
(( ${var+1} ))

Another method that's occasionally seen is to check the status of typeset -p. The above method should be preferred over this.

# Bash/ksh/zsh
typeset -p var >/dev/null 2>&1
# returns 0 if var exists, error otherwise

Bash 4.2 adds a -v test:

# Bash 4.2 / ksh93
if [[ -v var ]]; then echo "var is defined"; fi

ksh93 and bash (since 4.3) support array indices with the -v test. Bash 4.2 did not. This is the "best" but also least portable method to test for an unset variable.

Testing that a function has been defined

For determining whether a function with a given name is already defined, there are several answers, all of which require Bash (or at least, non-Bourne) commands. Testing that a function is defined should rarely be necessary.

declare -F f >/dev/null       # Bash only - declare outputs "f" and returns 0 if defined, returns non-zero otherwise.
typeset -f f >/dev/null       # Bash/Ksh - typeset outputs the entire function and returns 0 if defined, returns non-zero otherwise.
[[ $(type -t f) = function ]] # Bash-only - "type" outputs "function" if defined. In ksh (and mksh), the "type" alias for "whence -v" differs.

# Bash/Ksh. Workaround for the above, but the first two are preferable.
isFunction() [[ $(type ${BASH_VERSION:+-t} "$1") == ${KSH_VERSION:+"$1 is a "}function ]]; isFunction f

-  ⇤ ← Revision 17 as of 2012-11-23 09:57:53 → 
  Size: 4194
  Editor: ormaaj
  Comment: Corrections. Mostly for zsh.
+   ← Revision 22 as of 2015-04-06 17:17:02 → ⇥
  Size: 4348
  Editor: ormaaj
  Comment: -v with arrays in bash 4.3
-Deletions are marked like this.
+Additions are marked like this.
 Line 41:
-# POSIX
+# POSIX. Not Bourne-compatible.
! ${var+false} # Usually fastest and cleanest.
[ "$((${var+1}))" -ne 0 ]

# Bourne / POSIX
-Line 43:
+Line 47:
-! ${var+false}
-Line 53:
+Line 56:
+(( ${var+1} ))
-Line 70:
+Line 74:
-ksh93 additionally supports array indices with the `-v` test, while Bash so far does not. This should be the preferred method when targeting ksh93 specifically.
+ksh93 and bash (since 4.3) support array indices with the `-v` test. Bash 4.2 did not. This is the "best" but also least portable method to test for an unset variable.
-Line 77:
+Line 81:
-typeset -f f >/dev/null        # Bash/Ksh - typeset returns false if undefined, otherwise true.
[[ $(typeset -f f) ]]          # Bash/Ksh - typeset prints nothing if undefined, otherwise outputs the function's definition.
[[ $(type -t f) == function ]] # Bash-only - "type" outputs "function" if defined. In ksh (and mksh), the "type" alias for "whence -v" differs.
+declare -F f >/dev/null       # Bash only - declare outputs "f" and returns 0 if defined, returns non-zero otherwise.
typeset -f f >/dev/null       # Bash/Ksh - typeset outputs the entire function and returns 0 if defined, returns non-zero otherwise.
[[ $(type -t f) = function ]] # Bash-only - "type" outputs "function" if defined. In ksh (and mksh), the "type" alias for "whence -v" differs.