Mdthbs

How to write a case statement using regex as condition (to match numbers)? I try few deferent ways I come up with (e.g. [0-9]+ or ^[0-9][0-9]*$), non of them works. Like in following example the statement is matching the wildcard but not the numeric regex.

i=1

let arg_n=$#+1



while (( $i < $arg_n )); do

    case ${!i} in

    [0-9]+)

        n=${!i}

        ;;

    *)

        echo 'Invalid argument!'

        ;;

    esac

    let i=$i+1

done

Output:

$ ./cmd.sh 64

Invalid argument!

case does not use regexes, it uses patterns

For "1 or more digits", do this:

shopt -s extglob

...

    case ${!i} in

        +([[:digit:]]) )

            n=${!i}

            ;;

    ...

If you want to use regular expressions, use the =~ operator within [[...]]

if [[ ${!i} =~ ^[[:digit:]]+$ ]]; then

    n=${!i}

else

    echo "Invalid"

fi

As glenn says, “case does not use regexes, it uses patterns”. 
As bash(1) says,

case word in [ [(] pattern [ | pattern ] ... ) list ;; ] ... esac

A case command first expands word,
and tries to match it against each pattern in turn,
using the same matching rules as for pathname expansion
(see Pathname Expansion below).

Similarly, the POSIX specification says,

… each pattern … shall be compared against the expansion of word,
according to the rules described in Pattern Matching Notation …

So the patterns are pathname expansion patterns,
a.k.a. wildcards, a.k.a. globs, as in ls -l -- *.sh or rm -- *.bak.

Sure, shopt -s extglob and [[ … =~ … ]]
are the neatest thing since sliced bread,
but they aren’t POSIX,
and it can be useful to know how to use the original tools. 
For years, programmers checked, for example,
whether a string was a number
by checking whether it was not not a number. 
You’ve defined a number to be a string that consists
(entirely) of one or more digits. 
So a string is not a number if it is null,
or if it contains a character that is not a digit. 
We can test these conditions with a case statement as follows:

case "$1" in

    ("")

        # null

           ︙

        ;;

    (*[!0-9]*)

        # contains non-numeric character(s)

           ︙

        ;;

    (*)

        # is a whole number (non-negative integer)

           ︙

esac

where [!0-9] is the old-timey shell way of saying [^0-9],
which, of course, means any character other than a digit. 
([!…] and [^…] both work in bash. 
[!…] is required to work by POSIX; the result of [^…] is unspecified.) 
If you don’t care which kind of non-number a string is,
you can combine the non-number patterns:

case "$1" in

    ("" | *[!0-9]*)

        # not a number

           ︙

        ;;

    (*)

        # is a number

           ︙

esac

As an exercise,
here’s a case statement to handle any kind of real number —
to be precise, a string of one or more digits,
with optionally a period (.) somewhere,
and optionally a minus sign (-) at the beginning.

case "$1" in

    (*[!-.0-9]*)

        # contains non-numeric character(s)

        ;;

    (*?-*)

        # contains '-' somewhere other than the first position

        ;;

    (*.*.*)

        # contains multiple decimal points

        ;;

    (*)

        case "$1" in

            (*[0-9]*)

                # is a real number

                ;;

            (*)

                # not a number

        esac

esac

I added the case-within-a-case to verify that the string does, indeed,
contain at least one digit. 
That wasn’t necessary in the integer example
because I tested whether the string was null;
a test which I have removed from this statement. 
Without the second case, a single - or a single . —
or even -. — would qualify as a number. 
Of course we could add patterns to handle those exceptions,
but that can get complex. 
(For example, I almost posted this answer
without realizing that -. was one of the exceptions.) 
I believe that the above approach is more flexible and robust.

Of course the non-number patterns can be combined here, too:
(*[!-.0-9]* | *?-* | *.*.*).

To match numbers with regexp in case statements, you'd need a shell whose wildcards support regexps. I only know of ksh93 with those.

With ksh93 globs, you can do ~(E)^[0-9]+$ or ~(E:^[0-9]+$) to use an Extended regexp in a glob pattern, or ~(P)^d+$ to use a perl-like regexp (also G for basic regexp, X for augmented regexp, V for SysV regexp).

So:

#! /bin/ksh93

for i do

  case $i in

    (~(E)^[0-9]+$)

      n=$i;;

    (*)

      echo >&2 'Invalid argument!'

      usage

  esac

done