Tr Command in Linux with Examples

The tr command in Linux is a powerful text processing utility that allows users to translate, delete, or squeeze characters from standard input. This versatile command is essential for text manipulation tasks and forms a core part of the Linux command-line toolkit. Whether you’re performing case conversions, removing unwanted characters, or normalizing data formats, tr offers an efficient solution with minimal syntax complexity.

Introduction to the tr Command

The tr command, short for “translate,” is a simple yet powerful utility in Linux designed for character-based operations on text streams. It reads from standard input, performs character transformations, and writes the results to standard output. Unlike many other text processing tools, tr operates at the character level rather than on lines or patterns.

The tr command originated in early Unix systems and has remained relatively unchanged over decades due to its elegant simplicity and effectiveness. It excels at fundamental text transformation tasks that would otherwise require more complex commands or scripts.

As a streamlined utility, tr complements other Linux text processing tools like grep, sed, and awk. While these other tools focus on pattern matching and complex transformations, tr’s strength lies in its character-by-character operations. This makes it particularly useful for quick transformations in pipelines or scripts where the processing requirements are straightforward but essential.

Throughout this article, we’ll explore the various capabilities of the tr command, from basic syntax to advanced use cases, all illustrated with practical examples to enhance your Linux text processing skills.

Understanding the tr Command Syntax

The basic syntax of the tr command follows this pattern:

tr [OPTION] SET1 [SET2]

This deceptively simple structure conceals tr’s versatility. The command takes two primary parameters: SET1 and SET2, which represent character sets used for operations. When both sets are provided, tr translates each character from SET1 to the corresponding character in SET2.

For example, the following command replaces each ‘l’ with ‘r’, ‘i’ with ‘e’, and ‘n’ with ‘d’ in the word “linuxize”:

echo 'linuxize' | tr 'lin' 'red'

This produces the output “reduxeze”.

It’s important to understand that tr cannot directly read from files. Instead, it processes text from standard input, which is typically provided through pipes or redirections. For instance, to process text from a file, you would use:

cat filename.txt | tr 'a' 'b'

This limitation stems from tr’s design as a filter program that processes streams of text rather than files directly.

When SET2 is shorter than SET1, tr will reuse the last character of SET2 for the remaining characters in SET1. If no SET2 is provided with certain options like -d, tr will perform operations (like deletion) using only SET1 as reference.

The character sets in tr can be specified in several ways, including literal characters, character ranges (like a-z), character classes (like [:alpha:]), and escape sequences (like \n for newline). These flexible specifications make tr versatile enough to handle a wide range of text transformation tasks.

Key Options and Flags for tr Command

The tr command becomes even more powerful with its various options. Understanding these options is crucial for unleashing the full potential of this text processing tool.

The -d option: Deleting Characters

The -d option tells tr to delete all occurrences of characters specified in SET1 from the input. This is particularly useful for removing unwanted characters from text.

echo "Baeldung is in the top 10" | tr -d 'e'

This command removes all occurrences of the letter ‘e’, resulting in: “Baldung is in th top 10”. For more complex deletion, you can specify multiple characters:

echo "Baeldung is in the top 10" | tr -d 'aeiou'

This deletes all vowels, producing: “Bldng s n th tp 10”.

The -s option: Squeezing Repeated Characters

The -s option squeezes repeated occurrences of characters listed in SET1 into a single instance. This is particularly useful for normalizing whitespace or removing duplicate characters.

echo "hello world" | tr -s 'l'

This replaces multiple consecutive ‘l’ characters with a single ‘l’, resulting in: “helo world”. When combined with character sets, it becomes even more powerful:

echo "wwelcome to uultahost.ccom" | tr -s 'a-z'

This squeezes all consecutive lowercase letters, producing a normalized text output.

The -c option: Complementing Character Sets

The -c option instructs tr to complement the set of characters in SET1, meaning it operates on characters NOT in SET1. This is particularly useful for selective operations.

echo "My email id is user@example.com" | tr -cd [:digit:]

This command deletes all characters except digits, effectively extracting only the numbers from the text.

The -t option: Truncating SET1

The -t option forces tr to truncate SET1 to the length of SET2 before processing. This prevents the default behavior where tr reuses the last character of SET2.

These options can be combined to perform complex text transformations efficiently. The ability to delete, squeeze, complement, and truncate makes tr a versatile tool for many text processing tasks in Linux.

Character Sets and Special Sequences

The tr command’s power lies in its ability to work with various character sets and special sequences. Understanding these is essential for effective text manipulation.

Standard Character Classes

POSIX character classes provide an easy way to specify common sets of characters. Some commonly used classes include:

