Tester si la chaîne est un entier valide

J'essaie de faire quelque chose d'assez commun: analyser l'entrée utilisateur dans un script shell. Si l'utilisateur a fourni un entier valide, le script fait une chose, et s'il n'est pas valide, il fait autre chose. Le problème, c'est que je n'ai pas trouvé de moyen facile (et raisonnablement élégant) de faire cela - je ne veux pas avoir à le séparer caractère par caractère.

Je sais que ça doit être facile mais je ne sais pas comment. Je pourrais le faire dans une douzaine de langues, mais pas BASH!

Dans mes recherches, j'ai trouvé ceci:

Expression régulière pour tester si une chaîne se compose d'un nombre réel valide en base 10

Et il y a une réponse là-dedans qui parle de regex, mais pour autant que je sache, c'est une fonction disponible en C (entre autres). Pourtant, il avait ce qui ressemblait à une bonne réponse, alors je l'ai essayé avec grep, mais grep ne savait pas quoi en faire. J'ai essayé -P qui sur ma boîte signifie le traiter comme une expression rationnelle PERL - nada. Dash E (-E) ne fonctionnait pas non plus. Et -F non plus.

Juste pour être clair, j'essaye quelque chose comme ça, à la recherche de n'importe quelle sortie - à partir de là, je vais pirater le script pour profiter de tout ce que je reçois. (IOW, je m'attendais à ce qu'une entrée non conforme ne renvoie rien pendant qu'une ligne valide se répète.)

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

Quelqu'un pourrait-il illustrer comment cela est le plus facile à faire?

Franchement, c'est une lacune de TEST, à mon avis. Il devrait avoir un drapeau comme celui-ci

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

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

• Le ^indique le début du modèle d'entrée
• Le -est un "-" littéral
• Les ?moyens "0 ou 1 de la précédente ( -)"
• Les +moyens "1 ou plusieurs des précédents ( [0-9])"
• Le $indique la fin du modèle d'entrée

Ainsi, l'expression régulière correspond à une option -(pour le cas des nombres négatifs), suivie d'un ou plusieurs chiffres décimaux.

Références :

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

Wow ... il y a tellement de bonnes solutions ici !! De toutes les solutions ci-dessus, je suis d'accord avec @nortally que l'utilisation d' -equn seul liner est la plus cool.

J'utilise GNU bash, version 4.1.5(Debian). J'ai également vérifié cela sur ksh (SunSO 5.10).

Voici ma version de vérifier si $1est un entier ou non:

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

Cette approche tient également compte des nombres négatifs, dont certaines des autres solutions auront un résultat négatif erroné, et elle autorisera un préfixe de "+" (par exemple +30) qui est évidemment un entier.

Résultats:

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

La solution fournie par Ignacio Vazquez-Abrams était également très soignée (si vous aimez les regex) après avoir été expliquée. Cependant, il ne gère pas les nombres positifs avec le +préfixe, mais il peut facilement être corrigé comme ci-dessous:

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

Retard à la fête ici. Je suis extrêmement surpris qu'aucune des réponses ne mentionne la solution la plus simple, la plus rapide et la plus portable; la casedéclaration.

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

Le découpage de tout signe avant la comparaison ressemble à un petit hack, mais cela rend l'expression de l'instruction case tellement plus simple.

J'aime la solution utilisant le -eqtest, car il s'agit essentiellement d'un one-liner.

Ma propre solution était d'utiliser l'expansion des paramètres pour jeter tous les chiffres et voir s'il restait quelque chose. (J'utilise toujours la version 3.0, je ne l'ai jamais utilisé [[ou expravant, mais je suis heureux de les rencontrer.)

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

Pour la portabilité vers pré-Bash 3.1 (lors de l' =~introduction du test), utilisez 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 : REGEXrecherche REGEX ancré au début de STRING, faisant écho au premier groupe (ou durée de la correspondance, si aucune) et renvoyant le succès / échec. C'est une vieille syntaxe regex, d'où l'excès \. -\?signifie "peut-être -", [0-9]\+signifie "un ou plusieurs chiffres" et $signifie "fin de chaîne".

Bash prend également en charge les globes étendus, bien que je ne me souvienne pas de quelle version.

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])) ]]

@(-|)signifie " -ou rien", [0-9]signifie "chiffre" et *([0-9])signifie "zéro ou plusieurs chiffres".

Voici encore une autre interprétation (en utilisant uniquement la commande intégrée test et son code de retour):

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

Vous pouvez supprimer les non-chiffres et faire une comparaison. Voici un script de démonstration:

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

Voici à quoi ressemble la sortie du test:

44 44 Entier
-44 44 Entier
44-44 Non entier
4-4 44 Non entier
a4 4 Non entier
4a 4 Non entier
.4 4 Non entier
4.4 44 Non entier
-4,4 44 Non entier
09 9 Non entier

Pour moi, la solution la plus simple était d'utiliser la variable à l'intérieur d'une (())expression, comme ceci:

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

Bien entendu, cette solution n'est valable que si une valeur de zéro n'a pas de sens pour votre application. Cela s'est avéré être vrai dans mon cas, et c'est beaucoup plus simple que les autres solutions.

Comme indiqué dans les commentaires, cela peut vous exposer à une attaque d'exécution de code: L' (( ))opérateur évalue VAR, comme indiqué dans la Arithmetic Evaluationsection de la page de manuel bash (1) . Par conséquent, vous ne devez pas utiliser cette technique lorsque la source du contenu de VARest incertaine (et vous ne devez pas non plus utiliser TOUTE autre forme d'expansion variable, bien sûr).

ou avec 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

Ajout à la réponse d'Ignacio Vazquez-Abrams. Cela permettra au signe + de précéder l'entier et autorisera n'importe quel nombre de zéros comme points décimaux. Par exemple, cela permettra à +45,00000000 d'être considéré comme un entier.
Cependant, $ 1 doit être formaté pour contenir un point décimal. 45 n'est pas considéré comme un entier ici, mais 45,0 l'est.

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

Pour rire, j'ai rapidement élaboré un ensemble de fonctions pour le faire (is_string, is_int, is_float, est une chaîne alpha, ou autre) mais il existe des moyens plus efficaces (moins de code) de le faire:

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

Faites quelques tests ici, j'ai défini que -44 est un int mais 44- n'est pas 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

Production:

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 = 

REMARQUE: les 0 en tête pourraient déduire autre chose lors de l'ajout de nombres tels que octal, il serait donc préférable de les supprimer si vous avez l'intention de traiter '09' comme un int (ce que je fais) (par exemple expr 09 + 0ou supprimer avec sed)