Dizenin geçerli bir tam sayı olup olmadığını test edin

Yeterince yaygın bir şey yapmaya çalışıyorum: Kullanıcı girdisini bir kabuk betiğinde ayrıştırın. Kullanıcı geçerli bir tamsayı sağladıysa, komut dosyası bir şey yapar ve geçerli değilse başka bir şey yapar. Sorun şu ki, bunu yapmanın kolay (ve oldukça zarif) bir yolunu bulamadım - onu karakter karakter ayırmak istemiyorum.

Bunun kolay olduğunu biliyorum ama nasıl yapılacağını bilmiyorum. Bunu bir düzine dilde yapabilirdim ama BASH yapamazdım!

Araştırmamda şunu buldum:

Bir dizenin 10 tabanında geçerli bir gerçek sayı içerip içermediğini test etmek için normal ifade

Ve orada regex'ten bahseden bir cevap var, ama bildiğim kadarıyla bu, C'de (diğerlerinin yanı sıra) mevcut bir fonksiyon. Yine de harika bir cevap gibi görünen bir cevap vardı, bu yüzden grep ile denedim ama grep bununla ne yapacağını bilmiyordu. Kutumda onu bir PERL regexp - nada olarak ele almak anlamına gelen -P'yi denedim. Dash E (-E) de çalışmadı. Ve -F de yapmadı.

Açık olmak gerekirse, bunun gibi bir şey deniyorum, herhangi bir çıktı arıyorum - oradan, elde ettiğim her şeyden yararlanmak için senaryoyu hackleyeceğim. (IOW, uygun olmayan bir girişin geçerli bir satır tekrarlanırken hiçbir şey döndürmemesini bekliyordum.)

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

Lütfen birisi bunun en kolay nasıl yapıldığını gösterebilir mi?

Açıkçası, bence bu TEST'in kısa bir geleceği. Bunun gibi bir bayrağı olmalı

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

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

• ^Giriş deseni başladığını belirten
• -Bir hazır olduğunu "-"
• ?Araçlar "0 ya da önceki 1 ( -)"
• +Araçlar "önceki 1 ya da daha fazla ( [0-9])"
• $Giriş modeli sonunu gösterir

Dolayısıyla normal ifade, isteğe bağlı -(negatif sayılar için) ve ardından bir veya daha fazla ondalık basamakla eşleşir .

Referanslar :

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

Vay be ... burada çok iyi çözüm var !! Yukarıdaki tüm çözümlerden @nortally'ye katılıyorum, -eqtek astarı kullanmanın en havalı olduğu.

GNU bash sürümünü 4.1.5(Debian) çalıştırıyorum. Bunu ksh'de de kontrol ettim (SunSO 5.10).

İşte $1tam sayı olup olmadığını kontrol etme versiyonum :

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

Bu yaklaşım aynı zamanda, diğer çözümlerden bazılarının hatalı bir negatif sonuca sahip olacağı negatif sayıları da hesaba katar ve açıkça bir tam sayı olan "+" önekine (örneğin +30) izin verir.

Sonuçlar:

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

Ignacio Vazquez-Abrams tarafından sağlanan çözüm de açıklandıktan sonra çok temizdi (regex'i seviyorsanız). Bununla birlikte, +ön ekli pozitif sayıları işlemez , ancak aşağıdaki gibi kolayca düzeltilebilir:

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

Partiye geç geliyorum. Yanıtların hiçbirinin en basit, en hızlı, en taşınabilir çözümden bahsetmediğine çok şaşırdım; casebeyanı.

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

Karşılaştırmadan önce herhangi bir işaretin kırpılması biraz hile gibi geliyor, ancak bu durum ifadesinin ifadesini çok daha basit hale getiriyor.

Çözümü kullanarak seviyorum -eqTesti , çünkü temelde tek satırlık bir çözüm.

Benim çözümüm, tüm sayıları atmak ve kalan bir şey olup olmadığını görmek için parametre genişletmeyi kullanmaktı. (Hala 3.0 kullanıyorum, kullanmadım [[veya daha exprönce, ancak onlarla tanıştığıma memnun oldum.)

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

Bash 3.1'den önce taşınabilirlik için ( =~test sunulduğunda) kullanın 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 : REGEXSTRING'in başlangıcında sabitlenmiş REGEX'i arar, ilk grubu (veya yoksa eşleşmenin uzunluğunu) yineler ve başarı / başarısızlık döndürür. Bu eski normal sözdizimidir, dolayısıyla fazlalıktır \. -\?"belki -" [0-9]\+anlamına gelir, "bir veya daha fazla rakam" anlamına gelir ve$ anlamına gelir "dizenin sonu" anlamına gelir.

Bash ayrıca genişletilmiş globları da destekliyor, ancak hangi sürümden itibaren olduğunu hatırlamıyorum.

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

@(-|)" -veya hiçbiri" [0-9]anlamına gelir, "rakam" *([0-9])anlamına gelir ve "sıfır veya daha fazla rakam" anlamına gelir.

İşte buna başka bir yaklaşım (yalnızca test yerleşik komutunu ve dönüş kodunu kullanarak):

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

Rakam olmayanları çıkarabilir ve bir karşılaştırma yapabilirsiniz. İşte bir demo komut dosyası:

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

Test çıktısı şuna benzer:

44 44 Tamsayı
-44 44 Tam Sayı
44- 44 Tamsayı değil
4-4 44 Tamsayı değil
a4 4 Tamsayı değil
4a 4 Tamsayı değil
.4 4 Tamsayı değil
4.4 44 Tamsayı değil
-4.4 44 Tamsayı değil
09 9 Tamsayı değil

Benim için en basit çözüm, değişkeni bir (())ifadenin içinde kullanmaktı , şöyle ki:

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

Elbette bu çözüm, uygulamanız için sıfır değeri bir anlam ifade etmiyorsa geçerlidir. Bu benim durumumda doğru oldu ve bu diğer çözümlerden çok daha basit.

Yorumlarda belirtildiği gibi, bu sizi bir kod yürütme saldırısına maruz bırakabilir: (( ))Operatör , bash (1) man sayfasının bölümünde VARbelirtildiği gibi değerlendirir . Bu nedenle, içeriğinin kaynağı belirsiz olduğunda bu tekniği kullanmamalısınız (tabii ki başka HERHANGİ bir değişken genişletme biçimi kullanmamalısınız).Arithmetic EvaluationVAR

veya sed ile:

   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

Ignacio Vazquez-Abrams'ın cevabına ekleniyor. Bu, + işaretinin tamsayıdan önce gelmesine izin verecek ve ondalık nokta olarak herhangi bir sayıda sıfıra izin verecektir. Örneğin bu, +45.00000000'ün bir tamsayı olarak kabul edilmesini sağlayacaktır.
Ancak $ 1, ondalık nokta içerecek şekilde biçimlendirilmelidir. 45 burada bir tam sayı olarak kabul edilmez, ancak 45.0 eşittir.

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

Gülmek için kabaca bunu yapmak için bir dizi işlevi kabaca çabucak çözdüm (is_string, is_int, is_float, is alpha string, or other) ama bunu yapmanın daha verimli (daha az kod) yolları var:

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

Burada bazı testler yapın, tanımladım ki -44 bir int ama 44- değil vs ..:

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

Çıktı:

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 = 

NOT: Baştaki 0'lar, sekizlik gibi sayılar eklerken başka bir şey çıkarabilir, bu nedenle '09'u bir int olarak değerlendirmeyi düşünüyorsanız (ki bunu yapıyorum) (örneğin expr 09 + 0sed ile soyun) bunları çıkarmak daha iyi olacaktır.