Glob pattern matching comma separated numbers

Question

I want to write a glob pattern to match numbers separated by commas. What would the pattern be like?

Here are some examples

5
5,8,13

Have started with the following, but there some problem with it, as I do not get a match.

var="8,13,21"
echo "var: $var"
if [[ "$var" == ^*([[:digit:]])+(,+[[:digit:]])$ ]]; then
  echo "match"
fi

Answer 1

The bash manual says of the [[ expression ]] grammar:

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 under Pattern Matching, as if the extglob shell option were enabled¹.

The extglob shell option here means ksh-style extended globs, namely:

  ?(pattern-list)
         Matches zero or one occurrence of the given patterns
  *(pattern-list)
         Matches zero or more occurrences of the given patterns
  +(pattern-list)
         Matches one or more occurrences of the given patterns
  @(pattern-list)
         Matches one of the given patterns
  !(pattern-list)
         Matches anything except one of the given patterns

I suspect +[[:digit:]] was an attempt to match 1 or more digits - that would need to be +([[:digit:]]). So comma followed by 1 or more digits, all zero or more times would be *(,+([[:digit:]]), and finally

+([[:digit:]])*(,+([[:digit:]]))

to match 1 or more digits, followed by zero or more comma separated one-or-more-digits to make the comma-separated list.

Note that glob expressions don't use ^ and $ anchors - they are always whole-line, if you wanted partial matches you would need to bracket the expression with * wildcards.

---

^{¹ That's new since bash 4.1. In older versions, you'd need an explicit shopt -s extglob for those extended glob operators to be available inside like outside [[...]].}

Answer 2

Note that the syntax you use looks like a mixture of globbing and regular expression syntax.

If you want to use Bash's RegEx matching (as mentioned in a comment), then you would need to use the =~ comparison operator. In that case, the correct syntax for the test construct is

if [[ "$var" =~ ^([[:digit:]])+(,[[:digit:]]+)*$ ]]; then
...

Note that this differs from the attempt you showed in several aspects:

• In your current attempt, ,+[[:digit:]] would match "one or more commas, followed by exactly one digit".
• The * at the beginning of your RegEx seems stray - as long as you don't intend to match a literal *, it is either wrong (* in RegEx means "zero or more of the previous characters", not "any possible character combination") or superfluous (if you wanted to match $.*, you could as well get rid of the anchor and simply state ([[:digit:]])+(,+[[:digit:]])$).

---

On the other hand, if you actually wanted to use the "extended globbing" syntax (which is indeed accepted by default in the [[ ... ]] construct for the == operator), then

• the usage of anchors (^ and $) is wrong - they are only valid for RegExes, and not part of the globbing syntax, even in the extended form. They are also not needed, as glob patterns apply to the entire string by default.
• In addition, every item preceded by a "repeat specifier" (like * or +) would then need to be placed in parentheses, so one set of parentheses is missing in your +[[:digit:]] statement.

So in that case, your matching glob would need to look like

if [[ "$var" == +([[:digit:]])*(,+([[:digit:]])) ]]; then echo "match"; fi

Answer 3

For completeness, if you wanted to do that in sh using standard wildcards in a case statement ([[...]] is a kshism), you'd need to take a reverse approach:

case $var in
  ('' | *[!,0123456789]* | *, | ,* | *,,* ) echo WRONG;;
  (*) echo RIGHT;;
esac

There's not equivalent of ERE + (same as zsh's ## or ksh's +(...)) in standard glob patterns.

You can however do regexp matching¹ with the help of awk:

rematch() { awk -- 'BEGIN{exit(ARGV[1] !~ ARGV[2])}' "$@"; }

if rematch ",$var" '^(,[0123456789]+)+$'; then
  echo RIGHT
else
  echo WRONG
fi

---

^{¹ In awk, you get a variant of standard Extended Regular Expressions that also understands (or is meant to understand, not all do when used that way) ANSI C escape sequences such as \n, \t, \b (for backspace, not perl-style word boundary).}