Jak sprawdzić, czy zmienna jest liczbą w Bash?

Po prostu nie mogę się dowiedzieć, jak upewnić się, że argument przekazany do mojego skryptu jest liczbą, czy nie.

Chcę tylko coś takiego:

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

Jakaś pomoc?

Jednym z podejść jest użycie wyrażenia regularnego, takiego jak:

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

Jeśli wartość niekoniecznie jest liczbą całkowitą, rozważ odpowiednią zmianę wyrażenia regularnego; na przykład:

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

... lub, aby obsługiwać liczby ze znakiem:

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

Bez baszizmów (działa nawet w Systemie V sh),

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

To odrzuca puste ciągi i ciągi zawierające cyfry, akceptując wszystko inne.

Liczby ujemne lub zmiennoprzecinkowe wymagają dodatkowej pracy. Pomysł polega na wykluczeniu -/ .w pierwszym „złym” wzorcu i dodaniu kolejnych „złych” wzorców zawierających ich niewłaściwe użycie ( ?*-*/ *.*.*)

Poniższego rozwiązania można również użyć w podstawowych powłokach, takich jak Bourne, bez potrzeby używania wyrażeń regularnych. Zasadniczo wszelkie operacje oceny wartości liczbowych z użyciem liczb innych niż powodują błąd, który domyślnie będzie uważany za fałszywy w powłoce:

"$var" -eq "$var"

jak w:

#!/bin/bash

var=a

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

Możesz także przetestować za $? kod powrotu operacji, który jest bardziej wyraźny:

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

Przekierowanie standardowego błędu ma na celu ukrycie komunikatu „oczekiwane wyrażenie liczby całkowitej”, który bash wypisuje na wypadek, gdybyśmy nie mieli numeru.

PRZESTROGI (dzięki komentarzom poniżej):

• Liczby z kropkami dziesiętnymi nie są identyfikowane jako prawidłowe „liczby”
• Używanie [[ ]]zamiast [ ]zawsze zawsze będzie oznaczaćtrue
• Większość powłok innych niż Bash zawsze ocenia to wyrażenie jako true
• Zachowanie w Bash jest nieudokumentowane i dlatego może ulec zmianie bez ostrzeżenia
• Jeśli wartość zawiera spacje po liczbie (np. „1 a”) powoduje błąd, jak bash: [[: 1 a: syntax error in expression (error token is "a")
• Jeśli wartość jest taka sama jak nazwa-zmiennej (np. I = „i”), powoduje błąd, np bash: [[: i: expression recursion level exceeded (error token is "i")

Sprawdza, czy liczba jest nieujemną liczbą całkowitą i jest niezależna od powłoki (tj. Bez bashism) i wykorzystuje tylko wbudowane powłoki:

BŁĘDNY.

Ponieważ ta pierwsza odpowiedź (poniżej) pozwala na liczby całkowite ze znakami, o ile pierwsze nie są pierwsze w zmiennej.

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

PRAWIDŁOWO .

Jak skomentował i zasugerował w swojej odpowiedzi Jilles, jest to właściwy sposób, aby to zrobić za pomocą wzorców powłok.

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

Nikt nie sugerował rozszerzonego dopasowania wzoru bash :

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

Jestem zaskoczony rozwiązaniami bezpośrednio analizującymi formaty liczb w powłoce. shell nie nadaje się do tego dobrze, ponieważ jest DSL do kontrolowania plików i procesów. Trochę niżej jest dużo parserów liczb, na przykład:

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
}

Zmień '% f' na dowolny wymagany format.

Patrzyłem na odpowiedzi i ... zdałem sobie sprawę, że nikt nie myślał o liczbach FLOAT (z kropką)!

Świetnie jest też używać grep.
-E oznacza rozszerzone wyrażenie regularne
-q oznacza ciche (nie echo)
-qE jest kombinacją obu.

Aby przetestować bezpośrednio w wierszu polecenia:

$ 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

Używanie w skrypcie 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

Aby dopasować liczby całkowite JUST, użyj tego:

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

Tylko kontynuacja @mary. Ale ponieważ nie mam wystarczającej liczby przedstawicieli, nie mogłem tego opublikować jako komentarza do tego postu. W każdym razie oto, czego użyłem:

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

Funkcja zwróci „1”, jeśli argument jest liczbą, w przeciwnym razie zwróci „0”. Działa to zarówno dla liczb całkowitych, jak i liczb zmiennoprzecinkowych. Użycie jest takie jak:

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]}zastępuje dowolną cyfrę wartości $ipustym łańcuchem, patrz man -P 'less +/parameter\/' bash. -zsprawdza, czy wynikowy łańcuch ma zerową długość.

jeśli chcesz również wykluczyć przypadek, gdy $ijest pusty, możesz użyć jednej z tych konstrukcji:

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

W przypadku mojego problemu musiałem tylko upewnić się, że użytkownik nie przypadkowo wprowadzi jakiś tekst, dlatego starałem się, aby był on prosty i czytelny

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

Według strony podręcznika to właściwie robi to, czego chcę

Jeśli wartość wyrażenia jest niezerowa, zwracanym statusem jest 0

Aby zapobiec nieprzyjemnym komunikatom o błędach dla ciągów, które „mogą być liczbami”, ignoruję wynik błędu

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

Stare pytanie, ale chciałem tylko rozwiązać moje rozwiązanie. Ten nie wymaga żadnych dziwnych sztuczek z pociskami ani polegania na czymś, co nie istniało wiecznie.

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

Zasadniczo po prostu usuwa wszystkie cyfry z wejścia, a jeśli masz ciąg znaków o niezerowej długości, to nie jest to liczba.

Nie mogę jeszcze komentować, więc dodam własną odpowiedź, która jest rozszerzeniem odpowiedzi Glenna Jackmana za pomocą dopasowania wzorca bash.

Moją pierwotną potrzebą było identyfikowanie liczb oraz rozróżnianie liczb całkowitych i liczb zmiennoprzecinkowych. Definicje funkcji odliczone do:

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

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

Użyłem testów jednostkowych (z shUnit2), aby sprawdzić poprawność działania moich wzorców:

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

}

