Bagaimana saya menguji jika suatu variabel adalah angka di Bash?

Saya tidak tahu bagaimana cara memastikan argumen yang diteruskan ke skrip saya adalah angka atau tidak.

Yang ingin saya lakukan adalah sesuatu seperti ini:

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

Ada bantuan?

Salah satu pendekatan adalah menggunakan ekspresi reguler, seperti:

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

Jika nilainya belum tentu bilangan bulat, pertimbangkan untuk mengubah regex dengan tepat; contohnya:

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

... atau, untuk menangani angka dengan tanda:

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

Tanpa bashism (bekerja bahkan di System V sh),

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

Ini menolak string kosong dan string berisi non-digit, menerima yang lainnya.

Angka negatif atau floating-point membutuhkan beberapa pekerjaan tambahan. Gagasannya adalah untuk mengecualikan -/ .dalam pola "buruk" pertama dan menambahkan lebih banyak pola "buruk" yang mengandung penggunaannya yang tidak tepat ( ?*-*/ *.*.*)

Solusi berikut juga dapat digunakan dalam cangkang dasar seperti Bourne tanpa perlu ekspresi reguler. Pada dasarnya setiap operasi evaluasi nilai numerik menggunakan non-angka akan menghasilkan kesalahan yang secara implisit akan dianggap salah dalam shell:

"$var" -eq "$var"

seperti dalam:

#!/bin/bash

var=a

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

Anda juga dapat menguji untuk $? kode pengembalian operasi yang lebih eksplisit:

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

Ada pengalihan kesalahan standar untuk menyembunyikan pesan "ekspresi integer yang diharapkan" yang dicetak bash seandainya kita tidak memiliki nomor.

CAVEATS (terima kasih untuk komentar di bawah):

• Angka dengan titik desimal tidak diidentifikasi sebagai "angka" yang valid
• Menggunakan [[ ]]alih-alih [ ]akan selalu dievaluasitrue
• Sebagian besar cangkang non-Bash akan selalu mengevaluasi ekspresi ini sebagai true
• Perilaku di Bash tidak berdokumen dan karenanya dapat berubah tanpa peringatan
• Jika nilai termasuk spasi setelah angka (misalnya "1 a") menghasilkan kesalahan, seperti bash: [[: 1 a: syntax error in expression (error token is "a")
• Jika nilainya sama dengan var-name (mis. I = "i"), menghasilkan kesalahan, seperti bash: [[: i: expression recursion level exceeded (error token is "i")

Ini menguji apakah suatu bilangan merupakan bilangan bulat non-negatif dan keduanya tidak tergantung pada shell (yaitu tanpa bashisme) dan hanya menggunakan built-in shell:

SALAH.

Karena jawaban pertama ini (di bawah) memungkinkan untuk bilangan bulat dengan karakter di dalamnya selama yang pertama tidak pertama dalam variabel.

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

BENAR .

Sebagaimana jilles berkomentar dan menyarankan dalam jawabannya, ini adalah cara yang benar untuk melakukannya dengan menggunakan pola shell.

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

Tidak ada yang menyarankan pencocokan pola diperpanjang bash :

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

Saya terkejut dengan solusi yang langsung mem-parsing format angka di shell. shell tidak cocok untuk ini, karena DSL untuk mengendalikan file dan proses. Ada banyak pengurai yang sedikit lebih rendah ke bawah, misalnya:

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
}

Ubah '% f' ke format apa pun yang Anda butuhkan.

Saya melihat jawabannya dan ... menyadari bahwa tidak ada yang memikirkan angka FLOAT (dengan titik)!

Menggunakan grep juga bagus.
-E berarti extended regexp
-q berarti tenang (tidak menggema)
-qE adalah kombinasi keduanya.

Untuk menguji langsung di baris perintah:

$ 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

Menggunakan dalam skrip 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

Untuk mencocokkan JUST integer, gunakan ini:

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

Cukup tindak lanjuti ke @mary. Tetapi karena saya tidak memiliki cukup perwakilan, tidak dapat memposting ini sebagai komentar untuk posting itu. Bagaimanapun, inilah yang saya gunakan:

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

Fungsi akan mengembalikan "1" jika argumennya adalah angka, jika tidak akan mengembalikan "0". Ini berfungsi untuk bilangan bulat dan juga mengapung. Penggunaannya adalah seperti:

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]}mengganti digit apa pun dalam nilai $idengan string kosong, lihat man -P 'less +/parameter\/' bash. -zmemeriksa apakah string yang dihasilkan memiliki panjang nol.

jika Anda juga ingin mengecualikan kasing saat $ikosong, Anda dapat menggunakan salah satu konstruksi ini:

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

Untuk masalah saya, saya hanya perlu memastikan bahwa pengguna tidak sengaja memasukkan beberapa teks sehingga saya mencoba untuk membuatnya tetap sederhana dan mudah dibaca

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

Menurut halaman manual ini cukup banyak melakukan apa yang saya inginkan

Jika nilai ekspresi bukan nol, status pengembalian adalah 0

Untuk mencegah pesan kesalahan yang tidak diinginkan untuk string yang "mungkin angka", saya mengabaikan output kesalahan

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

Pertanyaan lama, tapi saya hanya ingin memperbaiki solusi saya. Yang ini tidak memerlukan trik shell aneh, atau mengandalkan sesuatu yang belum ada selamanya.

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

Pada dasarnya itu hanya menghapus semua digit dari input, dan jika Anda pergi dengan string yang tidak nol, maka itu bukan angka.

Tidak dapat berkomentar, jadi saya akan menambahkan jawaban saya sendiri, yang merupakan ekstensi untuk jawaban glenn jackman menggunakan pencocokan pola bash.

Kebutuhan awal saya adalah mengidentifikasi angka dan membedakan bilangan bulat dan pelampung. Definisi fungsi yang dikurangkan menjadi:

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

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

Saya menggunakan pengujian unit (dengan shUnit2) untuk memvalidasi pola saya berfungsi sebagaimana dimaksud:

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

}