• [:alpha:] – All alphabetic characters
• [:digit:] – All digits
• [:lower:] – All lowercase letters
• [:upper:] – All uppercase letters
• [:space:] – All whitespace characters
• [:alnum:] – All alphanumeric characters

For example, to convert all digits to the letter ‘X’:

echo "User123" | tr [:digit:] 'X'

This will output “UserXXX”.

Character Ranges

For simpler specifications, tr allows defining character ranges using hyphens:

• a-z – All lowercase letters
• A-Z – All uppercase letters
• 0-9 – All digits

These ranges can be combined in a single set:

echo "Hello123" | tr 'a-zA-Z' 'x'

This replaces all alphabetic characters with ‘x’.

Escape Sequences and Special Characters

Tr supports various escape sequences for special characters:

• \n – Newline
• \t – Tab
• \r – Carriage return
• \\ – Backslash
• \a – Alert (bell)

For example, to replace spaces with tabs:

echo "Baeldung is in the top 10" | tr [:space:] '\t'

This substitutes each space with a tab character.

Using Multiple Character Sets

Multiple character sets can be combined for complex transformations:

echo "Hello123World" | tr 'a-z0-9' 'A-Z_'

This converts lowercase letters to uppercase and digits to underscores.

Common Pitfalls

When working with character sets, be cautious about:

1. Order matters in character ranges (use a-z, not z-a)
2. Special characters often need escaping with backslashes
3. Character classes must be properly enclosed in brackets and colons
4. SET1 and SET2 should be appropriately matched for translation operations

Understanding these character sets and their proper usage will significantly enhance your ability to perform precise text transformations with the tr command.

Case Conversion Examples

One of the most common uses of the tr command is for case conversion. This section explores various approaches to manipulating text case.

Converting Lowercase to Uppercase

There are multiple ways to convert text from lowercase to uppercase using tr:

Using character ranges:

echo 'linuxize' | tr 'a-z' 'A-Z'

This produces: “LINUXIZE”.

Using POSIX character classes:

echo 'Linuxize' | tr '[:lower:]' '[:upper:]'

This converts all lowercase letters to uppercase: “LINUXIZE”.

Both methods effectively convert lowercase text to uppercase, but the character class approach is generally more readable and locale-aware.

Converting Uppercase to Lowercase

The reverse conversion is equally straightforward:

Using character ranges:

cat example.txt | tr 'A-Z' 'a-z'

This converts all uppercase characters to lowercase.

Using POSIX character classes:

cat linux.txt | tr [:upper:] [:lower:]

This approach also converts uppercase to lowercase, but uses the more explicit character classes.

Partial Case Conversion

Sometimes you might want to convert only specific characters. For instance, to convert only vowels to uppercase:

echo "linux command line" | tr 'aeiou' 'AEIOU'

This selectively changes only the vowels: “lInUx cOmmAnd lInE”.

Practical Use Cases in Scripts

Case conversion is particularly useful in shell scripts for:

1. Normalizing user input regardless of how it was entered
2. Standardizing data formats in log processing
3. Making case-insensitive comparisons
4. Formatting output data consistently

For example, this script converts all input to lowercase for consistent processing:

#!/bin/bash
read -p "Enter command: " cmd
cmd_lower=$(echo "$cmd" | tr 'A-Z' 'a-z')
case "$cmd_lower" in
  "help") echo "Help menu..." ;;
  "exit") echo "Exiting..." ;;
  *) echo "Unknown command" ;;
esac

These case conversion capabilities make tr an essential tool for text normalization in Linux environments.

Character Deletion Examples

The tr command excels at character deletion tasks through its -d option. This functionality is invaluable for cleaning and formatting text data.

Deleting Specific Characters

To delete specific characters from text, use the -d option followed by the characters to remove:

echo "Hello, World!" | tr -d ','

This removes all commas from the text, resulting in: “Hello World!”.

Multiple characters can be deleted at once:

echo "Hi, Welcome to idroot.us" | tr -d 'o'

This deletes all occurrences of the letter ‘o’, producing: “Hi, Welcome t idroot.us”.

Deleting Ranges of Characters

For more comprehensive deletion, character ranges can be specified:

echo "User123Name456" | tr -d '0-9'

This removes all digits, resulting in: “UserName”.

Deleting All Digits from Text

To specifically target digits in text:

echo "My email id is user@example.com" | tr -d [:digit:]

This removes all numeric digits from the email address.

Deleting All Non-Alphanumeric Characters

To create clean, alphanumeric text:

echo "Hello, World! 123" | tr -d -c '[:alnum:]'

This removes all characters except letters and numbers, resulting in: “HelloWorld123”.

