Offensive Security Researcher & Quantum Cryptography Analyst

How to Use Strings in Bash

Abdul Wahab Junaid
How to Use Strings in Bash

How to Use Strings in Bash

Strings are something you work with in almost every Bash script you’ll ever write, whether you’re printing a message, building a file path, or parsing user input. Unlike some programming languages, Bash doesn’t really have a formal “string type” — everything is treated as text unless you tell it otherwise — but that flexibility comes with its own set of quirks worth understanding. I want to walk through how strings actually behave in Bash, from the basics of declaring and printing them to more advanced manipulation techniques.

Declaring Strings in Bash

Creating a string variable in Bash is as simple as an assignment:

greeting="Hello, world!"

Note that there’s no space around the = sign — greeting = "Hello" will actually throw an error, because Bash interprets it as trying to run a command called greeting with arguments = and "Hello".

Single Quotes vs Double Quotes

This is one of the first things that trips people up. Single quotes preserve everything literally:

name="Alex"
echo 'Hello, $name'   # Output: Hello, $name

Double quotes allow variable expansion and command substitution:

echo "Hello, $name"   # Output: Hello, Alex

I use double quotes by default unless I specifically want to prevent expansion, since forgetting to quote a variable is one of the most common sources of bugs in Bash scripts.

Printing Strings

The two most common commands for printing strings are echo and printf.

echo "This is a simple string"

printf gives you more control over formatting:

printf "Name: %s, Age: %d\n" "Alex" 30

I tend to reach for printf when I need precise formatting, and echo for quick, simple output.

String Concatenation

Bash doesn’t have a dedicated concatenation operator — you just place strings next to each other:

first="Hello"
second="World"
combined="$first, $second!"
echo "$combined"   # Output: Hello, World!

You can also append to an existing variable:

message="Hello"
message+=", World!"
echo "$message"   # Output: Hello, World!

Getting String Length

text="Hello, World!"
echo "${#text}"   # Output: 13

