mjhjmtu

With GNU sed and provided POSIXLY_CORRECT is not in the environment (for single-line input):

sed -i ':a;N;$!ba;s/n/,/g' test.txt

From https://stackoverflow.com/questions/1251999/sed-how-can-i-replace-a-newline-n :

1. create a label via :a
   


2. append the current and next line to the pattern space via N
   


3. if we are before the last line, branch to the created label $!ba ($! means not to do it on the last line (as there should be one final newline)).


4. finally the substitution replaces every newline with a comma on the pattern space (which is the whole file).

From Oracle's web site:

The sed utility works by sequentially reading a file, line by line, into memory. It then performs all actions specified for the line and places the line back in memory to dump to the terminal with the requested changes made. After all actions have taken place to this one line, it reads the next line of the file and repeats the process until it is finished with the file.

Basically this means that because sed is reading line by line the newline character is not matched.

The solution from https://stackoverflow.com/questions/1251999/sed-how-can-i-replace-a-newline-n is:

sed ':a;N;$!ba;s/n/ /g'

An explanation into how that works is provided on that page.

This works:

sed -z 's/n/,/g' 

-z is included since 4.2.2

sed always removes the trailing newline just before populating pattern space, and then appends one before writing out the results of its script. A newline can be had in pattern-space by various means - but never if it is not the result of an edit. This is important - newlines in sed's pattern space always reflect a change, and never occur in the input stream. newlines are the only delimiter a sedder can count on with unknown input.

If you want to replace all newlines with commas and your file is not very large, then you can do:

sed 'H;1h;$!d;x;y/n/,/'

That appends every input line to hold space - except the first, which instead overwrites hold space - following a newline character. It then deletes every line not the $!last from output. On the last line Hold and pattern spaces are exchanged and all newline characters are y///translated to commas.

For large files this sort of thing is bound to cause problems - sed's buffer on line-boundaries, that can be easily overflowed with actions of this sort.

Alternatively, you can use a slightly simpler syntax:

sed ':a;N;s/n/,/g;ba'

...just changing sequence order.

There's some very nice sed magic here. And some good points raised about pattern space overflow. I love to use sed even when it's not the simplest way, because it's so compact and powerful. However it has it's limitations, and for large amounts of data the pattern space would have to be mahoosive.

GNU says this:

For those who want to write portable sed scripts, be aware that some implementations have been known to limit line lengths (for the pattern and hold spaces) to be no more than 4000 bytes. The posix standard specifies that conforming sed implementations shall support at least 8192 byte line lengths. GNU sed has no built-in limit on line length; as long as it can malloc() more (virtual) memory, you can feed or construct lines as long as you like.


However, recursion is used to handle subpatterns and indefinite repetition. This means that the available stack space may limit the size of the buffer that can be processed by certain patterns.

I don't have much to add, but I would like to point you towards my go-to guide for sed. It's excellent.
http://www.grymoire.com/Unix/Sed.html

and here is my solution:

for i in $(cat test.txt); do echo -n $i','; done; echo '' >> somewhere

well it works