Como faço para testar se uma variável é um número no Bash?

Eu simplesmente não consigo descobrir como garantir que um argumento passado para o meu script seja um número ou não.

Tudo o que eu quero fazer é algo como isto:

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

Qualquer ajuda?

Uma abordagem é usar uma expressão regular, assim:

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

Se o valor não for necessariamente um número inteiro, considere alterar o regex adequadamente; por exemplo:

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

... ou, para manipular números com um sinal:

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

Sem bashisms (funciona mesmo no System V sh),

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

Isso rejeita cadeias vazias e cadeias que não sejam dígitos, aceitando todo o resto.

Os números negativos ou de ponto flutuante precisam de algum trabalho adicional. Uma idéia é excluir -/ .no primeiro padrão "ruim" e adicionar mais padrões "ruins" contendo os usos inadequados deles ( ?*-*/ *.*.*)

A solução a seguir também pode ser usada em shells básicos, como Bourne, sem a necessidade de expressões regulares. Basicamente, qualquer operação de avaliação de valor numérico usando números não resultará em um erro que será implicitamente considerado falso no shell:

"$var" -eq "$var"

como em:

#!/bin/bash

var=a

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

Você também pode testar $? o código de retorno da operação que é mais explícita:

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

O redirecionamento do erro padrão está lá para ocultar a mensagem "expressão inteira esperada" que o bash é impresso caso não tenhamos um número.

CAVEATS (graças aos comentários abaixo):

• Números com casas decimais não são identificados como "números" válidos
• Usar em [[ ]]vez de [ ]sempre avaliará setrue
• A maioria dos shells não Bash sempre avaliará essa expressão como true
• O comportamento no Bash não é documentado e, portanto, pode ser alterado sem aviso
• Se o valor incluir espaços após o número (por exemplo, "1 a") produzir erro, como bash: [[: 1 a: syntax error in expression (error token is "a")
• Se o valor for o mesmo que var-name (por exemplo, i = "i"), gera erro, como bash: [[: i: expression recursion level exceeded (error token is "i")

Ele testa se um número é um número inteiro não negativo e é independente do shell (ou seja, sem basismos) e usa apenas os recursos internos do shell:

INCORRETA.

Como esta primeira resposta (abaixo) permite números inteiros com caracteres, desde que a primeira não seja a primeira na variável.

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

CORRETO .

Como Jilles comentou e sugeriu em sua resposta, esta é a maneira correta de fazê-lo usando padrões de shell.

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

Ninguém sugeriu a correspondência estendida de padrões do bash :

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

Estou surpreso com as soluções que analisam diretamente os formatos numéricos no shell. O shell não é adequado para isso, sendo uma DSL para controlar arquivos e processos. Existem amplos analisadores de números um pouco mais abaixo, por exemplo:

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
}

Altere '% f' para qualquer formato específico que você precisar.

Eu estava olhando as respostas e ... percebi que ninguém pensava nos números do FLOAT (com ponto)!

Usar grep também é ótimo.
-E significa regexp estendido
-q significa quiet (não ecoa)
-qE é a combinação de ambos.

Para testar diretamente na linha de comando:

$ 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

Usando em um script 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

Para corresponder apenas números inteiros, use este:

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

Apenas um acompanhamento para @mary. Mas como não tenho representante suficiente, não pude postar isso como um comentário nesse post. Enfim, aqui está o que eu usei:

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

A função retornará "1" se o argumento for um número, caso contrário, retornará "0". Isso funciona tanto para números inteiros quanto para flutuadores. O uso é algo como:

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]}substitui qualquer dígito no valor de $ipor uma sequência vazia, consulte man -P 'less +/parameter\/' bash. -zverifica se a sequência resultante tem comprimento zero.

se você também quiser excluir o caso quando $iestiver vazio, poderá usar uma destas construções:

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

Para o meu problema, eu só precisava garantir que um usuário não inserisse acidentalmente algum texto, portanto, tentei mantê-lo simples e legível

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

De acordo com a página de manual, isso praticamente faz o que eu quero

Se o valor da expressão for diferente de zero, o status de retorno será 0

Para evitar mensagens de erro desagradáveis ​​para seqüências de caracteres que "podem ser números", ignoro a saída de erro

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

Pergunta antiga, mas eu só queria aderir à minha solução. Este não requer truques estranhos de concha ou depende de algo que não existe há sempre.

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

Basicamente, ele remove todos os dígitos da entrada e, se você ficar com uma sequência de comprimento diferente de zero, não seria um número.

Ainda não posso comentar, portanto, adicionarei minha própria resposta, que é uma extensão da resposta de glenn jackman usando a correspondência de padrões de bash.

Minha necessidade original era identificar números e distinguir números inteiros e flutuantes. As definições de função deduzidas para:

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

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

Eu usei o teste de unidade (com shUnit2) para validar que meus padrões funcionavam como pretendido:

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

}

