如何在Bash中测试变量是否为数字？

我只是不知道如何确定传递给脚本的参数是否为数字。

我要做的就是这样：

test *isnumber* $1 && VAR=$1 || echo "need a number"

有什么帮助吗？

一种方法是使用正则表达式，如下所示：

re='^[0-9]+$'
if ! [[ $yournumber =~ $re ]] ; then
   echo "error: Not a number" >&2; exit 1
fi

如果该值不一定是整数，请考虑适当修改正则表达式；例如：

^[0-9]+([.][0-9]+)?$

...或使用带符号处理数字：

^[+-]?[0-9]+([.][0-9]+)?$

没有bashisms（即使在System V sh中也可以工作），

case $string in
    ''|*[!0-9]*) echo bad ;;
    *) echo good ;;
esac

这将拒绝空字符串和包含非数字的字符串，并接受其他所有内容。

负数或浮点数需要做一些额外的工作。一个想法是在第一个“不良”模式中排除-/ .并添加更多包含其不当使用的“不良”模式（?*-*/ *.*.*）

以下解决方案也可以在基本的Shell（例如Bourne）中使用，而无需使用正则表达式。基本上，任何使用非数字的数值评估操作都将导致错误，该错误在shell中将被隐式视为false：

"$var" -eq "$var"

如：

#!/bin/bash

var=a

if [ -n "$var" ] && [ "$var" -eq "$var" ] 2>/dev/null; then
  echo number
else
  echo not a number
fi

您还可以测试$？该操作的返回码更为明确：

[ -n "$var" ] && [ "$var" -eq "$var" ] 2>/dev/null
if [ $? -ne 0 ]; then
   echo $var is not number
fi

重定向标准错误是为了隐藏bash打印出来的“期望的整数表达式”消息，以防我们没有数字。

注意事项（由于以下评论）：

