An In-Depth Guide to Here Strings (<<<) in Bash

Bash, the Bourne Again SHell, is an incredibly powerful tool for managing and manipulating data. It offers a rich array of features, one of which is the ‘Here String’ (<<<). This lesser-known but powerful feature can make your Bash scripts more efficient and easier to read. In this guide, we'll delve into the what, why, and how of Here Strings in Bash.

What are Here Strings?

Here Strings, denoted by the symbol <<<, are a feature of Bash that allows you to pass a string directly into the standard input (stdin) of a command, much like a pipe (|). They were introduced in Bash version 3.0.

Here’s a simple example:

Advertisement

In this case, the string ‘foo bar’ is passed as input to the grep command. The grep command searches for the pattern ‘foo’, finds it, and prints ‘foo’ to stdout.

Why Use Here Strings?

Here Strings can make your Bash scripts more readable and efficient, especially when dealing with small amounts of data. They are great for providing short strings directly as input to commands, without needing to echo a string into a pipe.

Here Strings can also be used in interactive Bash sessions, for quick and dirty testing of commands and scripts. They reduce the need for unnecessary echo commands or temporary files, making your code cleaner and more straightforward.

How to Use Here Strings

Let’s dive into some examples to illustrate the power of Here Strings.

1. Simple Usage

In this example, we’re using the bc command (a basic calculator) and passing in the string ‘5 + 5’. This is equivalent to:

But with Here Strings, we’ve made it more streamlined and easier to understand at first glance.

2. Working with Variables

You can also use Here Strings with variables:

This will output Hello, World!, because the cat command prints the content it receives via stdin, which, in this case, is the value of the variable $var.

3. Here Strings and Arrays

Here Strings can also be used effectively with arrays:

Here, we’re using a Bash array and the tr command to replace spaces with newline characters. The `${arr[*]}` expands the array into a single string, with each element separated by a space. The Here String passes this to tr, which then prints each element on a new line.

4. Here Strings with Multi-line Input

Here Strings can also handle multi-line input:

This will output:

Line 1
Line 2
Line 3

Each line of the string is treated as a separate line of input.

Best Practices When Using Here Strings

While Here Strings are a powerful tool, it’s important to use them correctly. Here are a few best practices to keep in mind:

1. Use Here Strings for Short Strings: Here Strings are best used for passing short strings directly to commands. They’re not well-suited to handling large amounts of data.
2. Avoid Using Here Strings for File Contents: If you need to pass the contents of a file as input to a command, it’s generally better to use input redirection (<) rather than a Here String.
3. Use Quotation Marks for Variables: If your variable might include special characters or whitespace, it’s safer to enclose the variable in quotes when using it in a Here String:
   var="Hello, Bash!" cat <<< "$var"

   1 2	var="Hello, Bash!" cat <<< "$var"

4. Prefer Here Strings to echo and a Pipe: Here Strings are a cleaner, more readable alternative to using echo and a pipe (|):
   # Instead of this... echo "Hello, Bash!" | cat # ...use this: cat <<< "Hello, Bash!"

   1 2 3 4 5

   # Instead of this... echo "Hello, Bash!" | cat   # ...use this: cat <<< "Hello, Bash!"

Conclusion

Here Strings are a powerful and versatile feature of Bash. They offer a clean, efficient way to pass small amounts of data directly to the stdin of commands, making scripts more readable and straightforward. While they may not be suitable for handling large amounts of data, they’re perfect for quick tests, simple calculations, and improving the clarity of your scripts.

Remember, though, that like any tool, Here Strings should be used appropriately and thoughtfully, taking into account the requirements and constraints of your particular task. With the right application, they can be a potent addition to your Bash scripting toolkit.