Как заменить новую строку (" \n") пробелом (" ") с помощью sedкоманды?

Я безуспешно пытался:

sed 's#\n# #g' file
sed 's#^$# #g' file

Как мне это исправить?

Используйте это решение с GNU sed:

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

Это прочитает весь файл в цикле, а затем заменит символы новой строки пробелом.

Объяснение:

1. Создать ярлык через :a.
2. Добавьте текущую и следующую строку в пространство шаблона с помощью N.
3. Если мы находимся перед последней строкой, переходите к созданной метке $!ba(это $!означает, что не следует делать это в последней строке, так как должен быть один последний символ новой строки).
4. Наконец, подстановка заменяет каждую новую строку пробелом в пространстве образца (который является целым файлом).

Вот кроссплатформенный совместимый синтаксис, который работает с BSD и OS X sed(согласно комментарию @Benjie ):

sed -e ':a' -e 'N' -e '$!ba' -e 's/\n/ /g' file

Как вы можете видеть, использование sedэтой простой проблемы проблематично. Для более простого и адекватного решения см. Этот ответ .

sedпредназначен для использования на линейном вводе. Хотя он может делать то, что вам нужно.

Лучшим вариантом здесь является использование trкоманды следующим образом:

tr '\n' ' ' < input_filename

или полностью удалите символы новой строки:

tr -d '\n' < input.txt > output.txt

или если у вас есть версия GNU (с ее длинными опциями)

tr --delete '\n' < input.txt > output.txt

Быстрый ответ

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

1. : создать ярлык «а»
2. N добавить следующую строку в пространство образца
3. $! если не в последней строке , ба ветвь (перейти к) метка «а»
4. s заменить , / \ n / regex для новой строки , / / через пробел , / g глобальное совпадение (столько раз, сколько это возможно)

sed будет перебирать шаги с 1 по 3, пока не достигнет последней строки, в результате чего все строки поместятся в пространство шаблона, где sed заменит все символы \ n

альтернативы

Все альтернативы, в отличие от sed , не должны достигать последней строки, чтобы начать процесс

с баш , медленно

while read line; do printf "%s" "$line "; done < file

с perl , sed- подобной скоростью

perl -p -e 's/\n/ /' file

с tr , быстрее чем sed , может заменить только один символ

tr '\n' ' ' < file

с пастой , tr- like speed, может заменить только один символ

paste -s -d ' ' file

с awk , tr- like скоростью

awk 1 ORS=' ' file

Другая альтернатива, такая как «echo $ (<file)» , работает медленно, работает только с небольшими файлами и должна обработать весь файл, чтобы начать процесс.

Длинный ответ от sed FAQ 5.10

5.10. Почему я не могу сопоставить или удалить символ новой строки, используя escape-
последовательность \ n ? Почему я не могу сопоставить 2 или более строк, используя \ n?

\ N никогда не будет соответствовать новой строке в конце строки, потому что
новая строка всегда удаляется перед тем, как строка помещается в
пространство шаблона. Чтобы получить 2 или более строк в пространство шаблона, используйте
команду «N» или что-то подобное (например, «H; ...; g;»).

Sed работает следующим образом: sed читает по одной строке за раз, отсекает
завершающую новую строку , помещает то, что осталось, в пространство шаблона, где
сценарий sed может обратиться или изменить его, а когда пространство шаблона
печатается, добавляет новую строку в stdout (или в файл). Если
пространство шаблона полностью или частично удалено с помощью «d» или «D»,
символ новой строки в таких случаях не добавляется. Таким образом, сценарии, такие как

  sed 's/\n//' file       # to delete newlines from each line             
  sed 's/\n/foo\n/' file  # to add a word to the end of each line         

НИКОГДА не будет работать, потому что завершающий символ новой строки удаляется до
того, как строка помещается в пространство шаблона. Для выполнения вышеуказанных задач
используйте один из следующих сценариев:

  tr -d '\n' < file              # use tr to delete newlines              
  sed ':a;N;$!ba;s/\n//g' file   # GNU sed to delete newlines             
  sed 's/$/ foo/' file           # add "foo" to end of each line          