Combining Deletion with Other Operations

Character deletion becomes even more powerful when combined with other tr operations:

echo "Hello  World   Test" | tr -d ' ' | tr 'a-z' 'A-Z'

This first removes all spaces and then converts the remaining text to uppercase: “HELLOWORLDTEST”.

Real-World Examples

In system administration and data processing, character deletion is frequently used for:

1. Stripping unwanted formatting characters from data files
2. Removing special characters from user input
3. Cleaning log files by removing unnecessary symbols
4. Extracting specific character types from mixed content
5. Normalizing text data for consistent processing

For instance, this command extracts just the hostname from a fully qualified domain name:

echo "server.example.com" | tr -d -c '[:alnum:].\n' | tr '.' ' ' | awk '{print $1}'

The character deletion capability of tr is a powerful tool for text sanitization and extraction tasks in Linux environments.

Character Squeezing Examples

The tr command’s -s option allows for squeezing repeated characters into a single occurrence. This feature is particularly useful for normalizing text and formatting data.

Basic Concept of Squeezing Repeated Characters

Character squeezing replaces consecutive occurrences of the same character with a single instance:

echo "hello    world" | tr -s ' '

This reduces multiple spaces to a single space, resulting in: “hello world”.

Squeezing Whitespace into Single Spaces

One of the most common applications is normalizing whitespace in text:

echo "GNU \    Linux" | tr -s ' '

This command converts multiple consecutive spaces into a single space: “GNU \ Linux”.

Squeezing Tabs and Newlines

The squeeze option works with special characters too:

cat messy_file.txt | tr -s '\t\n'

This normalizes tabs and newlines in the file, removing any consecutive occurrences.

Combining Squeezing with Translation

You can combine squeezing with character translation for more complex transformations:

echo "GNU \    Linux" | tr -s ' ' '_'

This both squeezes repeated spaces and converts them to underscores: “GNU_\_Linux”.

Examples of Formatting Data with Squeeze Option

Character squeezing is invaluable for data formatting:

echo "1,,,2,,3,4,,,,5" | tr -s ','

This normalizes comma-separated values by reducing multiple commas to single ones: “1,2,3,4,5”.

For processing log files:

cat server.log | tr -s ' ' | cut -d' ' -f1,4,7

This squeezes spaces in log entries and then extracts specific fields, making log analysis more efficient.

When to Use Squeeze vs. Other Text Processing Tools

While other tools like sed and awk can also handle repeated characters, tr’s squeeze option is often the most straightforward solution when:

1. The operation is simple and character-based
2. Performance is a concern (tr is generally faster)
3. The transformation needs to be part of a pipeline
4. No complex pattern matching is required

For more complex operations involving patterns or conditional processing, sed or awk might be more appropriate.

The squeeze functionality of tr is particularly valuable in data cleaning workflows, making it an essential component of Linux text processing.

Complementing Character Sets

The tr command’s -c option provides a powerful way to work with the complement of character sets, allowing you to operate on all characters NOT in the specified set.

Understanding the Complement Operation

The complement operation with tr’s -c option inverts the specified character set:

echo "abc123xyz" | tr -c 'a-z' '?'

This replaces all non-lowercase letters with ‘?’, resulting in: “abc???xyz”.

Using -c with -d for Inverse Deletion

A common use case is combining -c with -d to delete all characters except those specified:

echo "My email id is user@example.com" | tr -cd [:digit:]

This deletes everything except digits, effectively extracting only the numbers: “321”.

Practical Examples of Complement Operations

Extract only alphabetic characters:

echo "User123@example.com" | tr -cd '[:alpha:]'

This produces: “Userexamplecom”.

Preserve only alphanumeric characters and newlines:

cat mixed_data.txt | tr -cd '[:alnum:]\n'

This removes all non-alphanumeric characters while preserving line breaks, which is useful for cleaning data files.

Common Scenarios Where Complement is Useful

The complement operation is particularly valuable for:

1. Data extraction (getting only specific character types)
2. Input validation (removing unwanted characters)
3. Creating “clean” versions of text by preserving only desired characters
4. Converting complex formats to simpler ones
5. Masking or obfuscating certain character types

Complementing with Character Classes

Using POSIX character classes makes complement operations more readable:

echo "test@example.com" | tr -cd '[:alnum:]@.'

This preserves only alphanumeric characters plus ‘@’ and ‘.’, effectively cleaning the email address while keeping it valid.

Potential Pitfalls and Solutions

When using complement operations, be aware of:

1. Forgetting to include necessary characters (like newlines)
2. Unexpected behavior with multibyte characters
3. Character class interpretation differences across locales

