Як перевірити, чи є змінною число в Bash?

Я просто не можу зрозуміти, як переконатися, що аргумент, переданий моєму сценарію, є числом чи ні.

Все, що я хочу зробити, - це щось подібне:

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

Будь-яка допомога?

Один із підходів - використовувати регулярний вираз, як-от так:

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

Якщо значення не обов'язково є цілим числом, подумайте про коригування регулярного вираження; наприклад:

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

... або для обробки чисел зі знаком:

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

Без башизмів (працює навіть у Системі V sh),

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

Це відхиляє порожні рядки та рядки, що містять нецифрові цифри, приймаючи все інше.

Негативні чи числа з плаваючою комою потребують додаткової роботи. Ідея полягає в тому, щоб виключити -/ .в перший "поганий" шаблон і додати більше "поганих" шаблонів, що містять нераціональне використання їх ( ?*-*/ *.*.*)

Наступне рішення також може бути використане в основних оболонках, таких як Борн, без необхідності регулярних виразів. В основному будь-які операції оцінювання числових значень, що використовують нечисло, призведе до помилки, яка неявно вважатиметься помилковою в оболонці:

"$var" -eq "$var"

як і в:

#!/bin/bash

var=a

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

Ви також можете протестувати на $? код повернення операції, який є більш явним:

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

Перенаправлення стандартної помилки існує, щоб приховати повідомлення "очікуване ціле вираження", яке друкує bash, якщо у нас немає номера.

ПЕРЕГЛЯД (завдяки коментарям нижче):

