Differences between revisions 1 and 18 (spanning 17 versions)
Revision 1 as of 2007-05-02 23:46:43
Size: 1429
Editor: redondos
Comment:
Revision 18 as of 2010-01-15 20:30:25
Size: 5228
Editor: ppp089210037022
Comment: a bit of clean, add the solutions using [ and printf
Deletions are marked like this. Additions are marked like this.
Line 1: Line 1:
[[Anchor(faq54)]] <<Anchor(faq54)>>
Line 4: Line 4:
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". === Hand Parsing ===
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 8:
# Bash
Line 8: Line 10:
   echo "'$foo' has a non-digit somewhere in it"   echo "'$foo' has a non-digit somewhere in it"
Line 10: Line 12:
   echo "'$foo' is strictly numeric"   echo "'$foo' is strictly numeric"
Line 14: Line 16:
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 17: Line 19:
# ksh, POSIX
Line 23: Line 26:
If what you actually mean is "a valid floating-point number" or something else more complex, then you might prefer to use a regular expression. Bash version 3 and above have regular expression support in the [[ command: 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 26: Line 29:
if [[ $foo =~ ^[-+]?[0-9]+\(\.[0-9]+\)?$ ]]; then # Bash -- extended globs must be enabled.
# Check whether the variable is all digits.
shopt -s extglob
[[ $var == +([0-9]) ]]
}}}

A more complex case:

{{{
# Bash use case instead of [[ ]] for old ksh
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.

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.

{{{
# put it in a var for backward compatibility with versions <3.2
regexp='^[-+]?[0-9]*(\.[0-9]*)?$'
if [[ $foo = *[0-9]* && $foo =~ $var ]]; then
Line 33: Line 72:
If you don't have bash version 3, then you would use {{{egrep}}}: === Using the parsing done by [ and printf ===
Line 36: Line 75:
if echo "$foo" | egrep '^[-+]?[0-9]+(\.[0-9]+)?$' >/dev/null; then
    echo "'$foo' might be a number"
else
    echo "'$foo' might not be a number"
# fails with ksh
if [ "$foo" -eq "$foo" ] 2>/dev/null;then
 echo "$foo is an integer"
fi
}}}

[ parses the variable and interprets it as in integer because of
the -eq. If the parsing succeds the test is trivially true, if it fails [ prints an error message
that 2>/dev/null hides and set a status different from 0.
However this method fails if the shell is ksh, because
ksh evaluates the variable as an arithmetic expression, see below
to learn while.

You can use the same trick with printf:
{{{
# posix
if printf "%f" "$foo" >/dev/null 2>&1;then
  echo "$foo is a float"
Line 43: Line 96:
Note that the parentheses in the {{{egrep}}} regular expression don't require backslashes in front of them, whereas the ones in the bash3 command do. You can use %d to parse an integer.
Take care that the parsing might (is supposed to be?) be locale dependant.

=== Using the integer type ===

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, the user's input is treated as an [[ArithmeticExpression|arithmetic expression]], as with assignment. In particular, if the user types an identifier, the variable will be set to the value of the variable with that name, and `read` will give no other indication of a problem.

{{{
# Bash (and ksh93, if you replace declare with typeset)
$ declare -i foo
$ read foo
hello
$ echo $foo # prints 0; 'hello' is unset, so is treated as 0 for arithmetic purposes
$ hello=5
$ read foo # user types hello again
hello
$ echo $foo # prints 5, the value of 'hello' as an arithmetic expression
}}}

Pretty useless if you want to read only integers.

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
}}}

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

Hand Parsing

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 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 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 use case instead of [[ ]] for old ksh 
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.

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 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 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.

# put it in a var for backward compatibility with versions <3.2
regexp='^[-+]?[0-9]*(\.[0-9]*)?$' 
if [[ $foo = *[0-9]* && $foo =~ $var ]]; then
    echo "'$foo' looks rather like a number"
else
    echo "'$foo' doesn't look particularly numeric to me"
fi

Using the parsing done by [ and printf

# fails with ksh
if [ "$foo" -eq "$foo" ] 2>/dev/null;then
 echo "$foo is an integer"
fi

[ parses the variable and interprets it as in integer because of the -eq. If the parsing succeds the test is trivially true, if it fails [ prints an error message that 2>/dev/null hides and set a status different from 0. However this method fails if the shell is ksh, because ksh evaluates the variable as an arithmetic expression, see below to learn while.

You can use the same trick with printf:

#  posix 
if printf "%f" "$foo" >/dev/null 2>&1;then
  echo "$foo is a float"
fi

You can use %d to parse an integer. Take care that the parsing might (is supposed to be?) be locale dependant.

Using the integer type

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 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, the user's input is treated as an arithmetic expression, as with assignment. In particular, if the user types an identifier, the variable will be set to the value of the variable with that name, and read will give no other indication of a problem.

# Bash (and ksh93, if you replace declare with typeset)
$ declare -i foo
$ read foo
hello
$ echo $foo    # prints 0; 'hello' is unset, so is treated as 0 for arithmetic purposes
$ hello=5
$ read foo     # user types hello again
hello
$ echo $foo    # prints 5, the value of 'hello' as an arithmetic expression

Pretty useless if you want to read only integers.

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-08-01 10:02:57 by 89)