Bash'te bir değişkenin sayı olup olmadığını nasıl test edebilirim?

Betiğime iletilen bir argümanın bir sayı olup olmadığından nasıl emin olduğumu nasıl anlayamıyorum.

Tek yapmak istediğim şu:

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

Herhangi bir yardım?

Bir yaklaşım aşağıdaki gibi düzenli bir ifade kullanmaktır:

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

Değer mutlaka bir tamsayı değilse, normal ifadeyi uygun şekilde değiştirmeyi düşünün; Örneğin:

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

... veya, işaretli sayıları işlemek için:

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

Bashisms olmadan (System V sh'de bile çalışır),

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

Bu, boş dizeleri ve basamak içermeyen dizeleri reddederek diğer her şeyi kabul eder.

Negatif veya kayan nokta sayıları için ek işler gerekir. Bir fikir, -/ .ilk "kötü" kalıbını hariç tutmak ve uygunsuz kullanımlarını içeren daha fazla "kötü" kalıp eklemek ( ?*-*/ *.*.*)

Aşağıdaki çözüm, düzenli ifadelere gerek kalmadan Bourne gibi temel kabuklarda da kullanılabilir. Temel olarak, sayı olmayan değerleri kullanan herhangi bir sayısal değer değerlendirme işlemi, kabukta dolaylı olarak yanlış olarak kabul edilecek bir hata ile sonuçlanır:

"$var" -eq "$var"

de olduğu gibi:

#!/bin/bash

var=a

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

Ayrıca $ için test edebilirsiniz? daha açık olan işlemin dönüş kodu:

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

Standart hatanın yeniden yönlendirilmesi, bir sayı yoksa, bash'ın yazdığı "tamsayı ifadesi bekleniyor" iletisini gizlemek için vardır.

MAĞARALAR (aşağıdaki yorumlar sayesinde):

• Ondalık noktalı sayılar değil geçerli olarak tanımlanan "Rakamlar"
• Kullanma [[ ]]yerine [ ]iradesine her zaman için değerlendirmektrue
• Bash olmayan kabukların çoğu bu ifadeyi her zaman şu şekilde değerlendirir: true
• Bash'teki davranış belgelenmemiştir ve bu nedenle uyarı vermeden değişebilir
• Değer, sayıdan sonra boşluklar içeriyorsa (örn. "1 a"), bash: [[: 1 a: syntax error in expression (error token is "a")
• Değer var-name ile aynıysa (örneğin, i = "i"), aşağıdaki gibi hata üretir bash: [[: i: expression recursion level exceeded (error token is "i")

Bu, bir sayının negatif olmayan bir tamsayı olup olmadığını ve hem kabuktan bağımsız (yani bashisms olmadan) olup olmadığını ve yalnızca kabuk yerleşiklerini kullanıp kullanmadığını test eder:

YANLIŞ.

Bu ilk cevap (aşağıda), ilkinde değişken olmayan ilk karakter olduğu sürece içinde karakter bulunan tamsayılara izin verir.

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

DOĞRU .

Gibi Jilles yorumlanmış ve önerilen onun cevabını bu kabuk kalıpları kullanarak bunu yapmak için doğru bir yoldur.

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

Hiç kimse bash'ın genişletilmiş desen eşleşmesini önermedi :

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

Kabuktaki sayı biçimlerini doğrudan ayrıştırma çözümlerine şaşırdım. shell, dosya ve süreçleri kontrol etmek için bir DSL olmak üzere buna çok uygun değildir. Örneğin, biraz daha düşük sayıda ayrıştırıcı vardır:

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
}

'% F' değerini istediğiniz biçime değiştirin.

Cevaplara bakıyordum ve ... hiç kimse FLOAT sayılarını (nokta ile) düşünmediğini fark etti!

Grep kullanmak da harika.
-E genişletilmiş regexp
anlamına gelir -q sessiz anlamına gelir (yankılamaz)
-qE her ikisinin birleşimidir.

Doğrudan komut satırında test etmek için:

$ 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

Bir bash betiğinde kullanma:

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

JUST tam sayılarını eşleştirmek için şunu kullanın:

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

@Mary için bir takip. Ancak yeterli temsilcim olmadığı için bunu bu gönderiye yorum olarak gönderemedim. Her neyse, işte kullandığım şey:

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

Bağımsız değişken bir sayı ise işlev "1" döndürür, aksi takdirde "0" döndürür. Bu, tamsayıların yanı sıra şamandıralar için de geçerlidir. Kullanımı şöyle bir şeydir:

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]}değerindeki herhangi bir rakamı $iboş bir dize ile değiştirir, bkz man -P 'less +/parameter\/' bash.-zsonuçta elde edilen dizginin uzunluğu sıfır olup olmadığını kontrol eder.

$iboşken davanın hariç tutulmasını istiyorsanız , aşağıdaki yapılardan birini kullanabilirsiniz:

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

Benim sorunum için, sadece bir kullanıcının yanlışlıkla bazı metin girmemesini sağlamak için gerekli böylece basit ve okunabilir tutmaya çalıştım

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

Man sayfasına göre bu istediğim şeyi yapıyor

İfadenin değeri sıfır değilse, dönüş durumu 0'dır.

"Sayı olabilir" dizeleri için kötü hata iletileri önlemek için Hata çıktı yoksay

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

Eski bir soru, ama sadece çözümümü ele almak istedim. Bu garip bir kabuk hilesi gerektirmez veya sonsuza kadar var olmayan bir şeye güvenmez.

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

Temel olarak girişteki tüm basamakları kaldırır ve sıfır uzunluklu olmayan bir dize bırakılırsanız sayı değildir.

Henüz yorum yapamam, bu yüzden bash desen eşleşmesini kullanarak glenn jackman'ın cevabına bir uzantı olan kendi cevabımı ekleyeceğim.

Benim asıl ihtiyacım sayıları tanımlamak, tamsayıları ve kayan noktaları ayırt etmekti. İşlev tanımları:

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

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

İstediğim gibi çalıştığım kalıpları doğrulamak için birim testi (shUnit2 ile) kullandım:

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

}

Notlar: isFloat deseni, ondalık nokta ( @(.,)) ve E sembolü ( @(Ee)) hakkında daha toleranslı olacak şekilde değiştirilebilir . Birim testlerim yalnızca tamsayı veya kayan noktalı değerleri test eder, ancak geçersiz girdi içermez.

Bunu denemek istiyorum:

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

Not: Bu, nan ve inf'yi sayı olarak tanır.

@Charles Dufy ve diğerleri tarafından açık bir cevap verilmiştir. Saf bir bash çözümü aşağıdakileri kullanıyor olabilir:

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

Gerçel sayılar için sayı tabanı noktasından önce bir sayı olması zorunlu değildir. .

Kayan sayıları ve bilimsel gösterimi daha kapsamlı bir şekilde desteklemek için (C / Fortran'daki birçok program veya şamandıra bu şekilde dışa aktarılacaktır), bu satıra yararlı bir ek aşağıdakiler olacaktır:

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

Böylece, belirli bir tür arıyorsanız, sayı türlerini ayırt etmenin bir yoluna yol açar:

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

Not: Ondalık ve bilimsel gösterim için sözdizimsel gereklilikleri sıralayabiliriz. Bunlardan biri virgülün taban noktası olarak ve "." Daha sonra böyle bir sayı tabanı noktası olması gerektiğini söyleyebiliriz. Bir [Ee] şamandıra içinde iki +/- işareti olabilir. Aulu'nun çalışmasından birkaç kural daha öğrendim ve '' '-' '-E-1' '0-0' gibi kötü dizelere karşı test ettim. İşte tutunuyor gibi görünüyor regex / substring / ifade araçları:

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"

-Negatif sayılar eklemeyi unutmayın !

Bunu kullanarak elde edilebilir grep konusu değişkenin genişletilmiş bir normal ifadeyle eşleşip eşleşmediğini görmek için .

Test tamsayısı 1120:

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

Çıktı: Valid number.

Tam sayı olmayan testi 1120a:

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

Çıktı: Error: not a number.

açıklama

• grep, -EAnahtar bize genişletilmiş düzenli ifade kullanmanızı sağlar '^[0-9]+$'. Bu normal ifade, değişkenin yalnızca değişkenin başından sonuna kadar sıfırdan dokuza kadar []sayı içermesi ve en azından0-9^$+ bir karakter .
• grep, -qSessiz anahtarı bir şey bulur olsun veya olmasın herhangi bir çıkış kapanır.
• ifçıkış durumunu kontrol eder grep. Çıkış durumu 0başarı anlamına gelir ve daha büyük bir şey hata anlamına gelir. grepKomut bir çıkış durumu vardır 0bir eşleşme bulursa ve 1öyle değil zaman;

Yani içinde, hep birlikte koyarak ifbiz testte echodeğişken $yournumberve |bunun için boru grepile hangi -qsessizce maçları anahtarı -Egenişletilmiş düzenli ifade '^[0-9]+$'ifadesini. Çıkış durumu grepolacak 0eğer grepbaşarılı ve bir eşleşme tespit 1doğru değilse. Eğer eşleşmeyi başarırsak, biz echo "Valid number.". Eğer eşleşmezse, biz echo "Error: not a number.".

Şamandıralar ve Çiftler İçin

Normal ifadeyi '^[0-9]+$'yerine'^[0-9]*\.?[0-9]+$' yüzen veya çiftlerde için.

Test şamandırası 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

Çıktı: Valid number.

Test şamandırası 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

Çıktı: Error: not a number.

Negatifler için

Negatif tamsayılara izin vermek için, normal ifadeyi olarak '^[0-9]+$'değiştirin '^\-?[0-9]+$'.

Negatif dalgalanmalara veya iki katına izin vermek için, normal ifadeyi olarak '^[0-9]*\.?[0-9]+$'değiştirin '^\-?[0-9]*\.?[0-9]+$'.

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

Ayrıca bash'ın karakter sınıflarını da kullanabilirsiniz.

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

Sayısal olarak boşluk, ondalık nokta ve kayan nokta için "e" veya "E" yer alır.

Ancak, bir C stili onaltılık sayı belirtirseniz, yani "0xffff" veya "0XFFFF" belirtirseniz, [[: digit:]] true değerini döndürür. Burada bir tuzak biraz, bash "0xAZ00" gibi bir şey yapmanıza izin verir ve hala bir rakam olarak saymak (16 dışında üsler için 0x gösterimi kullanmanıza izin veren GCC derleyicileri tuhaf garip değil mi ??? )

Onaltılık sayıları kabul etmek istemiyorsanız, girişinizin tamamen güvenilmezse sayısal olup olmadığını test etmeden önce "0x" veya "0X" için test etmek isteyebilirsiniz. Bu şu şekilde gerçekleştirilebilir:

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

En basit yol, rakam olmayan karakterler içerip içermediğini kontrol etmektir. Tüm basamak karakterlerini hiçbir şeyle değiştirmezsiniz ve uzunluğu kontrol edersiniz. Uzunluk varsa, bu bir sayı değildir.

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

Ben son zamanlarda bu kurcalamak zorunda olduğu gibi ve ünite ile karttu's yaklaşım gibi en test. Kodu revize ettim ve başka çözümler de ekledim, sonuçları görmek için kendiniz deneyin:

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

Yani isNumber () tire, virgül ve üstel gösterimi içerir ve bu nedenle tamsayılarda ve kayan noktalarda TRUE değerini döndürür ; diğer yandan isFloat () , tamsayı değerlerinde FALSE değerini döndürür ve isInteger () de float üzerinde FALSE değerini döndürür. Rahatlığınız için hepsi bir astar olarak:

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

Kullandığım İfade . Sayısal olmayan bir değere sıfır eklemeye çalışırsanız sıfırdan farklı bir değer döndürür:

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

Tamsayı olmayanlara ihtiyacınız varsa bc kullanmak mümkün olabilir , ancak bcaynı davranışa sahip olduğuna inanmıyorum . Sayı olmayan bir sayıya sıfır eklemek sıfır yapar ve sıfır da döndürür. Belki birleştirebilirsin bcve expr. 'A bcsıfır eklemek için kullanın $number. Cevap buysa, sıfır olmadığını doğrulamaya 0çalışın .expr$number

Alberto Zaccagni'nin cevabını seviyorum.

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

Önemli önkoşullar: - alt kabuklar ortaya çıkmaz - RE ayrıştırıcıları çağrılmaz - çoğu kabuk uygulaması gerçek sayı kullanmaz

Ancak $varkarmaşıksa (örn. İlişkisel dizi erişimi) ve sayı negatif olmayan bir tamsayı olacaksa (çoğu kullanım örneği), bu belki daha verimlidir?

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

Belirtilen diğer cevaplar olarak printf kullanıyorum, "% f" biçim dizgisini sağlarsanız veya "% i" printf denetimi sizin için yapar. Kontrolleri yeniden icat etmekten daha kolay, sözdizimi basit ve kısadır ve printf her yerde bulunur. Bu yüzden bence iyi bir seçim - ayrıca bir dizi şeyi kontrol etmek için aşağıdaki fikri kullanabilirsiniz, sadece sayıları kontrol etmek için yararlı değildir.

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

darbe Düzenli ifade vsdarbe parametre genişletme

Gibi Charles Duffy cevap çalışması, ama sadece kullanımdarbe Düzenli ifade , ve bunun yavaş olduğunu biliyorum, sadece kullanarak başka bir yol göstermek istiyorumdarbeparametre genişletme :

Yalnızca pozitif tamsayılar için:

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

Tamsayılar için:

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

Sonra yüzmek için:

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

İlk isteği eşleştirmek için:

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

Şimdi biraz karşılaştırma:

Charles Duffy'nin cevabına göre aynı kontrol var :

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

Bazı testler:

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

Tamam sorun değil. Şimdi tüm bunları kaç kez alacak (Benim ahududu pi üzerinde):

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

Sonra düzenli ifadelerle:

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

Negatif sayıları yakalamak için:

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

"Let" komutunu şu şekilde de kullanabilirsiniz:

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

Ama ben bu iş parçacığında bazı cevaplar gibi "= ~" Bash 3 + operatörü kullanmayı tercih ederim.

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

-\?Negatif tamsayıyı kabul etmiyorsanız, grep eşleştirme desenini kaldırın .

Burada aynı şeyi, tüm parçayı ve ondalık basamakları bir nokta ile ayrılmış olarak test eden düzenli bir ifade ile yaptım.

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

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

Aşağıdakileri kullanıyorum (tamsayılar için):

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

Benim için en pratik göründüğü için ultrasawblade'in tarifini denedim ve çalıştıramadım. Sonunda başka bir şekilde, parametre değiştirmede diğerleri gibi, bu kez regex değiştirme ile tasarladım:

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

$ Var içindeki her: digit: sınıf karakterini kaldırır ve boş bir dizeyle bırakılıp bırakılmadığımızı kontrol eder, bu da orijinalin sadece sayılar olduğunu gösterir.

Bu konuda ne gibi küçük ayak izi ve esneklik olduğunu. Bu formda yalnızca sınırlandırılmamış, temel 10 tamsayıları için çalışır, ancak diğer gereksinimlere uyacak şekilde desen eşleştirmeyi kullanabilirsiniz.

Hızlı ve Kirli: En zarif yol olmadığını biliyorum, ama genellikle sadece bir sıfır ekledim ve sonucu test ettim. şöyle:

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)), 0 $ veya tamsayı DEĞİLSE bomba döndürür. Örneğin:

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
}

NOT: Sanırım tüm senaryo bombasını yapacak şamandıraları veya karışık türleri kontrol etmeyi hiç düşünmedim ... benim durumumda, daha fazla gitmesini istemedim. Mrucci'nin çözümü ve Duffy'nin normal ifadesiyle oynayacağım - bash çerçevesindeki en sağlam görünüyorlar ...