Teste se a string é um número inteiro válido

Estou tentando fazer algo bastante comum: analisar a entrada do usuário em um script de shell. Se o usuário forneceu um número inteiro válido, o script faz uma coisa e, se não for válido, faz outra. O problema é que não encontrei uma maneira fácil (e razoavelmente elegante) de fazer isso - eu não quero ter que separá-lo char por char.

Sei que deve ser fácil, mas não sei como. Eu poderia fazer isso em uma dúzia de idiomas, mas não em BASH!

Em minha pesquisa, descobri o seguinte:

Expressão regular para testar se uma string consiste em um número real válido na base 10

E há uma resposta aqui que fala sobre regex, mas até onde eu sei, essa é uma função disponível em C (entre outras). Ainda assim, ele teve o que parecia ser uma ótima resposta, então tentei com grep, mas grep não sabia o que fazer com ele. Tentei -P, que na minha caixa significa tratá-lo como uma expressão regular PERL - nada. Traço E (-E) também não funcionou. E nem -F.

Só para ficar claro, estou tentando algo assim, procurando qualquer saída - a partir daí, vou hackear o script para aproveitar o que conseguir. (IOW, eu esperava que uma entrada não conforme retornasse nada enquanto uma linha válida fosse repetida.)

snafu=$(echo "$2" | grep -E "/^[-+]?(?:\.[0-9]+|(?:0|[1-9][0-9]*)(?:\.[0-9]*)?)$/")
if [ -z "$snafu" ] ;
then
   echo "Not an integer - nothing back from the grep"
else
   echo "Integer."
fi

Alguém poderia ilustrar como isso é feito mais facilmente?

Francamente, isso é uma lacuna do TEST, na minha opinião. Deve ter uma bandeira como esta

if [ -I "string" ] ;
then
   echo "String is a valid integer."
else
   echo "String is not a valid integer."
fi

[[ $var =~ ^-?[0-9]+$ ]]

• O ^indica o início do padrão de entrada
• O -é um "-" literal
• Os ?meios "0 ou 1 do anterior ( -)"
• Os +meios "1 ou mais das formas anteriores ( [0-9])"
• O $indica o fim do padrão de entrada

Portanto, a regex corresponde a um opcional -(no caso de números negativos), seguido por um ou mais dígitos decimais.

Referências :

• http://www.tldp.org/LDP/abs/html/bashver3.html#REGEXMATCHREF

Uau ... existem tantas soluções boas aqui !! De todas as soluções acima, concordo com @nortally que usar -equm liner é o mais legal.

Estou executando o GNU bash, versão 4.1.5(Debian). Eu também verifiquei isso no ksh (SunSO 5.10).

Aqui está minha versão para verificar se $1é um número inteiro ou não:

if [ "$1" -eq "$1" ] 2>/dev/null
then
    echo "$1 is an integer !!"
else
    echo "ERROR: first parameter must be an integer."
    echo $USAGE
    exit 1
fi

Esta abordagem também leva em conta os números negativos, que algumas das outras soluções terão um resultado negativo defeituoso e permitirá um prefixo de "+" (por exemplo, +30) que obviamente é um número inteiro.

Resultados:

$ int_check.sh 123
123 is an integer !!

$ int_check.sh 123+
ERROR: first parameter must be an integer.

$ int_check.sh -123
-123 is an integer !!

$ int_check.sh +30
+30 is an integer !!

$ int_check.sh -123c
ERROR: first parameter must be an integer.

$ int_check.sh 123c
ERROR: first parameter must be an integer.

$ int_check.sh c123
ERROR: first parameter must be an integer.

A solução fornecida por Ignacio Vazquez-Abrams também foi muito legal (se você gosta de regex) depois que foi explicada. No entanto, ele não lida com números positivos com o +prefixo, mas pode ser facilmente corrigido como a seguir:

[[ $var =~ ^[-+]?[0-9]+$ ]]