Catatan: Pola isFloat dapat dimodifikasi agar lebih toleran tentang titik desimal ( @(.,)) dan simbol E ( @(Ee)). Unit saya menguji hanya nilai yang bilangan bulat atau mengambang, tetapi tidak ada input yang tidak valid.

Saya akan mencoba ini:

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

Catatan: ini mengenali nan dan inf sebagai angka.

Jawaban yang jelas telah diberikan oleh @charles Dufy dan lainnya. Solusi bash murni akan menggunakan yang berikut:

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

Meskipun untuk bilangan real tidak wajib memiliki nomor sebelum titik radix .

Untuk memberikan dukungan yang lebih menyeluruh tentang angka mengambang dan notasi ilmiah (banyak program di C / Fortran atau yang akan mengekspor float dengan cara ini), tambahan yang bermanfaat untuk baris ini adalah sebagai berikut:

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

Jadi mengarah ke cara untuk membedakan jenis angka, jika Anda mencari jenis tertentu:

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

Catatan: Kita dapat membuat daftar persyaratan sintaksis untuk notasi desimal dan ilmiah, satu untuk memungkinkan koma sebagai titik radix, serta "." Kami kemudian akan menegaskan bahwa harus ada hanya satu titik radix tersebut. Mungkin ada dua tanda +/- dalam float [Ee]. Saya telah belajar beberapa aturan lagi dari karya Aulu, dan menguji terhadap string buruk seperti '' '-' '-E-1' '0-0'. Berikut adalah alat regex / substring / expr saya yang tampaknya bertahan:

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"

Jangan lupa -untuk memasukkan angka negatif!

Ini dapat dicapai dengan menggunakan grepuntuk melihat apakah variabel tersebut cocok dengan ekspresi reguler yang diperluas.

Bilangan bulat uji 1120:

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

Keluaran: Valid number.

Tes bukan bilangan bulat 1120a:

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

Keluaran: Error: not a number.

