Bash String Manipulation

Bash, a versatile shell scripting language, offers robust tools for manipulating strings. Whether you're processing text files, building dynamic commands, or cleaning user input, understanding string manipulation techniques is crucial for efficient scripting.

A string is a sequence of characters enclosed in single or double quotes. It can represent text data and is a fundamental data type used in shell scripting. Bash provides various built-in operations for manipulating strings, including concatenation, substring extraction, length calculation, and more.

Here are some common string manipulation techniques in Bash:


You can concatenate strings using the + operator or by simply placing them next to each other:

str1="Hello" str2="World" result="$str1 $str2" echo $result # Output: Hello World

Substring Extraction

You can extract a portion of a string using the ${string:start:length} syntax, where start is the starting index (0-based) and length is the number of characters to extract:

fullString="BashStringManipulation" substring=${fullString:4:6} echo $substring # Output: String

String Length

To find the length of a string, use the ${#string} syntax:

myString="Bash" length=${#myString} echo $length # Output: 4

Find and Replace

You can find and replace substrings within a string using the ${string/find/replace} syntax:

originalString="Hello World" newString=${originalString/Hello/Hi} echo $newString # Output: Hi World

To replace all occurrences, use the following:

originalString="Hello Hello Hello" newString=${originalString//Hello/Hi} echo $newString # Output: Hi Hi Hi

Uppercase and Lowercase Conversion:

To convert a string to uppercase, use ${string^^} . To convert to lowercase, use ${string,,}:

myString="ConvertMe" uppercase=${myString^^} lowercase=${myString,,} echo $uppercase # Output: CONVERTME echo $lowercase # Output: convertme

Regular Expressions

Regular expressions (regex) are powerful patterns for matching and manipulating text. They allow you to define complex search patterns. For example, using grep to find lines containing numbers:

echo "123 apples" | grep -E '[0-9]+' # Output: 123 apples

Here, [0-9]+ is a regular expression matching one or more digits.

sed can use regular expressions for text substitution:

echo "Hello 123" | sed 's/[0-9]+/World/' # Output: Hello World

Command Substitution

Command substitution allows embedding the output of a command within a string or assigning it to a variable.

currentDate=$(date +"%Y-%m-%d") echo "Today is $currentDate" # Output: Today is 2020-01-30

Here, date +"%Y-%m-%d" is a command whose output is assigned to the variable currentDate.


Arrays in Bash allow storing and manipulating multiple strings. Example:

fruits=("Apple" "Banana" "Orange") echo ${fruits[1]} # Output: Banana # Loop through array elements for fruit in "${fruits[@]}"; do echo $fruit done

In this example, fruits is an array with three elements. ${fruits[1]} accesses the second element (index 1). The loop iterates through all elements in the array.

Substring Replacement

Replace specific substrings within a string using ${string/substring/replacement}.

originalString="Hello World" replacedString=${originalString/World/Universe} echo $replacedString # Output: Hello Universe

Pattern Matching

Utilize wildcard characters (* and ?) for pattern matching and manipulation.

files=$(ls *.txt) # Match all text files in the current directory

Trimming Whitespace

Remove leading and trailing whitespace using parameter expansion.

stringWithWhitespace=" Trim Me " trimmedString=${stringWithWhitespace##*( )} trimmedString=${trimmedString%%*( )} echo $trimmedString # Output: Trim Me

String Comparison

Compare strings using conditional constructs like [[ $string1 == $string2 ]] or [[ $string1 != $string2 ]].

string1="Hello" string2="World" if [[ $string1 == $string2 ]]; then echo "Strings are equal." else echo "Strings are not equal." fi

String Slicing

Extract a range of characters from a string using parameter expansion: ${string:start:length}.

originalString="BashScripting" slicedString=${originalString:4:6} echo $slicedString # Output: Script

String Splitting

Split a string into an array using IFS (Internal Field Separator) and read into an array variable.

stringToSplit="one:two:three:four" IFS=":" read -ra myArray <<< "$stringToSplit" echo ${myArray[2]} # Output: three

String to Array Conversion

Convert a string to an array using read or by iterating over characters.

stringToArray="Bash" read -a charArray <<< $(echo $stringToArray | sed 's/./& /g') echo ${charArray[2]} # Output: s


Handle strings with special characters using single or double quotes for proper quoting and escaping.

specialString="This is a 'quoted' string." echo "$specialString" # Output: This is a 'quoted' string.

String Comparison for Sorting

Compare strings numerically or lexicographically to facilitate sorting operations.

stringArray=("Apple" "Banana" "Orange" "Mango") sortedArray=($(for item in "${stringArray[@]}"; do echo $item; done | sort))

String Length Check

Evaluate if a string is empty or not using conditional constructs like [[ -z $string ]] or [[ -n $string ]].

checkString="" if [[ -z $checkString ]]; then echo "String is empty." else echo "String is not empty." fi
Points to Remember:
  1. Quote your strings: Enclose strings in quotes to prevent unexpected interpretation by the shell. Single quotes (') preserve special characters, while double quotes (") allow variable expansion.
  2. Error handling: Check for errors and handle them smoothly to avoid script crashes. Use conditional statements and exit codes effectively.


String manipulation in Bash involves operations like concatenation, substring extraction, length calculation, find and replace, and case conversion. Bash provides built-in features for effective string handling, enabling tasks such as pattern matching with regular expressions and utilizing command substitution, while arrays offer a way to store and manipulate multiple strings.