Linux CLI 66 🐧 Case conversion in shell scripts - KandZ

#!/bin/bash
var="Hello World"
uppercase="${var^^}"
lowercase="${var,,}"
echo "$uppercase"
echo "$lowercase"

var1="Hello World"
uppercase1=$(echo "$var" | tr '[:lower:]' '[:upper:]')
lowercase1=$(echo "$var" | tr '[:upper:]' '[:lower:]')
echo "$uppercase1"
echo "$lowercase1"

var2="Hello World"
uppercase2=$(echo "$var" | awk '{print toupper($0)}')
lowercase2=$(echo "$var" | awk '{print tolower($0)}')
echo "$uppercase2"
echo "$lowercase2"

var3="Hello World"
uppercase3=$(echo "$var" | sed 's/[a-z]/\U&/g')
lowercase3=$(echo "$var" | sed 's/[A-Z]/\L&/g')
echo "$uppercase3"
echo "$lowercase3"

declare -l name="Hello World"
echo "$name"

declare -u name="Hello World"
echo "$name"

Converting strings to uppercase or lowercase comes up constantly — normalizing user input, formatting output, comparing values case-insensitively. Bash gives you four different ways to do it, each with different trade-offs in portability, speed, and readability.

Key point: The fastest and cleanest method is bash’s built-in parameter expansion (${var^^} and ${var,,}). The most portable is tr. The most flexible is awk or sed. And declare lets you force a variable’s case on assignment.

a – Case conversion with parameter expansion

Case conversion means converting strings to uppercase or lowercase. It can be performed using several methods, depending on the shell and the context of the script.

Method 1 — Parameter expansion ^^ and ,,:

#!/bin/bash
var="Hello World"
uppercase="${var^^}"
lowercase="${var,,}"
echo "$uppercase"
echo "$lowercase"

[ HELLO WORLD ]
[ hello world ]

${var^^} → uppercase the whole string
${var,,} → lowercase the whole string

There are also single-character versions:

Form	Effect
`${var^}`	Uppercase first character
`${var^^}`	Uppercase all characters
`${var,}`	Lowercase first character
`${var,,}`	Lowercase all characters

$ var="hello world"
$ echo "${var^}"
[ Hello world ]
$ echo "${var^^}"
[ HELLO WORLD ]

$ var="HELLO WORLD"
$ echo "${var,}"
[ hELLO WORLD ]
$ echo "${var,,}"
[ hello world ]

You can also convert only matching characters:

$ var="hello world"
$ echo "${var^^[hw]}"
[ Hello World ]
$ echo "${var^^[a-z]}"
[ HELLO WORLD ]

${var^^[pattern]} uppercases only characters matching pattern; ${var,,[pattern]} lowercases only those matching.

Pros:

Clean and readable
Fast and efficient
No external commands needed

Cons:

Not portable to non-bash shells (like dash, ksh, or zsh without set -o extglob)
Not POSIX-compliant
Requires bash 4.0+ for ^^ and ,, (4.2+ for the pattern variants)

Method 2 — tr:

#!/bin/bash
var1="Hello World"
uppercase1=$(echo "$var" | tr '[:lower:]' '[:upper:]')
lowercase1=$(echo "$var" | tr '[:upper:]' '[:lower:]')
echo "$uppercase1"
echo "$lowercase1"

[ HELLO WORLD ]
[ hello world ]

tr translates characters. [:lower:] → [:upper:] maps each lowercase letter to its uppercase counterpart.

You can also use explicit ranges:

$ echo "hello" | tr 'a-z' 'A-Z'
[ HELLO ]
$ echo "HELLO" | tr 'A-Z' 'a-z'
[ hello ]

Pros:

Works in any shell that supports tr
Portable and widely available on Unix systems
Predictable behavior

Cons:

Requires invoking an external command
Less efficient for large-scale operations
Spawns a subprocess for every call

Parameter expansion vs tr:

Aspect	`${var^^}` / `${var,,}`	`tr`
Speed	Instant (built-in)	Spawns a process
Portability	Bash 4+	Any shell
Readability	Very clean	Slightly noisy
Pattern control	Yes (`[a-z]`)	Via character ranges
Works on	Variable values	Streams / stdin

b – Case conversion with awk and sed

Method 3 — awk:

#!/bin/bash
var2="Hello World"
uppercase2=$(echo "$var" | awk '{print toupper($0)}')
lowercase2=$(echo "$var" | awk '{print tolower($0)}')
echo "$uppercase2"
echo "$lowercase2"

[ HELLO WORLD ]
[ hello world ]

awk‘s toupper() and tolower() functions operate on $0 (the whole line) or on any string expression.

Pros:

Can handle more complex string manipulation
Portable across shells
Useful when you’re already using awk for other processing

Cons:

Slightly slower than tr or parameter expansion
Requires the external awk command
Overkill for simple case conversion

Method 4 — sed:

#!/bin/bash
var3="Hello World"
uppercase3=$(echo "$var" | sed 's/[a-z]/\U&/g')
lowercase3=$(echo "$var" | sed 's/[A-Z]/\L&/g')
echo "$uppercase3"
echo "$lowercase3"

[ HELLO WORLD ]
[ hello world ]

sed‘s \U and \L escape sequences change the case of the replacement. Combined with & (the whole match), they convert each matched character.

s/[a-z]/\U&/g → for each lowercase letter, replace it with its uppercase form
s/[A-Z]/\L&/g → for each uppercase letter, replace it with its lowercase form

Pros:

Highly flexible for advanced text transformations
Can combine case conversion with other edits in one pass

Cons:

More complex and harder to read
Slower and less efficient
GNU-specific — \U and \L may not work in BSD/macOS sed

Comparison of all four methods:

Method	Speed	Portability	Readability	Best for
`${var^^}` / `${var,,}`	Fastest	Bash 4+	Highest	Bash scripts
`tr`	Fast	POSIX	High	Portable scripts
`awk`	Medium	POSIX	Medium	Complex processing
`sed`	Slow	GNU mostly	Low	Combined edits

Recommendations:

Use ${var^^} and ${var,,} if your script is bash-specific and you want cleaner, faster code
Use tr if you need POSIX compliance or maximum portability
Use awk if you need complex transformations or additional string manipulation
Use sed if you’re already using it for other edits and want to combine

A note on locale:

Case conversion is locale-aware. Under a UTF-8 locale, tr '[:lower:]' '[:upper:]' and ${var^^} handle accented characters (é → É). Under LC_ALL=C, they only handle ASCII. Set the locale explicitly if behavior matters:

$ LC_ALL=C tr '[:lower:]' '[:upper:]' <<< "café"
[ CAFé ]
$ LC_ALL=en_US.UTF-8 tr '[:lower:]' '[:upper:]' <<< "café"
[ CAFÉ ]

c – Case conversion with declare

The declare command is primarily used to declare variables and assign attributes to them — such as making them read-only, integer-typed, or modifying their case automatically.

While declare is not directly used for case conversion, it supports two options that automatically enforce case on the values of variables:

declare -l var → Forces the variable var to always store its value in lowercase
declare -u var → Forces the variable var to always store its value in uppercase

Example:

declare -l name="Hello World"
echo "$name"
[ hello world ]

declare -u name="Hello World"
echo "$name"
[ HELLO WORLD ]

Every assignment to a declare -l variable is automatically lowercased. Every assignment to a declare -u variable is automatically uppercased.

$ declare -l name
$ name="HELLO World"
$ echo "$name"
[ hello world ]

$ name="ANOTHER Assignment"
$ echo "$name"
[ another assignment ]

The variable stays lowercase no matter what you assign.

Useful for normalization:

#!/bin/bash
declare -l answer
read -p "Continue? (y/n): " answer

case "$answer" in
    y|yes) echo "Continuing" ;;
    n|no)  echo "Cancelled" ;;
    *)     echo "Please answer yes or no" ;;
esac

The user’s input is normalized to lowercase automatically, so Y, Yes, and YES all match.

Limitations:

Not POSIX-compliant — specific to bash
No string-level case conversion — it works on assignment, not on arbitrary expressions
No mixed-case enforcement — it’s all-or-nothing
Only works on variable assignment — not on command outputs or piped data
Resets on function scope — a declare -l inside a function applies only there

The declare case attributes:

Command	Effect
`declare -l var`	Variable is always lowercase
`declare -u var`	Variable is always uppercase
`declare -l var="HELLO"`	Declare and assign (value lowercased)
`declare -u var="hello"`	Declare and assign (value uppercased)

