Comment tester si une variable est un nombre dans Bash?

Je n'arrive pas à comprendre comment puis-je m'assurer qu'un argument transmis à mon script est un nombre ou non.

Tout ce que je veux faire, c'est quelque chose comme ceci:

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

De l'aide?

Une approche consiste à utiliser une expression régulière, comme ceci:

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

Si la valeur n'est pas nécessairement un entier, envisagez de modifier la regex de manière appropriée; par exemple:

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

... ou, pour gérer les nombres avec un signe:

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

Sans bashismes (fonctionne même dans le système V sh),

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

Cela rejette les chaînes vides et les chaînes contenant des non-chiffres, acceptant tout le reste.

Les nombres négatifs ou à virgule flottante nécessitent un travail supplémentaire. Une idée est d'exclure -/ .dans le premier "mauvais" modèle et d'ajouter plus de "mauvais" modèles contenant leurs utilisations inappropriées ( ?*-*/ *.*.*)

La solution suivante peut également être utilisée dans des shells basiques tels que Bourne sans avoir besoin d'expressions régulières. Fondamentalement, toute opération d'évaluation de valeur numérique utilisant des non-nombres entraînera une erreur qui sera implicitement considérée comme fausse dans le shell:

"$var" -eq "$var"

un péché:

#!/bin/bash

var=a

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

Vous pouvez également tester pour $? le code retour de l'opération qui est plus explicite:

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

La redirection de l'erreur standard est là pour masquer le message "expression entière attendue" que bash affiche au cas où nous n'aurions pas de nombre.

CAVEATS (merci aux commentaires ci-dessous):

