> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Bash Here String
The `<<<` operator, known as a **here-string**, is a form of input redirection in Bash that supplies a string directly to the standard input (stdin) of a command. It is a specialized variant of the here-document (`<<`) designed to feed a single evaluated word into file descriptor 0 without the overhead of invoking a subshell or the `echo`/`printf` utilities via a pipe (`|`).
```bash theme={"dark"}
command [arguments] <<< word
```
## Parsing and Expansion Mechanics
When the Bash parser encounters the `<<<` operator, it isolates the subsequent `word` token. Before redirecting the string to the command's stdin, Bash subjects the `word` to a specific sequence of shell expansions:
1. **Tilde Expansion:** (`~` resolves to `$HOME`)
2. **Parameter and Variable Expansion:** (`$VAR` or `${VAR}` are resolved)
3. **Command Substitution:** (`$(cmd)` or `` `cmd` `` are executed and replaced by their standard output)
4. **Arithmetic Expansion:** (`$((expression))` is evaluated)
5. **Quote Removal:** (Unescaped single and double quotes are stripped)
**Crucial Exception:** Bash explicitly bypasses **brace expansion**, **word splitting**, and **pathname expansion** (globbing) for the `word` token following a here-string operator.
```bash theme={"dark"}
# Variable expansion occurs
command <<< "$MY_VAR"
# Command substitution occurs
command <<< "$(generate_output)"
# No brace expansion occurs; '{a,b}' is treated as literal characters
command <<< {a,b}
# No word splitting or globbing occurs; '*' remains a literal asterisk
command <<< *
```
**Empty Variable Behavior:** Because token recognition occurs *before* variable expansion, and word splitting is bypassed for here-strings, an unquoted variable that expands to an empty string does not result in a missing token. The parser accepts the variable as a valid token, evaluates it to an empty string, and safely passes a single newline to the command. A syntax error only occurs if the token is literally omitted from the command line prior to parsing.
```bash theme={"dark"}
# Safe execution: evaluates to an empty string, passes a single newline (\n)
command <<< $EMPTY_VAR
# Safe execution: identical behavior, passes a single newline (\n)
command <<< "$EMPTY_VAR"
# Syntax error: bash: syntax error near unexpected token 'newline'
# (The token is literally missing before parsing)
command <<<
```
## Multiline Strings and Tokenization
Because the here-string operator expects a single `word` token, unquoted whitespace alters how the shell parses the command line. While the operator accepts only a single token, that token can easily span multiple lines.
```bash theme={"dark"}
# "string" is the here-string. "argument" is passed as an argument to the command.
command <<< string argument
# The entire quoted block is treated as the single here-string token.
command <<< "string argument"
# Multiline strings are fully supported via quoting or ANSI-C quoting.
command <<< "$MULTILINE_VAR"
command <<< $'line1\nline2'
```
## The Trailing Newline
By design, Bash automatically appends a single newline character (`\n`) to the evaluated string before passing it to the command. If the evaluated `word` is `"data"`, the command receives `"data\n"` on its stdin. This behavior is hardcoded into the here-string implementation and cannot be suppressed; if a strict stream of bytes without a trailing newline is required, `<<<` is the incorrect operator.
## Underlying Implementation
Historically, Bash implemented here-strings (and here-documents) by writing the expanded string to a temporary file in `/tmp` and connecting that file to the command's stdin.
In modern Bash (version 5.1 and later), the shell optimizes this process by attempting to use standard anonymous pipes (`pipe()`) to avoid disk I/O and improve performance. The shell only falls back to creating standard temporary files (via `mkstemp()`) if the expanded string exceeds the operating system's pipe buffer size.
Tired of Poor Bash Skills? Fix That With Deep Grasping!
Learn More
