Testen Sie, ob die Zeichenfolge eine gültige Ganzzahl ist

Ich versuche, etwas häufig genug zu tun: Benutzereingaben in einem Shell-Skript analysieren. Wenn der Benutzer eine gültige Ganzzahl angegeben hat, führt das Skript eine Sache aus, und wenn es nicht gültig ist, führt es etwas anderes aus. Das Problem ist, ich habe keinen einfachen (und einigermaßen eleganten) Weg gefunden, dies zu tun - ich möchte es nicht char für char auseinander nehmen müssen.

Ich weiß, dass das einfach sein muss, aber ich weiß nicht wie. Ich könnte es in einem Dutzend Sprachen machen, aber nicht BASH!

In meiner Forschung fand ich Folgendes:

Regulärer Ausdruck, um zu testen, ob eine Zeichenfolge aus einer gültigen reellen Zahl in Basis 10 besteht

Und darin gibt es eine Antwort, die über Regex spricht, aber soweit ich weiß, ist dies eine Funktion, die (unter anderem) in C verfügbar ist. Trotzdem hatte es eine großartige Antwort, also versuchte ich es mit grep, aber grep wusste nicht, was ich damit anfangen sollte. Ich habe -P ausprobiert, was auf meiner Box bedeutet, es als PERL-Regexp-Nada zu behandeln. Dash E (-E) hat auch nicht funktioniert. Und -F auch nicht -F.

Um ganz klar zu sein, ich versuche so etwas und suche nach einer Ausgabe - von dort aus werde ich das Skript hacken, um alles zu nutzen, was ich bekomme. (IOW, ich hatte erwartet, dass eine nicht konforme Eingabe nichts zurückgibt, während eine gültige Zeile wiederholt wird.)

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

Würde jemand bitte veranschaulichen, wie dies am einfachsten gemacht werden kann?

Ehrlich gesagt ist dies meiner Meinung nach ein Mangel an TEST. Es sollte eine Flagge wie diese haben

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

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

• Das ^zeigt den Beginn des Eingabemusters an
• Das -ist ein wörtliches "-"
• Das ?bedeutet "0 oder 1 des vorhergehenden ( -)"
• Das +bedeutet "1 oder mehr der vorhergehenden ( [0-9])"
• Das $zeigt das Ende des Eingabemusters an

Der reguläre Ausdruck entspricht also einer Option -(für den Fall negativer Zahlen), gefolgt von einer oder mehreren Dezimalstellen.

Referenzen :

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

Wow ... hier gibt es so viele gute Lösungen !! Von allen oben genannten Lösungen stimme ich @nortally zu, dass die Verwendung des -eqeinen Liners am coolsten ist.

Ich verwende GNU Bash, Version 4.1.5(Debian). Ich habe dies auch auf ksh (SunSO 5.10) überprüft.

Hier ist meine Version der Überprüfung, ob $1es sich um eine Ganzzahl handelt oder nicht:

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

Dieser Ansatz berücksichtigt auch negative Zahlen, bei denen einige der anderen Lösungen ein fehlerhaftes negatives Ergebnis haben, und ermöglicht ein Präfix von "+" (z. B. +30), was offensichtlich eine ganze Zahl ist.

Ergebnisse:

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

Die von Ignacio Vazquez-Abrams bereitgestellte Lösung war auch sehr ordentlich (wenn Sie Regex mögen), nachdem sie erklärt wurde. Es werden jedoch keine positiven Zahlen mit dem +Präfix verarbeitet, es kann jedoch wie folgt leicht behoben werden:

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

Nachzügler zur Party hier. Ich bin äußerst überrascht, dass in keiner der Antworten die einfachste, schnellste und tragbarste Lösung erwähnt wird. die caseAussage.

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

Das Trimmen eines Zeichens vor dem Vergleich fühlt sich wie ein Hack an, aber das macht den Ausdruck für die case-Aussage so viel einfacher.

Ich mag die Lösung mit dem -eqTest, weil es im Grunde ein Einzeiler ist.

