Bash New Line: 7 Easy Fixes, Avoid Newline Mistakes

Handling a bash new line sounds simple, until a file has no final newline or a script runs under sh. The old version of this post explained echo, printf and a few filters, and four of its statements are wrong in a real shell. This rewrite runs each example in Bash 5.2.37 on Debian 13 (and dash where it matters) and shows byte-level output with od -c and cat -A.

Bash new line with echo and printf

echo "Hello" printed the five letters and \n; echo -n "Hello, World!" printed no newline at all. printf "Line 1\nLine 2\n" printed both lines with their newlines. So far the old text is right. The next claim is about variables: var="Hello\nWorld" holds a backslash and the letter n, not a newline. echo "$var" printed Hello\nWorld on one line. Both echo -e $var and echo -e "$var" printed two lines, and printf '%b\n' "$var" did too. The cleanest way is to put a real newline in the variable with the $'...' form: v2=$'Hello\nWorld'.

The option -e is Bash behaviour. In dash, which is sh on Debian, sh -c 'echo -e "a\nb"' printed -e a and then b: the option was printed as text, and the escape was interpreted anyway. For scripts that must run under both shells, use printf. See the portable shell scripts post.

Two claims about the bash new line that are wrong

The old text says that echo "New line of text" >> file.txt adds a new line if necessary. It does not. A file created with printf 'first' (no final newline) became firstNew line of text$ under cat -A: one line. The same append to first\n gave two lines. Check the end of the file with tail -c1 file | od -c before you append, or write the file with a final newline in the first place.

The second claim is the "avoiding double new lines" example, echo -n "Line 1" && echo "Line 2". It printed Line 1Line 2. It does not avoid double newlines, it joins two lines into one. To print two lines without a blank line between them, use a single printf '%s\n%s\n' "$a" "$b". The FAQ example echo -e "\n" prints two newline characters (\n \n in the dump), one from the escape and one from echo itself. A single blank line is echo or printf '\n'.

Multi-line variables and removing a bash new line

A multi-line string kept its lines when it was quoted (echo "$m" printed three lines), but the unquoted echo $m printed Line 1 Line 2 Line 3 on one line, because the shell splits on whitespace including newlines. Quote the variable. Command substitution removes trailing newlines: x=$(printf 'abc\n\n\n') printed [abc]. To remove the newlines on purpose, four forms gave the same result for a three-line file: tr -d '\n' printed abc, the sed loop sed ':a;N;$!ba;s/\n//g' printed abc, "${v//$'\n'/ }" printed a b c, and paste -sd, - printed a,b,c. Pick tr for speed, the parameter form when the text is already in a variable, and paste to join with a separator.

Reading files with a bash new line: the last line and CRLF

The old post uses while IFS= read -r line, which is right, with one gap. On a file a\nb\nc without a final newline, the loop printed only [a] and [b], and wc -l reported 2 while grep -c '' reported 3. The fix is the condition while IFS= read -r l || [ -n "$l" ], which printed all three. A file from Windows has \r\n: the loop kept the carriage return ([one\r]), and tr -d '\r' removed it. mapfile -t lines < file.txt read the three lines into an array without a loop.

The sed one-liner for trimming trailing blank lines, sed -e :a -e '/^\n*$/{$d;N;};/\n$/ba', worked with GNU sed: a file x y followed by two blank lines was reduced to x\ny\n, two lines. The syntax is specific to GNU sed, so test it before you use it on another system. Details of the shell's word splitting are in the Bash manual; for the related field-splitting traps, see the IFS post.

A helper that appends a bash new line safely

When a script may append to files that you did not write, check the last byte first. This function adds the missing newline only when it is needed:

append_line() {
  if [ -s "$1" ] && [ -n "$(tail -c1 "$1")" ]; then printf '\n' >> "$1"; fi
  printf '%s\n' "$2" >> "$1"
}

The test produced first$ and New line of text$ for a file that had no final newline, the same two lines for a file that had one, and a single line into a new file$ for a file that did not exist. The trick is that $(tail -c1 file) is empty when the last byte is a newline, because command substitution strips it. Use this pattern for configuration files and logs, where a joined line can break a service. The same rule applies to every bash new line you write into a file.

Common mistakes with the bash new line

• Storing \n in a variable and expecting a newline.
• Appending to a file without checking the last byte.
• Using echo -e in a script that runs under sh.
• Leaving a multi-line variable unquoted.
• Reading a file whose last line has no newline with a plain while read.

Which tool to pick for a bash new line task

For printing, use printf with an explicit format. For joining lines, use paste or the parameter form. For reading, use while IFS= read -r with the extra test, or mapfile. For cleaning Windows files, use tr. The old post mixed these in one list without saying which is safe in which shell; the tests above give the answer for Bash 5.2.37 and for dash.

FAQ

How do I print a bash new line safely? Use printf '\n' for one blank line, or end each printf format with \n.

How do I put a bash new line in a variable? Use $'a\nb', or a quoted multi-line string; both worked in the tests.