There are two common pattern-matching systems: glob and regular expressions (regex). Glob is simpler and primarily used for filename matching, while regex is more expressive and used for matching, extracting, and replacing text content.

Glob (Wildcard)#

Glob patterns are used for filename matching in shell commands such as ls, cp, and rm. They are simpler than regex, but still powerful for day-to-day file operations.

Pattern/Symbol	Meaning	Example	Notes
BASIC WILDCARDS
`*`	Matches zero or more characters	`*.txt` -> `file.txt`, `a.txt`	Does not match hidden files (`.bashrc`)
`?`	Matches exactly one character	`?.txt` -> `a.txt`, `1.txt`	`ab.txt` will not match
`[list]`	Matches any single character in list	`[ab].txt` -> `a.txt`, `b.txt`	`c.txt` will not match
`[!list]`	Matches any single character NOT in list	`[!a].txt` -> `b.txt`, `c.txt`	`a.txt` will not match
`[c1-c2]`	Matches any single character in range	`[0-9].txt` -> `0.txt` to `9.txt`	Follows ASCII order
POSIX CLASSES			Must be used inside `[]`, e.g. `[[:digit:]]`
`[:alnum:]`	Alphanumeric characters	`[[:alnum:]]`	Equivalent to `[a-zA-Z0-9]`
`[:alpha:]`	Alphabetic characters	`[[:alpha:]]*.txt`	Equivalent to `[a-zA-Z]`
`[:digit:]`	Numeric digits	`log[[:digit:]].txt`	Equivalent to `[0-9]`
`[:lower:]`	Lowercase letters	`[[:lower:]]*.sh`	Equivalent to `[a-z]`
`[:upper:]`	Uppercase letters	`[[:upper:]]*`	Equivalent to `[A-Z]`
`[:space:]`	Whitespace characters	Useful for text processing	Space, tab, newline, etc.
BRACE EXPANSION			Expansion, not pattern matching
`{a,b,c}`	Comma-separated alternatives	`touch {a,b,c}.txt`	Creates `a.txt`, `b.txt`, `c.txt`
`{1..5}`	Numeric sequence	`mkdir folder_{1..5}`	Creates `folder_1` to `folder_5`
`{a..z}`	Alphabetic sequence	`echo {a..c}`	Outputs `a b c`
`{,.bak}`	Shorthand suffix expansion	`cp config.ini{,.bak}`	Same as `cp config.ini config.ini.bak`
EXTENDED GLOB (Bash)			Requires `shopt -s extglob`
`?(pattern)`	Matches zero or one occurrence	`file?(s).txt`	Matches `file.txt`, `files.txt`
`*(pattern)`	Matches zero or more occurrences	`file*(s).txt`	Matches `file.txt`, `filessss.txt`
`+(pattern)`	Matches one or more occurrences	`file+(s).txt`	Matches `files.txt` (not `file.txt`)
`@(pattern)`	Matches exactly one occurrence	`file@(a\|b).txt`	Matches `filea.txt`, `fileb.txt`
`!(pattern)`	Matches anything except pattern	`!(.jpg\|.png)`	All files except `.jpg` and `.png`

Quick Examples:

1
# Basic wildcards
2
ls log*              # All files starting with 'log'
3
ls log?              # 'log' + exactly one character
4
ls log[123].txt      # log1.txt, log2.txt, log3.txt
5
ls [!abc]*           # Files NOT starting with a, b, or c
6

7
# POSIX character classes
8
ls *[[:digit:]]*     # Files containing digits
9
ls [[:lower:]]*.txt  # Files starting with lowercase
10

11
# Brace expansion
12
touch file_{1..10}.txt           # Create file_1.txt to file_10.txt
13
cp config.ini{,.backup}          # Backup config.ini
14

15
# Extended glob (enable first: shopt -s extglob)
16
rm !(*.jpg|*.png)                # Delete all except images
17
ls file?(s).txt                  # Match with optional 's'

Glob Gotchas#

