Come posso verificare se una variabile è un numero in Bash?

Non riesco proprio a capire come posso assicurarmi che un argomento passato al mio script sia un numero o meno.

Tutto quello che voglio fare è qualcosa del genere:

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

Qualsiasi aiuto?

Un approccio consiste nell'utilizzare un'espressione regolare, in questo modo:

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

Se il valore non è necessariamente un numero intero, considerare di modificare la regex in modo appropriato; per esempio:

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

... oppure, per gestire i numeri con un segno:

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

Senza bashismi (funziona anche nel System V sh),

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

Questo rifiuta stringhe vuote e stringhe contenenti non cifre, accettando tutto il resto.

I numeri negativi o in virgola mobile richiedono un lavoro aggiuntivo. Un'idea è quella di escludere -/ .nel primo modello "cattivo" e aggiungere altri modelli "cattivi" contenenti gli usi inappropriati di essi ( ?*-*/ *.*.*)

La seguente soluzione può essere utilizzata anche in shell di base come Bourne senza la necessità di espressioni regolari. Fondamentalmente qualsiasi operazione di valutazione di valore numerico che utilizza non numeri comporterà un errore che sarà implicitamente considerato falso nella shell:

"$var" -eq "$var"

come in:

#!/bin/bash

var=a

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

Puoi anche provare per $? il codice di ritorno dell'operazione che è più esplicito:

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

Il reindirizzamento dell'errore standard è lì per nascondere il messaggio "espressione intera prevista" che bash stampa nel caso in cui non abbiamo un numero.

CAVEATS (grazie ai commenti qui sotto):

• I numeri con punti decimali non vengono identificati come "numeri" validi
• Usando [[ ]]invece di [ ]sarà sempre valutatotrue
• La maggior parte delle shell non Bash valuteranno sempre questa espressione come true
• Il comportamento in Bash non è documentato e può quindi cambiare senza preavviso
• Se il valore include spazi dopo il numero (ad es. "1 a") produce errore, ad esempio bash: [[: 1 a: syntax error in expression (error token is "a")
• Se il valore è uguale a var-name (ad es. I = "i"), produce un errore, come bash: [[: i: expression recursion level exceeded (error token is "i")

Questo verifica se un numero è un numero intero non negativo ed è sia indipendente dalla shell (cioè senza bashismi) e utilizza solo gli incorporamenti della shell:

NON CORRETTO.

Poiché questa prima risposta (sotto) consente numeri interi con caratteri, purché i primi non siano i primi nella variabile.

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

CORRETTO .

Come ha commentato Jilles e suggerito nella sua risposta, questo è il modo corretto di farlo usando schemi a conchiglia.

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

Nessuno ha suggerito la corrispondenza estesa del modello di bash :

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

Sono sorpreso dalle soluzioni che analizzano direttamente i formati numerici nella shell. shell non è adatta a questo, essendo un DSL per il controllo di file e processi. Esistono numerosi parser numerici un po 'più in basso, ad esempio:

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
}

Cambia '% f' nel formato particolare che desideri.

Stavo guardando le risposte e ... ho capito che nessuno pensava ai numeri di FLOAT (con punto)!

Anche usare grep è fantastico.
-E significa regexp esteso
-q significa silenzioso (non fa eco)
-qE è la combinazione di entrambi.

Per testare direttamente nella riga di 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 in uno 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

Per abbinare JUST interi, utilizzare questo:

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

Solo un seguito a @mary. Ma poiché non ho abbastanza rappresentante, non posso pubblicare questo come commento a quel post. Comunque, ecco cosa ho usato:

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

La funzione restituirà "1" se l'argomento è un numero, altrimenti restituirà "0". Funziona con numeri interi e float. L'utilizzo è qualcosa del tipo:

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]}sostituisce qualsiasi cifra nel valore di $icon una stringa vuota, vedere man -P 'less +/parameter\/' bash. -zcontrolla se la stringa risultante ha lunghezza zero.

se vuoi anche escludere il caso quando $iè vuoto, puoi usare una di queste costruzioni:

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

Per il mio problema, avevo solo bisogno di assicurarmi che un utente non inserisse accidentalmente del testo, quindi ho cercato di mantenerlo semplice e leggibile

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

Secondo la pagina man, questo fa praticamente quello che voglio

Se il valore dell'espressione è diverso da zero, lo stato di ritorno è 0

Per evitare cattivi messaggi di errore per stringhe che "potrebbero essere numeri", ignoro l'output dell'errore

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

Vecchia domanda, ma volevo solo fissare la mia soluzione. Questo non richiede strani trucchi conchiglia o non si basa su qualcosa che non esiste da sempre.

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

Fondamentalmente rimuove solo tutte le cifre dall'input e se ti rimane una stringa di lunghezza diversa da zero, allora non era un numero.

Non posso ancora commentare, quindi aggiungerò la mia risposta, che è un'estensione della risposta di Glenn Jackman usando la corrispondenza del modello bash.

Il mio bisogno originale era di identificare numeri e distinguere numeri interi e float. Le definizioni delle funzioni dedotte a:

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

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

Ho usato i test unitari (con shUnit2) per convalidare i miei schemi funzionando come previsto:

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

}