Notas: O padrão isFloat pode ser modificado para ser mais tolerante com o ponto decimal ( @(.,)) e o símbolo E ( @(Ee)). Meus testes de unidade testam apenas valores inteiros ou flutuantes, mas nenhuma entrada inválida.

Eu tentaria o seguinte:

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

Nota: isso reconhece nan e inf como número.

Uma resposta clara já foi dada por @charles Dufy e outros. Uma solução pura do bash usaria o seguinte:

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

Embora para números reais não seja obrigatório ter um número antes do ponto de raiz .

Para fornecer um suporte mais completo aos números flutuantes e à notação científica (muitos programas em C / Fortran, ou então exportarão float dessa maneira), uma adição útil a esta linha seria a seguinte:

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

Assim, você pode diferenciar tipos de número, se estiver procurando por um tipo específico:

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

Nota: Poderíamos listar os requisitos sintáticos para notação decimal e científica, sendo um para permitir vírgula como ponto de raiz, bem como ".". Afirmaríamos então que deve haver apenas um desses pontos de raiz. Pode haver dois sinais +/- em um flutuador [Ee]. Eu aprendi mais algumas regras com o trabalho de Aulu e testei contra strings ruins, como '' '-' '-E-1' '0-0'. Aqui estão minhas ferramentas regex / substring / expr que parecem estar se mantendo:

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"

Não se esqueça -de incluir números negativos!

Isso pode ser alcançado usando-se greppara verificar se a variável em questão corresponde a uma expressão regular estendida.

Inteiro de teste 1120:

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

Resultado: Valid number.

Teste não inteiro 1120a:

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

Resultado: Error: not a number.

Explicação

• O grep, a -Echave que nos permite usar expressão regular estendida '^[0-9]+$'. Essa expressão regular significa que a variável deve []conter apenas os números de 0-9zero a nove do ^início ao $final da variável e deve ter pelo menos +um caractere.
• A grep, o -qinterruptor tranquila desliga qualquer saída ou não encontra nada.
• if verifica o status de saída de grep . Status de saída 0significa sucesso e qualquer coisa maior significa erro. O grepcomando tem um status de saída 0se encontrar uma correspondência e 1quando não encontrar;

Então, reunindo tudo, no ifteste, nós echoa variável $yournumbere a |canalizamos para a grepqual, com a -qopção, corresponde silenciosamente à -Eexpressão de '^[0-9]+$'expressão regular estendida . O status de saída de grepserá0 se grepencontrou com sucesso um jogo e 1se ele não o fez. Se conseguiu combinar, nós echo "Valid number.". Se ele não corresponder, nós echo "Error: not a number.".

Para carros alegóricos ou duplos

Podemos apenas mudar a expressão regular de '^[0-9]+$'para '^[0-9]*\.?[0-9]+$'para carros alegóricos ou duplos.

Flutuador de teste 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

Resultado: Valid number.

Flutuador de teste 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

Resultado: Error: not a number.

Para negativos

Para permitir números inteiros negativos, basta alterar a expressão regular de '^[0-9]+$'para '^\-?[0-9]+$'.

Para permitir flutuações ou dobras negativas, basta alterar a expressão regular de '^[0-9]*\.?[0-9]+$'para '^\-?[0-9]*\.?[0-9]+$'.

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

Você também pode usar as classes de caracteres do bash.

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

Numéricos incluirão espaço, o ponto decimal e "e" ou "E" para ponto flutuante.

Porém, se você especificar um número hexadecimal no estilo C, ou seja, "0xffff" ou "0XFFFF", [[: digit:]] retornará verdadeiro. Um pouco de uma armadilha aqui, o bash permite que você faça algo como "0xAZ00" e ainda conte-o como um dígito (não é isso de alguma peculiaridade estranha dos compiladores do GCC que permitem usar a notação 0x para bases diferentes de 16 ??? )