Penjelasan

• The grep, -Eswitch memungkinkan kita untuk menggunakan ekspresi reguler yang diperluas '^[0-9]+$'. Ekspresi reguler ini berarti variabel hanya boleh []berisi angka 0-9nol hingga sembilan dari ^awal hingga $akhir variabel dan harus memiliki setidaknya +satu karakter.
• The grep, yang -qberalih tenang mematikan output apapun apakah atau tidak menemukan apa-apa.
• ifmemeriksa status keluar dari grep. Status keluar 0berarti sukses dan yang lebih besar berarti kesalahan. The grepperintah memiliki status keluar dari 0jika menemukan kecocokan dan 1ketika tidak;

Jadi menyatukan semuanya, dalam ifpengujian, kita echovariabel $yournumberdan |pipa itu grepyang dengan -qswitch diam-diam cocok dengan -Eekspresi '^[0-9]+$'ekspresi reguler diperpanjang . Status keluar grepakan 0jika grepberhasil menemukan kecocokan dan 1jika tidak. Jika berhasil mencocokkan, kami echo "Valid number.". Jika gagal mencocokkan, kami echo "Error: not a number.".

Untuk Mengapung atau Ganda

Kami hanya dapat mengubah ekspresi reguler dari '^[0-9]+$'menjadi '^[0-9]*\.?[0-9]+$'untuk mengapung atau ganda.

Test float 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

Keluaran: Valid number.

Test float 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

Keluaran: Error: not a number.

Untuk Negatif

Untuk mengizinkan bilangan bulat negatif, cukup ubah ekspresi reguler dari '^[0-9]+$'menjadi '^\-?[0-9]+$'.

Untuk memungkinkan mengapung atau menggandakan negatif, cukup ubah ekspresi reguler dari '^[0-9]*\.?[0-9]+$'menjadi '^\-?[0-9]*\.?[0-9]+$'.

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

Anda juga dapat menggunakan kelas karakter bash.

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

Numerik akan menyertakan spasi, titik desimal, dan "e" atau "E" untuk titik mengambang.

Tetapi, jika Anda menentukan nomor heks C-style, yaitu "0xffff" atau "0XFFFF", [[: digit:]] mengembalikan true. Sedikit jebakan di sini, bash memungkinkan Anda melakukan sesuatu seperti "0xAZ00" dan masih menghitungnya sebagai digit (bukankah ini dari beberapa kekhasan aneh dari kompiler GCC yang memungkinkan Anda menggunakan notasi 0x untuk pangkalan selain dari 16 ??? )

Anda mungkin ingin menguji "0x" atau "0X" sebelum menguji apakah itu numerik jika input Anda benar-benar tidak dapat dipercaya, kecuali jika Anda ingin menerima nomor hex. Itu akan dicapai dengan:

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

Cara paling sederhana adalah memeriksa apakah itu berisi karakter non-digit. Anda mengganti semua karakter digit dengan apa-apa dan memeriksa panjangnya. Jika ada panjang, itu bukan angka.

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

Karena saya harus mengutak-atik ini dan akhir-akhir ini menyukai pendekatan karttu dengan unit test yang paling. Saya merevisi kode dan menambahkan beberapa solusi lain juga, coba sendiri untuk melihat hasilnya:

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

Jadi isNumber () termasuk tanda hubung, koma dan notasi eksponensial dan karenanya mengembalikan BENAR pada bilangan bulat & mengapung di mana di sisi lain isFloat () mengembalikan FALSE pada nilai integer dan isInteger () juga mengembalikan FALSE pada float. Untuk kenyamanan Anda semua sebagai satu liners:

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

Saya menggunakan expr . Ini mengembalikan bukan nol jika Anda mencoba menambahkan nol ke nilai non-numerik:

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

Mungkin dimungkinkan untuk menggunakan bc jika Anda membutuhkan non-integer, tetapi saya tidak percaya bcmemiliki perilaku yang sama. Menambahkan nol ke non-angka membuat Anda nol dan mengembalikan nilai nol juga. Mungkin Anda bisa menggabungkan bcdan expr. Gunakan bcuntuk menambahkan nol $number. Jika jawabannya adalah 0, maka cobalah expruntuk memverifikasi bahwa $numberitu bukan nol.