• Les nombres avec des décimales ne sont pas identifiés comme des "nombres" valides
• Utiliser [[ ]]au lieu de [ ]sera toujours évalué àtrue
• La plupart des shells non-Bash évalueront toujours cette expression comme true
• Le comportement dans Bash n'est pas documenté et peut donc changer sans avertissement
• Si la valeur inclut des espaces après le nombre (par exemple "1 a"), une erreur se produit, comme bash: [[: 1 a: syntax error in expression (error token is "a")
• Si la valeur est la même que var-name (par exemple i = "i"), produit une erreur, comme bash: [[: i: expression recursion level exceeded (error token is "i")

Cela teste si un nombre est un entier non négatif et est à la fois indépendant du shell (c'est-à-dire sans bashismes) et n'utilise que des shell intégrés:

INCORRECT.

Comme cette première réponse (ci-dessous) permet des nombres entiers avec des caractères tant que les premiers ne sont pas premiers dans la variable.

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

CORRECT .

Comme jilles l'a commenté et suggéré dans sa réponse, c'est la bonne façon de le faire en utilisant des motifs de coquille.

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

Personne n'a suggéré la correspondance étendue des motifs de bash :

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

Je suis surpris des solutions analysant directement les formats de nombres dans le shell. shell n'est pas bien adapté à cela, étant un DSL pour contrôler les fichiers et les processus. Il existe de nombreux analyseurs de nombres un peu plus bas, par exemple:

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
}

Remplacez «% f» par le format particulier dont vous avez besoin.

Je regardais les réponses et ... réalisé que personne ne pensait aux nombres FLOAT (avec point)!

L'utilisation de grep est également très bien.
-E signifie regexp étendu
-q signifie silencieux (ne fait pas écho)
-qE est la combinaison des deux.

Pour tester directement dans la ligne de commande:

$ 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

Utilisation dans un 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

Pour faire correspondre les entiers JUST, utilisez ceci:

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

Juste un suivi à @mary. Mais parce que je n'ai pas assez de représentants, je ne pouvais pas poster ceci en tant que commentaire. Bref, voici ce que j'ai utilisé:

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

La fonction retournera "1" si l'argument est un nombre, sinon retournera "0". Cela fonctionne aussi bien pour les nombres entiers que pour les flottants. L'utilisation est quelque chose comme:

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]}remplace tout chiffre de la valeur de $ipar une chaîne vide, voir man -P 'less +/parameter\/' bash. -zvérifie si la chaîne résultante a une longueur nulle.

si vous souhaitez également exclure le cas lorsqu'il $iest vide, vous pouvez utiliser l'une de ces constructions:

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

Pour mon problème, je devais seulement m'assurer qu'un utilisateur n'entre pas accidentellement du texte, j'ai donc essayé de le garder simple et lisible

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

Selon la page de manuel, cela fait à peu près ce que je veux

Si la valeur de l'expression est différente de zéro, l'état de retour est 0

Pour éviter les messages d'erreur désagréables pour les chaînes qui "pourraient être des nombres", j'ignore la sortie d'erreur

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

Vieille question, mais je voulais juste clouer ma solution. Celui-ci ne nécessite pas d'étranges obus ou ne repose pas sur quelque chose qui n'a pas existé depuis toujours.

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

Fondamentalement, il supprime simplement tous les chiffres de l'entrée, et si vous vous retrouvez avec une chaîne de longueur non nulle, ce n'était pas un nombre.

Je ne peux pas encore commenter donc j'ajouterai ma propre réponse, qui est une extension de la réponse de Glenn Jackman en utilisant la correspondance de motifs bash.

Mon besoin initial était d'identifier les nombres et de distinguer les entiers et les flottants. Les définitions de fonction déduites:

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

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

J'ai utilisé des tests unitaires (avec shUnit2) pour valider mes modèles qui fonctionnaient comme prévu:

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

}

Remarques: Le modèle isFloat peut être modifié pour être plus tolérant au point décimal ( @(.,)) et au symbole E ( @(Ee)). Mes tests unitaires testent uniquement les valeurs entières ou flottantes, mais pas toute entrée non valide.

J'essaierais ceci:

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

Remarque: cela reconnaît nan et inf comme nombre.

Une réponse claire a déjà été donnée par @charles Dufy et d'autres. Une solution bash pure utiliserait ce qui suit:

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

Bien que pour les nombres réels, il n'est pas obligatoire d'avoir un nombre avant le point de radix .

Pour fournir un support plus complet des nombres flottants et de la notation scientifique (de nombreux programmes en C / Fortran ou bien exporteront float de cette façon), un ajout utile à cette ligne serait le suivant:

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

Menant ainsi à un moyen de différencier les types de numéro, si vous recherchez un type spécifique:

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

Remarque: Nous pourrions énumérer les exigences syntaxiques pour la notation décimale et scientifique, l'une étant d'autoriser la virgule comme point radix, ainsi que ".". Nous affirmerions alors qu'il ne doit y avoir qu'un seul point radix. Il peut y avoir deux signes +/- dans un flotteur [Ee]. J'ai appris quelques règles supplémentaires du travail d'Aulu et testé contre de mauvaises chaînes telles que '' '-' '-E-1' '0-0'. Voici mes outils regex / substring / expr qui semblent tenir le coup:

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'oubliez pas -d'inclure des nombres négatifs!

Ceci peut être réalisé en utilisant greppour voir si la variable en question correspond à une expression régulière étendue.

Entier de test 1120:

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

Production: Valid number.

Test non entier 1120a:

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

Production: Error: not a number.

Explication

• Le grep, le -Ecommutateur nous permet d'utiliser l'expression régulière étendue '^[0-9]+$'. Cette expression régulière signifie que la variable ne doit []contenir que les chiffres de 0-9zéro à neuf du ^début à la $fin de la variable et doit avoir au moins +un caractère.
• Le grep, le -qcommutateur silencieux désactive toute sortie, qu'il trouve ou non quelque chose.
• ifvérifie l'état de sortie de grep. Le statut de sortie 0signifie le succès et toute valeur supérieure signifie une erreur. La grepcommande a un statut de sortie 0si elle trouve une correspondance et 1quand elle ne le fait pas;

Donc, en mettant tout cela ensemble, dans le iftest, nous avons echola variable $yournumberet la |dirige vers celle grepqui avec le -qcommutateur correspond silencieusement à l' -Eexpression d' '^[0-9]+$'expression régulière étendue . Le statut de sortie de grepsera 0s'il grepa trouvé une correspondance avec succès et 1s'il ne l'a pas fait. Si réussi à correspondre, nous echo "Valid number.". Si cela ne correspondait pas, nous echo "Error: not a number.".

Pour flotteurs ou doubles

Nous pouvons simplement changer l'expression régulière de '^[0-9]+$'en '^[0-9]*\.?[0-9]+$'pour flottants ou doubles.

Flotteur d'essai 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

Production: Valid number.

Flotteur d'essai 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

Production: Error: not a number.

Pour les négatifs

Pour autoriser des entiers négatifs, changez simplement l'expression régulière de '^[0-9]+$'à '^\-?[0-9]+$'.

Pour autoriser des flottants ou des doubles négatifs, changez simplement l'expression régulière de '^[0-9]*\.?[0-9]+$'à '^\-?[0-9]*\.?[0-9]+$'.

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

Vous pouvez également utiliser les classes de personnages de bash.

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

Les valeurs numériques incluront l'espace, le point décimal et "e" ou "E" pour le point flottant.

Mais, si vous spécifiez un nombre hexadécimal de style C, c'est-à-dire "0xffff" ou "0XFFFF", [[: digit:]] renvoie true. Un peu un piège ici, bash vous permet de faire quelque chose comme "0xAZ00" et de toujours le compter comme un chiffre (n'est-ce pas d'une bizarrerie bizarre de compilateurs GCC qui vous permettent d'utiliser la notation 0x pour des bases autres que 16 ??? )

