Verifica se la stringa è un numero intero valido

Sto cercando di fare qualcosa di abbastanza comune: analizzare l'input dell'utente in uno script di shell. Se l'utente ha fornito un numero intero valido, lo script fa una cosa e, se non è valido, fa qualcos'altro. Il problema è che non ho trovato un modo semplice (e ragionevolmente elegante) per farlo - non voglio doverlo separare carattere per carattere.

So che dev'essere facile ma non so come. Potrei farlo in una dozzina di lingue, ma non BASH!

Nella mia ricerca ho trovato questo:

Espressione regolare per verificare se una stringa è costituita da un numero reale valido in base 10

E c'è una risposta in essa che parla di regex, ma per quanto ne so, questa è una funzione disponibile in C (tra le altre). Tuttavia, aveva quella che sembrava un'ottima risposta, quindi l'ho provato con grep, ma grep non sapeva cosa farne. Ho provato -P che sulla mia scatola significa trattarlo come una regexp PERL - nada. Anche il trattino E (-E) non ha funzionato. E nemmeno -F.

Giusto per essere chiari, sto provando qualcosa di simile, cercando qualsiasi output - da lì, modificherò lo script per sfruttare tutto ciò che ottengo. (IOW, mi aspettavo che un input non conforme non restituisse nulla mentre una riga valida viene ripetuta.)

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

Qualcuno potrebbe illustrare come è più facile farlo?

Francamente, questo è un difetto del TEST, secondo me. Dovrebbe avere una bandiera come questa

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

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

• Il ^indica l'inizio del pattern di input
• Il -è un letterale "-"
• Il ?mezzo "0 o 1 del precedente ( -)"
• Il +mezzo "1 o più dei precedenti ( [0-9])"
• Il $indica la fine del pattern di input

Quindi la regex corrisponde a un opzionale -(per il caso di numeri negativi), seguito da una o più cifre decimali.

Riferimenti :

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

Wow ... ci sono così tante buone soluzioni qui !! Di tutte le soluzioni di cui sopra, sono d'accordo con @nortally sul fatto che l'uso di -equn rivestimento sia il più interessante.

Sto eseguendo GNU bash, versione 4.1.5(Debian). L'ho verificato anche su ksh (SunSO 5.10).

Ecco la mia versione per verificare se $1è un numero intero o meno:

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

Questo approccio tiene conto anche dei numeri negativi, che alcune delle altre soluzioni avranno un risultato negativo errato, e consentirà un prefisso "+" (es. +30) che ovviamente è un numero intero.

risultati:

$ 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 soluzione fornita da Ignacio Vazquez-Abrams è stata anche molto chiara (se ti piacciono le espressioni regolari) dopo che è stata spiegata. Tuttavia, non gestisce numeri positivi con il +prefisso, ma può essere facilmente risolto come di seguito:

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

Ritardatario alla festa qui. Sono estremamente sorpreso che nessuna delle risposte menziona la soluzione più semplice, veloce e portatile; la casedichiarazione.

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

Il taglio di qualsiasi segno prima del confronto sembra un po 'un trucco, ma ciò rende l'espressione per la dichiarazione del caso molto più semplice.

Mi piace la soluzione che utilizza il -eqtest, perché è fondamentalmente un one-liner.

La mia soluzione è stata quella di utilizzare l'espansione dei parametri per buttare via tutti i numeri e vedere se era rimasto qualcosa. (Sto ancora usando 3.0, non ho usato [[oexpr prima, ma sono contento di incontrarli.)

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

Per la portabilità a pre-Bash 3.1 (quando =~è stato introdotto il test), utilizzare 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 : REGEXcerca REGEX ancorato all'inizio di STRING, facendo eco al primo gruppo (o alla lunghezza della corrispondenza, se nessuna) e restituendo successo / fallimento. Questa è la vecchia sintassi regex, da cui l'eccesso \. -\?significa "forse -", [0-9]\+significa "una o più cifre" e $significa "fine della stringa".

Bash supporta anche i glob estesi, anche se non ricordo da quale versione in poi.

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 " -o niente", [0-9]significa "cifra" e *([0-9])significa "zero o più cifre".

Ecco un'altra versione (usando solo il comando integrato test e il suo codice di ritorno):

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

Puoi rimuovere le non cifre e fare un confronto. Ecco uno script demo:

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

Questo è l'aspetto dell'output di prova:

44 44 Intero
-44 44 Intero
44- 44 Non intero
4-4 44 Non intero
a4 4 Non intero
4a 4 Non intero
.4 4 Non intero
4.4 44 Non intero
-4,4 44 Non intero
09 9 Non intero

Per me, la soluzione più semplice era usare la variabile all'interno di (())un'espressione, in questo modo:

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

Naturalmente, questa soluzione è valida solo se un valore zero non ha senso per la tua applicazione. Questo è successo nel mio caso, e questo è molto più semplice delle altre soluzioni.

Come sottolineato nei commenti, questo può renderti soggetto ad un attacco di esecuzione di codice: L' (( ))operatore valuta VAR, come indicato nella Arithmetic Evaluationsezione della pagina man bash (1) . Pertanto, non dovresti usare questa tecnica quando l'origine dei contenuti di VARè incerta (né dovresti usare QUALSIASI altra forma di espansione variabile, ovviamente).

o con 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

In aggiunta alla risposta di Ignacio Vazquez-Abrams. Ciò consentirà al segno + di precedere il numero intero e consentirà qualsiasi numero di zeri come punti decimali. Ad esempio, questo consentirà a +45.00000000 di essere considerato un numero intero.
Tuttavia, $ 1 deve essere formattato per contenere un punto decimale. 45 non è considerato un numero intero qui, ma 45,0 lo è.

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

Per le risate ho elaborato più o meno rapidamente una serie di funzioni per farlo (is_string, is_int, is_float, è una stringa alfa o altro) ma ci sono modi più efficienti (meno codice) per farlo:

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

Esegui alcuni test qui, ho definito che -44 è un int ma 44- non è ecc ..:

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

Produzione:

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: gli 0 iniziali potrebbero dedurre qualcos'altro quando si aggiungono numeri come ottale, quindi sarebbe meglio rimuoverli se intendi trattare '09' come un int (cosa che sto facendo) (ad esempio expr 09 + 0o strip con sed)