[[ ]]: patterns, regex and BASH_REMATCH

[[ $s == report-* ]] is true for report-final.pdf, and [[ $s == "report-*" ]] is false for the same name. In Bash’s double brackets the right side of == is a pattern, and two quote marks turn it back into plain text. The same rule decides whether =~ reads a regular expression or a literal string.

You will write safe string tests without the quoting traps of [ ], match glob patterns and extended regular expressions, take version numbers apart with BASH_REMATCH, and see exactly where a #!/bin/sh script cannot use any of it.

Double brackets are a Bash keyword, so values are never split

[[ … ]] looks like [ … ] but is not a command: it is a keyword that Bash parses itself. The manual spells out the consequence: the words between [[ and ]] do not undergo word splitting or filename expansion. An empty or spaced value therefore stays one value, quoted or not, and &&, || and < can be used inside the test:

from session import run, write

# [[ ]] is a Bash keyword: variables inside it are not split or globbed, the right side of == is a glob pattern unless
# it is quoted, && and || work inside it, and < compares strings.
write("notes.txt", "remember the milk\n")
write("check.sh", "#!/bin/sh\nif [[ -n \"$1\" ]]; then echo set; fi\n")
run("""
x=''; [[ $x == "" ]] && echo "empty, no quotes needed"
name='Asha Rao'; [[ $name == 'Asha Rao' ]] && echo "one word, spaces and all"
s=report-final.pdf
[[ $s == report-* ]] && echo "glob: starts with report-"
[[ $s == "report-*" ]] || echo "quoted: not the literal text report-*"
[[ $s != *[0-9]* ]] && echo "no digit in the name"
[[ -f notes.txt && $s == *.pdf ]] && echo "both tests in one"
[[ 10 < 9 ]] && echo "10 sorts before 9 as text"
[[ 9 < 10 ]] || echo "9 sorts after 10 as text"
(( 10 < 9 )) || echo "as numbers, 10 is not less than 9"
shopt -s nocasematch; [[ REPORT == report ]] && echo "nocasematch ignores case"; shopt -u nocasematch
!dash -c '[[ 1 == 1 ]] && echo yes'
!shellcheck check.sh
""")