Поскольку версии sed, отличные от GNU sed, имеют ограничения по размеру
буфера шаблонов, здесь предпочтительнее использовать утилиту «tr» Unix.
Если последняя строка файла содержит новую строку, GNU sed добавит
эту новую строку в вывод, но удалит все остальные, тогда как tr
удалит все новые строки.

Чтобы сопоставить блок из двух или более строк, есть 3 основных варианта:
(1) используйте команду 'N', чтобы добавить следующую строку в пространство шаблона;
(2) использовать команду «H» как минимум дважды, чтобы добавить текущую строку
в пространство удержания, а затем извлечь строки из пространства удержания
с помощью x, g или G; или (3) использовать диапазоны адресов (см. раздел 3.3 выше)
для сопоставления линий между двумя указанными адресами.

Варианты (1) и (2) будут помещать \ n в пространство шаблона, где к нему
можно обращаться по своему усмотрению ('s / ABC \ nXYZ / alphabet / g'). Один из примеров
использования N для удаления блока строк приведен в разделе 4.13
(«Как удалить блок из определенных последовательных строк?»). Этот
пример можно изменить, изменив команду удаления на что
- то другое, например «p» (печать), «i» (вставка), «c» (изменение), «a» (добавление)
или «s» (замена) ,

Выбор (3) не положит \ п в пространстве картины, но это действительно
соответствует блок последовательных линий, так что это может быть , что вы не
даже нуждаетесь в \ п , чтобы найти то , что вы ищете. Начиная с GNU sed
версии 3.02.80, теперь поддерживается следующий синтаксис:

  sed '/start/,+4d'  # to delete "start" plus the next 4 lines,           

в дополнение к традиционным диапазонам
адресов «/ from here /, / to there / {...}» , возможно, можно полностью избежать использования \ n.

Более короткая альтернатива awk:

awk 1 ORS=' '

объяснение

Программа awk состоит из правил, которые состоят из условных кодовых блоков, а именно:

condition { code-block }

Если код-блок опущен, то по умолчанию используется: { print $0 }. Таким образом, 1интерпретируется как истинное условие и print $0выполняется для каждой строки.

Когда awkсчитывает ввод, он разбивает его на записи на основе значения RS(Разделитель записей), которое по умолчанию является новой awkстрокой , поэтому по умолчанию будет анализировать ввод по строке. Разделение также включает удаление RSиз входной записи.

Теперь при печати записи ORS(к ней добавляется разделитель выходных записей) по умолчанию снова вводится новая строка. Таким образом, при переходе ORSна пробел все новые строки заменяются пробелами.

В GNU SED есть опция -zдля записей, разделенных нулями (строк). Вы можете просто позвонить:

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

Версия Perl работает так, как вы ожидали.

perl -i -p -e 's/\n//' file

Как указано в комментариях, стоит отметить, что это редактируется на месте. -i.bakперед заменой даст вам резервную копию исходного файла на случай, если ваше регулярное выражение окажется не таким умным, как вы думали.

Кому нужно sed? Вот bashпуть:

cat test.txt |  while read line; do echo -n "$line "; done

Чтобы заменить все символы новой строки пробелами, используя awk, без чтения всего файла в память:

awk '{printf "%s ", $0}' inputfile

Если вы хотите последний перевод строки:

awk '{printf "%s ", $0} END {printf "\n"}' inputfile

Вы можете использовать символ, отличный от пробела:

awk '{printf "%s|", $0} END {printf "\n"}' inputfile

tr '\n' ' ' 

это команда.

Легко и просто использовать.

Три вещи.

1. tr(или catи т. д.) абсолютно не нужны. (ГНУ)sed и (GNU) awk, если объединены, могут выполнять 99,9% любой обработки текста, которая вам нужна.

