Проверить, является ли строка допустимым целым числом

Я пытаюсь сделать что-то достаточно распространенное: анализировать вводимые пользователем данные в сценарии оболочки. Если пользователь предоставил действительное целое число, сценарий выполняет одно действие, а если он недопустим, - другое. Проблема в том, что я не нашел простого (и достаточно элегантного) способа сделать это - я не хочу, чтобы ему приходилось разбирать char на char.

Я знаю, что это должно быть легко, но не знаю как. Я мог бы сделать это на десятке языков, но не на БАШЕ!

В своем исследовании я обнаружил следующее:

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

И там есть ответ, в котором говорится о регулярном выражении, но, насколько я знаю, эта функция доступна в C (среди прочего). Тем не менее, это выглядело как отличный ответ, поэтому я попробовал его с помощью grep, но grep не знал, что с ним делать. Я попробовал -P, что на моем поле означает рассматривать его как регулярное выражение PERL - нада. Dash E (-E) тоже не работал. И -F тоже.

Чтобы быть ясным, я пробую что-то подобное, ищу какой-либо вывод - оттуда я взламываю сценарий, чтобы использовать все, что я получаю. (IOW, я ожидал, что несоответствующий ввод ничего не вернет, а действительная строка будет повторяться.)

snafu=$(echo "$2" | grep -E "/^[-+]?(?:\.[0-9]+|(?:0|[1-9][0-9]*)(?:\.[0-9]*)?)$/")
if [ -z "$snafu" ] ;
then
   echo "Not an integer - nothing back from the grep"
else
   echo "Integer."
fi

Не могли бы вы проиллюстрировать, как это проще всего сделать?

Честно говоря, это, на мой взгляд, недостаток TEST. У него должен быть такой флаг

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

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

• Значок ^указывает на начало входного шаблона.
• -Является буквальным «-»
• В ?означает «0 или 1 из предшествующего ( -)»
• Эти +средства «1 или более из предшествующих ( [0-9])»
• Значок $указывает на конец входного шаблона

Таким образом, регулярное выражение соответствует необязательному -(в случае отрицательных чисел), за которым следует одна или несколько десятичных цифр.

Ссылки :

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

Ух ты ... тут столько хороших решений !! Из всех вышеперечисленных решений я согласен с @nortally, что использование -eqодного лайнера - самое крутое.

Я запускаю GNU bash, версия 4.1.5 (Debian). Я также проверял это на ksh (SunSO 5.10).

Вот моя версия проверки, $1является ли целое число или нет:

if [ "$1" -eq "$1" ] 2>/dev/null
then
    echo "$1 is an integer !!"
else
    echo "ERROR: first parameter must be an integer."
    echo $USAGE
    exit 1
fi

Этот подход также учитывает отрицательные числа, которые в некоторых других решениях будут иметь ошибочный отрицательный результат, и он позволит использовать префикс «+» (например, +30), который, очевидно, является целым числом.

Полученные результаты:

$ int_check.sh 123
123 is an integer !!

$ int_check.sh 123+
ERROR: first parameter must be an integer.

$ int_check.sh -123
-123 is an integer !!

$ int_check.sh +30
+30 is an integer !!

$ int_check.sh -123c
ERROR: first parameter must be an integer.

$ int_check.sh 123c
ERROR: first parameter must be an integer.

$ int_check.sh c123
ERROR: first parameter must be an integer.

Решение, предоставленное Игнасио Васкес-Абрамсом, также было очень аккуратным (если вам нравится регулярное выражение) после того, как оно было объяснено. Однако он не обрабатывает положительные числа с +префиксом, но его легко исправить, как показано ниже:

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

Опоздавший на вечеринку здесь. Я очень удивлен, что ни в одном из ответов не упоминается самое простое, быстрое и портативное решение; caseзаявление.

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

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

Мне нравится решение, использующее -eqтест, потому что оно в основном однострочное.

Мое собственное решение заключалось в том, чтобы использовать расширение параметров, чтобы выбросить все цифры и посмотреть, осталось ли что-нибудь. (Я все еще использую 3.0, не использовал [[и exprраньше, но рад их встретить.)

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

Для переносимости на pre-Bash 3.1 (когда =~был представлен тест) используйте expr.

if expr "$string" : '-\?[0-9]\+$' >/dev/null
then
  echo "String is a valid integer."
else
  echo "String is not a valid integer."
fi

expr STRING : REGEXищет REGEX, закрепленный в начале STRING, повторяя первую группу (или длину совпадения, если нет) и возвращая успех / неудачу. Это старый синтаксис регулярных выражений, отсюда и его избыток \. -\?означает «может быть -», [0-9]\+означает «одну или несколько цифр» и $означает «конец строки».

Bash также поддерживает расширенные глобусы, хотя я не помню, с какой версии и далее.

shopt -s extglob
case "$string" of
    @(-|)[0-9]*([0-9]))
        echo "String is a valid integer." ;;
    *)
        echo "String is not a valid integer." ;;
esac

# equivalently, [[ $string = @(-|)[0-9]*([0-9])) ]]

@(-|)означает « -или ничего», [0-9]означает «цифру» и *([0-9])означает «ноль или более цифр».

Вот еще один вариант (только с использованием встроенной команды test и ее кода возврата):

function is_int() { return $(test "$@" -eq "$@" > /dev/null 2>&1); } 

input="-123"

if $(is_int "${input}");
then
   echo "Input: ${input}"
   echo "Integer: $[${input}]"
