It's not about adding an extra newline at the end of a file, it's about not removing the newline that should be there.
A text file, under unix, consists of a series of lines, each of which ends with a newline character (\n
). A file that is not empty and does not end with a newline is therefore not a text file.
Utilities that are supposed to operate on text files may not cope well with files that don't end with a newline; historical Unix utilities might ignore the text after the last newline, for example. GNU utilities have a policy of behaving decently with non-text files, and so do most other modern utilities, but you may still encounter odd behavior with files that are missing a final newline¹.
With GNU diff, if one of the files being compared ends with a newline but not the other, it is careful to note that fact. Since diff is line-oriented, it can't indicate this by storing a newline for one of the files but not for the others — the newlines are necessary to indicate where each line in the diff file starts and ends. So diff uses this special text \ No newline at end of file
to differentiate a file that didn't end in a newline from a file that did.
By the way, in a C context, a source file similarly consists of a series of lines. More precisely, a translation unit is viewed in an implementation-defined as a series of lines, each of which must end with a newline character (n1256 §5.1.1.1). On unix systems, the mapping is straightforward. On DOS and Windows, each CR LF sequence (\r\n
) is mapped to a newline (\n
; this is what always happens when reading a file opened as text on these OSes). There are a few OSes out there which don't have a newline character, but instead have fixed- or variable-sized records; on these systems, the mapping from files to C source introduces a \n
at the end of each record. While this isn't directly relevant to unix, it does mean that if you copy a C source file that's missing its final newline to a system with record-based text files, then copy it back, you'll either end up with the incomplete last line truncated in the initial conversion, or an extra newline tacked onto it during the reverse conversion.
¹
Example: the output of GNU sort always ends with a newline. So if the file foo
is missing its final newline, you'll find that sort foo | wc -c
reports one more character than cat foo | wc -c
.
sed -i
uses tempfiles as an implementation detail, which is what you are experiencing; however, prepending data to the beginning of a data stream without overwriting the existing contents requires rewriting the file, there's no way to get around that, even when avoiding sed -i
.
If rewriting the file is not an option, you might consider manipulating it when it is read, for example:
{ echo some prepended text ; cat file ; } | command
Also, sed is for editing streams -- a file is not a stream. Use a program that is meant for this purpose, like ed or ex. The -i
option to sed is not only not portable, it will also break any symlinks to your file, since it essentially deletes it and recreates it, which is pointless.
You can do this in a single command with ed
like so:
ed -s file << 'EOF'
0a
prepend these lines
to the beginning
.
$a
append these lines
to the end
.
w
EOF
Note that depending on your implementation of ed, it may use a paging file, requiring you to have at least that much space available.
Best Answer
tail -c 1
outputs the last character (more precisely, the last byte) of its input.Command substitution strips off a trailing newline, so
$(tail -c 1 <…)
is empty if the last character of the file is a newline. It's also empty if the last character is a null byte (in most shells), but text files don't have null bytes.Keep in mind that an empty file doesn't need an extra newline.