Um retardatário para a festa aqui. Estou extremamente surpreso por nenhuma das respostas mencionar a solução mais simples, rápida e portátil; a casedeclaração.

case ${variable#[-+]} in
  *[!0-9]* | '') echo Not a number ;;
  * ) echo Valid number ;;
esac

O corte de qualquer sinal antes da comparação parece um pouco um hack, mas isso torna a expressão para a declaração de caso muito mais simples.

Eu gosto da solução usando o -eqteste, porque é basicamente um one-liner.

Minha própria solução foi usar a expansão dos parâmetros para jogar fora todos os numerais e ver se restava algo. (Ainda estou usando 3.0, não usei [[nem exprantes, mas fico feliz em conhecê-los.)

if [ "${INPUT_STRING//[0-9]}" = "" ]; then
  # yes, natural number
else
  # no, has non-numeral chars
fi

Para portabilidade para pré-Bash 3.1 (quando o =~ teste foi introduzido), use expr.

if expr "$string" : '-\?[0-9]\+$' >/dev/null
then
  echo "String is a valid integer."
else
  echo "String is not a valid integer."
fi

expr STRING : REGEXprocura REGEX ancorado no início de STRING, ecoando o primeiro grupo (ou duração da correspondência, se nenhuma) e retornando sucesso / falha. Esta é uma sintaxe regex antiga, daí o excesso \. -\?significa "talvez -", [0-9]\+significa "um ou mais dígitos" e $significa "fim da string".

O Bash também oferece suporte a globs estendidos, embora não me lembre de qual versão em diante.

shopt -s extglob
case "$string" of
    @(-|)[0-9]*([0-9]))
        echo "String is a valid integer." ;;
    *)
        echo "String is not a valid integer." ;;
esac

# equivalently, [[ $string = @(-|)[0-9]*([0-9])) ]]

@(-|)significa " -ou nada", [0-9]significa "dígito" e *([0-9])significa "zero ou mais dígitos".

Aqui está mais uma abordagem sobre ele (usando apenas o comando test builtin e seu código de retorno):

function is_int() { return $(test "$@" -eq "$@" > /dev/null 2>&1); } 

input="-123"

if $(is_int "${input}");
then
   echo "Input: ${input}"
   echo "Integer: $[${input}]"
else
   echo "Not an integer: ${input}"
fi

Você pode retirar os não dígitos e fazer uma comparação. Aqui está um script de demonstração:

for num in "44" "-44" "44-" "4-4" "a4" "4a" ".4" "4.4" "-4.4" "09"
do
    match=${num//[^[:digit:]]}    # strip non-digits
    match=${match#0*}             # strip leading zeros
    echo -en "$num\t$match\t"
    case $num in
        $match|-$match)    echo "Integer";;
                     *)    echo "Not integer";;
    esac
done

Esta é a aparência da saída do teste:

44 44 Inteiro
-44 44 Inteiro
44- 44 Não inteiro
4-4 44 Não é inteiro
a4 4 Não é inteiro
4a 4 Não é inteiro
.4 4 Não é inteiro
4,4 44 Não inteiro
-4,4 44 Não inteiro
09 9 Não inteiro

Para mim, a solução mais simples era usar a variável dentro de uma (())expressão, assim:

if ((VAR > 0))
then
  echo "$VAR is a positive integer."
fi

Obviamente, essa solução só é válida se um valor zero não fizer sentido para o seu aplicativo. Aconteceu que isso era verdade no meu caso, e isso é muito mais simples do que as outras soluções.

Conforme apontado nos comentários, isso pode torná-lo sujeito a um ataque de execução de código: O (( ))operador avalia VAR, conforme declarado na Arithmetic Evaluationseção de página do manual bash (1) . Portanto, você não deve usar esta técnica quando a fonte do conteúdo VARé incerta (nem deve usar QUALQUER outra forma de expansão de variável, é claro).