2. поток! = строка на основе. edэто линейный редактор. sedне является. См. Sed лекцию для получения дополнительной информации о разнице. Большинство людей путают, sedчто они основаны на строках, потому что по умолчанию они не очень жадные в сопоставлении с образцом для совпадений SIMPLE - например, при поиске и замене по шаблону одним или двумя символами, он по умолчанию заменяет только первое совпадение он находит (если не указано иное глобальной командой). Не было бы даже глобальной команды, если бы она основывалась на строках, а не на STREAM, потому что она будет оценивать только строки за раз. Попробуйте запустить ed; Вы заметите разницу. edЭто довольно полезно, если вы хотите перебирать определенные строки (например, в цикле for), но в большинстве случаев вам просто нужно sed.

3. Что, как говорится,

   sed -e '{:q;N;s/\n/ /g;t q}' file
   

   прекрасно работает в GNU sedверсии 4.2.1. Приведенная выше команда заменит все новые строки пробелами. Это некрасиво и немного громоздко набирать, но работает просто отлично. Их {}можно пропустить, поскольку они включены только по соображениям здравомыслия.

Ответ с меткой ...

Как заменить символ новой строки (\ n) с помощью sed?

... не работает в freebsd 7.2 в командной строке:

(эхо фу; эхо бар) | sed ': a; N; $! ba; s / \ n / / g'
sed: 1: ": a; N; $! ba; s / \ n / / g": неиспользуемая метка 'a; N; $! ba; s / \ n / / g'
Foo
бар

Но если вы помещаете скрипт sed в файл или используете -e, чтобы "собрать" скрипт sed ...

> (echo foo; echo bar) | sed -e: -e N -e '$! ba' -e 's / \ n / / g'
фу бар

или ...

> cat > x.sed << eof
:a
N
$!ba
s/\n/ /g
eof

> (echo foo; echo bar) | sed -f x.sed
foo bar

Возможно sed в OS X похож.

Простое для понимания решение

У меня была эта проблема. Главное, что мне нужно было решение для работы с BSD (Mac OS X) и GNU (Linux и Cygwin ) sedи tr:

$ echo 'foo
bar
baz


foo2
bar2
baz2' \
| tr '\n' '\000' \
| sed 's:\x00\x00.*:\n:g' \
| tr '\000' '\n'

Вывод:

foo
bar
baz

(завершающий перевод строки)

Он работает на Linux, OS X и BSD - даже без поддержки UTF-8 или с дерьмовым терминалом.

1. Используйте, trчтобы заменить новую строку другим символом.

   NULL (\000 или \x00) хорошо, потому что он не нуждается в поддержке UTF-8 и вряд ли будет использоваться.

2. использование sed чтобы соответствоватьNULL

3. Используйте, trчтобы поменять местами дополнительные символы новой строки, если они вам нужны

Вы можете использовать XARGS :

seq 10 | xargs

или

seq 10 | xargs echo -n