• 带小数点的数字不被标识为有效的“数字”
• 使用[[ ]]代替[ ]将始终评估为true
• 大多数非Bash外壳程序始终会将此表达式评估为 true
• Bash中的行为是未记录的，因此可能会更改而不会发出警告
• 如果该值在数字后出现空格（例如“ 1 a”），则会产生错误，例如 bash: [[: 1 a: syntax error in expression (error token is "a")
• 如果该值与var-name相同（例如i =“ i”），则产生错误，例如 bash: [[: i: expression recursion level exceeded (error token is "i")

这将测试一个数字是否为非负整数并且是否与外壳无关（即没有bashisms）并且仅使用外壳内置函数：

不正确

因为这个第一个答案（如下）允许整数中包含字符，只要该变量中的第一个不是第一个。

[ -z "${num##[0-9]*}" ] && echo "is a number" || echo "is not a number";

正确。

正如jilles在他的回答中所评论和建议的那样，这是使用shell模式进行操作的正确方法。

[ ! -z "${num##*[!0-9]*}" ] && echo "is a number" || echo "is not a number";

没有人建议bash 扩展模式匹配：

[[ $1 == ?(-)+([0-9]) ]] && echo "$1 is an integer"

我对直接在shell中解析数​​字格式的解决方案感到惊讶。shell不适用于此，它是用于控制文件和进程的DSL。下方有一些足够多的解析器，例如：

isdecimal() {
  # filter octal/hex/ord()
  num=$(printf '%s' "$1" | sed "s/^0*\([1-9]\)/\1/; s/'/^/")

  test "$num" && printf '%f' "$num" >/dev/null 2>&1
}

将“％f”更改为所需的任何特定格式。

我看着答案，发现没有人想到浮点数（带点）！

使用grep也很棒。
-E表示扩展的正则表达式
-q表示安静（不回显）
-qE是两者的组合。

要在命令行中直接测试：

$ echo "32" | grep -E ^\-?[0-9]?\.?[0-9]+$  
# answer is: 32

$ echo "3a2" | grep -E ^\-?[0-9]?\.?[0-9]+$  
# answer is empty (false)

$ echo ".5" | grep -E ^\-?[0-9]?\.?[0-9]+$  
# answer .5

$ echo "3.2" | grep -E ^\-?[0-9]?\.?[0-9]+$  
# answer is 3.2

在bash脚本中使用：

check=`echo "$1" | grep -E ^\-?[0-9]*\.?[0-9]+$`

if [ "$check" != '' ]; then    
  # it IS numeric
  echo "Yeap!"
else
  # it is NOT numeric.
  echo "nooop"
fi

要匹配仅整数，请使用以下命令：

# change check line to:
check=`echo "$1" | grep -E ^\-?[0-9]+$`

只是对@mary的跟进。但是因为我没有足够的代表，所以无法将其发布为该帖子的评论。无论如何，这是我所使用的：

isnum() { awk -v a="$1" 'BEGIN {print (a == a + 0)}'; }

如果参数为数字，则该函数将返回“ 1”，否则将返回“ 0”。这适用于整数和浮点数。用法类似于：

n=-2.05e+07
res=`isnum "$n"`
if [ "$res" == "1" ]; then
     echo "$n is a number"
else
     echo "$n is not a number"
fi

test -z "${i//[0-9]}" && echo digits || echo no no no

${i//[0-9]}将$i空值中的任何数字替换为空字符串，请参见man -P 'less +/parameter\/' bash。-z检查结果字符串的长度是否为零。

如果您还想排除$i为空的情况，则可以使用以下一种构造：

test -n "$i" && test -z "${i//[0-9]}" && echo digits || echo not a number
[[ -n "$i" && -z "${i//[0-9]}" ]] && echo digits || echo not a number

对于我的问题，我只需要确保用户不会意外输入一些文本，因此我尝试使其保持简单易读

isNumber() {
    (( $1 )) 2>/dev/null
}

根据手册页，这几乎可以满足我的要求

如果表达式的值不为零，则返回状态为0

为了防止“可能是数字”的字符串出现讨厌的错误消息，我忽略了错误输出

$ (( 2s ))
bash: ((: 2s: value too great for base (error token is "2s")

老问题了，但我只是想提出自己的解决方案。这不需要任何奇怪的shell技巧，也不需要依靠永远不会出现的东西。

if [ -n "$(printf '%s\n' "$var" | sed 's/[0-9]//g')" ]; then
    echo 'is not numeric'
else
    echo 'is numeric'
fi

基本上，它只是从输入中删除所有数字，如果您留下的字符串长度不为零，则它不是数字。

无法发表评论，因此我将添加自己的答案，这是使用bash模式匹配对glenn jackman的答案的扩展。

我最初的需求是识别数字并区分整数和浮点数。函数定义推导为：

function isInteger() {
    [[ ${1} == ?(-)+([0-9]) ]]
}

function isFloat() {
    [[ ${1} == ?(-)@(+([0-9]).*([0-9])|*([0-9]).+([0-9]))?(E?(-|+)+([0-9])) ]]
}

我使用单元测试（通过shUnit2）来验证我的模式是否按预期工作：

oneTimeSetUp() {
    int_values="0 123 -0 -123"
    float_values="0.0 0. .0 -0.0 -0. -.0 \
        123.456 123. .456 -123.456 -123. -.456
        123.456E08 123.E08 .456E08 -123.456E08 -123.E08 -.456E08 \
        123.456E+08 123.E+08 .456E+08 -123.456E+08 -123.E+08 -.456E+08 \
        123.456E-08 123.E-08 .456E-08 -123.456E-08 -123.E-08 -.456E-08"
}

testIsIntegerIsFloat() {
    local value
    for value in ${int_values}
    do
        assertTrue "${value} should be tested as integer" "isInteger ${value}"
        assertFalse "${value} should not be tested as float" "isFloat ${value}"
    done

    for value in ${float_values}
    do
        assertTrue "${value} should be tested as float" "isFloat ${value}"
        assertFalse "${value} should not be tested as integer" "isInteger ${value}"
    done

}

注意：可以修改isFloat模式，使其对小数点（@(.,)）和E符号（@(Ee)）的容忍度更高。我的单元测试仅测试整数或浮点值，而不测试任何无效输入。

我会尝试这样的：

printf "%g" "$var" &> /dev/null
if [[ $? == 0 ]] ; then
    echo "$var is a number."
else
    echo "$var is not a number."
fi

注意：这会将nan和inf识别为数字。

@charles Dufy和其他人已经给出了明确的答案。一个纯bash解决方案将使用以下方法：

string="-12,345"
if [[ "$string" =~ ^-?[0-9]+[.,]?[0-9]*$ ]]
then
    echo $string is a number
else
    echo $string is not a number
fi

尽管对于实数，在小数点前没有数字是强制性的。

为了提供对浮点数和科学计数法的更彻底的支持（C / Fortran中的许多程序，否则将以这种方式导出浮点数），此行的有用补充如下：

string="1.2345E-67"
if [[ "$string" =~ ^-?[0-9]*[.,]?[0-9]*[eE]?-?[0-9]+$ ]]
then
    echo $string is a number
else
    echo $string is not a number
fi

因此，如果您要查找任何特定类型，则可以找到一种区分数字类型的方法：

string="-12,345"
if [[ "$string" =~ ^-?[0-9]+$ ]]
then
    echo $string is an integer
elif [[ "$string" =~ ^-?[0-9]*[.,]?[0-9]*$ ]]
then
    echo $string is a float
elif [[ "$string" =~ ^-?[0-9]*[.,]?[0-9]*[eE]-?[0-9]+$ ]]
then
    echo $string is a scientific number
else
    echo $string is not a number
fi

注意：我们可以列出十进制和科学计数法的句法要求，其中之一是允许逗号作为小数点以及“。”。然后，我们断言必须只有一个这样的小数点。[Ee]浮点数中可以有两个+/-符号。我从Aulu的工作中学到了一些规则，并针对诸如''-''-E-1''0-0'之类的错误字符串进行了测试。这是我似乎正在使用的regex / substring / expr工具：

parse_num() {
 local r=`expr "$1" : '.*\([.,]\)' 2>/dev/null | tr -d '\n'` 
 nat='^[+-]?[0-9]+[.,]?$' \
 dot="${1%[.,]*}${r}${1##*[.,]}" \
 float='^[\+\-]?([.,0-9]+[Ee]?[-+]?|)[0-9]+$'
 [[ "$1" == $dot ]] && [[ "$1" =~ $float ]] || [[ "$1" =~ $nat ]]
} # usage: parse_num -123.456

[[ $1 =~ ^-?[0-9]+$ ]] && echo "number"

不要忘记-添加负数！

这可以通过使用grep查看所讨论的变量是否匹配扩展的正则表达式来实现。

测试整数1120：

yournumber=1120
if echo "$yournumber" | grep -qE '^[0-9]+$'; then
    echo "Valid number."
else
    echo "Error: not a number."
fi

输出： Valid number.

测试非整数1120a：

yournumber=1120a
if echo "$yournumber" | grep -qE '^[0-9]+$'; then
    echo "Valid number."
else
    echo "Error: not a number."
fi

输出： Error: not a number.

说明

• 的 grep，该-E开关允许我们使用扩展正则表达式'^[0-9]+$'。此正则表达式表示变量从变量的开始到结束应仅[]包含数字0-90到9，并且至少应包含一个字符。^$+
• 的grep，在-q安静的开关关闭任何输出是否发现任何东西。
• if 检查的退出状态 grep。退出状态0表示成功，更大的状态表示错误。该grep命令的退出状态为0是否找到匹配项以及1何时没有找到匹配项；

因此，将所有内容放在一起，在if测试中，我们echo将变量$yournumber并通过|管道将grep其通过管道-q与-E扩展的正则表达式'^[0-9]+$'表达式进行静默匹配。的退出状态grep将是0，如果grep成功找到了一根火柴，1如果它没有。如果匹配成功，我们echo "Valid number."。如果匹配失败，我们echo "Error: not a number."。

对于浮球或双打

我们可以将正则表达式从'^[0-9]+$'更改'^[0-9]*\.?[0-9]+$'为float或double。

测试浮子 1120.01：

yournumber=1120.01
if echo "$yournumber" | grep -qE '^[0-9]*\.?[0-9]+$'; then
    echo "Valid number."
else
    echo "Error: not a number."
fi

输出： Valid number.

测试浮点数11.20.01：

yournumber=11.20.01
if echo "$yournumber" | grep -qE '^[0-9]*\.?[0-9]+$'; then
    echo "Valid number."
else
    echo "Error: not a number."
fi

输出： Error: not a number.

对于负数

要允许负整数，只需将正则表达式从更改'^[0-9]+$'为'^\-?[0-9]+$'。

要允许负浮点数或双精度数，只需将正则表达式从更改为'^[0-9]*\.?[0-9]+$'即可'^\-?[0-9]*\.?[0-9]+$'。

http://tldp.org/LDP/Bash-Beginners-Guide/html/sect_04_03.html

您还可以使用bash的字符类。

if [[ $VAR = *[[:digit:]]* ]]; then
 echo "$VAR is numeric"
else
 echo "$VAR is not numeric"
fi

数字将包括空格，小数点和浮点数的“ e”或“ E”。

但是，如果指定C样式的十六进制数字，即“ 0xffff”或“ 0XFFFF”，则[[：digit：]]返回true。bash有点陷阱，bash允许您执行“ 0xAZ00”之类的操作，并且仍将其算作一个数字（这不是GCC编译器的一些怪癖，它使您可以将0x表示法用于除16以外的基数吗？ ）

如果您的输入完全不受信任，则可能需要先测试“ 0x”或“ 0X”是否为数字，除非您想接受十六进制数字。这将通过以下方式实现：

if [[ ${VARIABLE:1:2} = "0x" ]] || [[ ${VARIABLE:1:2} = "0X" ]]; then echo "$VAR is not numeric"; fi

最简单的方法是检查它是否包含非数字字符。您将所有数字字符替换为空并检查其长度。如果有长度，则不是数字。

if [[ ! -n ${input//[0-9]/} ]]; then
    echo "Input Is A Number"
fi

因为我最近不得不对此进行修改，并且最喜欢单元测试的karttu的方法。我修改了代码并添加了其他一些解决方案，您可以自己尝试一下以查看结果：

#!/bin/bash

    # N={0,1,2,3,...} by syntaxerror
function isNaturalNumber()
{
 [[ ${1} =~ ^[0-9]+$ ]]
}
    # Z={...,-2,-1,0,1,2,...} by karttu
function isInteger() 
{
 [[ ${1} == ?(-)+([0-9]) ]]
}
    # Q={...,-½,-¼,0.0,¼,½,...} by karttu
function isFloat() 
{
 [[ ${1} == ?(-)@(+([0-9]).*([0-9])|*([0-9]).+([0-9]))?(E?(-|+)+([0-9])) ]]
}
    # R={...,-1,-½,-¼,0.E+n,¼,½,1,...}
function isNumber()
{
 isNaturalNumber $1 || isInteger $1 || isFloat $1
}

bools=("TRUE" "FALSE")
int_values="0 123 -0 -123"
float_values="0.0 0. .0 -0.0 -0. -.0 \
    123.456 123. .456 -123.456 -123. -.456 \
    123.456E08 123.E08 .456E08 -123.456E08 -123.E08 -.456E08 \
    123.456E+08 123.E+08 .456E+08 -123.456E+08 -123.E+08 -.456E+08 \
    123.456E-08 123.E-08 .456E-08 -123.456E-08 -123.E-08 -.456E-08"
false_values="blah meh mooh blah5 67mooh a123bc"

for value in ${int_values} ${float_values} ${false_values}
do
    printf "  %5s=%-30s" $(isNaturalNumber $value) ${bools[$?]} $(printf "isNaturalNumber(%s)" $value)
    printf "%5s=%-24s" $(isInteger $value) ${bools[$?]} $(printf "isInteger(%s)" $value)
    printf "%5s=%-24s" $(isFloat $value) ${bools[$?]} $(printf "isFloat(%s)" $value)
    printf "%5s=%-24s\n" $(isNumber $value) ${bools[$?]} $(printf "isNumber(%s)" $value)
done

所以isNumber（）包含破折号，逗号和指数符号，因此在整数和浮点数上返回TRUE，而在另一方面，isFloat（）在整数值上返回FALSE，而isInteger（）在浮点数上同样返回FALSE。为了您的方便，所有衬板：

isNaturalNumber() { [[ ${1} =~ ^[0-9]+$ ]]; }
isInteger() { [[ ${1} == ?(-)+([0-9]) ]]; }
isFloat() { [[ ${1} == ?(-)@(+([0-9]).*([0-9])|*([0-9]).+([0-9]))?(E?(-|+)+([0-9])) ]]; }
isNumber() { isNaturalNumber $1 || isInteger $1 || isFloat $1; }

我使用expr。如果尝试将零添加到非数字值，它将返回非零值：

if expr -- "$number" + 0 > /dev/null 2>&1
then
    echo "$number is a number"
else
    echo "$number isn't a number"
fi

如果您需要非整数，则可能可以使用bc，但是我不认为它bc具有完全相同的行为。将零加到非数字上将得到零，并且它也返回零值。也许你可以结合bc和expr。用于bc向加上零$number。如果答案为0，则尝试expr验证其$number不为零。

我喜欢Alberto Zaccagni的回答。

if [ "$var" -eq "$var" ] 2>/dev/null; then

重要的先决条件：-不产生子外壳-不调用RE解析器-大多数外壳应用程序不使用实数

但是，如果$var是复杂的（例如，关联数组访问），并且该数字是一个非负整数（大多数用例），那么这也许更有效？

if [ "$var" -ge 0 ] 2> /dev/null; then ..

如果您提供格式字符串“％f”或“％i”，我将使用printf作为其他答案，printf将为您进行检查。比重新发明检查更容易，语法简单，简短，并且printf无处不在。因此，在我看来，这是一个不错的选择-您还可以使用以下想法来检查各种事物，它不仅对检查数字有用。

declare  -r CHECK_FLOAT="%f"  
declare  -r CHECK_INTEGER="%i"  

 ## <arg 1> Number - Number to check  
 ## <arg 2> String - Number type to check  
 ## <arg 3> String - Error message  
function check_number() { 
  local NUMBER="${1}" 
  local NUMBER_TYPE="${2}" 
  local ERROR_MESG="${3}"
  local -i PASS=1 
  local -i FAIL=0   
  case "${NUMBER_TYPE}" in 
    "${CHECK_FLOAT}") 
        if ((! $(printf "${CHECK_FLOAT}" "${NUMBER}" &>/dev/random;echo $?))); then 
           echo "${PASS}"
        else 
           echo "${ERROR_MESG}" 1>&2
           echo "${FAIL}"
        fi 
        ;;                 
    "${CHECK_INTEGER}") 
        if ((! $(printf "${CHECK_INTEGER}" "${NUMBER}" &>/dev/random;echo $?))); then 
           echo "${PASS}"
        else 
           echo "${ERROR_MESG}" 1>&2
           echo "${FAIL}"
        fi 
        ;;                 
                     *) 
        echo "Invalid number type format: ${NUMBER_TYPE} to check_number()." 1>&2
        echo "${FAIL}"
        ;;                 
   esac
} 

>$ var=45

>$ (($(check_number $var "${CHECK_INTEGER}" "Error: Found $var - An integer is required."))) && { echo "$var+5" | bc; }

重击 正则表达式 vs重击 参数扩展

作为Charles Duffy的答案作品，但仅用于重击正则表达式，我知道这很慢，我想展示另一种方式，仅使用重击参数扩展：

仅对于正整数：

is_num() { [ "$1" ] && [ -z "${1//[0-9]}" ] ;}

对于整数：

is_num() { 
    local chk=${1#[+-]};
    [ "$chk" ] && [ -z "${chk//[0-9]}" ]
}

然后进行浮动：

is_num() { 
    local chk=${1#[+-]};
    chk=${chk/.}
    [ "$chk" ] && [ -z "${chk//[0-9]}" ]
}

要匹配初始请求：

set -- "foo bar"
is_num "$1" && VAR=$1 || echo "need a number"
need a number

set -- "+3.141592"
is_num "$1" && VAR=$1 || echo "need a number"

echo $VAR
+3.141592

现在比较一下：

根据Charles Duffy的回答，有相同的检查：

cdIs_num() { 
    local re='^[+-]?[0-9]+([.][0-9]+)?$';
    [[ $1 =~ $re ]]
}

一些测试：

if is_num foo;then echo It\'s a number ;else echo Not a number;fi
Not a number
if cdIs_num foo;then echo It\'s a number ;else echo Not a number;fi
Not a number
if is_num 25;then echo It\'s a number ;else echo Not a number;fi
It's a number
if cdIs_num 25;then echo It\'s a number ;else echo Not a number;fi
It's a number
if is_num 3+4;then echo It\'s a number ;else echo Not a number;fi
Not a number
if cdIs_num 3+4;then echo It\'s a number ;else echo Not a number;fi
Not a number
if is_num 3.1415;then echo It\'s a number ;else echo Not a number;fi
It's a number
if cdIs_num 3.1415;then echo It\'s a number ;else echo Not a number;fi
It's a number

没关系。现在这需要多少时间（在我的树莓派上）：

time for i in {1..1000};do is_num +3.14159265;done
real    0m2.476s
user    0m1.235s
sys     0m0.000s

然后使用正则表达式：

time for i in {1..1000};do cdIs_num +3.14159265;done
real    0m4.363s
user    0m2.168s
sys     0m0.000s

捕捉负数：

if [[ $1 == ?(-)+([0-9.]) ]]
    then
    echo number
else
    echo not a number
fi

您也可以这样使用“ let”：

[ ~]$ var=1
[ ~]$ let $var && echo "It's a number" || echo "It's not a number"
It\'s a number
[ ~]$ var=01
[ ~]$ let $var && echo "It's a number" || echo "It's not a number"
It\'s a number
[ ~]$ var=toto
[ ~]$ let $var && echo "It's a number" || echo "It's not a number"
It\'s not a number
[ ~]$ 

但是我更喜欢使用“ =〜” Bash 3+运算符，例如该线程中的一些答案。

printf '%b' "-123\nABC" | tr '[:space:]' '_' | grep -q '^-\?[[:digit:]]\+$' && echo "Integer." || echo "NOT integer."

-\?如果您不接受负整数，则删除in grep匹配模式。

在这里用正则表达式做同样的事情，该正则表达式测试整个部分和小数部分，并用点分隔。

re="^[0-9]*[.]{0,1}[0-9]*$"

if [[ $1 =~ $re ]] 
then
   echo "is numeric"
else
  echo "Naahh, not numeric"
fi

我使用以下（用于整数）：

## ##### constants
##
## __TRUE - true (0)
## __FALSE - false (1)
##
typeset -r __TRUE=0
typeset -r __FALSE=1

## --------------------------------------
## isNumber
## check if a value is an integer 
## usage: isNumber testValue 
## returns: ${__TRUE} - testValue is a number else not
##
function isNumber {
  typeset TESTVAR="$(echo "$1" | sed 's/[0-9]*//g' )"
  [ "${TESTVAR}"x = ""x ] && return ${__TRUE} || return ${__FALSE}
}

isNumber $1 
if [ $? -eq ${__TRUE} ] ; then
  print "is a number"
fi

我尝试了Ultrasawblade的食谱，因为它对我来说似乎是最实用的方法，但无法使其起作用。最后，我设计了另一种方法，与其他参数替换方法一样，这次使用正则表达式替换：

[[ "${var//*([[:digit:]])}" ]]; && echo "$var is not numeric" || echo "$var is numeric"

它删除$ var中的每个：digit：类字符，并检查是否留有空字符串，这意味着原始字符只是数字。

我喜欢这个的原因是它的占地面积小和灵活性。以这种形式，它仅适用于以10为基数的非定界整数，尽管您可以确定地使用模式匹配使其适合其他需求。

快速与肮脏：我知道这不是最优雅的方法，但是我通常只是在其中添加一个零并测试结果。像这样：

function isInteger {
  [ $(($1+0)) != 0 ] && echo "$1 is a number" || echo "$1 is not a number"
 }

x=1;      isInteger $x
x="1";    isInteger $x
x="joe";  isInteger $x
x=0x16 ;  isInteger $x
x=-32674; isInteger $x   

$（（$ 1 + 0））将返回0或炸弹，如果$ 1不是整数。例如：

function zipIt  { # quick zip - unless the 1st parameter is a number
  ERROR="not a valid number. " 
  if [ $(($1+0)) != 0 ] ; then  # isInteger($1) 
      echo " backing up files changed in the last $1 days."
      OUT="zipIt-$1-day.tgz" 
      find . -mtime -$1 -type f -print0 | xargs -0 tar cvzf $OUT 
      return 1
  fi
    showError $ERROR
}

注意：我想我从没想过要检查会导致整个脚本炸弹爆炸的浮点数或混合类型……就我而言，我不希望它进一步发展。我将使用mrucci的解决方案和Duffy的正则表达式-它们似乎是bash框架中最强大的...