Written by

Ojash

Reviewed by

Akshat

Last updated: May 1, 2024

Expert verified

Managing multi-line strings in Bash scripting can be tricky, especially when you’re working with complex configurations or automating scripts. Fortunately, using cat EOF is a powerful way to simplify these challenges. This method is excellent for handling large amounts of string data efficiently. In this post, I’ll show you five practical ways to use cat EOF for various tasks—from embedding dynamic content to building detailed scripts. I’ll also share some key best practices to keep your scripts robust and easy to read.

How to Use Cat EOF for Multi-line Strings in Bash?

Now let’s explore several effective methods to utilize cat EOF in your Bash scripts. Each method is designed to cater to different needs, from writing direct text to files to embedding dynamic variables and more:

1. Writing Multi-Line Text to a File

This method is used to write blocks of multi-line text directly into a file from the command line, useful for creating configuration files, scripts, or documenting information within a project. Follow these steps:

1. Open your terminal. Make sure you have access to a Bash shell.

2. Enter the command below, substituting output.txt with your desired file name:

cat << EOF > output.txt

This is line one

This is line two

This is line three

EOF

This command directs the text between << EOF and EOF into output.txt.

3. Check the file content by typing:

cat output.txt

This command displays the contents of output.txt to ensure your text has been written correctly.

2. Storing Multi-Line String in a Variable

Store multi-line strings in a variable for reuse throughout your script, enhancing script clarity and reducing duplication. Here is how to do it:

1. Access your command window and run the following script to store the multi-line string in a variable named my_variable:

read -r -d ' ' my_variable << 'EOF' line 1 line 2 line 3 EOF

This script uses the read command to capture the multi-line text into my_variable until it encounters an EOF marker.

2. Display the variable by entering:

echo "$my_variable"

This command prints the contents of my_variable to verify that it stores the correct string.

3. Embedding Variables within the Text

Dynamically insert Bash variables into your multi-line text, allowing for personalized scripts or configurations. Here is the step-by-step guide to do it:

1. Launch your Terminal and define the variable you want to use, e.g.:

username="John"

This command assigns the value "John" to the variable username.

2. Use the following cat EOF syntax to embed the variable within the multi-line text:

cat << EOF
Hello, $username!
Welcome to the system.
EOF

This script will dynamically insert the value of the username into the text at the specified location.

4. Using cat EOF in Loops

Generate repeated blocks of text with variations, useful for creating multiple configuration files or similar environments in bulk. Here are the steps to do it:

1. In your Terminal type the following loop script:

for i in {1..5}; do
cat << EOF
This is iteration $i
Another line
EOF
done

This loop uses cat EOF to generate a text block for each iteration, inserting the loop counter $i into each block.

2. Execute the script and observe the output, demonstrating the effect of the loop on the generated text.

5. Creating Scripts or Code Blocks

Quickly generate executable scripts or code templates directly from the command line, streamlining development processes and automation tasks. Follow these steps:

1. Open your command prompt and use cat EOF to write a new script to a file:

cat << EOF > my_script.sh #!/bin/bash echo "Starting the script..." # Add more commands here echo "Script ended." EOF

This command writes a complete bash script to my_script.sh.

2. Make the script executable by running:

chmod +x my_script.sh

This command changes the permissions of my_script.sh, making it executable.

3. Verify the script by executing:

./my_script.sh

This command runs the script, allowing you to verify its functionality.

5 Best Practices for Using cat EOF in Bash Scripting

When using cat EOF for handling multi-line strings in Linux Bash, following best practices can greatly improve the efficiency, security, and readability of your scripts. Here are five key tips to help you use this feature effectively:

• 📝 Use Indentation Consistently: Always keep the lines between your EOF markers indented at the same level. This uniformity makes your scripts easier to read and understand. Be consistent with your choice of tabs or spaces to prevent issues when running scripts on different systems or editors.
• 🔒 Escape Variables When Needed: If you don’t want Bash to replace variables with their values inside the EOF block, surround EOF with single quotes, like EOF. This tells Bash to treat everything inside as plain text, not as code or variables. It’s useful when you want to show examples in your script or store exact text.
• 🚀 Avoid Using Reserved Words as Delimiters: Choose a unique word for your EOF delimiter to prevent confusion with words Bash already uses (like for, done, or fi). Using common words can lead to errors where Bash misinterprets your intentions. 
• 🛡️ Secure Input Data: Always check and clean data from outside your script before using it in an EOF block. This is crucial to prevent harmful code from sneaking into your script, which can happen if you include user input or data from the internet. Use tools or methods to sanitize this data first.
• 🧹 Close EOF Properly: Make sure the EOF delimiter has no extra spaces or characters before or after it. This precise placement ensures that your script recognizes the end of the text block correctly. Mistakes here can cause parts of your script not to run or errors to appear.

In a Nutshell

In this article, I’ve shown you five methods to use cat EOF for handling multi-line strings in Bash. From creating simple text files to embedding variables dynamically in scripts, these techniques form the foundation for effective Bash scripting. By sticking to the best practices I discussed, you’ll make your scripts not only functional but also secure and easy to manage.

If you’re keen to take your Bash scripting skills further, consider exploring topics such as how to echo a new line in Bash Shell Scripts to manage script outputs better, enhance your command knowledge by learning to use the Help command, and master string manipulation through learning how to replace a string in Bash. These will directly enhance and build upon your existing scripting abilities.