Note: il modello isFloat può essere modificato per essere più tollerante rispetto al punto decimale ( @(.,)) e al simbolo E ( @(Ee)). I test delle mie unità testano solo valori interi o float, ma nessun input non valido.

Vorrei provare questo:

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

Nota: questo riconosce nan e inf come numero.

Una risposta chiara è già stata data da @charles Dufy e altri. Una soluzione bash pura sarebbe usare il seguente:

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

Sebbene per i numeri reali non sia obbligatorio disporre di un numero prima del punto di radice .

Per fornire un supporto più completo ai numeri fluttuanti e alla notazione scientifica (molti programmi in C / Fortran o altrimenti esporteranno il float in questo modo), un'utile aggiunta a questa riga sarebbe la seguente:

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

In questo modo si ottiene un modo per differenziare i tipi di numero, se si sta cercando un tipo specifico:

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: potremmo elencare i requisiti sintattici per la notazione decimale e scientifica, uno è quello di consentire la virgola come punto radicale, così come ".". Vorremmo quindi affermare che ci deve essere solo uno di questi punti radicali. Ci possono essere due segni +/- in un float [Ee]. Ho imparato alcune altre regole dal lavoro di Aulu e ho testato contro stringhe errate come '' '-' '-E-1' '0-0'. Ecco i miei strumenti regex / substring / expr che sembrano reggere:

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"

Non dimenticare -di includere numeri negativi!

Ciò può essere ottenuto utilizzando grepper vedere se la variabile in questione corrisponde a un'espressione regolare estesa.

Numero intero di prova 1120:

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

Produzione: Valid number.

Test non intero 1120a:

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

Produzione: Error: not a number.

Spiegazione

• Il grep, l' -Einterruttore ci permette di utilizzare l'espressione regolare estesa '^[0-9]+$'. Questa espressione regolare indica che la variabile deve []contenere solo i numeri da 0-9zero a nove ^dall'inizio alla $fine della variabile e deve avere almeno +un carattere.
• Il grep, l' -qinterruttore silenzioso si spegne qualsiasi uscita se sia o non trova nulla.
• ifcontrolla lo stato di uscita di grep. Lo stato di uscita 0significa successo e qualcosa di più grande significa un errore. Il grepcomando ha uno stato di uscita 0se trova una corrispondenza e 1quando non lo fa;

Quindi mettendo tutto insieme, nel iftest, abbiamo echola variabile $yournumbere la |pipe a grepcui con l' -qinterruttore abbina silenziosamente l' -Eespressione estesa estesa '^[0-9]+$'. Lo stato di uscita grepsarà 0se è grepstata trovata correttamente una corrispondenza e in 1caso contrario. Se siamo riusciti ad abbinare, noi echo "Valid number.". Se non ci riuscissimo, noi echo "Error: not a number.".

Per galleggianti o doppie

Possiamo semplicemente cambiare l'espressione regolare da '^[0-9]+$'a '^[0-9]*\.?[0-9]+$'per float o double.

Galleggiante di prova 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

Produzione: Valid number.

Galleggiante di prova 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

Produzione: Error: not a number.

Per i negativi

Per consentire numeri interi negativi, basta cambiare l'espressione regolare da '^[0-9]+$'a '^\-?[0-9]+$'.

Per consentire float o double negativi, basta cambiare l'espressione regolare da '^[0-9]*\.?[0-9]+$'a '^\-?[0-9]*\.?[0-9]+$'.

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

Puoi anche usare le classi di personaggi di bash.

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

La numerazione includerà lo spazio, il punto decimale e "e" o "E" per il virgola mobile.

Tuttavia, se si specifica un numero esadecimale in stile C, ad esempio "0xffff" o "0XFFFF", [[: digit:]] restituisce true. Un po 'una trappola qui, bash ti permette di fare qualcosa come "0xAZ00" e ancora contarlo come una cifra (non è questo da qualche strana stranezza di compilatori GCC che ti consente di usare la notazione 0x per basi diverse da 16 ??? )