Listing declared variables:

$ declare -l name
$ declare -p name
[ declare -l name="hello world" ]

$ declare -u code
$ code="abc"
$ declare -p code
[ declare -u code="ABC" ]

declare -l vs ${var,,}:

Aspect	`declare -l`	`${var,,}`
When it applies	On assignment	When you ask
Persistence	Always	One-time
Syntax	`declare -l x`	`${x,,}`
Use for	Normalized storage	One-off conversion

If a variable should always be lowercase — user input, config keys, hostnames — use declare -l. If you need to lowercase something once for comparison, use ${var,,}.

Complete Example Session

# ============================================
# PART 1: PARAMETER EXPANSION
# ============================================

$ var="Hello World"
$ echo "${var^^}"
[ HELLO WORLD ]
$ echo "${var,,}"
[ hello world ]

$ echo "${var^}"
[ Hello World ]
$ echo "${var,}"
[ hello World ]

# ============================================
# PART 2: PATTERN-SPECIFIC CONVERSION
# ============================================

$ var="hello world"
$ echo "${var^^[hw]}"
[ Hello World ]
$ echo "${var^^[a-z]}"
[ HELLO WORLD ]

# ============================================
# PART 3: TR
# ============================================

$ var1="Hello World"
$ echo "$var1" | tr '[:lower:]' '[:upper:]'
[ HELLO WORLD ]
$ echo "$var1" | tr '[:upper:]' '[:lower:]'
[ hello world ]

$ echo "hello" | tr 'a-z' 'A-Z'
[ HELLO ]
$ echo "HELLO" | tr 'A-Z' 'a-z'
[ hello ]

# ============================================
# PART 4: AWK
# ============================================

$ var2="Hello World"
$ echo "$var2" | awk '{print toupper($0)}'
[ HELLO WORLD ]
$ echo "$var2" | awk '{print tolower($0)}'
[ hello world ]

# ============================================
# PART 5: SED
# ============================================

$ var3="Hello World"
$ echo "$var3" | sed 's/[a-z]/\U&/g'
[ HELLO WORLD ]
$ echo "$var3" | sed 's/[A-Z]/\L&/g'
[ hello world ]

# ============================================
# PART 6: DECLARE
# ============================================

$ declare -l name="Hello World"
$ echo "$name"
[ hello world ]

$ declare -u code="hello world"
$ echo "$code"
[ HELLO WORLD ]

$ declare -l answer
$ answer="YES"
$ echo "$answer"
[ yes ]

# ============================================
# PART 7: COMPARE — SAME RESULT
# ============================================

$ var="Hello World"

$ echo "${var^^}"
[ HELLO WORLD ]
$ echo "$var" | tr '[:lower:]' '[:upper:]'
[ HELLO WORLD ]
$ echo "$var" | awk '{print toupper($0)}'
[ HELLO WORLD ]
$ echo "$var" | sed 's/[a-z]/\U&/g'
[ HELLO WORLD ]

# ============================================
# PART 8: LOCALE MATTERS
# ============================================

$ LC_ALL=C tr '[:lower:]' '[:upper:]' <<< "café"
[ CAFé ]
$ LC_ALL=en_US.UTF-8 tr '[:lower:]' '[:upper:]' <<< "café"
[ CAFÉ ]

# ============================================
# PART 9: NORMALIZE USER INPUT
# ============================================

$ declare -l answer
$ read -p "Continue? (y/n): " answer
Continue? (y/n): Y
$ echo "$answer"
[ y ]

# ============================================
# PART 10: CASE-INSENSITIVE COMPARISON
# ============================================

$ name="ALICE"
$ expected="alice"

# ❌ Case-sensitive
$ [ "$name" = "$expected" ] && echo "match" || echo "no match"
[ no match ]

# ✅ Lowercase both sides
$ [ "${name,,}" = "${expected,,}" ] && echo "match" || echo "no match"
[ match ]

# ============================================
# PART 11: NORMALIZE FILE EXTENSIONS
# ============================================

$ for f in *.TXT *.Txt *.txt; do
>     [ -e "$f" ] || continue
>     echo "${f,,}"
> done
[ file1.txt ]
[ file2.txt ]
[ file3.txt ]