ou com sed:

   test -z $(echo "2000" | sed s/[0-9]//g) && echo "integer" || echo "no integer"
   # integer

   test -z $(echo "ab12" | sed s/[0-9]//g) && echo "integer" || echo "no integer"
   # no integer

Somando-se à resposta de Ignacio Vazquez-Abrams. Isso permitirá que o sinal + preceda o número inteiro e permitirá qualquer número de zeros como casas decimais. Por exemplo, isso permitirá que +45,00000000 seja considerado um número inteiro.
No entanto, $ 1 deve ser formatado para conter um ponto decimal. 45 não é considerado um número inteiro aqui, mas 45,0 é.

if [[ $1 =~ ^-?[0-9]+.?[0]+$ ]]; then
    echo "yes, this is an integer"
elif [[ $1 =~ ^\+?[0-9]+.?[0]+$ ]]; then
    echo "yes, this is an integer"
else
    echo "no, this is not an integer"
fi

Para rir, eu desenvolvi quase que rapidamente um conjunto de funções para fazer isso (is_string, is_int, is_float, é string alfa ou outro), mas existem maneiras mais eficientes (menos código) de fazer isso:

#!/bin/bash

function strindex() {
    x="${1%%$2*}"
    if [[ "$x" = "$1" ]] ;then
        true
    else
        if [ "${#x}" -gt 0 ] ;then
            false
        else
            true
        fi
    fi
}

function is_int() {
    if is_empty "${1}" ;then
        false
        return
    fi
    tmp=$(echo "${1}" | sed 's/[^0-9]*//g')
    if [[ $tmp == "${1}" ]] || [[ "-${tmp}" == "${1}" ]] ; then
        #echo "INT (${1}) tmp=$tmp"
        true
    else
        #echo "NOT INT (${1}) tmp=$tmp"
        false
    fi
}

function is_float() {
    if is_empty "${1}" ;then
        false
        return
    fi
    if ! strindex "${1}" "-" ; then
        false
        return
    fi
    tmp=$(echo "${1}" | sed 's/[^a-z. ]*//g')
    if [[ $tmp =~ "." ]] ; then
        #echo "FLOAT  (${1}) tmp=$tmp"
        true
    else
        #echo "NOT FLOAT  (${1}) tmp=$tmp"
        false
    fi
}

function is_strict_string() {
    if is_empty "${1}" ;then
        false
        return
    fi
    if [[ "${1}" =~ ^[A-Za-z]+$ ]]; then
        #echo "STRICT STRING (${1})"
        true
    else
        #echo "NOT STRICT STRING (${1})"
        false
    fi
}

function is_string() {
    if is_empty "${1}" || is_int "${1}" || is_float "${1}" || is_strict_string "${1}" ;then
        false
        return
    fi
    if [ ! -z "${1}" ] ;then
        true
        return
    fi
    false
}
function is_empty() {
    if [ -z "${1// }" ] ;then
        true
    else
        false
    fi
}

Executei alguns testes aqui, eu defini que -44 é um int, mas 44- não é etc.:

for num in "44" "-44" "44-" "4-4" "a4" "4a" ".4" "4.4" "-4.4" "09" "hello" "h3llo!" "!!" " " "" ; do
    if is_int "$num" ;then
        echo "INT = $num"

    elif is_float "$num" ;then
        echo "FLOAT = $num"

    elif is_string "$num" ; then
        echo "STRING = $num"

    elif is_strict_string "$num" ; then
        echo "STRICT STRING = $num"
    else
        echo "OTHER = $num"
    fi
done

Resultado:

INT = 44
INT = -44
STRING = 44-
STRING = 4-4
STRING = a4
STRING = 4a
FLOAT = .4
FLOAT = 4.4
FLOAT = -4.4
INT = 09
STRICT STRING = hello
STRING = h3llo!
STRING = !!
OTHER =  
OTHER = 

NOTA: Os zeros iniciais podem inferir outra coisa ao adicionar números, como octal, então seria melhor removê-los se você pretende tratar '09' como um int (o que estou fazendo) (por exemplo, expr 09 + 0ou tira com sed)