$ x=''; [[ $x == "" ]] && echo "empty, no quotes needed"
empty, no quotes needed
$ name='Asha Rao'; [[ $name == 'Asha Rao' ]] && echo "one word, spaces and all"
one word, spaces and all
$ s=report-final.pdf
$ [[ $s == report-* ]] && echo "glob: starts with report-"
glob: starts with report-
$ [[ $s == "report-*" ]] || echo "quoted: not the literal text report-*"
quoted: not the literal text report-*
$ [[ $s != *[0-9]* ]] && echo "no digit in the name"
no digit in the name
$ [[ -f notes.txt && $s == *.pdf ]] && echo "both tests in one"
both tests in one
$ [[ 10 < 9 ]] && echo "10 sorts before 9 as text"
10 sorts before 9 as text
$ [[ 9 < 10 ]] || echo "9 sorts after 10 as text"
9 sorts after 10 as text
$ (( 10 < 9 )) || echo "as numbers, 10 is not less than 9"
as numbers, 10 is not less than 9
$ shopt -s nocasematch; [[ REPORT == report ]] && echo "nocasematch ignores case"; shopt -u nocasematch
nocasematch ignores case
$ dash -c '[[ 1 == 1 ]] && echo yes'
dash: 1: [[: not found
[exit status 127]
$ shellcheck check.sh

In check.sh line 2:
if [[ -n "$1" ]]; then echo set; fi
   ^-----------^ SC3010 (warning): In POSIX sh, [[ ]] is undefined.

For more information:
  https://www.shellcheck.net/wiki/SC3010 -- In POSIX sh, [[ ]] is undefined.
[exit status 1]

With x empty, [[ $x == "" ]] worked without quotes, and [[ $name == 'Asha Rao' ]] compared the whole name, where the single-bracket lesson had to quote both variables. [[ -f notes.txt && $s == *.pdf ]] combined two tests in one. The < and > operators compare strings in the locale’s order, not numbers: [[ 10 < 9 ]] was true, because the text 10 sorts before 9, while (( 10 < 9 )) compared the numbers. shopt -s nocasematch made REPORT match report.

The last two lines show the cost. dash answered [[: not found with status 127, and ShellCheck flagged the same test in a #!/bin/sh script as SC3010, “In POSIX sh, [[ ]] is undefined”. POSIX’s rationale for test records that a proposal to add the double-bracket command to POSIX.1-2024 was rejected: the existing versions were found error-prone, and they behaved too differently from one shell to the next.

The right side of the comparison is a pattern, unless it is quoted

After == or !=, Bash reads the right side as a glob patternA pattern written in the notation of file name globbing, with *, ? and [ ]. After == or != in double brackets, Bash compares it with a string and never looks at files., with *, ? and […] as in file names, and matches it against the text on the left, never against the files in the folder. [[ $s == report-* ]] was true for report-final.pdf. Quoting any part of the pattern makes that part match literally, so [[ $s == "report-*" ]] asked whether the name is the eight characters report-*, and it was not. The left side needs no quotes, the right side decides:

A regular expression match saves its groups in an array

=~ compares the left side with a POSIX extended regular expressionextended regular expression: The POSIX regex dialect grep -E, sed -E, awk and Bash's [[ =~ ]] read. + ? | ( ) and { } are metacharacters, so a plain + is one or more and (a|ab) is an alternation. More in “Regular expressions for grep, sed and awk”. The match may succeed anywhere in the string, so ^ and $ anchor it to the whole value. Each parenthesised group is a capture groupcapture group: A part of a regular expression in round brackets, such as ([0-9]+), whose matched text is saved; Bash puts the saved texts in BASH_REMATCH[1] onwards., and its text is saved: BASH_REMATCH[0] holds the whole match and BASH_REMATCH[1] onwards the groups. Store the pattern in a variable and leave the variable unquoted, which keeps backslashes and brackets away from the shell’s own quoting:

from session import files, run

# =~ matches an extended regular expression. Kept in a variable and left unquoted, the pattern is a regex; quoted, it
# is matched as literal text. Capture groups land in BASH_REMATCH.
files("ifsc.sh")
run("""
re='^v([0-9]+)\\.([0-9]+)\\.([0-9]+)$'
[[ v5.3.20 =~ $re ]] && echo "major ${BASH_REMATCH[1]}, minor ${BASH_REMATCH[2]}, patch ${BASH_REMATCH[3]}"
[[ v5.3 =~ $re ]] || echo "v5.3 does not match"
echo "after the failed match: ${#BASH_REMATCH[@]} elements"
[[ v5.3.20 =~ "$re" ]] || echo "quoted: the pattern is literal text"
[[ 'a.b' =~ a.b ]] && [[ 'axb' =~ a.b ]] && echo ". matches any character"
bash ifsc.sh ABCD0123456 ABCD1123456 abcd0123456 ABCD0A1B2C3 ABCD012345
""")

$ re='^v([0-9]+)\.([0-9]+)\.([0-9]+)$'
$ [[ v5.3.20 =~ $re ]] && echo "major ${BASH_REMATCH[1]}, minor ${BASH_REMATCH[2]}, patch ${BASH_REMATCH[3]}"
major 5, minor 3, patch 20
$ [[ v5.3 =~ $re ]] || echo "v5.3 does not match"
v5.3 does not match
$ echo "after the failed match: ${#BASH_REMATCH[@]} elements"
after the failed match: 0 elements
$ [[ v5.3.20 =~ "$re" ]] || echo "quoted: the pattern is literal text"
quoted: the pattern is literal text
$ [[ 'a.b' =~ a.b ]] && [[ 'axb' =~ a.b ]] && echo ". matches any character"
. matches any character
$ bash ifsc.sh ABCD0123456 ABCD1123456 abcd0123456 ABCD0A1B2C3 ABCD012345
ABCD0123456  valid shape (bank ABCD, branch 123456)
ABCD1123456  not an IFSC shape
abcd0123456  not an IFSC shape
ABCD0A1B2C3  valid shape (bank ABCD, branch A1B2C3)
ABCD012345  not an IFSC shape

With re='^v([0-9]+)\.([0-9]+)\.([0-9]+)$', [[ v5.3.20 =~ $re ]] matched and printed major 5, minor 3, patch 20, and v5.3 did not match, because the pattern needs three numbers. That failed test also emptied the array, which held 0 elements afterwards: a match that fails throws away the groups of the last one that succeeded, so copy the groups into variables of their own right after the match that set them. [[ v5.3.20 =~ "$re" ]] failed: the manual says that quoting the variable makes the whole pattern match literally, so Bash looked for the characters of the pattern itself. An unescaped . matches any character, which is why both a.b and axb matched a.b. A pattern that is not a valid regular expression is a third outcome: the manual gives the test status 2 then, not 1. Step through the version match, then the failed one:

ifsc.sh uses the same tools for a shape check. In its NEFT questions and answers, the Reserve Bank of India gives the IFSC as an 11-character code: the bank in the first four letters, 0 as the fifth character, and the branch in the last six. The pattern ^[A-Z]{4}0[A-Z0-9]{6}$ accepted ABCD0123456 and ABCD0A1B2C3 and refused a fifth character of 1, lower-case letters and a code one character short. It checks the format only; whether a branch exists needs a lookup, which MySmartCoPilot’s IFSC code finder does, and the regex tester helps build and try a pattern first.

Practise: patterns and regular expressions

The questions use the names, versions and codes of the sessions with new values. Decide what each test returns and what BASH_REMATCH holds before you compare it with the recorded output:

Interview questions

Warm-up (2–5 years): how is [[ ]] different from [ ] in Bash?

[ ] is the test command, so the shell expands and splits its arguments first: unquoted empty or spaced values change the test, and &&, ||, < and > would be read as shell operators. [[ ]] is a keyword that Bash parses itself: no word splitting or filename expansion happens inside it, && and || combine tests, == matches the right side as a glob pattern unless it is quoted, and =~ matches an extended regular expression with groups in BASH_REMATCH. The cost is portability: POSIX does not define it and dash does not have it, so #!/bin/sh scripts use [ ] and case.

Two harder questions follow, about a filename check that stopped matching after someone added quotes and about a validation that accepts more than it should. Decide what you would check first, then open each first step:

Key takeaways

• [[ ]] is a Bash keyword: values inside it are not split or globbed, && and || combine tests, and < and > compare text, not numbers.
• After == and != the right side is a glob pattern, and quoting it, or part of it, makes that part literal.
• =~ matches a POSIX extended regular expression anywhere in the string unless it is anchored, and the groups land in BASH_REMATCH[1] onwards; a quoted variable makes the whole pattern literal.
• dash has no [[ ]] and ShellCheck reports it as SC3010 in sh scripts, so portable scripts keep to [ ] and case.