# ============================================
# PART 12: FULL SCRIPT
# ============================================

$ cat > case.sh << 'EOF'
#!/bin/bash
var="Hello World"
uppercase="${var^^}"
lowercase="${var,,}"
echo "$uppercase"
echo "$lowercase"

var1="Hello World"
uppercase1=$(echo "$var" | tr '[:lower:]' '[:upper:]')
lowercase1=$(echo "$var" | tr '[:upper:]' '[:lower:]')
echo "$uppercase1"
echo "$lowercase1"

var2="Hello World"
uppercase2=$(echo "$var" | awk '{print toupper($0)}')
lowercase2=$(echo "$var" | awk '{print tolower($0)}')
echo "$uppercase2"
echo "$lowercase2"

var3="Hello World"
uppercase3=$(echo "$var" | sed 's/[a-z]/\U&/g')
lowercase3=$(echo "$var" | sed 's/[A-Z]/\L&/g')
echo "$uppercase3"
echo "$lowercase3"

declare -l name="Hello World"
echo "$name"

declare -u name="Hello World"
echo "$name"
EOF
$ chmod +x case.sh
$ ./case.sh
[ HELLO WORLD ]
[ hello world ]
[ HELLO WORLD ]
[ hello world ]
[ HELLO WORLD ]
[ hello world ]
[ HELLO WORLD ]
[ hello world ]
[ hello world ]
[ HELLO WORLD ]

Quick Reference

Parameter Expansion (bash 4+)

Form	Effect
`${var^}`	Uppercase first char
`${var^^}`	Uppercase all
`${var,}`	Lowercase first char
`${var,,}`	Lowercase all
`${var^^[pattern]}`	Uppercase matching
`${var,,[pattern]}`	Lowercase matching

tr

Command	Effect
`tr '[:lower:]' '[:upper:]'`	Uppercase
`tr '[:upper:]' '[:lower:]'`	Lowercase
`tr 'a-z' 'A-Z'`	Uppercase
`tr 'A-Z' 'a-z'`	Lowercase

awk

Command	Effect
`awk '{print toupper($0)}'`	Uppercase
`awk '{print tolower($0)}'`	Lowercase

sed (GNU)

Command	Effect
`sed 's/[a-z]/\U&/g'`	Uppercase
`sed 's/[A-Z]/\L&/g'`	Lowercase

declare

Command	Effect
`declare -l var`	Force lowercase
`declare -u var`	Force uppercase
`declare -l var="HELLO"`	Declare + assign, lowercased
`declare -u var="hello"`	Declare + assign, uppercased
`declare -p var`	Show declaration

Method Comparison

Method	Speed	Portability	Bash 4+ only
`${var^^}` / `${var,,}`	Fastest	❌ Bash only	✅
`tr`	Fast	✅ POSIX	❌
`awk`	Medium	✅ POSIX	❌
`sed`	Slow	GNU mostly	❌
`declare -l/-u`	Fastest	❌ Bash only	✅

Locale

Setting	Effect
`LC_ALL=C`	ASCII only
`LC_ALL=en_US.UTF-8`	Unicode-aware

Best Practices

✅ Do This:

# Use parameter expansion in bash scripts
uppercase="${var^^}"                   # ✅
lowercase="${var,,}"                   # ✅

# Use tr for portability
uppercase=$(echo "$var" | tr '[:lower:]' '[:upper:]')  # ✅

# Normalize user input
declare -l answer                      # ✅

# Lowercase both sides for comparison
[ "${a,,}" = "${b,,}" ]                # ✅

# Set locale for Unicode
LC_ALL=en_US.UTF-8 tr '[:lower:]' '[:upper:]'  # ✅

# Use case-insensitive comparison
shopt -s nocasematch
[[ $a == "$b" ]]                       # ✅

❌ Don’t Do This:

# Don't assume ^^ works in sh
#!/bin/sh
echo "${var^^}"                        # ❌ not POSIX

# Don't forget the locale for accents
echo "café" | tr '[:lower:]' '[:upper:]'  # ⚠️  may not uppercase é

# Don't mix methods unnecessarily
uppercase=$(echo "$var" | tr ... | awk ... | sed ...)  # ❌ overkill