È possibile che si desideri verificare "0x" o "0X" prima di verificare se è un valore numerico se l'input è completamente non attendibile, a meno che non si desideri accettare numeri esadecimali. Ciò sarebbe realizzato da:

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

Il modo più semplice è verificare se contiene caratteri non numerici. Sostituisci tutti i caratteri delle cifre con nulla e controlla la lunghezza. Se c'è lunghezza non è un numero.

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

Siccome ho dovuto manometterlo ultimamente e mi piace l' approccio di karttu con l'unità che prova di più. Ho rivisto il codice e aggiunto anche alcune altre soluzioni, provalo tu stesso per vedere i risultati:

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

Quindi isNumber () include trattini, virgole e notazione esponenziale e quindi restituisce VERO su numeri interi e float dove d'altra parte isFloat () restituisce FALSE su valori interi e isInteger () restituisce FALSE anche su float. Per tua comodità, tutto come una fodera:

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

Uso expr . Restituisce un valore diverso da zero se si tenta di aggiungere uno zero a un valore non numerico:

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

Potrebbe essere possibile usare bc se hai bisogno di numeri non interi, ma non credo bcabbia lo stesso comportamento. L'aggiunta di zero a un non numero porta a zero e restituisce anche un valore pari a zero. Forse puoi combinare bce expr. Utilizzare bcper aggiungere zero a $number. Se la risposta è 0, allora prova expra verificare che $numbernon sia zero.

Mi piace la risposta di Alberto Zaccagni.

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

Prerequisiti importanti: - non vengono generati subshells - non viene richiamato nessun parser RE - la maggior parte delle applicazioni della shell non usano numeri reali

Ma se $varè complesso (ad es. Un accesso di array associativo) e se il numero sarà un numero intero non negativo (la maggior parte dei casi d'uso), allora questo è forse più efficiente?

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

Uso printf come altre risposte menzionate, se fornite la stringa di formato "% f" o "% i" printf farà il controllo per voi. Più facile che reinventare i controlli, la sintassi è semplice e breve e la stampa è onnipresente. Quindi secondo me è una buona scelta: puoi anche usare la seguente idea per verificare una serie di cose, non è utile solo per controllare i numeri.

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

bash espressione regolare vsbash espansione dei parametri

Come la risposta di Charles Duffy funziona, ma usa solobash espressione regolare , e so che questo è lento, vorrei mostrare un altro modo, usando solobashespansione dei parametri :

Solo per numeri interi positivi:

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

Per numeri interi:

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

Quindi per il galleggiamento:

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

Per abbinare la richiesta iniziale:

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

Ora un po 'di confronto:

C'è uno stesso controllo basato sulla risposta di Charles Duffy :

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

Alcuni test:

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 va bene. Ora quante volte ci vorrà tutto questo (sul mio lampone pi):

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

Quindi con espressioni regolari:

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

Per prendere numeri negativi:

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

Puoi usare "let" anche in questo modo:

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

Ma preferisco usare l'operatore "= ~" Bash 3+ come alcune risposte in questo thread.

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

Rimuovi il -\?modello di corrispondenza in grep se non accetti numeri interi negativi.

Ha fatto la stessa cosa qui con un'espressione regolare che verifica l'intera parte e la parte decimale, separata da un punto.

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

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

Uso quanto segue (per numeri interi):

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

Ho provato la ricetta di ultrasawblade perché mi sembrava la più pratica e non riuscivo a farlo funzionare. Alla fine ho escogitato un altro modo, basato come altri sulla sostituzione dei parametri, questa volta con la sostituzione regex:

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

Rimuove ogni carattere: digit: class in $ var e controlla se ci rimane una stringa vuota, il che significa che l'originale era solo numeri.

Quello che mi piace di questo è il suo ingombro ridotto e la flessibilità. In questa forma funziona solo per numeri interi di base 10 non delimitati, anche se sicuramente puoi usare la corrispondenza dei modelli per adattarla ad altre esigenze.

Veloce e sporco: so che non è il modo più elegante, ma di solito ho appena aggiunto uno zero e testare il risultato. così:

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)) restituirà 0 o bomba se $ 1 NON è un numero intero. per esempio:

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
}

NOTA: Immagino di non aver mai pensato di cercare float o tipi misti che rendessero l'intera bomba dello script ... nel mio caso, non volevo che andasse oltre. Giocherò con la soluzione di Mrucci e la regex di Duffy: sembrano i più robusti nel framework bash ...