How to Replace String in Bash [6 Best Ways]

Written by

Ojash

Reviewed by

Akshat

Last updated: July 24, 2024

Expert verified

Changing a word or phrase in multiple files or lines of text can be time-consuming if done manually, but Bash provides powerful tools to automate this. This post will show you various methods for replacing strings in Bash, troubleshooting common errors, and quick tips to make the process smoother.

In this guide, you’ll learn how to use sed, awk, tr, regular expressions, and Bash built-in functions for string replacement. I’ll provide step-by-step instructions and examples to help you master these techniques. By the end, you’ll be equipped to handle string replacement tasks efficiently and effectively.

What is String Replacement?

String replacement means changing one part of a text (a string) to another part. In Bash, this is useful for many tasks, such as modifying text files, renaming files, or updating configuration settings.

Example:

If you have a text file that says:

Hello World

and you want it to say:

Hello Bash

you would replace the word “World” with “Bash.” This process is called string replacement.

Why Use String Replacement?

• Consistency: Ensure uniform changes across multiple files or lines of text.
• Automate Tasks: Quickly modify large amounts of text without manual editing.
• Efficiency: Save time by automating repetitive text changes.

How to Replace String in Bash [6 Easy Ways]

Here, I’ll provide step-by-step instructions for each of six different methods to replace string in bash:

1. sed Command

sed (stream editor) is a powerful text processing tool in Unix-based systems, primarily used for text substitution. Here’s how to use it:

1. Launch the Terminal app and execute the command below to read the text file:

cat filename

2. Now, run the command below to replace string in Bash.

sed 's/original/replacement/g' input-file > output-file

3. This command will replace all occurrences of “original” with “replacement”. Now, you’ll see the following output using the cat command:

2. awk Command

awk is a versatile text processing tool that operates with patterns and actions. You can use this command to replace string in Bash in the following way:

1. Execute the command below to read the text file in the Terminal window:

cat filename

2. Run the following command in the Linux command prompt:

awk '{gsub(/original/, "replacement")}1' input-file > output-file

2. Now, you’ll see all occurrences of “string 1” replaced with “string 2”:

3. tr Command

tr (translate) is a command for character-level translations and deletions. Follow these steps to use it to replace string in Bash:

1. Run the cat command in the command prompt to read the file.

cat filename

2. Enter the following command in the Terminal window:

tr 'original' 'replacement' < input-file > output-file

2. tr 'aeiou' 'AEIOU' < text.txt > text_modified.txt will find and replace all lowercase vowels with their uppercase counterparts. Here is the output:

4. Bash Built-In Functions

Bash provides built-in string manipulation functions using parameter expansion, substring replacement, and case modification. To replace string in Bash, try these built-in functions:

1. Save the string “The quick brown fox jumps over the lazy dog” in a variable named “myString” with the following command:

myString="The quick brown fox jumps over the lazy dog"

2. Now, you can use the variable “myString” in other commands to manipulate or display its contents. To confirm the variable value, run the echo $myString command in the Linux command prompt:

3. To replace only the first occurrence of a substring “brown” with “red” in the string, you can use the following command:

echo ${myString/brown/red}

2. The output would be:

3. You can also run the following command to replace all occurrences of a substring:

echo ${myString//e/a}

3. If done correctly, it’ll replace string in Bash, and you’ll get the output in Terminal:

4. You can also convert a string to uppercase with the following command:

echo ${myString^^}

5. You’ll get the following output in the Terminal window.

6. Similarly, if you want to replace string in Bash with its lowercase, run the following command:

echo ${myString,,}

7. The output of this command would be:

5. Regular Expressions

Regular expressions (regex) are a powerful way to define search patterns in text. It is a sequence of characters that specifies a search pattern. It can be used to match, find, or replace specific strings within a text. Here’s how you can use it:

1. Create and save the text file with the following content:

123456789
The quick brown fox jumps over the 9 lazy dogs.

2. Launch the Terminal app and execute the cat command to confirm the text file content.

3. Now, use the sed command below to replace all digits with an ‘X’:

sed 's/[0-9]/X/g' input-file > output-file

4. Use the cat command to see the output in your Terminal window.

5. Alternatively, you can use the awk command to replace all digits with an ‘X’:

awk '{gsub(/[0-9]/, "X")}1' input-file > output-file

6. You’ll see the following output using the cat command:

6. Bash Scripting and Automation

You can create reusable scripts and automate the string replacement tasks to replace string in Bash. This can save time and reduce errors. To do so, follow these steps:

1. Create a Bash script file:

touch replace_string.sh

2. Execute the nano command with the filename.

nano replace_string.sh

3. Add the following content to the script:

#!/bin/bash
input_file="$1"
search_string="$2"
replacement_string="$3" 
output_file="$4"
sed "s/$search_string/$replacement_string/g" "$input_file" > "$output_file"  

This script takes four arguments: the input file name, the search string, the replacement string, and the output file name. It uses the sed command to replace all occurrences of the search string with the replacement string in the input file and saves the output to the specified output file.

3. Press Ctrl + O and Enter to save. Then, press Ctrl + X to exit the Nano text editor.

4. Make the script executable:

chmod +x replace_string.sh

4. Execute the cat command to read the input file.

cat filename

5. Run the script in the Terminal window:

./replace_string.sh input-file search-string replacement-string output-file

6. Run the cat command to see the output:

Common Pitfalls and How to Avoid Them

When replacing strings in Bash, you might encounter some common problems. Here’s how to avoid them:

1. Mistakes in Regex Patterns

Regular expressions (regex) can be tricky. A small mistake can mess up your string replacement.

Solution:

• Double-check your regex patterns.
• Test them with a small sample of text before using them on large files.

2. Overwriting Original Files

Using the -i flag with sed can overwrite your original files. If you make a mistake, you might lose important data.

Solution:

• Always make a backup of your files before running the sed command.
• Use the -i.bak option with sed to create a backup automatically.

3. Case Sensitivity Issues

By default, string replacement commands are case-sensitive. This means they won’t replace strings that have different cases (e.g., “String” vs “string”).

Solution:

• Use the I flag with sed to make the replacement case-insensitive: sed 's/old_string/new_string/I' filename.

4. Performance Problems with Large Files

Processing large files can be slow, especially if your script is inefficient.

Solution:

• Use the most efficient tool for the job. For simple replacements, sed is usually faster than awk.
• Avoid running multiple commands when one can do the job.
• Test your scripts with a subset of your data to identify and fix slow parts.

5. Testing and Debugging

It’s easy to make mistakes when writing scripts, and those mistakes can be hard to find.

Solution:

• Always test your commands on a small set of data first.
• Use the echo command to print out what your variables contain and what your commands are doing.
• Read error messages carefully, they often tell you exactly what’s wrong.

6. Wrong File Path

Incorrect file paths can cause your script to fail.

Solution:

• Use absolute paths (full paths) instead of relative paths (shorter paths) to avoid confusion.
• Double-check the paths to your files.

4 Quick Tips to Replace String in Bash Efficiently

To replace string in Bash efficiently, use optimized techniques to do it. This is especially important when handling large datasets and complex automation processes. Consider the following four tips to optimize your string replacement techniques and improve your Bash scripting skills:

• 🚀 Speed considerations: For simple string replacement tasks, use built-in Bash functions, as they are generally faster than external tools like sed and awk. However, you may still have to use sed or awk over Bash built-in functions for large files, as they handle the memory more efficiently.
• 🧪 Test the string replacement: Always test your string replacement commands and scripts on sample data before applying them to critical files or production environments. Keep your scripts modular and reusable to reduce the likelihood of errors and improve maintainability.
• 💾 Memory usage: Be mindful of memory usage when working with large files or data sets. sed and awk can be more memory-efficient than built-in Bash functions for such tasks.
• 📄 Print specific lines: Use the -n option with sed to disable automatic printing of output, and then use the p command to print only specific lines that match your search pattern. This can save time and resources when working with large files.

Final Thoughts

By now, you should have a solid understanding of various techniques to replace string in Bash using the sed, awk, tr, and regex methods. You can further explore Bash string manipulation to help you automate tasks and streamline your workflow:

• Learn how to find the length of a string in Bash to optimize your scripts.
• Explore methods to split strings in Bash, enhancing your data processing capabilities.
• Discover how to use bash set -x for effective debugging and troubleshooting of your scripts.

Frequently Asked Questions