Linux sed Command (Find and Replace Strings in Files)

The Linux sed command is one of those tools that makes life easier when working with text files. It’s not just for replacing words, it’s a powerful way to automate repetitive editing tasks, saving you time and effort. Whether you’re updating configuration files, processing logs, or just cleaning up data, sed is a tool you’ll find yourself reaching for again and again.

This guide will walk you through everything you need to know about sed, from the basics of finding and replacing text to more advanced tricks like working with regular expressions and editing multiple files at once. By the end, you’ll have the confidence to use sed effectively and avoid common pitfalls. Let’s get started and see how this command can make your workflow smoother.

Understanding the sed Command

Before jumping into examples, it helps to get familiar with the basics of the sed command. On most Linux distributions, GNU sed comes pre-installed, so you’re ready to go. At its core, sed is about making text manipulation simple and efficient.

Here’s the general syntax for finding and replacing text:

sed -i 's/SEARCH_REGEX/REPLACEMENT/g' INPUTFILE

Let’s break it down step by step:

• -i: This tells sed to edit the file in place. If you want to keep a backup of the original file, you can add an extension like .bak (e.g., -i.bak).
• s: The substitute command, used for search-and-replace operations.
• Delimiters (/): While / is the default delimiter, you can use others like | or : if it makes your command easier to read.
• SEARCH_REGEX: The string or regular expression pattern you’re looking for.
• REPLACEMENT: The text you want to replace it with.
• g: The global flag. Without it, only the first match on each line is replaced. Add this to replace all matches.

With this foundation, you’re ready to start using sed to tackle text editing tasks of all sizes.

Basic sed Command Usage for String Replacement

Let’s start with the basics of sed by looking at how to find and replace text in a file. Here’s an example using a file called file.txt with the following content:

123 Foo foo foo
foo /bin/bash Ubuntu foobar 456

Replace the First Instance of a String

To replace only the first occurrence of a string on each line, you can use the following command:

sed -i 's/foo/linux/' file.txt

Output:

123 Foo linux foo
linux /bin/bash Ubuntu foobar 456

Notice that only the first foo on each line was replaced, while other instances remain unchanged.

Replace All Occurrences of a String

To replace every occurrence of a string on each line, add the g flag for “global”:

sed -i 's/foo/linux/g' file.txt

Output:

123 Foo linux linux
linux /bin/bash Ubuntu linuxbar 456

This replaces every instance of foo, including substrings like foobar.

Avoid Matching Substrings

If you don’t want sed to replace partial matches (like foo inside foobar), you can use word boundaries (\b) around the search term:

sed -i 's/\bfoo\b/linux/g' file.txt

Output:

123 Foo linux linux
linux /bin/bash Ubuntu foobar 456

Case-Insensitive Replacement

To make the replacement case-insensitive, include the I flag:

sed -i 's/foo/linux/gI' file.txt

Output:

123 linux linux linux
linux /bin/bash Ubuntu linuxbar 456

Replace Strings Containing Special Characters

If the string you’re replacing includes special characters like /, you’ll need to escape them with a backslash (\). For example, to replace /bin/bash with /usr/bin/zsh:

sed -i 's/\/bin\/bash/\/usr\/bin\/zsh/g' file.txt

Or, use a different delimiter (like |) to make the command more readable:

sed -i 's|/bin/bash|/usr/bin/zsh|g' file.txt

Output:

123 Foo foo foo
foo /usr/bin/zsh Ubuntu foobar 456

Quick Tip:

• Test Before Committing Changes: Run your sed commands without the -i option to preview the changes before modifying the file.
• Always Create Backups: Use -i.bak to save a backup of the original file, just in case. For example:

sed -i.bak 's/foo/linux/g' file.txt

What’s Next?

If you’re ready to take your skills to the next level, the next section will cover advanced sed features. This includes working with regular expressions, line-specific replacements, and handling larger files or directories.

Advanced String Operations with sed

Once you’ve mastered the basics of sed, you can move on to its more advanced capabilities. With support for regular expressions, line-specific operations, and complex text transformations, sed becomes a powerful tool for handling even the most intricate text manipulation tasks.