else
   echo "Not an integer: ${input}"
fi

Вы можете удалить нецифровые цифры и провести сравнение. Вот демонстрационный сценарий:

for num in "44" "-44" "44-" "4-4" "a4" "4a" ".4" "4.4" "-4.4" "09"
do
    match=${num//[^[:digit:]]}    # strip non-digits
    match=${match#0*}             # strip leading zeros
    echo -en "$num\t$match\t"
    case $num in
        $match|-$match)    echo "Integer";;
                     *)    echo "Not integer";;
    esac
done

Вот как выглядит тестовый результат:

44 44 Целое число
-44 44 Целое число
44-44 Не целое число
4-4 44 Не целое число
a4 4 Не целое число
4a 4 Не целое число
.4 4 Не целое
4.4 44 Не целое число
-4,4 44 Не целое
09 9 Не целое число

Для меня самым простым решением было использовать переменную внутри (())выражения, например:

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

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

Как указано в комментариях, это может привести к атаке выполнения кода: (( ))оператор VARвыполняет оценку , как указано в Arithmetic Evaluationразделе справочной страницы bash (1) . Следовательно, вы не должны использовать эту технику, когда источник содержимого VARнеизвестен (и, конечно, вы не должны использовать ЛЮБУЮ другую форму расширения переменных).

или с помощью sed:

   test -z $(echo "2000" | sed s/[0-9]//g) && echo "integer" || echo "no integer"
   # integer

   test -z $(echo "ab12" | sed s/[0-9]//g) && echo "integer" || echo "no integer"
   # no integer

Дополнение к ответу Игнасио Васкес-Абрамса. Это позволит знаку + предшествовать целому числу и позволит использовать любое количество нулей в качестве десятичных знаков. Например, это позволит считать +45.00000000 целым числом.
Однако $ 1 должен быть отформатирован так, чтобы содержать десятичную точку. 45 здесь не считается целым числом, а 45,0 - таковым.

if [[ $1 =~ ^-?[0-9]+.?[0]+$ ]]; then
    echo "yes, this is an integer"
elif [[ $1 =~ ^\+?[0-9]+.?[0]+$ ]]; then
    echo "yes, this is an integer"
else
    echo "no, this is not an integer"
fi

Для смеха я примерно быстро разработал набор функций для этого (is_string, is_int, is_float, is alpha string или другие), но есть более эффективные (меньше кода) способы сделать это:

#!/bin/bash

function strindex() {
    x="${1%%$2*}"
    if [[ "$x" = "$1" ]] ;then
        true
    else
        if [ "${#x}" -gt 0 ] ;then
            false
        else
            true
        fi
    fi
}

function is_int() {
    if is_empty "${1}" ;then
        false
        return
    fi
    tmp=$(echo "${1}" | sed 's/[^0-9]*//g')
    if [[ $tmp == "${1}" ]] || [[ "-${tmp}" == "${1}" ]] ; then
        #echo "INT (${1}) tmp=$tmp"
        true
    else
        #echo "NOT INT (${1}) tmp=$tmp"
        false
    fi
}

function is_float() {
    if is_empty "${1}" ;then
        false
        return
    fi
    if ! strindex "${1}" "-" ; then
        false
        return
    fi
    tmp=$(echo "${1}" | sed 's/[^a-z. ]*//g')
    if [[ $tmp =~ "." ]] ; then
        #echo "FLOAT  (${1}) tmp=$tmp"
        true
    else
        #echo "NOT FLOAT  (${1}) tmp=$tmp"
        false
    fi
}

function is_strict_string() {
    if is_empty "${1}" ;then
        false
        return
    fi
    if [[ "${1}" =~ ^[A-Za-z]+$ ]]; then
        #echo "STRICT STRING (${1})"
        true
    else
        #echo "NOT STRICT STRING (${1})"
        false
    fi
}

function is_string() {
    if is_empty "${1}" || is_int "${1}" || is_float "${1}" || is_strict_string "${1}" ;then
        false
        return
    fi
    if [ ! -z "${1}" ] ;then
        true
        return
    fi
    false
}
function is_empty() {
    if [ -z "${1// }" ] ;then
        true
    else
        false
    fi
}

Пройдя здесь несколько тестов, я определил, что -44 - это int, а 44- - нет и т. Д .:

for num in "44" "-44" "44-" "4-4" "a4" "4a" ".4" "4.4" "-4.4" "09" "hello" "h3llo!" "!!" " " "" ; do
    if is_int "$num" ;then
        echo "INT = $num"

    elif is_float "$num" ;then
        echo "FLOAT = $num"

    elif is_string "$num" ; then
        echo "STRING = $num"

    elif is_strict_string "$num" ; then
        echo "STRICT STRING = $num"
    else
        echo "OTHER = $num"
    fi
done

Вывод:

INT = 44
INT = -44
STRING = 44-
STRING = 4-4
STRING = a4
STRING = 4a
FLOAT = .4
FLOAT = 4.4
FLOAT = -4.4
INT = 09
STRICT STRING = hello
STRING = h3llo!
STRING = !!
OTHER =  
OTHER = 

ПРИМЕЧАНИЕ: ведущие 0 могут означать что-то еще при добавлении чисел, таких как восьмеричное, поэтому было бы лучше удалить их, если вы намерены рассматривать '09' как int (что я делаю) (например, expr 09 + 0или разделить с помощью sed)