Uwagi: Wzorzec isFloat można zmodyfikować, aby był bardziej tolerancyjny w stosunku do kropki dziesiętnej ( @(.,)) i symbolu E ( @(Ee)). Moje testy jednostkowe testują tylko wartości całkowite lub zmiennoprzecinkowe, ale nie są to żadne nieprawidłowe dane wejściowe.

Spróbowałbym tego:

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

Uwaga: rozpoznaje to nan i inf jako liczbę.

Jasna odpowiedź została już udzielona przez @charles Dufy i innych. Rozwiązaniem czysto bashowym byłoby użycie:

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

Chociaż w przypadku liczb rzeczywistych nie jest obowiązkowe, aby mieć liczbę przed punktem bazowym .

Aby zapewnić dokładniejszą obsługę liczb zmiennoprzecinkowych i notacji naukowej (wiele programów w C / Fortran lub w inny sposób eksportuje liczby zmiennoprzecinkowe w ten sposób), przydatnym dodatkiem do tego wiersza byłoby:

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

Prowadząc w ten sposób do rozróżnienia typów liczb, jeśli szukasz jakiegoś konkretnego typu:

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

Uwaga: Moglibyśmy wymienić wymagania syntaktyczne dla notacji dziesiętnej i naukowej, przy czym jednym z nich jest zezwolenie na przecinek jako punkt radix, a także „.”. Twierdzilibyśmy wtedy, że musi istnieć tylko jeden taki punkt bazowy. Mogą występować dwa znaki +/- w pływaka [Ee]. Nauczyłem się jeszcze kilku zasad z pracy Aulu i przetestowałem na złych ciągach, takich jak „” - „” -E-1 ”„ 0-0 ”. Oto moje narzędzia regex / substring / expr, które wydają się wstrzymywać:

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"

Nie zapomnij -podać liczb ujemnych!

Można to osiągnąć, grepsprawdzając, czy dana zmienna pasuje do rozszerzonego wyrażenia regularnego.