Я не эксперт, но я думаю sed, что сначала вам нужно добавить следующую строку в пространство шаблонов, используя " N". Из раздела «Пространство многострочных шаблонов» в «Расширенных командах sed» книги sed & awk (Дейл Догерти и Арнольд Роббинс; О'Рейли, 1997 год; стр. 107 в превью ):

Многострочная команда Next (N) создает многострочное пространство шаблонов, читая новую строку ввода и добавляя ее к содержимому пространства шаблонов. Исходное содержимое пространства шаблона и новая строка ввода разделены новой строкой. Встроенный символ новой строки можно сопоставить в шаблонах с помощью escape-последовательности "\ n". В многострочном шаблонном пространстве метасимвол «^» соответствует самому первому символу шаблонного пространства, а не символу (ам) после любой встроенной новой строки (ей). Точно так же «$» соответствует только последней новой строке в пространстве шаблона, а не любой встроенной новой строке (строкам). После выполнения команды Next управление передается последующим командам в сценарии.

От man sed:

[2addr] Н

Добавьте следующую строку ввода в пространство шаблона, используя встроенный символ новой строки, чтобы отделить добавленный материал от исходного содержимого. Обратите внимание, что текущий номер строки изменяется.

Я использовал это для поиска (нескольких) плохо отформатированных файлов журналов, в которых строка поиска может быть найдена в «потерянной» следующей строке.

Я использовал гибридный подход для обхода новой строки, используя tr для замены новой строки на вкладки, а затем заменяя вкладки тем, что я хочу. В этом случае "
", так как я пытаюсь генерировать разрывы HTML.

echo -e "a\nb\nc\n" |tr '\n' '\t' | sed 's/\t/ <br> /g'`

В ответ на приведенное выше решение «tr» в Windows (возможно, с использованием версии tr для Gnuwin32) предлагаемое решение:

tr '\n' ' ' < input

не работал для меня, он либо по ошибке, либо фактически заменил \ nw / '' по какой-то причине.

Используя другую функцию tr, опция -d «delete» сработала:

tr -d '\n' < input

или '\ r \ n' вместо '\ n'

Пуленепробиваемое решение. Бинарные данные безопасны и POSIX-совместимы, но медленно.

POSIX SED требует ввода в соответствии с текстовым файлом POSIX и POSIX линии определениями , поэтому NULL-байты и слишком длинные строки не допускаются, и каждая строка должна заканчиваться новой строкой (включая последнюю строку). Это затрудняет использование sed для обработки произвольных входных данных.

Следующее решение исключает sed и вместо этого преобразует входные байты в восьмеричные коды, а затем снова в байты, но перехватывает восьмеричный код 012 (новая строка) и выводит замещающую строку вместо нее. Насколько я могу судить, решение является POSIX-совместимым, поэтому оно должно работать на самых разных платформах.

od -A n -t o1 -v | tr ' \t' '\n\n' | grep . |
  while read x; do [ "0$x" -eq 012 ] && printf '<br>\n' || printf "\\$x"; done

Справочная документация POSIX: sh , язык команд оболочки , od , tr , grep , read , [ , printf .

Оба read, [и printfявляются встроенными, по крайней мере, в bash, но это, вероятно, не гарантируется POSIX, поэтому на некоторых платформах может случиться так, что каждый входной байт будет запускать один или несколько новых процессов, что замедляет работу. Даже в bash это решение достигает только 50 кБ / с, поэтому оно не подходит для больших файлов.

Протестировано на Ubuntu (bash, dash и busybox), FreeBSD и OpenBSD.

В некоторых ситуациях, возможно, вы можете изменить RSна другую строку или символ. Таким образом, \ n доступен для sub / gsub:

$ gawk 'BEGIN {RS="dn" } {gsub("\n"," ") ;print $0 }' file

Сила сценариев оболочки заключается в том, что если вы не знаете, как это сделать одним способом, вы можете сделать это другим способом. И во многих случаях вам нужно принимать во внимание больше вещей, чем принимать комплексное решение простой проблемы.

Что касается того, что gawk работает медленно ... и читает файл в память, я этого не знаю, но мне кажется, что gawk работает с одной строкой за раз и работает очень-очень быстро (не так быстро, как некоторые другие , но время для написания и тестирования также имеет значение).

Я обрабатываю МБ и даже ГБ данных, и единственное ограничение, которое я нашел, - это размер строки.

Если вам не повезло иметь дело с окончаниями строк Windows, вам нужно удалить \rи\n

tr '[\r\n]' ' ' < $input > $output

Вы можете использовать xargs- он заменит \nпробел по умолчанию.

Тем не менее, это может привести к проблемам, если ваш ввод имеет какой-либо регистр unterminated quote, например, если знаки кавычек в данной строке не совпадают.

Находит и заменяет с помощью разрешения \ n

sed -ie -z 's/Marker\n/# Marker Comment\nMarker\n/g' myfile.txt

маркер

становится

# Маркерный комментарий

маркер

Почему я не нашел простого решения с awk?

awk '{printf $0}' file

printf напечатает каждую строку без перевода строки, если вы хотите отделить исходные строки пробелом или другим:

awk '{printf $0 " "}' file

В Mac OS X (с использованием FreeBSD sed):

# replace each newline with a space
printf "a\nb\nc\nd\ne\nf" | sed -E -e :a -e '$!N; s/\n/ /g; ta'
printf "a\nb\nc\nd\ne\nf" | sed -E -e :a -e '$!N; s/\n/ /g' -e ta

Чтобы удалить пустые строки:

sed -n "s/^$//;t;p;"

Использование Awk:

awk "BEGIN { o=\"\" }  { o=o \" \" \$0 }  END { print o; }"

Решение, которое мне особенно нравится, состоит в том, чтобы добавить весь файл в область хранения и заменить все новые строки в конце файла:

$ (echo foo; echo bar) | sed -n 'H;${x;s/\n//g;p;}'
foobar

Однако кто-то сказал мне, что пространство удержания может быть конечным в некоторых реализациях sed.

Замените символы новой строки любой строкой, а также замените последний символ новой строки.

Чистые trрешения могут заменяться только одним символом, а чистые sedрешения не заменяют последнюю новую строку ввода. Следующее решение устраняет эти проблемы и, по-видимому, безопасно для двоичных данных (даже при использовании языка UTF-8):

printf '1\n2\n3\n' |
  sed 's/%/%p/g;s/@/%a/g' | tr '\n' @ | sed 's/@/<br>/g;s/%a/@/g;s/%p/%/g'

Результат:

1<br>2<br>3<br>

Именно sed вводит новые строки после «нормальной» замены. Сначала он обрезает символ новой строки, затем обрабатывает в соответствии с вашими инструкциями, затем вводит новую строку.

Используя sed, вы можете заменить «конец» строки (не символ новой строки) после обрезки выбранной строкой для каждой строки ввода; но sed выведет разные строки. Например, предположим, что вы хотели заменить «конец строки» на «===» (более общий, чем замена на один пробел):

PROMPT~$ cat <<EOF |sed 's/$/===/g'
first line
second line
3rd line
EOF

first line===
second line===
3rd line===
PROMPT~$

Чтобы заменить символ новой строки на строку, вы можете, хотя и неэффективно, использовать tr , как указано выше, чтобы заменить символы новой строки на «специальный символ», а затем использовать sed, чтобы заменить этот специальный символ строкой, которую вы хотите. ,

Например:

PROMPT~$ cat <<EOF | tr '\n' $'\x01'|sed -e 's/\x01/===/g'
first line
second line
3rd line
EOF

first line===second line===3rd line===PROMPT~$

Вы также можете использовать этот метод

sed 'x;G;1!h;s/\n/ /g;$!d'

объяснение

x   - which is used to exchange the data from both space (pattern and hold).
G   - which is used to append the data from hold space to pattern space.
h   - which is used to copy the pattern space to hold space.
1!h - During first line won't copy pattern space to hold space due to \n is
      available in pattern space.
$!d - Clear the pattern space every time before getting next line until the
      last line.

Поток:
Когда первая строка получает входные данные, выполняется обмен, поэтому 1 переходит в пространство пробелов, а \ n переходит в пространство шаблонов, затем добавляется пространство удержаний в пространство шаблонов, затем выполняется подстановка и удаляется пространство шаблонов.
Во время обмена второй строкой 2 переходит в область пробелов, а 1 переходит в пространство паттернов, затем Gдобавляет пространство удержаний в пространство паттернов, затем hкопирует в него паттерн, и подстановка выполняется и удаляется. Эта операция продолжается до тех пор, пока eof не будет достигнут, затем выведите точный результат.

Другой метод GNU sed , почти такой же, как ответ Жолта Ботыкай , но он использует sedменее часто используемую y( транслитерируемую ) команду, которая сохраняет один байт кода (завершающий g):

sed ':a;N;$!ba;y/\n/ /'

Можно было бы надеяться, yчто он будет работать быстрее, чем s(возможно, на trскорости, в 20 раз быстрее), но в GNU sed v4.2.2 y примерно на 4% медленнее, чем s.

Более портативная версия BSD sed :

sed -e ':a' -e 'N;$!ba' -e 'y/\n/ /'