Convém testar "0x" ou "0X" antes de testar se é numérico se sua entrada não for totalmente confiável, a menos que você queira aceitar números hexadecimais. Isso seria realizado por:

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

A maneira mais simples é verificar se ele contém caracteres que não sejam dígitos. Você substitui todos os caracteres de dígito por nada e verifica o comprimento. Se houver comprimento, não é um número.

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

Como eu tive que mexer com isso ultimamente e como o apelo de karttu com o teste de unidade, mais. Revisei o código e adicionei outras soluções também, tente você mesmo ver os resultados:

#!/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

Portanto, isNumber () inclui traços, vírgulas e notação exponencial e, portanto, retorna TRUE em números inteiros e flutuantes, onde por outro lado isFloat () retorna FALSE em valores inteiros e isInteger () da mesma forma retorna FALSE em flutuadores. Para sua conveniência, tudo em um só forro:

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

Eu uso expr . Retorna um diferente de zero se você tentar adicionar um zero a um valor não numérico:

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

Pode ser possível usar o bc se você não precisar de números inteiros, mas não acredito que bctenha o mesmo comportamento. Se você adicionar zero a um número não, você receberá zero e também retornará um valor zero. Talvez você possa combinar bce expr. Use bcpara adicionar zero a $number. Se a resposta for 0, tente exprverificar $numberse não é zero.

Eu gosto da resposta de Alberto Zaccagni.

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

Pré-requisitos importantes: - nenhum sub-shell gerado - nenhum analisador de ER invocado - a maioria dos aplicativos de shell não usa números reais

Mas se $varé complexo (por exemplo, um acesso associativo à matriz) e se o número for um número inteiro não negativo (na maioria dos casos de uso), isso talvez seja mais eficiente?

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

Uso printf como as outras respostas mencionadas, se você fornecer a string de formato "% f" ou "% i" printf fará a verificação por você. Mais fácil do que reinventar as verificações, a sintaxe é simples e curta e a impressão é onipresente. Portanto, é uma escolha decente na minha opinião - você também pode usar a seguinte idéia para verificar uma variedade de coisas, não apenas útil para verificar números.

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

bater expressão regular vsbater expansão de parâmetro

Como resposta de Charles Duffy funciona, mas use apenasbater expressão regular e sei que isso é lento, gostaria de mostrar outra maneira, usando apenasbaterexpansão de parâmetro :

Apenas para números inteiros positivos:

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

Para números inteiros:

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

Então para flutuar:

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

Para corresponder à solicitação inicial:

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

Agora uma pequena comparação:

Existe uma mesma verificação com base na resposta de Charles Duffy :

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

Alguns testes:

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

OK, tudo bem. Agora, quanto tempo levará tudo isso (no meu raspberry pi):

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

Depois, com expressões regulares:

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

Para pegar números negativos:

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

Você pode usar "let" assim:

[ ~]$ 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
[ ~]$ 

Mas eu prefiro usar o operador "= ~" Bash 3+ como algumas respostas neste tópico.

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

Remova o -\?padrão de correspondência grep se você não aceitar um número inteiro negativo.

Fiz a mesma coisa aqui com uma expressão regular que testa a parte inteira e a parte decimal, separadas por um ponto.

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

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

Eu uso o seguinte (para números inteiros):

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

Tentei a receita da lâmina ultrasaw, pois parecia a mais prática para mim, e não consegui fazê-la funcionar. No final, eu criei outra maneira, com base em outros na substituição de parâmetros, desta vez com substituição de regex:

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

Ele remove todos os caracteres: digit: class em $ var e verifica se ficamos com uma string vazia, o que significa que o original era apenas números.

O que eu gosto sobre este é sua pegada pequena e flexibilidade. Nesse formulário, ele funciona apenas para números inteiros de base 10 não delimitados, embora certamente você possa usar a correspondência de padrões para adequá-lo a outras necessidades.

Rápido e sujo: Eu sei que não é o caminho mais elegante, mas geralmente adiciono zero a ele e testo o resultado. igual a:

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)) retornará 0 ou bombeará se $ 1 NÃO for um número inteiro. por exemplo:

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
}

OBSERVAÇÃO: Acho que nunca pensei em procurar tipos flutuantes ou mistos que fizessem o script inteiro explodir ... no meu caso, eu não queria que isso fosse mais longe. Vou brincar com a solução de mrucci e o regex de Duffy - eles parecem os mais robustos dentro da estrutura do bash ...