Liczba całkowita testowa 1120:

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

Wynik: Valid number.

Testuj liczbę całkowitą 1120a:

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

Wynik: Error: not a number.

Wyjaśnienie

• grepThe -Eprzełącznik pozwala nam korzystać z rozszerzonego wyrażenia regularnego '^[0-9]+$'. To wyrażenie regularne oznacza, że ​​zmienna powinna []zawierać tylko liczby od 0-9zera do dziewięciu od ^początku do $końca zmiennej i powinna mieć co najmniej +jeden znak.
• grepThe -qprzełącznik cichy wyłącza każdym wyjściu czy nie stwierdzi nic.
• ifsprawdza status wyjścia grep. Status wyjścia 0oznacza sukces, a cokolwiek większego oznacza błąd. grepKomenda ma status wyjścia 0, jeżeli stwierdzi mecz i 1gdy nie robi;

Więc łącząc to wszystko, w ifteście, my echozmienną $yournumberi |potokujemy ją, do grepktórej -qprzełącznikiem po cichu dopasowuje -Erozszerzone wyrażenie regularne '^[0-9]+$'. Status wyjścia grepbędzie, 0jeśli grepuda się znaleźć dopasowanie, a 1jeśli nie. Jeśli uda się dopasować, my echo "Valid number.". Jeśli to nie pasuje, my echo "Error: not a number.".

Dla pływaków lub podwajaczy

Możemy tylko zmienić wyrażenie regularne od '^[0-9]+$'celu '^[0-9]*\.?[0-9]+$'dla pływaków lub dwuosobowe.

Pływak testowy 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

Wynik: Valid number.

Pływak testowy 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

Wynik: Error: not a number.

Dla negatywów

Aby zezwolić na ujemne liczby całkowite, wystarczy zmienić wyrażenie regularne z '^[0-9]+$'na '^\-?[0-9]+$'.

Aby zezwolić na liczby zmiennoprzecinkowe lub podwójne, po prostu zmień wyrażenie regularne z '^[0-9]*\.?[0-9]+$'na '^\-?[0-9]*\.?[0-9]+$'.

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

Możesz także użyć klas postaci basha.

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

Numeryczne będą zawierać spację, kropkę dziesiętną oraz „e” lub „E” dla liczby zmiennoprzecinkowej.

Ale jeśli podasz liczbę szesnastkową w stylu C, tj. „0xffff” lub „0XFFFF”, [[: digit:]] zwróci true. Trochę pułapki tutaj, bash pozwala ci zrobić coś takiego jak „0xAZ00” i nadal liczyć to jako cyfrę (czy nie jest to dziwne dziwactwo kompilatorów GCC, które pozwalają używać notacji 0x dla baz innych niż 16 ??? )

Możesz przetestować na „0x” lub „0X” przed przetestowaniem, czy jest to wartość liczbowa, jeśli dane wejściowe są całkowicie niezaufane, chyba że chcesz zaakceptować liczby szesnastkowe. Można to osiągnąć poprzez:

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

Najprostszym sposobem jest sprawdzenie, czy zawiera znaki niecyfrowe. Wszystkie cyfry zamieniasz na nic i sprawdzasz długość. Jeśli jest długość, nie jest to liczba.

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

Ponieważ ostatnio musiałem to manipulować i najbardziej podobało mi się podejście karttu do testu jednostkowego. Zmodyfikowałem kod i dodałem też kilka innych rozwiązań, wypróbuj go sam, aby zobaczyć wyniki:

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

Tak więc isNumber () zawiera myślniki, przecinki i notację wykładniczą, a zatem zwraca PRAWDA na liczbach całkowitych i liczbach zmiennoprzecinkowych, gdzie z drugiej strony isFloat () zwraca wartość FAŁSZ na liczbach całkowitych, a isInteger () podobnie zwraca wartość FAŁSZ na liczbach zmiennoprzecinkowych . Dla Twojej wygody wszystko jako jedna wkładka:

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

Używam wyrażenie . Zwraca niezerową, jeśli spróbujesz dodać zero do wartości nienumerycznej:

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

