Как проверить, является ли переменная числом в Bash?

600

Я просто не могу понять, как сделать так, чтобы аргумент, передаваемый моему сценарию, был числом или нет.

Все, что я хочу сделать, это что-то вроде этого:

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

Любая помощь?

Flávio Amieiro
источник
17
Кроме того - у используемого test && echo "foo" && exit 0 || echo "bar" && exit 1вами подхода могут быть некоторые непреднамеренные побочные эффекты - если эхо не выполнится (возможно, вывод на закрытый FD), exit 0он будет пропущен, а затем попытается выполнить код echo "bar". Если и при этом &&произойдет сбой, условие не будет выполнено и даже не выполнится exit 1! Использование реальных ifутверждений, а не &&/ ||менее подвержено неожиданным побочным эффектам.
Чарльз Даффи
@CharlesDuffy Это действительно умное мышление, к которому большинство людей приходят, только когда им приходится выслеживать волосатых жуков ...! Я никогда не думал, что эхо может вернуть неудачу.
Камило Мартин
6
Немного опоздал на вечеринку, но я знаю об опасностях, о которых писал Чарльз, так как мне пришлось пережить их довольно давно. Итак, вот вам 100% надежная (и хорошо читаемая) строка для вас: [[ $1 =~ "^[0-9]+$" ]] && { echo "number"; exit 0; } || { echo "not a number"; exit 1; }фигурные скобки указывают, что вещи НЕ должны выполняться в подоболочке (что определенно будет так, если ()вместо этого использовать круглые скобки). Предостережение: никогда не пропускайте последнюю точку с запятой . В противном случае вы можете bashраспечатать самые уродливые (и самые бессмысленные) сообщения об ошибках ...
syntaxerror
5
Это не работает в Ubuntu, если вы не удалите кавычки. Так и должно быть[[ 12345 =~ ^[0-9]+$ ]] && echo OKKK || echo NOOO
Тревиньо
4
Вы должны быть более конкретными о том, что вы подразумеваете под «числом» . Целое число? Число с фиксированной точкой? Научная ("е") запись? Существует ли требуемый диапазон (например, 64-разрядное значение без знака), или вы разрешаете писать любое число?
Тоби Спейт

Ответы:

804

Один из подходов заключается в использовании регулярного выражения, например так:

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

Если значение не обязательно является целым числом, попробуйте соответствующим образом изменить регулярное выражение; например:

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

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

^[+-]?[0-9]+([.][0-9]+)?$
Чарльз Даффи
источник
7
+1 для этого подхода, но будьте осторожны с десятичными числами, выполняя этот тест, например, с ошибкой «1.0» или «1,0»: «Не число».
sourcerebels
15
Я нашел '' exec> & 2; эхо ... '' довольно глупо. Просто '' эхо ...> & 2 ''
1
5
@Ben вы действительно хотите обрабатывать более одного знака минус? Я бы сделал это ^-?лучше, чем ^-*если вы на самом деле не выполняете работу по правильной обработке нескольких инверсий.
Чарльз Даффи
4
@SandraSchlichting Заставляет весь будущий вывод идти в stderr. Здесь нет особого смысла, когда есть только одно эхо, но это привычка, к которой я стремлюсь, в случаях, когда сообщения об ошибках занимают несколько строк.
Чарльз Даффи
29
Я не уверен, почему регулярное выражение должно быть сохранено в переменной, но если это ради совместимости, я не думаю, что это необходимо. Вы можете просто применить выражение непосредственно: [[ $yournumber =~ ^[0-9]+$ ]].
konsolebox
284

Без башмизмов (работает даже в Системе В Ш),

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

Это отклоняет пустые строки и строки, содержащие не-цифры, принимая все остальное.

Отрицательные числа или числа с плавающей точкой требуют дополнительной работы. Идея состоит в том, чтобы исключить -/ .в первом «плохом» шаблоне и добавить больше «плохих» шаблонов, содержащих их ненадлежащее использование ( ?*-*/ *.*.*)