A common solution to preserve line breaks is explicitly including ‘\n’ in your character set:

cat data.txt | tr -cd '[:digit:]\n'

This ensures digits are kept without collapsing the file into a single line.

The complement functionality offers an elegant way to approach character filtering from an “exclusive” rather than “inclusive” perspective, making it valuable for many text processing tasks.

Combining tr with Other Commands

The tr command becomes even more powerful when combined with other Linux utilities in command pipelines. This section explores effective combinations that enhance text processing workflows.

Using tr in Pipelines

The tr command is designed to work seamlessly in Unix pipelines:

cat file.txt | tr 'a-z' 'A-Z' | sort | uniq > processed.txt

This pipeline converts text to uppercase, sorts the lines, removes duplicates, and saves the result to a new file.

Combining with grep, sed, and awk

With grep:

cat server.log | tr '[:upper:]' '[:lower:]' | grep 'error'

This converts all text to lowercase before searching, ensuring case-insensitive matching for ‘error’.

With sed:

cat data.csv | tr -s ',' | sed 's/,/ | /g'

This normalizes multiple commas and then replaces them with a more readable separator.

With awk:

grep -i "googlebot" access.log | tr '[:upper:]' '[:lower:]' | awk '{print $1,$7}' > googlebot_requests.txt

This extracts Googlebot requests from logs, normalizes case, and then extracts specific fields.

Using tr with File Redirection

While tr itself doesn’t read from files directly, it works well with redirection:

tr 'a-z' 'A-Z' < input.txt > output.txt

This converts lowercase to uppercase, reading from input.txt and writing to output.txt.

Creating Complex Text Processing Workflows

For more complex tasks, tr can be part of sophisticated processing chains:

cat log.txt | tr -s ' ' | cut -d' ' -f1,4 | tr ' ' ',' > processed.csv

This normalizes spaces in log entries, extracts specific fields, converts spaces to commas, and creates a CSV file.

Shell Scripts Using tr

Incorporating tr into shell scripts enhances text processing capabilities:

#!/bin/bash
cat logs.txt | tr 'A-Z' 'a-z' | tr -s ' ' > newLogFile.txt

This script converts text to lowercase and removes extra spaces, saving the result to a new file.

Performance Considerations in Complex Pipelines

When building pipelines with tr, consider:

1. tr is generally fast for simple character operations
2. For large files, consider streaming processing rather than loading entire files
3. Position tr early in pipelines when it can reduce data volume for downstream commands
4. For very complex transformations, combining multiple tr commands may be less efficient than a single sed or awk script

Effectively combining tr with other commands creates powerful, efficient text processing solutions that leverage each tool’s strengths.

Advanced tr Command Usage

Beyond basic operations, the tr command offers advanced capabilities for sophisticated text transformations. This section explores these more complex use cases.

Handling Special Characters and Escaping

When working with special characters in tr, proper escaping is essential:

echo "Path: /usr/local/bin" | tr '/' '\\'

This converts forward slashes to backslashes, but requires proper escaping of the backslash character.

For characters with special meaning in the shell:

echo "Price: $100" | tr '$' 'USD'

This might require additional escaping or quoting depending on your shell.

Working with Unicode and Multibyte Characters

The tr command has limitations with multibyte characters:

echo "こんにちは" | tr 'こ' 'コ'

This may not work as expected with many implementations of tr, which primarily operate on single-byte characters.

For Unicode processing, consider using specialized tools like iconv or perl with the tr operator:

echo "こんにちは" | perl -CSD -pe 's/こ/コ/g'

Translating Between Different Character Sets

For complex translations between character sets:

echo "abcdef" | tr 'abcdef' '123456'

This maps each character in the first set to its corresponding position in the second set: “123456”.

Using tr for Basic Encryption/Decryption

The tr command can be used for simple ROT13 encoding:

echo "secret text" | tr 'a-zA-Z' 'n-za-mN-ZA-M'

This implements a basic Caesar cipher, shifting letters by 13 positions.

And to decode:

echo "frperg grkg" | tr 'a-zA-Z' 'n-za-mN-ZA-M'

This applies the same transformation to reverse the encoding.

Handling Binary Data with tr

While primarily designed for text, tr can process binary data with caution:

hexdump -C binary_file | tr '[:lower:]' '[:upper:]'

This converts the hexadump output to uppercase for analysis.

Limitations and Workarounds

The tr command has several limitations to be aware of:

1. Limited pattern matching compared to sed or awk
2. Cannot directly read from files
3. Challenges with multibyte characters
4. No direct replacement for specific patterns

Workarounds often involve combining tr with other tools:

cat file.txt | sed 's/pattern/replacement/g' | tr 'a-z' 'A-Z'

This uses sed for pattern matching and tr for character-level transformation.

Understanding these advanced aspects of tr helps leverage its capabilities while recognizing when to supplement it with other tools for comprehensive text processing.

Common tr Command Use Cases

The tr command finds application in numerous practical scenarios. This section explores some of the most common and useful applications.

Text Normalization for Data Processing

Normalizing text is crucial for consistent data processing:

cat raw_data.txt | tr -s ' \t\n' ' ' | tr '[:upper:]' '[:lower:]'

This command reduces multiple whitespaces to single spaces and converts text to lowercase, creating normalized data that’s easier to process.

Cleaning Input Data

Removing unwanted characters from input is a frequent requirement:

cat user_input.txt | tr -cd '[:alnum:] \n'

This retains only alphanumeric characters, spaces, and newlines, effectively sanitizing the input.

Format Conversion

Converting between different text formats is straightforward with tr:

cat windows.txt | tr -d '\r' > unix.txt

This removes carriage returns, converting Windows text format to Unix format.

Password Generation

The tr command can be used for basic password generation:

head -c 20 /dev/urandom | tr -cd '[:alnum:]' | head -c 12

This creates a 12-character password containing only alphanumeric characters.

CSV and Data File Manipulation

For working with CSV files and other structured data:

cat data.csv | tr -s ',' | tr ',' '\t' > data.tsv

This normalizes multiple commas and then converts the CSV to tab-separated format.

Log File Processing and Analysis

The tr command is valuable for log file processing:

cat access.log | tr -s ' ' | cut -d' ' -f1,7 | tr ' ' ','

This normalizes spaces in log entries, extracts specific fields (like IP address and requested URL), and converts spaces to commas for easier analysis.

Common practical applications for tr include:

1. Data cleaning in ETL workflows
2. Standardizing text formats in document processing
3. Simplifying complex character sets for analysis
4. Input validation in shell scripts
5. Converting between different data representation formats

These use cases demonstrate tr’s versatility in real-world text processing scenarios, making it an essential tool for many Linux users.

Troubleshooting and Best Practices

Effective use of the tr command requires understanding common issues and following best practices. This section provides guidance for troubleshooting and optimizing your use of tr.

Common Errors and Their Solutions

1. Character sets of unequal length:

When SET1 is longer than SET2, tr will reuse the last character of SET2. To avoid unexpected behavior, use the -t option to truncate SET1:

echo 'Linux ize' | tr -t 'abcde' '12'

Without -t, ‘e’ would be translated to ‘2’ (last character of SET2).

2. Misunderstanding complement operations:

Using -c incorrectly can lead to unexpected results. Remember that -c complements the first set:

echo "test@example.com" | tr -cd '[:alnum:]@.'

This preserves alphanumerics plus ‘@’ and ‘.’, not removes them.

3. Forgetting to escape special characters:

Special characters need proper escaping:

echo "Path/to/file" | tr '/' '\\'

This requires escaped backslashes to correctly translate forward slashes to backslashes.

Performance Optimization Tips

For optimal performance with tr:

1. Position tr early in pipelines when it can reduce data volume
2. Use character classes rather than listing many individual characters
3. Combine multiple tr operations into a single command when possible
4. For very large files, consider streaming processing

Alternatives When tr is Insufficient

When tr’s capabilities are insufficient, consider:

1. sed for pattern-based replacements
2. awk for field-based processing
3. perl for complex text transformations
4. iconv for character encoding conversions

Debugging tr Command Issues

To troubleshoot tr commands:

1. Test with small, simple inputs first
2. Echo the exact command to verify escaping
3. Use ‘set -x’ in shell scripts to see command expansion
4. Check character encoding of input files

Best Practices for Maintainable Scripts Using tr

To create maintainable scripts with tr:

1. Document the purpose of character transformations
2. Use meaningful variable names for complex character sets
3. Consider creating functions for common transformations
4. Use character classes for better readability
5. Test with edge cases

#!/bin/bash
# Function to normalize text for processing
normalize_text() {
    tr -s '[:space:]' ' ' | tr '[:upper:]' '[:lower:]'
}

cat "$1" | normalize_text > normalized.txt

Security Considerations

When using tr in security-sensitive contexts:

1. Be cautious with user-supplied input to tr
2. Don’t rely on tr alone for input sanitization
3. Consider potential encoding issues that might bypass filters
4. Remember tr doesn’t understand context or semantics

Following these troubleshooting tips and best practices will help you use tr more effectively and avoid common pitfalls in your text processing workflows.