# Don't use sed for simple case conversion
echo "$var" | sed 's/[a-z]/\U&/g'      # ⚠️  slower than ${var^^}

# Don't forget declare is bash-only
declare -l x                           # ❌ not in sh

# Don't ignore mixed-case patterns
${var^^[a-z]}                          # ✅ converts only letters

Common Pitfalls

Pitfall	Problem	Solution
`^^` in sh	Not POSIX	Use `tr`
Old bash	`^^` not supported	Bash 4.0+ required
Locale	Accents mishandled	Set `LC_ALL`
`sed \U` on macOS	BSD sed differs	Use `tr` or `awk`
Extra subprocess	Slow loops	Use `${var^^}`
`declare -l` in sh	Not supported	Use `${var,,}`
Comparing mixed case	Fails	Lowercase both sides

Real-World Examples

1. Parameter Expansion Uppercase

#!/bin/bash
var="Hello World"
echo "${var^^}"
[ HELLO WORLD ]

2. Parameter Expansion Lowercase

#!/bin/bash
var="Hello World"
echo "${var,,}"
[ hello world ]

3. First Character Only

#!/bin/bash
var="hello world"
echo "${var^}"
[ Hello world ]

4. tr Uppercase

#!/bin/bash
var1="Hello World"
echo "$var1" | tr '[:lower:]' '[:upper:]'
[ HELLO WORLD ]

5. tr Lowercase

#!/bin/bash
var1="Hello World"
echo "$var1" | tr '[:upper:]' '[:lower:]'
[ hello world ]

6. awk Uppercase

#!/bin/bash
var2="Hello World"
echo "$var2" | awk '{print toupper($0)}'
[ HELLO WORLD ]

7. awk Lowercase

#!/bin/bash
var2="Hello World"
echo "$var2" | awk '{print tolower($0)}'
[ hello world ]

8. sed Uppercase

#!/bin/bash
var3="Hello World"
echo "$var3" | sed 's/[a-z]/\U&/g'
[ HELLO WORLD ]

9. sed Lowercase

#!/bin/bash
var3="Hello World"
echo "$var3" | sed 's/[A-Z]/\L&/g'
[ hello world ]

10. declare Lowercase

#!/bin/bash
declare -l name="Hello World"
echo "$name"
[ hello world ]

11. declare Uppercase

#!/bin/bash
declare -u name="Hello World"
echo "$name"
[ HELLO WORLD ]

12. Case-Insensitive Comparison

#!/bin/bash
a="ALICE"
b="alice"
if [ "${a,,}" = "${b,,}" ]; then
    echo "Match"
fi
[ Match ]

13. Normalize User Input

#!/bin/bash
declare -l answer
read -p "Continue? (y/n): " answer
case "$answer" in
    y|yes) echo "Continuing" ;;
    n|no)  echo "Cancelled" ;;
    *)     echo "Invalid" ;;
esac

14. Normalize File Extensions

#!/bin/bash
for f in *; do
    ext="${f##*.}"
    if [ "${ext,,}" = "txt" ]; then
        echo "Text file: $f"
    fi
done

15. Uppercase Config Keys

#!/bin/bash
while IFS='=' read -r key value; do
    echo "${key^^}=$value"
done < config.ini

16. Check Root Username

#!/bin/bash
if [ "${USER,,}" = "root" ]; then
    echo "Running as root"
fi

17. Normalize Hostname

#!/bin/bash
host="${1,,}"
echo "Connecting to $host..."

18. Convert Filename Case

#!/bin/bash
for f in *.txt; do
    echo "${f^^}"
done

19. Batch Rename to Lowercase

#!/bin/bash
for f in *; do
    new="${f,,}"
    [ "$f" != "$new" ] && mv "$f" "$new"
done

20. Full Script

#!/bin/bash
var="Hello World"
uppercase="${var^^}"
lowercase="${var,,}"
echo "$uppercase"
echo "$lowercase"

var1="Hello World"
uppercase1=$(echo "$var" | tr '[:lower:]' '[:upper:]')
lowercase1=$(echo "$var" | tr '[:upper:]' '[:lower:]')
echo "$uppercase1"
echo "$lowercase1"

var2="Hello World"
uppercase2=$(echo "$var" | awk '{print toupper($0)}')
lowercase2=$(echo "$var" | awk '{print tolower($0)}')
echo "$uppercase2"
echo "$lowercase2"