Saya suka jawaban Alberto Zaccagni.

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

Prasyarat penting: - tidak ada subkulit yang muncul - tidak ada parser RE yang dipanggil - sebagian besar aplikasi shell tidak menggunakan bilangan real

Tetapi jika $varkompleks (misalnya akses array asosiatif), dan jika angka tersebut akan menjadi bilangan bulat non-negatif (kebanyakan kasus penggunaan), maka ini mungkin lebih efisien?

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

Saya menggunakan printf sebagai jawaban lain yang disebutkan, jika Anda memberikan string format "% f" atau "% i" printf akan melakukan pengecekan untuk Anda. Lebih mudah daripada menciptakan kembali cek, sintaksinya sederhana dan pendek dan printf ada di mana-mana. Jadi itu pilihan yang layak menurut saya - Anda juga dapat menggunakan ide berikut untuk memeriksa berbagai hal, itu tidak hanya berguna untuk memeriksa angka.

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

pesta ekspresi reguler vspesta ekspansi parameter

Sebagai jawaban Charles Duffy berhasil, tetapi hanya digunakanpestaekspresi reguler , dan saya tahu ini lambat, saya ingin menunjukkan cara lain, hanya menggunakanpestaekspansi parameter :

Hanya untuk bilangan bulat positif:

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

Untuk bilangan bulat:

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

Kemudian untuk mengambang:

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

Untuk mencocokkan permintaan awal:

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

Sekarang sedikit perbandingan:

Ada cek yang sama berdasarkan jawaban Charles Duffy :

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

Beberapa tes:

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

Baiklah tidak apa apa. Sekarang berapa banyak waktu yang diperlukan untuk semua ini (Pada raspberry pi saya):

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

Kemudian dengan ekspresi reguler:

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

Untuk menangkap angka negatif:

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

Anda dapat menggunakan "biarkan" juga seperti ini:

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

Tapi saya lebih suka menggunakan operator "= ~" Bash 3+ seperti beberapa jawaban di utas ini.

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

Hapus -\?pola pencocokan grep jika Anda tidak menerima bilangan bulat negatif.

Melakukan hal yang sama di sini dengan ekspresi reguler yang menguji seluruh bagian dan bagian desimal, dipisahkan dengan titik.

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

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

Saya menggunakan yang berikut (untuk bilangan bulat):

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

Saya mencoba resep ultrasawblade karena rasanya paling praktis bagi saya, dan tidak bisa membuatnya bekerja. Pada akhirnya saya menemukan cara lain, berdasarkan yang lain dalam penggantian parameter, kali ini dengan penggantian regex:

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

Ini menghapus setiap: digit: karakter kelas dalam $ var dan memeriksa apakah kita dibiarkan dengan string kosong, yang berarti bahwa aslinya hanya angka.

Yang saya sukai dari yang satu ini adalah footprint dan fleksibilitasnya yang kecil. Dalam bentuk ini hanya berfungsi untuk bilangan bulat basis 10 tanpa batas, meskipun tentunya Anda dapat menggunakan pencocokan pola yang sesuai dengan kebutuhan lain.

Cepat & Kotor: Saya tahu ini bukan cara yang paling elegan, tapi saya biasanya hanya menambahkan nol dan menguji hasilnya. seperti itu:

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)) akan mengembalikan 0 atau bom jika $ 1 BUKAN bilangan bulat. sebagai contoh:

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
}

CATATAN: Saya kira saya tidak pernah berpikir untuk memeriksa pelampung atau jenis campuran yang akan membuat seluruh skrip bom ... dalam kasus saya, saya tidak ingin itu berjalan lebih jauh. Saya akan bermain-main dengan solusi mrucci dan regex Duffy - mereka tampaknya paling kuat dalam kerangka bash ...