## 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 seems to be that, when people ask this, they actually mean "a non-negative integer, with no leading + sign". Or in other words, a string of all digits.

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

This can be done in Korn and legacy Bourne shells as well, using case:

```case "\$foo" in
*[!0-9]*) echo "'\$foo' has a non-digit somewhere in it" ;;
*) echo "'\$foo' is strictly numeric" ;;
esac```

If what you actually mean is "a valid floating-point number" or something else more complex, then there are a few possible ways. One of them is to use Bash's extglob capability:

```# Bash example; extended globs are disabled by default
shopt -s extglob
[[ \$foo = *[0-9]* && \$foo = ?([+-])*([0-9])?(.*([0-9])) ]] && echo "foo is a 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 example using extended globs
case \$foo in
*[0-9]*)
case \$foo in
?([+-])*([0-9])?(.*([0-9]))) echo "foo is a number";;
esac;;
esac```

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 a regular expression. Here is a portable version, using egrep:

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

(Like the extended globs, this extended regular expression matches a lone + or -, and the code may therefore require adjustment. 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.

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

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:

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

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 assigned 0
foo="Some random string" #result in an error.```

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