Using Regular Expressions for Advanced Matching

Regular expressions allow you to match patterns, not just literal strings. For instance, to replace all 3-digit numbers with the word number:

sed -i 's/\b[0-9]\{3\}\b/number/g' file.txt

Output:

number Foo foo foo
foo /bin/bash Ubuntu foobar number

This matches only 3-digit numbers (e.g., 123 or 456) and replaces them, leaving other numbers unaffected.

Reusing the Matched Pattern with &

The & character corresponds to the matched pattern and can be used in the replacement string. For example, if you want to surround every 3-digit number with curly braces:

sed -i 's/\b[0-9]\{3\}\b/{&}/g' file.txt

Output:

{123} Foo foo foo
foo /bin/bash Ubuntu foobar {456}

Here, {&} inserts the matched number between the curly braces.

Line-Specific String Replacements

You can target specific lines or ranges of lines for replacement:

• Replace text on a specific line (e.g., line 2):

sed '2s/foo/linux/' file.txt

• Replace text in a range of lines (e.g., lines 2 to 4):

sed '2,4s/foo/linux/' file.txt

This gives you fine-grained control over where replacements occur, avoiding unintended changes.

Deleting Lines Matching a Pattern

You can delete all lines that contain a specific string. For example, to remove any line with the word foo:

sed '/foo/d' file.txt

Output:

123 Foo foo foo
/bin/bash Ubuntu foobar 456

Inserting or Appending Lines

To add a line before or after a specific pattern, use the i (insert) or a (append) commands. For example:

• Insert a line before every line containing foo:

sed '/foo/i\This is a new line' file.txt

• Append a line after every line containing foo:

sed '/foo/a\This is a new line' file.txt

Changing Entire Lines

To replace entire lines that match a pattern, use the c (change) command. For example, to replace all lines containing foo with This is a new line:

sed '/foo/c\This is a new line' file.txt

Output:

123 Foo foo foo
This is a new line
/bin/bash Ubuntu foobar 456

Combining Multiple Commands

You can chain multiple commands by separating them with semicolons. For instance, to replace foo with linux, delete lines containing Ubuntu, and append a line after bar:

sed -i 's/foo/linux/g;/Ubuntu/d;/bar/a\This line was added' file.txt

This approach lets you perform complex transformations in a single command.

Working with Large Files or Multiple Directories

When working with large files or directories, combining sed with other tools like find or grep becomes incredibly useful:

• Recursive Search and Replace: Replace all occurrences of foo with bar in the current directory and its subdirectories:

find . -type f -exec sed -i 's/foo/bar/g' {} +

• Target Specific File Types: Replace foo with bar only in .txt files:

find . -type f -name "*.txt" -exec sed -i 's/foo/bar/g' {} +

Using grep for Matching Files: Search for files containing foo and replace it with bar, while creating backups:

grep -rlZ 'foo' . | xargs -0 sed -i.bak 's/foo/bar/g'

These techniques allow you to handle large-scale text manipulations with precision.

Advanced Tip: Speed Up sed with Unbuffered Mode

When working with large files, enable unbuffered mode using the -u option. This processes the file in chunks instead of loading it all into memory, improving performance:

sed -u 's/foo/bar/g' largefile.txt

Frequently Asked Questions (FAQs)

Conclusion: Mastering sed for Everyday Text Editing on Linux

The sed command is a reliable and versatile tool for editing text in Linux. Whether you’re making simple changes or handling complex transformations, sed can save you time and effort with its robust features. From basic find-and-replace tasks to advanced pattern matching and recursive edits, it’s an essential skill for anyone working with text files.

In this guide, we’ve covered the basics, explored advanced use cases, and shared tips to help you avoid common pitfalls. The flexibility of sed means you can adapt it to suit your specific needs, whether you’re managing configurations, processing data, or cleaning up file contents.

Share Your Thoughts

Have you tried using sed in your workflow? What challenges did you face or tips would you share with others? Let us know in the comments. Your feedback helps improve guides like this and builds a stronger Linux community.