Meine eigene Lösung bestand darin, die Parametererweiterung zu verwenden, um alle Ziffern wegzuwerfen und festzustellen, ob noch etwas übrig war. (Ich benutze immer noch 3.0, habe es noch nicht benutzt [[oder exprvorher, bin aber froh, sie kennenzulernen.)

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

=~Verwenden Sie für die Portabilität auf Pre-Bash 3.1 (als der Test eingeführt wurde) 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 : REGEXSucht nach REGEX, das zu Beginn von STRING verankert ist, wobei die erste Gruppe (oder die Länge der Übereinstimmung, falls keine vorhanden) wiedergegeben wird und Erfolg / Misserfolg zurückgegeben wird. Dies ist die alte Regex-Syntax, daher der Überschuss \. -\?bedeutet "vielleicht -", [0-9]\+bedeutet "eine oder mehrere Ziffern" und $bedeutet "Ende der Zeichenfolge".

Bash unterstützt auch erweiterte Globs, obwohl ich mich nicht mehr daran erinnere, ab welcher 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])) ]]

@(-|)bedeutet " -oder nichts", [0-9]bedeutet "Ziffer" und *([0-9])bedeutet "null oder mehr Ziffern".

Hier ist noch eine andere Sichtweise (nur mit dem Befehl test builtin und seinem Rückkehrcode):

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

Sie können Nicht-Ziffern entfernen und einen Vergleich durchführen. Hier ist ein Demo-Skript:

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

So sieht die Testausgabe aus:

44 44 Ganzzahl
-44 44 Ganzzahl
44- 44 Nicht ganzzahlig
4-4 44 Nicht ganzzahlig
a4 4 Nicht ganzzahlig
4a 4 Nicht ganzzahlig
.4 4 Nicht ganzzahlig
4.4 44 Nicht ganzzahlig
-4.4 44 Nicht ganzzahlig
09 9 Nicht ganzzahlig

Für mich war die einfachste Lösung, die Variable in einem (())Ausdruck wie folgt zu verwenden:

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

Diese Lösung ist natürlich nur gültig, wenn ein Wert von Null für Ihre Anwendung keinen Sinn ergibt. Das stimmte in meinem Fall, und das ist viel einfacher als die anderen Lösungen.

Wie in den Kommentaren erwähnt, kann dies zu einem Angriff auf die Codeausführung führen: Der (( ))Operator wertet aus VAR, wie im Arithmetic EvaluationAbschnitt der Manpage bash (1) angegeben . Daher sollten Sie diese Technik nicht verwenden, wenn die Quelle des Inhalts von VARungewiss ist (und natürlich auch KEINE andere Form der variablen Erweiterung verwenden).

oder mit 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

Hinzufügen zur Antwort von Ignacio Vazquez-Abrams. Dadurch kann das + -Zeichen vor der Ganzzahl stehen, und es können beliebig viele Nullen als Dezimalstellen verwendet werden. Auf diese Weise kann beispielsweise +45.00000000 als Ganzzahl betrachtet werden.
$ 1 muss jedoch so formatiert sein, dass es einen Dezimalpunkt enthält. 45 wird hier nicht als Ganzzahl betrachtet, 45.0 jedoch.

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

Zum Lachen habe ich ungefähr schnell eine Reihe von Funktionen ausgearbeitet, um dies zu tun (is_string, is_int, is_float, is alpha string oder andere), aber es gibt effizientere (weniger Code) Möglichkeiten, dies zu tun:

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

Führen Sie hier einige Tests durch, ich habe definiert, dass -44 ein int ist, aber 44- nicht 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

Ausgabe:

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 = 

HINWEIS: Führende Nullen können beim Hinzufügen von Zahlen wie Oktal auf etwas anderes schließen. Daher ist es besser, sie zu entfernen, wenn Sie beabsichtigen, '09' als int zu behandeln (was ich tue) (z. B. expr 09 + 0oder mit sed entfernen).