Hidden files: * does not match dotfiles by default; use .* explicitly.
Path separator: Wildcards do not cross /. Use */* or ** (with shopt -s globstar).
Shell expansion: The shell expands wildcards before passing args to commands.
Quote protection: Quote wildcards when passing patterns as literals, e.g. find . -name "*.txt".
Case sensitivity: Matching is case-sensitive by default; use shopt -s nocaseglob if needed.

Regex (Regular Expression)#

Regex is the “surgical knife” for text matching, extraction, and replacement. Unlike glob, regex is designed for content patterns inside strings, not filename expansion.

Regex consists of two building blocks:

Literal characters: match themselves, e.g. a matches a.
Metacharacters: symbols with special meaning, e.g. . matches almost any single character.

Pattern/Symbol	Meaning	Example Pattern	Notes / Typical Matches
BASIC MATCHING
`a`, `cat`, `2026`	Literal match	`cat`	Matches exact text `cat`
`.`	Any single character except newline (usually)	`b.g`	`bag`, `big`, `b0g`
`\.`	Escape metacharacter	`\.com`	Matches literal `.com`
`[abc]`	Any one character in set	`[bt]ag`	`bag`, `tag`
`[^abc]`	Any one character not in set	`[^b]ag`	`tag`, `cag` (not `bag`)
`[a-z]`, `[0-9]`	Character range	`[A-F0-9]`	One hex-like character
QUANTIFIERS			Quantifiers apply to the token immediately on the left
`*`	0 or more	`ab*`	`a`, `ab`, `abbb`
`+`	1 or more	`ab+`	`ab`, `abbb` (not `a`)
`?`	0 or 1 (optional)	`colou?r`	`color`, `colour`
`{n}`	Exactly n	`a{3}`	`aaa`
`{n,}`	At least n	`a{2,}`	`aa`, `aaa`, …
`{n,m}`	Between n and m	`a{2,4}`	`aa`, `aaa`, `aaaa`
`*?`, `+?`, `{n,m}?`	Non-greedy (lazy) quantifiers	`<.*?>`	Matches the shortest tag-like segment
ANCHORS & BOUNDARIES			Restrict where matching can happen
`^`	Start of line/string	`^Hello`	Matches lines starting with `Hello`
`$`	End of line/string	`done$`	Matches lines ending with `done`
`\b`	Word boundary	`\bhi\b`	Matches standalone `hi`, not `high`
`\B`	Not a word boundary	`\Bend\B`	Can match internal `end` in `bendable`
`\A`, `\Z`	Absolute start/end (engine-dependent)	`\AINFO:.*\Z`	Useful when `^`/`$` behavior changes in multiline mode
PREDEFINED CLASSES			Common shorthand classes
`\d` / `\D`	Digit / non-digit	`\d{4}`	`2026`
`\w` / `\W`	Word char / non-word	`\w+`	letters, digits, underscore
`\s` / `\S`	Whitespace / non-whitespace	`\s+`	spaces, tabs, newlines
GROUPING & BRANCHING			Build larger matching logic
`(abc)`	Capturing group	`(ab)+`	Repeats `ab` as a group
`(?:abc)`	Non-capturing group	`(?:cat\|dog)s?`	Group structure without storing capture
`(a\|b\|c)`	Alternation (`or`)	`cat\|dog`	Matches `cat` or `dog`
`\1`, `\2`	Backreference to captured group	`(\w+)\s+\1`	Matches repeated word, e.g. `go go`
LOOKAROUNDS			Assert context without consuming characters
`(?=...)`	Positive lookahead	`\w+(?=:)`	Word before `:`
`(?!...)`	Negative lookahead	`foo(?!bar)`	`foo` not followed by `bar`
`(?<=...)`	Positive lookbehind	`(?<=\$)\d+`	Number after `$`
`(?<!...)`	Negative lookbehind	`(?<!-)\d+`	Number not prefixed by `-`
EMPTY / BLANK MATCHING			Useful for cleanup and empty-line checks
`^$`	Empty line (no character at all)	`^$`	Matches truly blank lines
`^\s*$`	Blank or whitespace-only line	`^\s*$`	Matches empty lines, spaces-only, tabs-only
`^\s+\|\s+$`	Leading or trailing whitespace	`^\s+\|\s+$`	Common in trim replacement patterns

Quick Examples:

bash examples

1
# grep -P uses PCRE (if your grep supports -P)
2
grep -P '^\d{4}-\d{2}-\d{2}$' dates.txt      # ISO date: 2026-03-15
3
grep -P '^\s*$' notes.txt                      # Empty or whitespace-only lines
4
grep -P '\b(error|warn|fatal)\b' app.log      # Any of error/warn/fatal

javascript examples

1
// Extract duplicated words: "go go", "yes yes"
2
const re = /(\w+)\s+\1/g;
3
"go go stop".match(re); // ["go go"]
4

5
// Trim via regex replacement
6
"   hello  ".replace(/^\s+|\s+$/g, ""); // "hello"

Regex Gotchas#

Engine differences: JS, Python, PCRE, and Java differ in lookbehind support, Unicode behavior, and flags.
Greedy by default: .* consumes as much as possible; use .*? for shortest matches.
Escaping layers: Inside strings, you often need double escaping, e.g. "\\d+".
Multiline vs singleline: m affects ^/$; s allows . to match newline.
Performance pitfalls: Nested quantifiers can cause catastrophic backtracking.
Python tip: Prefer raw strings like r"\d+" to avoid accidental escapes.

Welcome to Yurika!

Glob (Wildcard)#

Glob Gotchas#

Regex (Regular Expression)#

Regex Gotchas#