The ${#variable} syntax returns the number of characters in the string.

Extracting Substrings

Bash supports substring extraction using the ${variable:start:length} syntax:

text="Hello, World!"
echo "${text:7}"      # Output: World!
echo "${text:7:5}"    # Output: World

The first number is the starting index (zero-based), and the optional second number is the length of the substring to extract.

Replacing Parts of a String

You can replace substrings without needing external tools like sed for simple cases:

text="Hello, World!"
echo "${text/World/Bash}"    # Output: Hello, Bash!

To replace all occurrences instead of just the first, use a double slash:

text="foo bar foo baz foo"
echo "${text//foo/qux}"    # Output: qux bar qux baz qux

Removing Parts of a String

Bash provides pattern-based removal from the beginning or end of a string:

filename="document.tar.gz"

echo "${filename%.gz}"     # Removes shortest match from the end: document.tar
echo "${filename%%.*}"     # Removes longest match from the end: document
echo "${filename#*.}"      # Removes shortest match from the start: tar.gz
echo "${filename##*.}"     # Removes longest match from the start: gz

This pattern (%, %%, #, ##) is incredibly useful for things like stripping file extensions or parsing paths, and it’s much faster than piping to external tools since it’s handled directly by Bash.

Changing Case

Bash 4 and later supports case conversion directly:

text="Hello World"
echo "${text,,}"    # Output: hello world (lowercase)
echo "${text^^}"    # Output: HELLO WORLD (uppercase)

Comparing Strings

str1="apple"
str2="banana"

if [ "$str1" == "$str2" ]; then
    echo "Strings are equal."
else
    echo "Strings are different."
fi

You can also check if a string is empty:

value=""
if [ -z "$value" ]; then
    echo "The string is empty."
fi

if [ -n "$value" ]; then
    echo "The string is not empty."
fi

-z checks for a zero-length string, while -n checks for a non-zero-length string.

Splitting Strings

There’s no built-in “split” function, but you can achieve it using IFS (Internal Field Separator) and read into an array:

csv_line="apple,banana,cherry"
IFS=',' read -ra fruits <<< "$csv_line"

for fruit in "${fruits[@]}"; do
    echo "$fruit"
done

This outputs each fruit name on its own line, having split the original comma-separated string.

Checking If a String Contains a Substring

text="Hello, World!"

if [[ "$text" == *"World"* ]]; then
    echo "Found 'World' in the string."
fi

The [[ ]] construct with *pattern* allows for simple pattern matching without needing a separate command like grep.

How String Handling Works Internally

Bash treats variables as untyped by default, meaning a variable holding "123" is stored the same way as a variable holding "hello" — both are just sequences of bytes. Bash only interprets a variable as a number when it’s used in an arithmetic context, like inside $(( )) or with the -eq test operator. Parameter expansions like ${var/pattern/replacement} and ${var#pattern} are handled internally by Bash’s parser without spawning any external process, which is why they tend to be much faster than piping the same string through sed or awk for simple operations. More complex operations, like regex-based splitting or multi-line transformations, generally do require an external tool, since Bash’s own string capabilities are intentionally limited to keep the shell lightweight.

Real-World Use Cases

Building a dynamic file path:

username="alex"
date_str=$(date +%Y-%m-%d)
log_path="/var/log/${username}_${date_str}.log"
echo "$log_path"

Parsing a filename to get its extension:

file="report.final.pdf"
extension="${file##*.}"
echo "File extension: $extension"   # Output: pdf

Validating user input format:

read -p "Enter your email: " email

if [[ "$email" == *"@"*"."* ]]; then
    echo "Looks like a valid email format."
else
    echo "Invalid email format."
fi

Automation Example: Log Message Formatter

#!/bin/bash

log_message() {
    local level="$1"
    local message="$2"
    local timestamp
    timestamp=$(date "+%Y-%m-%d %H:%M:%S")

    printf "[%s] [%s] %s\n" "$timestamp" "${level^^}" "$message"
}

log_message "info" "Service started successfully"
log_message "error" "Failed to connect to database"

This script builds a small logging function that formats messages with a timestamp and an uppercased log level, using the string tools covered above.

Best Practices

Security Considerations

Optimization Tips

Troubleshooting

Variable doesn’t expand inside single quotes: This is expected behavior — single quotes suppress all expansion. Switch to double quotes if you need $variable to be replaced with its value.

Comparison always evaluates as unequal even though strings look the same: Check for hidden whitespace or trailing newlines, especially in strings read from files or command output. Consider trimming with "${var%$'\n'}" or using $(command) (which strips trailing newlines automatically).

Case conversion ${var^^} doesn’t work: This feature requires Bash 4.0 or later. Check your version with bash --version; older systems (including some default macOS installations) ship with Bash 3.2.

Common Mistakes

  1. Forgetting to quote variables, leading to unexpected word-splitting when the string contains spaces.
  2. Using = for string comparison inside [[ ]] when == is the more conventional choice (though both work in this context).
  3. Assuming Bash strings behave like arrays of characters that support indexing the way other languages do — accessing individual characters requires substring syntax instead.
  4. Mixing up #/## (remove from start) with %/%% (remove from end).

FAQs

How do I check if two strings are equal in Bash? Use [ "$str1" == "$str2" ] or [[ "$str1" == "$str2" ]] inside an if statement.

How do I convert a string to uppercase or lowercase? Use ${var^^} for uppercase and ${var,,} for lowercase, available in Bash 4.0 and later.

How can I check if a string contains a specific substring? Use [[ "$string" == *"substring"* ]].

Does Bash support regular expressions for strings? Yes, through the =~ operator inside [[ ]], for example: [[ "$string" =~ ^[0-9]+$ ]] checks if the string is entirely numeric.

Summary

Strings in Bash are simple on the surface but come with a set of behaviors worth understanding thoroughly — from quoting rules to built-in parameter expansion for substring extraction, replacement, and case conversion. Leaning on Bash’s native string tools instead of always reaching for external commands like sed or awk will make your scripts faster and easier to read. Once you’re comfortable with these patterns, string manipulation becomes one of the more enjoyable parts of shell scripting rather than a constant source of quoting headaches.

References

Exit mobile version