Просто продолжение @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")

Этого можно добиться, используя 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]+$'.

Старый вопрос, но я просто хотел остановиться на своем решении. Этот не требует каких-либо странных уловок с оболочкой и не полагается на то, чего не было вечно.

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

По сути, он просто удаляет все цифры из ввода, и если у вас осталась строка ненулевой длины, то это не было числом.

Я бы попробовал это:

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

Примечание: это распознает nan и inf как числа.

Пока не могу комментировать, поэтому я добавлю свой собственный ответ, который является расширением ответа Гленна Джекмана с использованием сопоставления с шаблоном 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)). Мои модульные тесты проверяют только значения, которые являются целыми или плавающими, но не содержат недопустимые входные данные.

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

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"

Не забывайте - включать отрицательные числа!

Я использую 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 не равно нулю.

Поскольку мне пришлось вмешиваться в это в последнее время, и мне больше всего нравится приложение karttu с модульным тестом. Я отредактировал код и добавил еще несколько решений, попробуйте сами, чтобы увидеть результаты:

#!/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 () включает дефисы, запятые и экспоненциальную нотацию и поэтому возвращает ИСТИНА для целых чисел и чисел с плавающей запятой, тогда как, с другой стороны, isFloat () возвращает ЛОЖЬ для целочисленных значений и 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; }

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:]] вернет истину. Здесь небольшая ловушка, bash позволяет вам делать что-то вроде "0xAZ00" и при этом считать это цифрой (разве это не из-за какой-то странной причуды компиляторов GCC, которые позволяют вам использовать нотацию 0x для оснований, отличных от 16 ??? )

Возможно, вы захотите проверить "0x" или "0X" перед проверкой, является ли это числовым, если ваш ввод полностью ненадежен, если вы не хотите принимать шестнадцатеричные числа. Этого можно добиться за счет:

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

Я использую 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; }

Самый простой способ - проверить, не содержит ли он нецифровых символов. Вы заменяете все цифровые символы ничем и проверяете длину. Если есть длина, это не число.

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

Мне нравится ответ Альберто Закканьи.

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

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

Но если $var является сложным (например, доступ к ассоциативному массиву), и если число будет неотрицательным целым числом (в большинстве случаев использования), то это, возможно, более эффективно?

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

Чтобы поймать отрицательные числа:

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

Вы также можете использовать "let" вот так:

[ ~]$ 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: class в $ 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 и регулярным выражением Duffy - они кажутся наиболее надежными в рамках bash ...

Нашел довольно короткую версию:

function isnum()
{
    return `echo "$1" | awk -F"\n" '{print ($0 != $0+0)}'`
}

• переменная для проверки

  number=12345 or number=-23234 or number=23.167 or number=-345.234

• проверьте числовой или нечисловой

  echo $number | grep -E '^-?[0-9]*\.?[0-9]*$' > /dev/null

• принять решение о дальнейших действиях на основании статуса выхода из вышеуказанного

  if [ $? -eq 0 ]; then echo "Numeric"; else echo "Non-Numeric"; fi

Продолжая ответ Дэвида В. от октября 2013 г., при использовании expr это может быть лучше

test_var=`expr $am_i_numeric \* 0` >/dev/null 2>&1
if [ "$test_var" = "" ]
then
    ......

Если числовой, умноженный на 1, вы получите то же значение (включая отрицательные числа). В противном случае вы получите null, который можно проверить на

Синтаксис почти такой, как вы хотите. Просто нужна функция isnumber:

#!/usr/bin/bash

isnumber(){
  num=$1
  if [ -z "${num##*[!0-9]*}" ]; 
    then return 1
  else
    return 0
  fi
}

$(isnumber $1) && VAR=$1 || echo "need a number";
echo "VAR is $VAR"

тестовое задание:

$ ./isnumtest 10
VAR is 10
$ ./isnumtest abc10
need a number
VAR is 

Простое для понимания и совместимое решение с командой test:

test $myVariable -eq 0 2>/dev/null
if [ $? -le 1 ]; then echo 'ok'; else echo 'KO'; fi

Если myVariable = 0, код возврата - 0
Если myVariable ›0, код возврата - 1
Если myVariable не целое число, код возврата - 2

Принятый ответ не работал у меня во всех случаях BASH 4+, поэтому:

# -- is var an integer? --
# trim leading/trailing whitespace, then check for digits return 0 or 1
# Globals: None
# Arguments: string
# Returns: boolean
# --
is_int() {
    str="$(echo -e "${1}" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')"
    case ${str} in ''|*[!0-9]*) return 1 ;; esac
    return 0
}

Как это использовать ?

Действителен (вернет 0 = истина):

is_int "100" && echo "return 0" || echo "return 1"

Неверно (вернет 1 = ложь):

is_int "100abc" && echo "returned 0" || echo "returned 1"
is_int ""  && echo "returned 0" || echo "returned 1"
is_int "100 100"  && echo "returned 0" || echo "returned 1"
is_int "      "  && echo "returned 0" || echo "returned 1"
is_int $NOT_SET_VAR  && echo "returned 0" || echo "returned 1"
is_int "3.14"   && echo "returned 0" || echo "returned 1"

Выход:

returned 0
returned 1
returned 1
returned 1
returned 1
returned 1
returned 1

обратите внимание, в Bash 1 = false, 0 = true. Я просто распечатываю его там, где более вероятно что-то вроде этого:

if is_int ${total} ; then
    # perform some action 
fi

Принятый ответ здесь не работает, я использую MacOS. Следующий код работает:

if [ $(echo "$number" | grep -c '^[0-9]\+$') = 0 ]; then 
    echo "it is a number"
else
    echo "not a number"
fi

Стек выскочил, и меня спросили, действительно ли я хочу ответить после 30+ ответов? Но конечно!!! Используйте новые функции bash, и вот они: (после комментария я внес изменения)

function isInt () {([[$ 1 -eq $ (($ 1 + 0))]] 2> / dev / null && [[$ 1! = '']] && echo 1) || эхо ''}

function isInt() {
   ([[ $1 =~ ^[-+0-9]+$  ]] && [[ $1 -eq $(( $1 + 0 )) ]] 2>/dev/null && [[ $1 != '' ]] && echo 1) || echo ''
}

Поддерживает:

===============out-of-the-box==================
 1. negative integers (true & arithmetic),
 2. positive integers (true & arithmetic),
 3. with quotation (true & arithmetic),
 4. without quotation (true & arithmetic),
 5. all of the above with mixed signs(!!!) (true & arithmetic),
 6. empty string (false & arithmetic),
 7. no value (false & arithmetic),
 8. alphanumeric (false & no arithmetic),
 9. mixed only signs (false & no arithmetic),
================problematic====================
 10. positive/negative floats with 1 decimal (true & NO arithmetic),
 11. positive/negative floats with 2 or more decimals (FALSE & NO arithmetic).

Истина / ложь - это то, что вы получаете от функции только при использовании в сочетании с подстановкой процесса, как в [[ $( isInt <arg> ) ]], поскольку в bash нет логического типа и return значение функции.