Vous voudrez peut-être tester "0x" ou "0X" avant de tester s'il s'agit d'un numérique si votre entrée n'est pas entièrement fiable, sauf si vous souhaitez accepter des nombres hexadécimaux. Cela serait accompli par:

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

Le moyen le plus simple consiste à vérifier s'il contient des caractères non numériques. Vous remplacez tous les caractères numériques par rien et vérifiez la longueur. S'il y a de la longueur, ce n'est pas un nombre.

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

Comme j'ai dû falsifier ces derniers temps et comme l' approche de karttu avec le test unitaire le plus. J'ai révisé le code et ajouté quelques autres solutions aussi, essayez vous-même pour voir les résultats:

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

Donc isNumber () inclut des tirets, des virgules et une notation exponentielle et retourne donc TRUE sur les entiers et les flottants alors que d'autre part isFloat () renvoie FALSE sur les valeurs entières et isInteger () retourne également FALSE sur les flottants. Pour votre commodité tout en un:

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

J'utilise expr . Il renvoie un non-zéro si vous essayez d'ajouter un zéro à une valeur non numérique:

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

Il pourrait être possible d'utiliser bc si vous avez besoin de non-entiers, mais je ne pense pas qu'il bcait le même comportement. L'ajout de zéro à un non-nombre vous donne zéro et renvoie également une valeur de zéro. Vous pouvez peut-être combiner bcet expr. Utilisez bcpour ajouter zéro à $number. Si la réponse est 0, essayez exprde vérifier que ce $numbern'est pas zéro.

J'aime la réponse d'Alberto Zaccagni.

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

Conditions préalables importantes: - aucun sous-shell généré - aucun analyseur RE invoqué - la plupart des applications shell n'utilisent pas de vrais nombres

Mais si $varest complexe (par exemple un accès à un tableau associatif), et si le nombre sera un entier non négatif (la plupart des cas d'utilisation), alors c'est peut-être plus efficace?

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

J'utilise printf comme les autres réponses mentionnées, si vous fournissez la chaîne de format "% f" ou "% i" printf fera la vérification pour vous. Plus simple que de réinventer les contrôles, la syntaxe est simple et courte et printf est omniprésent. Donc, c'est un choix décent à mon avis - vous pouvez également utiliser l'idée suivante pour vérifier une gamme de choses, ce n'est pas seulement utile pour vérifier les chiffres.

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

frapper expression régulière vsfrapper expansion des paramètres

Comme la réponse de Charles Duffy fonctionne, mais utilisez uniquementfrapperexpression régulière , et je sais que cela est lent, je voudrais montrer une autre façon, en utilisant uniquementfrapperexpansion des paramètres :

Pour les entiers positifs uniquement:

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

Pour les entiers:

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

Puis pour flotter:

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

Pour correspondre à la demande initiale:

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

Maintenant une petite comparaison:

Il y a un même contrôle basé sur la réponse de Charles Duffy :

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

Quelques tests:

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, c'est bon. Maintenant, combien de temps prendra tout cela (Sur ma framboise pi):

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

Puis avec des expressions régulières:

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

Pour attraper des nombres négatifs:

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

Vous pouvez également utiliser "let" comme ceci:

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

Mais je préfère utiliser l'opérateur "= ~" Bash 3+ comme certaines réponses dans ce fil.

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

Supprimez le -\?modèle de correspondance in grep si vous n'acceptez pas un entier négatif.

A fait la même chose ici avec une expression régulière qui teste la partie entière et la partie décimale, séparée par un point.

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

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

J'utilise ce qui suit (pour les entiers):

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

J'ai essayé la recette d'ultrasawblade car elle me semblait la plus pratique et je n'ai pas pu la faire fonctionner. En fin de compte, j'ai imaginé une autre manière, basée sur d'autres comme la substitution de paramètres, cette fois avec le remplacement de l'expression régulière:

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

Il supprime chaque caractère: digit: class dans $ var et vérifie s'il nous reste une chaîne vide, ce qui signifie que l'original n'était que des nombres.

Ce que j'aime dans celui-ci, c'est son faible encombrement et sa flexibilité. Sous cette forme, cela ne fonctionne que pour les entiers de base 10 non délimités, bien que vous puissiez sûrement utiliser la correspondance de modèles pour l'adapter à d'autres besoins.

Quick & Dirty: Je sais que ce n'est pas la manière la plus élégante, mais je viens généralement d'ajouter un zéro et de tester le résultat. ainsi:

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)) retournera 0 ou bombera si $ 1 n'est PAS un entier. par exemple:

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
}

NOTE: Je suppose que je n'ai jamais pensé à vérifier les flotteurs ou les types mixtes qui rendraient la bombe de script entière ... dans mon cas, je ne voulais pas que cela aille plus loin. Je vais jouer avec la solution de mrucci et le regex de Duffy - ils semblent les plus robustes dans le cadre bash ...