We closed the arrays lesson with two debts: ${amount%.*}, which trimmed the cents, and ${SHIPMENTS[$c]:-0}, which supplied a default value. You already know the second from 03-06; the first belongs to a much bigger family. Bash can cut, trim, substitute and transform strings without calling any external program, using the same old ${...} syntax. This matters for two reasons: the code comes out shorter, and above all it is ten to a hundred times faster, because every sed or cut inside a loop is a brand-new operating system process. In this lesson you complete the whole family and learn to format the output of daily-report.sh with printf.

1. Length and substrings
2. Removing prefixes and suffixes
3. Text substitution
4. Uppercase and lowercase
5. Concatenation
6. Comparison and pattern matching
7. Splitting a string into an array
8. printf: widths, alignment and decimals
9. Expansions versus sed, cut, basename
10. Integrating example

The syntax is ${string:offset:length}, with the offset starting at 0. Three practical notes: the space before a negative number is mandatory, because without it ${s:-7} means "default value 7", a completely different expansion (${s:(-7)} also works); both numbers accept arithmetic, like ${s:i:n} or ${s:0:${#s}-4}; and it counts characters, not bytes, as long as the locale is UTF-8, so an ñ counts as 1. It works on arguments too: ${1:0:4} is the first four characters of $1.

Four operators that trim whatever matches a glob pattern (the ones from 02-05: *, ?, [...]), not a regular expression:

Mnemonic, looking at a keyboard: # is to the left of $ and trims from the left; % is to the right and trims from the right. And doubling the symbol means "eat as much as you can".

Applied to our data:

That final block extracts date, time, level and message from an app.log line without launching a single process. The \\[ and \\] are escaped because in a glob pattern brackets define a character class.

Summary: one slash substitutes the first match, two slashes all of them, /# anchors at the beginning and /% at the end. The search pattern is once again a glob, which allows things like:

That idiom for trimming spaces is ugly but it is the standard in pure Bash; save it as a trim() function in your library.

Four operators, available since Bash 4:

The most frequent use is normalizing before comparing, so the user can type VALENCIA, valencia or Valencia: city="${1,,}"; city="${city^}" always yields Valencia. It can be restricted to certain characters with a pattern (${s^^[aeiou]} uppercases only the vowels), although that is rare.

Bash has no concatenation operator: you just write the strings one after another.

The braces in ${prefix}_ are mandatory here: without them Bash would look for a variable called prefix_. And to accumulate text in a loop:

+= on a string concatenates; on an array (04-03) it appends elements; on a declare -i variable it adds. The same operator, three behaviors depending on the type.

Inside [[ ]], the == operator does more than compare: if the right-hand side is unquoted, it is interpreted as a glob pattern.

This is the only situation in the course where dropping the quotes is deliberate and correct: when you want the variable's content to work as a pattern. In any other context, quotes.

Other string operators in [[ ]], already seen in 03-03: !=, < and > (alphabetical order according to the locale), -z (empty) and -n (non-empty).

For matches a glob cannot express —"three digits followed by a letter", "a valid IP"— you need the =~ operator with regular expressions. That is the full topic of 05-04; for now, if the pattern can be written with * and ?, use ==.

You already saw this in 04-03; we bring it back here because it is a string operation in its own right:

The second variant fails if a field contains *, because globbing will expand it into file names. The inverse operation, joining an array into a string, is done with "${arr[*]}" and the right IFS:

Note: only the first character of IFS is used as the separator in ${arr[*]}, so the example above joins with a space. For multi-character separators, use printf or a loop.

You already know from 03-06 that printf is preferable to echo. Here we exploit its specifiers to build tables:

Three printf behaviors worth knowing: it reuses the format while arguments remain, so printf '%s\n' "${cities[@]}" prints each city on its own line with no loop needed; the width can come from a variable using *, as in printf '%-*s\n' 15 "$city"; and %.2f rounds, it does not truncate (printf '%.2f' 2.005 gives 2.01), accepting decimals even though Bash cannot compute them, because the formatting is done by printf and not by the shell's arithmetic (04-06). With accented characters the width is counted in characters if the locale is UTF-8; if your columns wobble, check LANG.

Everything in this lesson can also be done with external tools. The difference is the cost:

Every left-hand column launches a new process: the kernel does a fork, loads the binary, sets up a pipe and waits. That is a few milliseconds... multiplied by the number of iterations.

The rule of thumb: inside a loop, expansion; outside a loop, whichever tool reads better. And if the job is to process a whole file at once, awk in a single pass almost always wins (06-01); we will come back to this when we measure for real in 08-02. One nuance in favor of basename/dirname: they handle the odd cases (paths ending in /, ., ..) according to the standard, whereas "${path%/*}" on a file.txt with no slashes returns file.txt and not .. For paths you control, the expansion is perfect; for arbitrary user paths, use the tools.

An app.log analyzer that extracts the fields with expansions and formats a table with printf, with no cut, no awk and no sed:

Output: a HOUR / ERRORS table with lines like 10:00 14. Notes on the new parts:

• [[ "$line" == "$report_date"* ]]: the variable is quoted and the * is outside, so the date is compared literally and anything is accepted after it. It is the correct idiom for "starts with".
• ${rest%%:*} cuts at the first :, leaving the hour. With % instead of %% we would have cut at the last one and got 10:15.
• $(( 10#$h )) forces base-10 interpretation. An hour like 08 would be read as invalid octal and raise an error; it is a classic trap that we dismantle completely in 04-06.

And in daily-report.sh, the formatting function fits on one line: city_row() { printf '%-10s %8d %13d %10.2f€\n' "${1^}" "$2" "$3" "$4"; }. The ${1^} normalizes the city's initial and the fixed widths guarantee the columns line up whatever the data looks like.

• Forgetting the space in ${s: -3}. Without it, ${s:-3} is "default value", a different expansion that will not raise an error but will return something else.
• Confusing #/## with %/%%. Always test with an echo before putting it in the script; the difference between the shortest and the longest match breaks paths with several dots.
• Believing that the patterns are regexes. ${s#[0-9]+} does not work: + is not a quantifier in globbing. For regexes, =~ in 05-04.
• Quoting the pattern in [[ $f == "*.gz" ]]. It turns it literal and always yields false. The pattern goes unquoted; the variable, quoted.
• Applying ${s^^} on Bash 3.2 (macOS). It does not exist; there you have to use tr.
• Tip: when a chain of trims becomes unreadable (${${x#a}%b} is not even valid in Bash), use named intermediate variables. Three clear lines are worth more than one cryptic one.

Exercise 1. Given path="/srv/veloz/data/shipments-2026-08-03.csv", obtain with expansions: the file name, the directory, the name without extension and the date 2026-08-03 it carries inside.

Exercise 2. Write normalize_city() that accepts any combination of case (SEVILLA, sevilla, SeViLla) and always returns Sevilla; if the city is not one of the four, return code 1.

Exercise 3. From the line 2026-08-03 10:15:22 [WARN] delivery queue above the threshold, extract date, time, level and message into four variables without using external tools, and print them with printf in aligned columns.

Solution 1.

Solution 2.

Normalizing both sides to lowercase and comparing is more robust than playing with ${c^}, because it returns the exact canonical form from the list.

Solution 3.

Each line uses the minimum operator needed: %% for "up to the first one from the right", # for "the first one from the left". Zero processes launched.

You no longer need cut, tr or sed for routine string work. ${#s} measures, ${s:i:n} cuts by position, #/##/%/%% trim by pattern from each end, / and // substitute, ^/, change case, += concatenates, [[ $s == pattern* ]] compares against globs, IFS splits a line into an array, and printf with widths and %.2f produces tables that line up. All inside the same process, which in a loop over thousands of lines is the difference between seconds and minutes.

One structural piece is still missing. When in exercise 2 you walked four cities with a loop to see whether a string was valid, you were using the wrong tool: comparing a value against a closed list of alternatives is exactly what case does, the construct that in 04-05 will finally get the formal treatment we only used in passing in 03-05 to parse options. With it we will give daily-report.sh subcommands (summary, detail, cities) and build veloz-menu.sh, an interactive toolkit menu with select.