Differences between revisions 12 and 13
Revision 12 as of 2008-05-02 11:03:52
Size: 5644
Editor: 194
Comment: added shopt -s extglob
Revision 13 as of 2008-05-02 12:55:51
Size: 5780
Editor: GreyCat
Comment: clean up (including the ridiculous error in the almighty xmb's example)
Deletions are marked like this. Additions are marked like this.
Line 4: Line 4:
- first the real bash answer [by xmb] - 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]:
Line 7: Line 7:
shopt -s extglob
[[ $var == @([0-9]) ]]
}}}

--- rest is crap that was on the faq before -

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.

{{{
# Bash
Line 23: Line 15:
This can be done in Korn and legacy Bourne shells as well, using {{{case}}}: The same thing can be done in Korn and POSIX shells as well, using {{{case}}}:
Line 26: Line 18:
# ksh, POSIX
Line 32: Line 25:

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:
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]:
Line 36: Line 28:
# Bash example; extended globs are disabled by default # Bash -- extended globs must be enabled.
#
Check whether the variable is all digits.
Line 38: Line 31:
[[ $foo = *[0-9]* && $foo = ?([+-])*([0-9])?(.*([0-9])) ]] && echo "foo is a number" [[ $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"
Line 43: Line 45:
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: 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:
Line 46: Line 48:
# Ksh example using extended globs # ksh - extended globs are on by default
Line 57: Line 59:
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 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}}}:
Line 60: Line 62:
if test "$foo" && echo "$foo" | egrep '^[-+]?[0-9]*(\.[0-9]*)?$' >/dev/null; then # Bourne
if test "$foo" && echo "$foo" | egrep '^[-+]?[0-9]*(\.[0-9]*)?$' >/dev/null
then
Line 67: Line 71:
(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)}}}.) (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)}}}.)
Line 72: Line 76:
if [[ $foo = *[0-9]* && $foo =~ ^[-+]?[0-9]*\(\.[0-9]*\)?$ ]]; then  # Bash 3.1 only! # Bash 3.1 ONLY
if [[ $foo = *[0-9]* && $foo =~ ^[-+]?[0-9]*\(\.[0-9]*\)?$ ]]; then
Line 82: Line 87:
if [[ $foo = *[0-9]* && $foo =~ ^[-+]?[0-9]*(\.[0-9]*)?$ ]]; then    # **PATCHED** Bash 3.2 only! # Bash 3.2 *PATCHED* only!
if [[ $foo = *[0-9]* && $foo =~ ^[-+]?[0-9]*(\.[0-9]*)?$ ]]; then
Line 95: Line 101:
Line 100: Line 105:
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.
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.
Line 110: Line 118:
# bash (and ksh93, if you replace declare with typeset) # Bash (and ksh93, if you replace declare with typeset)
Line 116: Line 124:
In the 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. 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.

Anchor(faq54)

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"
else
    echo "'$foo' is strictly numeric"
fi

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" ;;
esac

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
  *[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 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
then
    echo "'$foo' might be a number"
else
    echo "'$foo' might not be a number"
fi

(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"
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:

# Bash 3.2 *PATCHED* only!
if [[ $foo = *[0-9]* && $foo =~ ^[-+]?[0-9]*(\.[0-9]*)?$ ]]; then
    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 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
hello
ksh: hello: bad number
$ echo $?
1
$ echo $foo
42

BashFAQ/054 (last edited 2022-04-19 05:23:33 by emanuele6)