Sprawdź, czy ciąg jest prawidłową liczbą całkowitą

Próbuję zrobić coś dość powszechnego: przeanalizować dane wejściowe użytkownika w skrypcie powłoki. Jeśli użytkownik podał prawidłową liczbę całkowitą, skrypt robi jedną rzecz, a jeśli nie jest poprawny, robi coś innego. Kłopot w tym, że nie znalazłem łatwego (i dość eleganckiego) sposobu na zrobienie tego - nie chcę, aby trzeba było go rozdzielać po znaku.

Wiem, że to musi być łatwe, ale nie wiem jak. Mógłbym to zrobić w kilkunastu językach, ale nie w BASH!

W moich badaniach znalazłem to:

Wyrażenie regularne do sprawdzenia, czy ciąg składa się z prawidłowej liczby rzeczywistej o podstawie 10

I jest w tym odpowiedź, która mówi o wyrażeniu regularnym, ale o ile wiem, jest to funkcja dostępna w C (między innymi). Mimo to miał coś, co wyglądało na świetną odpowiedź, więc spróbowałem go z grep, ale grep nie wiedział, co z tym zrobić. Spróbowałem -P, co na moim pudełku oznacza traktowanie go jako wyrażenia regularnego PERL - nada. Dash E (-E) też nie działał. Ani też -F.

Żeby było jasne, próbuję czegoś takiego, szukając jakichkolwiek wyników - stamtąd zhakuję skrypt, aby wykorzystać wszystko, co otrzymam. (IOW, spodziewałem się, że niezgodne dane wejściowe nic nie zwracają, podczas gdy poprawna linia jest powtarzana.)

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

Czy ktoś mógłby zilustrować, jak najłatwiej to zrobić?

Szczerze mówiąc, jest to moim zdaniem niedostatek TESTU. Powinien mieć taką flagę

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

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

• Symbol ^wskazuje początek wzorca wejściowego
• To -jest dosłowne „-”
• Te ?środki „0 lub 1 z poprzedzającego ( -)”
• Te +środki „1 lub więcej z powyższych ( [0-9])”
• Symbol $wskazuje koniec wzorca wejściowego

Zatem wyrażenie regularne dopasowuje opcjonalne -(w przypadku liczb ujemnych), po którym następuje jedna lub więcej cyfr dziesiętnych.

Referencje :

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

Wow ... jest tu tak wiele dobrych rozwiązań !! Ze wszystkich powyższych rozwiązań zgadzam się z @nortally, że używanie -eqone linera jest najfajniejsze.

Używam GNU bash, wersja 4.1.5(Debian). Sprawdziłem to również na ksh (SunSO 5.10).

Oto moja wersja sprawdzania, czy $1jest liczbą całkowitą, czy nie:

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

Podejście to uwzględnia również liczby ujemne, które w przypadku niektórych innych rozwiązań będą miały błędny wynik ujemny i pozwoli na przedrostek „+” (np. +30), który oczywiście jest liczbą całkowitą.

Wyniki:

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

Rozwiązanie dostarczone przez Ignacio Vazquez-Abrams było również bardzo zgrabne (jeśli lubisz regex) po tym, jak zostało wyjaśnione. Jednak nie obsługuje liczb dodatnich z +prefiksem, ale można go łatwo naprawić, jak poniżej:

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

Spóźniony na przyjęcie tutaj. Jestem niezwykle zaskoczony, że żadna z odpowiedzi nie wspomina o najprostszym, najszybszym i najbardziej przenośnym rozwiązaniu; casestwierdzenie.

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

Przycinanie dowolnego znaku przed porównaniem wydaje się trochę hackem, ale to sprawia, że ​​wyrażenie w instrukcji case jest o wiele prostsze.

Podoba mi się rozwiązanie wykorzystujące -eqtest, ponieważ jest to w zasadzie jednolinijkowy.

Moje własne rozwiązanie polegało na zastosowaniu rozszerzenia parametrów, aby wyrzucić wszystkie cyfry i sprawdzić, czy coś zostało. (Nadal używam 3.0, nie używałem [[ani exprwcześniej, ale cieszę się, że je spotykam.)

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

Aby zapewnić przenośność do wersji pre-Bash 3.1 (gdy =~test został wprowadzony), użyj 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 : REGEXwyszukuje REGEX zakotwiczony na początku ŁAŃCUCHA, powtarzając pierwszą grupę (lub długość dopasowania, jeśli nie ma) i zwracając sukces / niepowodzenie. To jest stara składnia wyrażeń regularnych, stąd nadmiar \. -\?oznacza „być może -”, [0-9]\+oznacza „jedną lub więcej cyfr” i $oznacza „koniec łańcucha”.

Bash obsługuje również rozszerzone globi, chociaż nie pamiętam, od której wersji.

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

@(-|)oznacza „ -albo nic”, [0-9]oznacza „cyfrę” i *([0-9])oznacza „zero lub więcej cyfr”.

Oto jeszcze jedno podejście (tylko przy użyciu wbudowanego polecenia test i jego kodu powrotu):

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

Możesz usunąć niecyfry i zrobić porównanie. Oto skrypt demonstracyjny:

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

Oto jak wygląda wynik testu:

44 44 Integer
-44 44 Integer
44-44 Nie jest liczbą całkowitą
4-4 44 Nie jest liczbą całkowitą
a4 4 Nie jest liczbą całkowitą
4a 4 Nie jest liczbą całkowitą
.4 4 Nie jest liczbą całkowitą
4,4 44 Nie jest liczbą całkowitą
-4,4 44 Nie jest liczbą całkowitą
09 9 Nie jest liczbą całkowitą

Dla mnie najprostszym rozwiązaniem było użycie zmiennej wewnątrz (())wyrażenia, tak jak:

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

Oczywiście to rozwiązanie jest poprawne tylko wtedy, gdy wartość zero nie ma sensu dla twojej aplikacji. Tak się stało w moim przypadku i jest to znacznie prostsze niż inne rozwiązania.

Jak wskazano w komentarzach, może to narazić Cię na atak polegający na wykonaniu kodu: (( ))Operator ocenia VAR, jak stwierdzono w Arithmetic Evaluationsekcji strony podręcznika bash (1) . Dlatego nie powinieneś używać tej techniki, gdy źródło treści VARjest niepewne (ani oczywiście nie powinieneś używać ŻADNEJ innej formy rozwijania zmiennych).

lub z 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

Dodając do odpowiedzi Ignacio Vazquez-Abrams. Umożliwi to znak + poprzedzający liczbę całkowitą i dowolną liczbę zer jako miejsc dziesiętnych. Na przykład pozwoli to na uznanie +45,00000000 za liczbę całkowitą.
Jednak $ 1 musi być sformatowany tak, aby zawierał kropkę dziesiętną. 45 nie jest tutaj uważane za liczbę całkowitą, ale 45.0 jest.

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

Dla śmiechu z grubsza po prostu szybko opracowałem zestaw funkcji do tego (is_string, is_int, is_float, is alpha string lub other), ale są bardziej wydajne (mniej kodu) sposoby na zrobienie tego:

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

Przeprowadziłem tutaj kilka testów, zdefiniowałem, że -44 to int, ale 44- nie jest itd.:

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

Wynik:

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 = 

UWAGA: Wiodące zera mogą wywnioskować coś innego podczas dodawania liczb, takich jak ósemkowe, więc lepiej byłoby je usunąć, jeśli zamierzasz traktować '09' jako int (co robię) (np. expr 09 + 0Lub usuń sed)