• Числа з десятковими знаками є не ідентифікуються як дійсні "цифри"
• Використання [[ ]]замість[ ] завжди буде оцінюватиtrue
• Більшість не-башівських оболонок завжди оцінюють цей вираз як true
• Поведінка у Bash є недокументованою і тому може змінюватися без попередження
• Якщо значення включає пробіли після числа (наприклад, "1 a"), створює помилку, наприклад bash: [[: 1 a: syntax error in expression (error token is "a")
• Якщо значення таке ж, як var-name (наприклад, i = "i"), створює помилку, як bash: [[: i: expression recursion level exceeded (error token is "i")

Цей тест перевіряє, якщо число невід'ємне ціле число і обоє оболонку незалежно (тобто без башизмів) і використовує лише вбудовані оболонки:

НЕПРАВИЛЬНО.

Оскільки ця перша відповідь (нижче) передбачає цілі числа з символами в них до тих пір, поки перші не будуть першими в змінній.

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

ПРАВИЛЬНО .

Як прокоментував у своїй відповіді джиллес, це правильний спосіб зробити це за допомогою шаблонів оболонок.

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

Ніхто не запропонував розгорнутий узор моделі Bash :

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

Я здивований рішенням, що безпосередньо аналізують формати чисел у оболонці. оболонка не дуже підходить для цього, тому що це DSL для управління файлами та процесами. Існує достатня кількість парсерів трохи нижче, наприклад:

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" на потрібний формат.

Я дивився на відповіді і ... зрозумів, що ніхто не думає про номери FLOAT (з крапкою)!

Використання grep теж чудово.
-E означає розширений regexp
-q означає тихий (не лунає)
лунає -qE - це комбінація обох.

Для тестування безпосередньо в командному рядку:

$ 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

Використання 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

Щоб відповідати справедливим цілим числам, використовуйте це:

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

Лише наступні дії до @mary. Але оскільки у мене недостатньо представників, я не міг опублікувати це як коментар до цього допису. У будь-якому випадку, ось що я використав:

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

Функція поверне "1", якщо аргументом є число, інакше поверне "0". Це працює для цілих чисел, а також плавців. Використання - це щось на кшталт:

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]}замінює будь-яку цифру у значенні $iпустим рядком, див man -P 'less +/parameter\/' bash. -zперевіряє, чи є отриманий рядок нульовою довжиною.

якщо ви також хочете виключити випадок, коли $iвін порожній, ви можете використовувати одну з таких конструкцій:

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

Для своєї проблеми мені потрібно було лише переконатися, що користувач випадково не вводить текст, тому я намагався зробити його простим і читабельним

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

На думку чоловічої сторінки, це майже все, що я хочу

Якщо значення виразу не дорівнює нулю, стан повернення дорівнює 0

Щоб запобігти неприємним повідомленням про помилки для рядків, які "можуть бути числами", я ігнорую вихід помилки

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

Старе питання, але я просто хотів зайнятися своїм рішенням. Цей не вимагає жодних дивних хитрощів з оболонками або покладатися на те, що не існувало вічно.

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

В основному він просто видаляє всі цифри з вхідних даних, і якщо вам залишилося рядок з нульовою довжиною, це не було число.

Ще не можу коментувати, тому я додам свою власну відповідь, яка є розширенням до відповіді Глена Джекмана за допомогою відповідності шаблону bash.

Моя первісна потреба полягала в тому, щоб визначити числа та розрізняти цілі числа та поплавці. Визначення функції віднімаються до:

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

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

Я використовував модульне тестування (з shUnit2), щоб перевірити свої шаблони, як працювали:

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

}

Примітки: Шаблон isFloat може бути змінений, щоб він був більш толерантним щодо десяткової крапки ( @(.,)) та символу E ( @(Ee)). Мій блок тестує тестування лише значень, які є цілими чи плаваючими, але не є недійсним введенням.

Я б спробував це:

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

Примітка: це розпізнає nan та inf як число.

Чітку відповідь вже дали @charles Dufy та інші. Чистим розчином баша буде використання наступного:

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

Хоча для дійсних чисел не обов’язково мати число перед точкою радіусу .

Щоб надати більш ретельну підтримку плаваючих чисел та наукових позначень (багато програм у C / Fortran або ще експортуватимуть плавати таким чином), корисним доповненням до цього рядка буде наступне:

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

Таким чином, ведучи до способу диференціювання типів чисел, якщо ви шукаєте конкретний тип:

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

Примітка. Ми можемо перерахувати синтаксичні вимоги до десяткової та наукової нотації, одна з яких повинна дозволити кому як точку радіації, а також ".". Тоді ми б стверджували, що повинна бути лише одна така точка радіусу. У плавці [Ee] може бути два знаки +/-. Я дізнався ще кілька правил з роботи Аулу і перевірив погані рядки, такі як '' '-' '-E-1' '0-0'. Ось мій інструмент regex / substring / expr, який, здається, тримає:

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"

Не забудьте -включити від’ємні цифри!

Цього можна досягти, використовуючи, grepщоб побачити, чи відповідає змінна, про яку йдеться, з розширеним регулярним виразом.

Ціле тест 1120:

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

Вихід: Valid number.

Тест не цілого числа 1120a:

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

Вихід: Error: not a number.

Пояснення

• grep, То -Eперемикач дозволяє використовувати розширені регулярні вирази '^[0-9]+$'. Цей регулярний вираз означає, що змінна повинна []містити лише числа від 0-9нуля до дев'яти від ^початку до $кінця змінної і повинна мати принаймні +один символ.
• grep, То -qперемикач тихо відключає будь-який вихід знаходить він чи ні нічого.
• ifперевіряє стан виходу grep. Статус виходу 0означає успіх, і все, що більше, означає помилку. grepКоманда має статус завершення , 0якщо він знаходить збіг , і 1коли він не робить;

Таким чином, склавши це все разом, в ifтесті ми змінюємо echoзмінну $yournumberі передаємо |її до grepякої з -qперемикачем мовчки відповідає-E розширеним регулярним виразом '^[0-9]+$'вираження. Статус виходу grepбуде, 0якщо grepуспішно знайдено збіг, а 1якщо він не відбувся. Якщо вдалося відповідати, ми echo "Valid number.". Якщо не вдалося збігтися, ми echo "Error: not a number.".

Для поплавців або пар

Ми можемо просто змінити регулярний вираз з '^[0-9]+$'на'^[0-9]*\.?[0-9]+$' для поплавців або двійників.

Тестовий поплавок 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

Вихід: Valid number.

Тестовий поплавок 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

Вихід: Error: not a number.

Для негативів

Щоб дозволити негативні цілі числа, просто змініть регулярний вираз з '^[0-9]+$' на'^\-?[0-9]+$' .

Щоб дозволити негативне плавання чи подвійне значення, просто змініть регулярний вираз з '^[0-9]*\.?[0-9]+$'на '^\-?[0-9]*\.?[0-9]+$'.

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

Ви також можете використовувати класи символів bash.

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

Числові дані включатимуть пробіл, десяткову точку та "e" або "E" для плаваючої точки.

Але, якщо ви вказали шістнадцятковий номер у стилі C, тобто "0xffff" або "0XFFFF", [[: digit:]] повертає значення true. Трохи пастки тут, bash дозволяє вам зробити щось на кшталт "0xAZ00" і все ще вважати це цифрою (хіба це не з якоїсь дивної химерності компіляторів GCC, що дозволяють використовувати позначення 0x для баз, крім 16 ??? )

Ви можете перевірити наявність "0x" або "0X" перед тестуванням, чи є це числовим, якщо ваше введення повністю не довірено, якщо ви не хочете приймати шістнадцяткові числа. Це було б досягнуто:

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

Найпростіший спосіб - перевірити, чи містить він нецифрові символи. Ви замінюєте всі цифри символів нічим і перевіряєте їх довжину. Якщо є довжина, це не число.

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

Як мені довелося останнім часом втручатися в це, і найбільше подобається набір картту з тестовою одиницею. Я переглянув код і додав ще деякі рішення, спробуйте його самі, щоб побачити результати:

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

Так isNumber () включає тире, коми і експоненціальні позначення, і тому повертає TRUE на цілі числа та плавці, де з іншого боку isFloat () повертає FALSE на цілі числа значень, а isInteger () також повертає FALSE на поплавках. Для вашої зручності всі як один вкладиш:

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

Я використовую expr . Він повертає нульове значення, якщо ви спробуєте додати нуль до нечислового значення:

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

Можливо, можна використовувати bc, якщо вам потрібні не цілі числа, але я не вірю, що bcмає таку саму поведінку. Додавання нуля до нечислового значення отримує нуль, і воно також повертає значення нуля. Можливо, ви можете комбінувати bcі expr. Використовуйте, bcщоб додати нуль до $number. Якщо відповідь є 0, спробуйте exprпереконатися, що $numberце не нуль.

Мені подобається відповідь Альберто Закканні.

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

Важливі передумови: - не породжуються підзаголовки - не викликаються RE-парсери - більшість програм оболонки не використовують реальні номери

Але якщо $varскладний (наприклад, доступ до асоціативного масиву) і якщо число буде невід'ємним цілим числом (більшість випадків використання), то це, можливо, є більш ефективним?

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

Я використовую printf в якості інших згаданих відповідей, якщо ви надаєте рядок формату "% f" або "% i" printf зробить перевірку за вас. Простіше, ніж винаходити чеки, синтаксис простий і короткий, а printf - всюдисущий. Отже, на мій погляд, це гідний вибір - ви також можете використати наступну ідею, щоб перевірити наявність речей, корисних не лише для перевірки номерів.

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

баш регулярне вираження vsбаш розширення параметра

Як відповідь Чарльза Даффі працює, але тільки використовуватибашрегулярний вираз , і я знаю, що це повільно, я хотів би показати інший спосіб, використовуючи лишебашРозширення параметра :

Лише для додатних цілих чисел:

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

Для цілих чисел:

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

Потім для плаваючого:

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

Щоб відповідати початковому запиту:

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

Тепер невелике порівняння:

Існує така ж перевірка, заснована на відповіді Чарльза Даффі :

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

Деякі тести:

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

Гаразд, це добре. Тепер скільки часу займе все це (На моєму малиновому пі):

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

Потім з регулярними виразами:

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

Щоб зловити від’ємні числа:

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

Ви можете також використовувати "нехай":

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

Але я вважаю за краще використовувати оператор "= ~" Bash 3+, як деякі відповіді в цій темі.

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

Видаліть -\?узор відповідності grep, якщо ви не приймаєте від'ємне ціле число.

Зробив те саме тут із регулярним виразом, який перевіряє всю частину та десяткову частину, розділену крапкою.

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

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

Я використовую наступне (для цілих чисел):

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

Я спробував рецепт ультразйомки, як це здалося мені найбільш практичним, і не міг змусити його працювати. Зрештою, я придумав інший спосіб, хоча, заснований як інші на заміні параметрів, цього разу із заміною регулярних виразів:

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

Він видаляє кожен: digit: символ класу в $ var і перевіряє, чи залишилися ми з порожнім рядком, тобто в оригіналі були лише числа.

Що мені подобається в цьому, є його невеликий слід і гнучкість. У цій формі він працює лише для необмежених базових 10 цілих чисел, хоча, безумовно, ви можете використовувати відповідність шаблону, щоб відповідати іншим потребам.

Швидке та брудне: я знаю, що це не найелегантніший спосіб, але я зазвичай просто додаю нуль і перевіряю результат. так:

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 або бомбу, якщо $ 1 НЕ ціле число. наприклад:

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
}

ПРИМІТКА: Я думаю, я ніколи не думав перевіряти наявність поплавців чи змішаних типів, які зроблять всю скрипт-бомбу ... в моєму випадку я не хотів, щоб вона йшла далі. Я пограю з рішенням mrucci і регексом Даффі - вони здаються найбільш надійними в рамках башу ...