jilles
источник
20
+1 - это идиоматичный, переносимый способ возврата к исходной оболочке Bourne, со встроенной поддержкой подстановочных знаков в стиле glob. Если вы пришли из другого языка программирования, это выглядит жутко, но это гораздо элегантнее, чем справляться с хрупкостью различных проблем цитирования и бесконечными проблемами обратной / боковой совместимости сif test ...
tripleee
6
Вы можете изменить первую строку на ${string#-}(которая не работает в античных оболочках Борна, но работает в любой оболочке POSIX), чтобы принимать отрицательные целые числа.
Жиль "ТАК - перестань быть злым"
4
Кроме того, это легко распространить на поплавки - просто добавьте '.' | *.*.*запрещенные шаблоны и добавьте точку к разрешенным символам. Точно так же вы можете разрешить дополнительный знак раньше, хотя тогда я предпочел case ${string#[-+]}бы просто игнорировать знак.
tripleee
Смотрите это для обработки целых чисел со знаком
Никлас Питер
2
@Dor Кавычки не нужны, так как команда case в любом случае не выполняет разбиение слов и генерацию пути к этому слову. (Тем не менее, для расширений в случае шаблонов может потребоваться
заключить в кавычки,
193

Следующее решение также можно использовать в базовых оболочках, таких как Bourne, без необходимости использования регулярных выражений. В основном любые операции вычисления числовых значений, использующие не числа, приведут к ошибке, которая будет неявно рассматриваться как ложная в оболочке:

"$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")
Альберто Закканьи
источник
8
Я все еще рекомендую это (но с переменными в кавычках, чтобы учесть пустые строки), так как результат гарантированно будет использоваться как число в Bash, несмотря ни на что.
10
21
Будьте осторожны, чтобы использовать одинарные скобки; [[ a -eq a ]]оценивается как истина (оба аргумента конвертируются в ноль)
Tgr
3
Очень хорошо! Обратите внимание, что это работает только для целого числа, а не для любого числа. Мне нужно было проверить один аргумент, который должен быть целым числом, так что это сработало хорошо:if ! [ $# -eq 1 -o "$1" -eq "$1" ] 2>/dev/null; then
haridsv
6
Я бы настоятельно рекомендовал не использовать этот метод из-за немалого числа оболочек, чьи [встроенные функции будут оценивать аргументы как арифметические. Это верно как для ksh93, так и для mksh. Кроме того, поскольку оба этих массива поддерживают, существует легкая возможность для внедрения кода. Вместо этого используйте сопоставление с образцом.
ormaaj
3
@AlbertoZaccagni, в текущих выпусках bash эти значения интерпретируются с правилами числового контекста только для, [[ ]]но не для [ ]. Тем не менее, это поведение не определено ни стандартом POSIX для, ни testв собственной документации bash; будущие версии bash могут изменить поведение, чтобы соответствовать ksh, не нарушая никаких задокументированных поведенческих обещаний, поэтому уверенность в том, что его текущее поведение сохраняется, не гарантированно безопасна.
Чарльз Даффи
43

Это проверяет, является ли число неотрицательным целым числом и является ли оно независимым от оболочки (то есть без башизмов), и использует только встроенные функции оболочки:

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

Поскольку этот первый ответ (ниже) допускает целые числа с символами в них, пока первые не являются первыми в переменной.

[ -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";
mrucci
источник
5
Это не работает должным образом, оно принимает любую строку, начинающуюся с цифры. Обратите внимание, что WORD в $ {VAR ## WORD} и аналогичных ему является шаблоном оболочки, а не регулярным выражением.
Джилл
2
Можете ли вы перевести это выражение на английский, пожалуйста? Я действительно хочу использовать это, но я не понимаю этого достаточно, чтобы доверять этому, даже после просмотра страницы руководства bash.
CivFan
2
*[!0-9]*это шаблон, который соответствует всем строкам, по крайней мере, с 1 нецифровым символом. ${num##*[!0-9]*}это «расширение параметра», где мы берем содержимое numпеременной и удаляем самую длинную строку, которая соответствует шаблону. Если результат раскрытия параметра не пустой ( ! [ -z ${...} ]), то это число, так как оно не содержит нецифровых символов.
Mrucci
К сожалению, это не работает, если в аргументе есть цифры, даже если это недопустимое число. Например, «exam1ple» или «a2b».
Studgeek
Оба терпят неудачу с122s :-(
Hastur
40

Никто не предложил расширенное сопоставление с образцом в bash :

[[ $1 == ?(-)+([0-9]) ]] && echo "$1 is an integer"
Гленн Джекман
источник
5
Гленн, я удалить shopt -s extglobиз вашего поста (что я upvoted, это одна из моих любимых ответов здесь), так как в условных конструктах вы можете прочитать: Когда ==и !=используются операторы, строка справа оператора считается образцом и соответствием согласно правилам, описанным ниже в Pattern Matching , как если бы extglobопция оболочки была включена. Надеюсь, ты не против!
gniourf_gniourf
В таких условиях вам не нужно shopt extglob... это хорошо знать!
gniourf_gniourf
Хорошо работает для простых целых чисел.
2
@Jdamian: вы правы, это было добавлено в Bash 4.1 (который был выпущен в конце 2009 года… Bash 3.2 был выпущен в 2006 году… теперь это античное программное обеспечение, извините за тех, кто застрял в прошлом). Кроме того, вы можете утверждать, что extglobs были введены в версии 2.02 (выпущенной в 1998 году) и не работают в версиях <2.02 ... Теперь ваш комментарий послужит предупреждением относительно более старых версий.
gniourf_gniourf
1
Переменные внутри [[...]]не подлежат разделению слов или расширению глобуса.
Гленн Джекман
26

Я удивлен решениями, непосредственно разбирающими числовые форматы в оболочке. shell не очень подходит для этого, поскольку является 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» на тот формат, который вам требуется.

pixelbeat
источник
4
isnumber(){ printf '%f' "$1" &>/dev/null && echo "this is a number" || echo "not a number"; }
Жиль Квено
4
@sputnick ваша версия нарушает внутреннюю (и полезную) семантику возвращаемого значения исходной функции. Поэтому вместо этого просто оставьте функцию как есть и используйте ее:isnumber 23 && echo "this is a number" || echo "not a number"
Майкл
4
Разве это не должно иметь 2>/dev/null, чтобы isnumber "foo"не загрязнять stderr?
Джоеле
4
Называть современные оболочки, такие как bash, «DSL для управления файлами и процессами» - значит игнорировать то, что они используются для чего-то большего - некоторые дистрибутивы построили на нем целые менеджеры пакетов и веб-интерфейсы (какими бы уродливыми они ни были). Пакетные файлы соответствуют вашему описанию, хотя даже установка переменной там затруднительна.
Камило Мартин
7
Забавно, что ты пытаешься быть умным, копируя некоторые идиомы с других языков. К сожалению, это не работает в оболочках. Оболочки очень особенные, и, не зная о них, вы, скорее всего, напишите неработающий код. Ваш код не работает: isnumber "'a"вернет true. Это задокументировано в спецификации POSIX, где вы прочтете: если начальный символ - одинарная или двойная кавычка, значение должно быть числовым значением в базовом наборе кодов символа, следующего за одинарной или двойной кавычкой. ,
gniourf_gniourf
16

Я смотрел на ответы и ... понял, что никто не думал о числах FLOAT (с точкой)!

Использование grep тоже замечательно.
-E означает расширенное регулярное выражение
-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

Чтобы соответствовать JUST целым числам, используйте это:

# change check line to:
check=`echo "$1" | grep -E ^\-?[0-9]+$`
Серхио Абреу
источник
Решения, использующие awk by triple_r и tripleee, работают с поплавками.
Кен Джексон
Спасибо за это и очень хороший момент! Потому что вопрос в том, как проверить, является ли это число, а не целое число.
Танасис
Я тоже благодарю вас, Танасис! Давайте помогать друг другу всегда.
Серхио Абреу
12

Просто продолжение до @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
triple_r
источник
4
Печать номера менее полезна, чем установка кода выхода. 'BEGIN { exit(1-(a==a+0)) }'немного трудно , но обращали внимание может быть использован в функции , которая возвращает истину или ложь так же , как [, grep -qи т.д.
tripleee
9
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
user2683246
источник
Недурно специально для man -P 'less +/parameter\/' bashчасти. Узнавать что-то новое каждый день. :)
Дэвид
@sjas Вы можете легко добавить \-регулярное выражение для решения проблемы. Используйте [0-9\-\.\+]для учета поплавков и подписанных номеров.
user2683246
@sjas ок, моя вина
user2683246
@sjasecho $i | python -c $'import sys\ntry:\n float(sys.stdin.read().rstrip())\nexcept:\n sys.exit(1)' && echo yes || echo no
user2683246
9

Для моей проблемы мне нужно было только убедиться, что пользователь случайно не введет какой-то текст, поэтому я старался сделать его простым и читабельным

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

Согласно справочной странице это в значительной степени делает то, что я хочу

Если значение выражения не равно нулю, возвращаемое состояние равно 0

Чтобы предотвратить неприятные сообщения об ошибках для строк, которые могут быть числами, я игнорирую вывод ошибок

$ (( 2s ))
bash: ((: 2s: value too great for base (error token is "2s")
Hachi
источник
Это больше похоже на isInteger. Но здорово, спасибо!
Нахил
8

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

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

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

Sammitch
источник
Это не для пустой var.
gniourf_gniourf
Или для переменных с завершающими символами новой строки или что-то в этом роде $'0\n\n\n1\n\n\n2\n\n\n3\n'.
gniourf_gniourf
7

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

karttu
источник
Извините, не понял, как должна использоваться функция редактирования.
3ronco
6

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

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

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

переполненный
источник
2
или дубликат, или, возможно, лучше подходит как комментарий к ответу pixelbeat (в %fлюбом случае лучше использовать)
Майкл
3
Вместо того, чтобы проверять предыдущий код состояния, почему бы просто не поместить его в ifсебя? Вот что ifзначит ...if printf "%g" "$var" &> /dev/null; then ...
Камило Мартин
3
Это имеет другие предостережения. Это проверит пустую строку и строки вроде 'a.
gniourf_gniourf
6

Четкий ответ уже дали @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 или иначе будут экспортировать float таким способом), полезным дополнением к этой строке будет следующее:

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
Aulo
источник
6
[[ $1 =~ ^-?[0-9]+$ ]] && echo "number"

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

D_i
источник
Какая минимальная версия bash? Я просто получаю bash: условный двоичный оператор, ожидаемый bash: синтаксическая ошибка рядом с неожиданным токеном `= ~ '
Пол Харгривз
1
@PaulHargreaves =~существовал по крайней мере еще в bash 3.0.
Жиль "ТАК ... перестать быть злым"
@PaulHargreaves, что у вас, вероятно, была проблема с вашим первым операндом, например, слишком много кавычек или тому подобное
Джошуа Клейтон,
@JoshuaClayton Я спросил о версии, потому что это очень старая версия bash для Solaris 7, которую мы до сих пор имеем и не поддерживаем = ~
Пол Харгривз
6

Это может быть достигнуто с помощью 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]+$'для float или double.

Тест поплавок 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]+$'.

Джозеф Ши
источник
Вы правы, @CharlesDuffy. Спасибо. Я убрал ответ.
Иосиф Ши
Верно, ты снова, @CharlesDuffy. Исправлена!
Джозеф Ши
1
LGTM; Ответ отредактирован имеет +1. Единственные вещи, которые я бы сделал по-другому на данном этапе, это просто вопросы мнения, а не правильности (f / e, использование [-]вместо \-и [.]вместо \.немного более многословно, но это означает, что ваши строки не должны изменяться, если они ' используется в контексте, где обратные слеши потребляются).
Чарльз Даффи
4

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

Числа включают пробел, десятичную точку и «е» или «Е» для числа с плавающей запятой.

Но если вы укажете шестнадцатеричное число в стиле 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
ultrasawblade
источник
17
[[ $VAR = *[[:digit:]]* ]]возвращает истину , если переменная содержит число, только если это не является целым числом.
Гленн Джекман
[[ "z3*&" = *[[:digit:]]* ]] && echo "numeric"отпечатки numeric. Протестировано в Bash версии 3.2.25(1)-release.
Jdamian
1
@ultraswadable, ваше решение обнаруживает строки, содержащие, по крайней мере, одну цифру, окруженную (или нет) любыми другими символами. Я понизил.
Дждамян
Поэтому очевидно правильный подход состоит в том, чтобы обратить это вспять и использовать[[ -n $VAR && $VAR != *[^[:digit:]]* ]]
eschwartz
@eschwartz, ваше решение не работает с отрицательными числами
Angel
4

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

if [[ ! -n ${input//[0-9]/} ]]; then
    echo "Input Is A Number"
fi
Энди
источник
2
Для обработки отрицательных чисел потребуется более сложный подход.
Энди
... или необязательный положительный знак.
tripleee
@tripleee Я хотел бы увидеть ваш подход, если вы знаете, как это сделать.
Энди
4

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

#!/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; }
3ronco
источник
Лично я удалил бы functionключевое слово, поскольку оно не делает ничего полезного. Кроме того, я не уверен насчет полезности возвращаемых значений. Если не указано иное, функции будут возвращать состояние выхода последней команды, поэтому вам ничего не нужно returnсамостоятельно.
Том Фенек
Хорошо, действительно, returnони сбивают с толку и делают его менее читабельным. Использование functionключевых слов или нет - это больше вопрос личного вкуса, по крайней мере, я убрал их из одних строк, чтобы сэкономить место. Спасибо.
3ronco
Не забывайте, что точки с запятой нужны после тестов для однострочных версий.
Том Фенек
2
isNumber вернет 'true' для любой строки, в которой есть число.
DrStrangepork
@DrStrangepork Действительно, в моем массиве false_values ​​отсутствует этот случай. Я буду смотреть на это. Спасибо за подсказку.
3ronco
4

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

Дэвид В.
источник
1
Это довольно плохо. Чтобы сделать это немного лучше, вы должны использовать expr -- "$number" + 0; все же это все еще притворится 0 isn't a number. От man expr:Exit status is 0 if EXPRESSION is neither null nor 0, 1 if EXPRESSION is null or 0,
gniourf_gniourf
3

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

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

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

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

if [ "$var" -ge 0 ] 2> /dev/null; then ..
user3895088
источник
2

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


источник
2

регулярное выражение против расширение параметра

Как работают ответы Чарльза Даффи , но используют толькорегулярное выражение , и я знаю, что это медленно, я хотел бы показать другой способ, используя толькорасширение параметра :

Только для натуральных чисел:

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
Ф. Хаури
источник
Я согласен, во всяком случае, я предпочитаю не использовать регулярные выражения, когда я мог бы использовать расширение параметров ... Злоупотребление RE замедлит сценарий bash
Ф. Хаури
Отредактированный ответ: Нет необходимости extglob(и немного быстрее)!
Ф. Хаури
@CharlesDuffy, На моем Raspberry Pi 1000 итераций займут 2,5 секунды в моей версии и 4,4 секунды в вашей версии!
Ф. Хаури
С этим не поспоришь. Charles
Чарльз Даффи
1

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

if [[ $1 == ?(-)+([0-9.]) ]]
    then
    echo number
else
    echo not a number
fi
user28490
источник
Кроме того, для этого необходимо сначала включить расширенную глобализацию. Это функция только для Bash, которая по умолчанию отключена.
tripleee
Расширенное глобирование @tripleee активируется автоматически при использовании == или! = When the ‘==’ and ‘!=’ operators are used, the string to the right of the operator is considered a pattern and matched according to the rules described below in Pattern Matching, as if the extglob shell option were enabled. gnu.org/software/bash/manual/bashref.html#index-_005b_005b
Бадр Элмерс
@BadrElmers Спасибо за обновление. Кажется, это новое поведение, которое не соответствует действительности в моем Bash 3.2.57 (MacOS Mojave). Я вижу, что это работает, как вы описали в 4.4.
трипл
1

Вы можете использовать «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+, как некоторые ответы в этой теме.

Идрисс Нойманн
источник
5
Это очень опасно. Не оценивайте непроверенную арифметику в оболочке. Это должно быть проверено другим способом в первую очередь.
ormaaj
1
printf '%b' "-123\nABC" | tr '[:space:]' '_' | grep -q '^-\?[[:digit:]]\+$' && echo "Integer." || echo "NOT integer."

Удалите -\?шаблон сопоставления in grep, если вы не принимаете отрицательное целое число.

Ане Диджитак
источник
2
Даунвот за отсутствие объяснений. Как это работает? Он выглядит сложным и хрупким, и неясно, какие именно данные он примет. (Например, действительно ли необходимо удалить пробелы? Почему? Он скажет, что число со встроенными пробелами является допустимым числом, что может быть нежелательно.)
tripleee
1

Сделали то же самое здесь с регулярным выражением, которое проверяет всю часть и десятичную часть, разделенные точкой.

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

if [[ $1 =~ $re ]] 
then
   echo "is numeric"
else
  echo "Naahh, not numeric"
fi
Джером
источник
Не могли бы вы объяснить, почему ваш ответ в корне отличается от других старых ответов, например, ответа Чарльза Даффи? Ну, ваш ответ на самом деле не работает, поскольку он проверяет один период.
gniourf_gniourf
Я не уверен, что понимаю единственный период здесь ... это один или нулевой период, ожидаемый .... Но верно, ничего принципиально иного, просто нашел регулярное выражение легче для чтения.
Джером
также использование * должно соответствовать большему количеству реальных случаев
Джером
Дело в том, что вы сопоставляете пустую строку a=''и строку, содержащую только точку, a='.'поэтому ваш код немного сломан ...
gniourf_gniourf
0

Я использую следующее (для целых чисел):

## ##### 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
Marnix
источник
Почти правильно (вы принимаете пустую строку), но излишне сложно до такой степени запутывать.
Жиль "ТАК - перестань быть злым"
2
Неправильно: вы принимаете -nи т. Д. (Из-за echo), и вы принимаете переменные с завершающими символами новой строки (из-за $(...)). И, кстати, printне является допустимой командой оболочки.
gniourf_gniourf
0

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

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

Он удаляет каждый символ: digit: class в $ var и проверяет, остались ли у нас пустые строки, что означает, что оригинал был только числами.

Что мне нравится в этом, так это его небольшой размер и гибкость. В этой форме он работает только для целых 10 без разделителей, хотя, безусловно, вы можете использовать сопоставление с образцом, чтобы удовлетворить его другим потребностям.

ата
источник
Читая решение mrucci, оно выглядит почти так же, как мое, но с использованием обычной замены строк вместо «стиля sed». Оба используют одинаковые правила для сопоставления с образцом и, AFAIK, являются взаимозаменяемыми решениями.
ата
sedэто POSIX, а ваше решение есть bash. Оба имеют свое применение
v010dya
0

Quick & Dirty: я знаю, что это не самый элегантный способ, но я обычно просто добавляю ноль к нему и проверяю результат. вот так:

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 и регулярным выражением Даффи - они кажутся наиболее надежными в рамках bash ...

WWWIZARDS
источник
4
Это принимает арифметические выражения как 1+1, но отклоняет некоторые натуральные числа с ведущими 0s (потому что 08это недопустимая восьмеричная константа).
Жиль "ТАК - перестань быть злым"
2
Это и другие вопросы тоже: 0не число, и оно подлежит произвольному инъекции коды, попробуйте: isInteger 'a[$(ls)]'. По электронной почте Ой.
gniourf_gniourf
1
И расширение не заключено $((...))в кавычки, число IFS=123изменит его.
Исаак