var3="Hello World"
uppercase3=$(echo "$var" | sed 's/[a-z]/\U&/g')
lowercase3=$(echo "$var" | sed 's/[A-Z]/\L&/g')
echo "$uppercase3"
echo "$lowercase3"

declare -l name="Hello World"
echo "$name"

declare -u name="Hello World"
echo "$name"

Visual: Four Ways, Same Result

┌──────────────────────────────────────────────┐
│  Input: "Hello World"                        │
│                                              │
│  ┌────────────────────────────────────────┐  │
│  │  ${var^^}                              │  │
│  │  → HELLO WORLD          (fastest)      │  │
│  └────────────────────────────────────────┘  │
│                                              │
│  ┌────────────────────────────────────────┐  │
│  │  tr '[:lower:]' '[:upper:]'            │  │
│  │  → HELLO WORLD          (portable)     │  │
│  └────────────────────────────────────────┘  │
│                                              │
│  ┌────────────────────────────────────────┐  │
│  │  awk '{print toupper($0)}'             │  │
│  │  → HELLO WORLD          (flexible)     │  │
│  └────────────────────────────────────────┘  │
│                                              │
│  ┌────────────────────────────────────────┐  │
│  │  sed 's/[a-z]/\U&/g'                   │  │
│  │  → HELLO WORLD          (combined)     │  │
│  └────────────────────────────────────────┘  │
│                                              │
└──────────────────────────────────────────────┘

Visual: declare -l vs ${var,,}

┌──────────────────────────────────────────────┐
│           declare -l (persistent)            │
│                                              │
│  declare -l name                             │
│  name="HELLO World"                          │
│  echo "$name"  → hello world                 │
│  name="ANOTHER"                              │
│  echo "$name"  → another                     │
│                                              │
│  Always lowercase, on every assignment.      │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│           ${var,,} (one-time)                │
│                                              │
│  name="HELLO World"                          │
│  echo "${name,,}"  → hello world             │
│  echo "$name"      → HELLO World             │
│                                              │
│  Lowercases only when you ask.               │
│                                              │
└──────────────────────────────────────────────┘

Summary

Method	Syntax	Speed	Portability
Parameter expansion	`${var^^}` / `${var,,}`	Fastest	Bash 4+
tr	`tr '[:lower:]' '[:upper:]'`	Fast	POSIX
awk	`awk '{print toupper($0)}'`	Medium	POSIX
sed	`sed 's/[a-z]/\U&/g'`	Slow	GNU
declare	`declare -l/-u var`	Fastest	Bash only

Key takeaways:

${var^^} and ${var,,} are the fastest, cleanest way — but bash 4+ only
tr is the most portable — works everywhere, POSIX
awk is flexible — good when you’re already using it
sed with \U / \L is powerful but slower and GNU-specific
declare -l and declare -u force a variable’s case on every assignment
Use ${var^} and ${var,} for first-character-only conversion
Use ${var^^[pattern]} to convert only matching characters
Case conversion is locale-aware — set LC_ALL for Unicode
For case-insensitive comparison, lowercase both sides: [ "${a,,}" = "${b,,}" ]
For normalizing input, declare -l is elegant
In bash scripts, default to ${var^^} — it’s the idiomatic, fastest choice
In portable scripts, use tr

Remember: Case conversion is a common task with multiple solutions. In modern bash, reach for ${var^^} and ${var,,} — they’re built-in, fast, and clean. When portability matters, use tr. When you want a variable to always be normalized, use declare -l or declare -u. And remember that case conversion is locale-sensitive — set LC_ALL when Unicode matters. Master these four methods and you’ll pick the right one every time.

Stop using slow, ad-bloated tool sites! 🤮

🔎 Search “KandZ Tools” on Google to use many professional utilities for free.

KandZ.me is the ultimate minimalist hub for:
✅ Finance (Mortgage, Interest, Inflation)
✅ Tech (Base64, JSON, Dev Suite, IP)
✅ Health (BMI, BMR, TDEE)
✅ Productivity (Timer, Workspace, QR)

⚡️ Fast & Private
🔒 No data leaves your device
💎 100% Free

🔗 Use it now: https://tools.kandz.me
🔖 Bookmark it—you’ll need it later!