How can I tell whether a variable contains a valid number?

First, you have to define what you mean by "number". The most common case when people ask this seems to be "a non-negative integer, with no leading + sign". Or in other words, a string of all digits. This can be checked using standard [:glob:globs]:

# Bash
if [[ $foo = *[^0-9]* ]]; then
    echo "'$foo' has a non-digit somewhere in it"
    echo "'$foo' is strictly numeric"

The same thing can be done in Korn and POSIX shells as well, using case:

# ksh, POSIX
case "$foo" in
    *[!0-9]*) echo "'$foo' has a non-digit somewhere in it" ;;
    *) echo "'$foo' is strictly numeric" ;;

If what you actually mean is "a valid floating-point number" or something else more complex, then there are a few possible ways. Standard globs aren't expressive enough to do this, but we can use [:glob:extended globs]:

# Bash -- extended globs must be enabled.
# Check whether the variable is all digits.
shopt -s extglob
[[ $var == +([0-9]) ]]

A more complex case:

# Bash
shopt -s extglob
[[ $foo = *[0-9]* && $foo = ?([+-])*([0-9])?(.*([0-9])) ]] &&
  echo "foo is a floating-point number"

The leading test of $foo is to ensure that it contains at least one digit. The extended glob, by itself, would match the empty string, or a lone + or -, which may not be desirable behavior.

The features enabled with extglob in Bash are also allowed in the Korn shell by default. The difference here is that ksh lacks Bash's [[ and must use case instead:

# ksh - extended globs are on by default
case $foo in
    case $foo in
        ?([+-])*([0-9])?(.*([0-9]))) echo "foo is a number";;

Note that this uses the same extended glob as the Bash example before it; the third closing parenthesis at the end of it is actually part of the case syntax.

If your definition of "a valid number" is even more complex, or if you need a solution that works in legacy Bourne shells, you might prefer to use an external tool's [:RegularExpression:regular expression] syntax. Here is a portable version, using egrep:

# Bourne
if test "$foo" && echo "$foo" | egrep '^[-+]?[0-9]*(\.[0-9]*)?$' >/dev/null
    echo "'$foo' might be a number"
    echo "'$foo' might not be a number"

(Like the extended globs, this [:RegularExpression:extended regular expression] will match a lone + or -. The initial test command only requires a non-empty string. Closing the last "bug" is left as an exercise for the reader, mostly because GreyCat is too damned lazy to learn expr(1).)

Bash version 3 and above have regular expression support in the [[ command. However, due to serious bugs and syntax changes in Bash's [[ regex support, we do not recommend using it. Nevertheless, if I simply omit all Bash regex answers here, someone will come along and fill them in -- and they probably won't work, or won't contain all the caveats necessary. So, in the interest of preventing disasters, here are the Bash regex answers that you should not use.

# Bash 3.1 ONLY
if [[ $foo = *[0-9]* && $foo =~ ^[-+]?[0-9]*\(\.[0-9]*\)?$ ]]; then
    echo "'$foo' looks rather like a number"
    echo "'$foo' doesn't look particularly numeric to me"

Unfortunately, Bash changed the syntax of its regular expression support after version 3.1, so the following may work in some patched versions of Bash 3.2:

# Bash 3.2 *PATCHED* only!
if [[ $foo = *[0-9]* && $foo =~ ^[-+]?[0-9]*(\.[0-9]*)?$ ]]; then
    echo "'$foo' looks rather like a number"
    echo "'$foo' doesn't look particularly numeric to me"

It fails rather spectacularly in bash 3.1 and in bash 3.2 without patches.

Note that the parentheses in the egrep regular expression and the bash 3.2.patched regular expression don't require backslashes in front of them, whereas the ones in the bash 3.1 command do.

Stuffing the Bash regex into a variable, and then using [[ $foo =~ $bar ]], may also be an effective workaround in some cases. But this belongs in a separate FAQ....

If you just want to guarantee ahead of time that a variable contains an integer, without actually checking, you can give the variable the "integer" attribute.

declare -i foo
foo=-10+1; echo "$foo"    # prints -9

foo="hello"; echo "$foo"
# the value of the variable "hello" is evaluated; if unset, foo is 0

foo="Some random string"  # results in an error.

Any value assigned to a variable with the integer attribute set is evaluated as an [:ArithmeticExpression:arithmetic expression] just like inside $(( )). Bash will raise an error if you try to assign an invalid arithmetic expression.

In Bash and ksh93, if a variable which has been declared integer is used in a read command, and the user types an invalid integer variable, the variable will have a value of 0 instead of whatever the user typed. read will give no other indication of a problem.

# Bash (and ksh93, if you replace declare with typeset)
declare -i foo
read foo     # user types hello; bash doesn't complain, and read returns success
echo $foo    # prints 0

Pretty useless....

In the older Korn shell (ksh88), if a variable is declared integer and used in a read command, and the user types an invalid integer, the shell complains, the read command returns an error status, and the value of the variable is unchanged.

# ksh88
$ typeset -i foo
$ foo=42
$ read foo
ksh: hello: bad number
$ echo $?
$ echo $foo