Może być możliwe użycie bc, jeśli potrzebujesz liczb całkowitych, ale nie sądzę bc, że zachowuje się tak samo. Dodanie zera do nieliczbowej daje zero i zwraca również wartość zero. Może możesz połączyć bci expr. Użyj, bcaby dodać zero do $number. Jeśli odpowiedź brzmi 0, spróbuj exprsprawdzić, czy $numbernie jest to zero.

Podoba mi się odpowiedź Alberto Zaccagniego.

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

Ważne warunki wstępne: - brak odrodzenia podpowłoki - brak wywoływanych parserów RE - większość aplikacji powłoki nie używa liczb rzeczywistych

Jednak, jeśli $varjest złożona (np asocjacyjny dostęp do tablicy), a jeśli liczba będzie nieujemną liczbę całkowitą (w większości przypadków użycia), to jest być może bardziej skuteczne?

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

Używam printf jako innych wspomnianych odpowiedzi, jeśli podasz ciąg formatu „% f” lub „% i” printf zrobi to za ciebie. Łatwiej niż na nowo wymyślić kontrole, składnia jest prosta i krótka, a printf jest wszechobecny. Moim zdaniem jest to więc dobry wybór - możesz również skorzystać z następującego pomysłu, aby sprawdzić zakres rzeczy, nie tylko przydaje się do sprawdzania liczb.

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

grzmotnąć wyrażenie regularne vsgrzmotnąć rozszerzenie parametru

Jak odpowiedź Charlesa Duffy działa, ale tylko użyjgrzmotnąćwyrażenie regularne i wiem, że jest to powolne, chciałbym pokazać inny sposób, używając tylkogrzmotnąćrozszerzenie parametru :

Tylko dla dodatnich liczb całkowitych:

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

Dla liczb całkowitych:

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

Następnie dla pływających:

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

Aby dopasować początkowe żądanie:

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

Teraz małe porównanie:

Ta sama kontrola opiera się na odpowiedzi Charlesa Duffy'ego :

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

Niektóre testy:

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

W porządku. Ile czasu zajmie to wszystko (na moim malinowym pi):

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

Następnie z wyrażeniami regularnymi:

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

Aby złapać liczby ujemne:

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

Możesz też użyć „let” w ten sposób:

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

Ale wolę używać operatora „= ~” Bash 3+ jak niektórych odpowiedzi w tym wątku.

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

Usuń -\?wzór dopasowania grep, jeśli nie akceptujesz ujemnej liczby całkowitej.

Zrobił to samo z wyrażeniem regularnym, które testuje całą część i część dziesiętną, oddzielone kropką.

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

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

Używam następujących (dla liczb całkowitych):

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

Wypróbowałem przepis ultrasawblade, który wydawał mi się najbardziej praktyczny i nie mogłem go uruchomić. W końcu jednak wymyśliłem inny sposób, oparty na podstawieniu parametrów, tym razem z zastąpieniem wyrażeń regularnych:

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

Usuwa każdy znak: digit: class w $ var i sprawdza, czy został nam pusty ciąg znaków, co oznacza, że ​​oryginał zawierał tylko liczby.

Najbardziej podoba mi się jego niewielka powierzchnia i elastyczność. W tej formie działa tylko w przypadku liczb całkowitych nieokreślonych liczbami podstawowymi, ale z pewnością można użyć dopasowania wzorca, aby dopasować go do innych potrzeb.

Quick & Dirty: Wiem, że nie jest to najbardziej elegancki sposób, ale zwykle po prostu dodałem do niego zero i testowałem wynik. tak:

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)) zwróci 0 lub bombę, jeśli 1 $ NIE jest liczbą całkowitą. na przykład:

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
}

UWAGA: Wydaje mi się, że nigdy nie myślałem, aby sprawdzić zmiennoprzecinkowe lub mieszane typy, które spowodowałyby, że cały skrypt bomby… w moim przypadku nie chciałem, aby poszedł dalej. Pobawię się rozwiązaniem Mrucciego i regexem Duffy'ego - wydają się najbardziej niezawodne w ramach bash ...