sed jest przeznaczony do stosowania na wejściu liniowym. Chociaż może zrobić to, czego potrzebujesz.

Lepszym rozwiązaniem jest użycie polecenia tr w następujący sposób:

tr '\n' ' ' < input_filename

Lub całkowicie usunąć znaki nowej linii:

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

Lub jeśli posiadasz wersję GNU (z długimi opcjami)

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

Szybka Odpowiedź

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

1. :a Utwórz etykietę " a "
2. N dołączenie następnego wiersza do przestrzeni wzorca
3. $! jeśli nie ostatnia linijka, ba branch (go to) label " a "
4. s substytut, /\n/ regex dla nowej linii, / / przez przestrzeń, /g global match (tyle razy, ile can)

Sed będzie przechodzić przez krok od 1 do 3 aż do ostatniego wiersza, aby wszystkie linie zmieściły się w przestrzeni wzorca, gdzie sed zastąpi wszystkie znaki \n

Alternatywy

Z bash , slow

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

Z perlem, sed - jak prędkość

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

Z tr, szybciej niż sed , może zastąpić tylko jednym znakiem

tr '\n' ' ' < file

Z wklej, tr - podobnie jak prędkość, może zastąpić tylko jednym znakiem

paste -s -d ' ' file

Z awk, tr - jak prędkość

awk 1 ORS=' ' file

Inna alternatywa jak "echo $( jest powolna, działa tylko na małych plikach i musi przetworzyć cały plik, aby rozpocząć proces.

Długa odpowiedź z sed FAQ 5.10

5.10. Dlaczego nie mogę dopasować lub usunąć newline using the \ N escape
Sekwencja? Dlaczego nie mogę dopasować 2 lub więcej linii używając \n?

\N nigdy nie będzie pasować do nowej linii na końcu linii, ponieważ
nowy wiersz jest zawsze usuwany przed umieszczeniem go w
przestrzeń wzorca. Aby uzyskać 2 lub więcej linii w przestrzeni wzorca, użyj
polecenie ' N 'lub coś podobnego (np.' H;...; g;').

Sed działa tak: sed czyta jedną linijkę na raz, odcina
kończenie nowej linii, stawia to, co jest w lewo w Przestrzeń wzorca gdzie
skrypt sed może go adresować lub zmieniać, a gdy przestrzeń wzorca
jest drukowany, dodaje nowy wiersz do stdout (lub do pliku). Jeśli
przestrzeń wzorca jest całkowicie lub częściowo usunięta za pomocą " d " lub "D",
newline to , a nie dodawane w takich przypadkach. Tak więc skrypty jak

  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         

Nigdy nie zadziała, ponieważ końcowa linia nowego wiersza jest usuwana przed
linia jest umieszczana w przestrzeni wzoru. Aby wykonać powyższe zadania,
zamiast tego użyj jednego z tych skryptów:

  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          

Ponieważ wersje sed inne niż GNU sed mają ograniczenia do rozmiaru
bufor wzorca, uniksowe narzędzie 'tr' ma być tutaj preferowane.
Jeśli ostatnia linia pliku zawiera znak nowej linii, GNU sed doda
ta nowa linia do wyjścia, ale usuwa wszystkie inne, podczas gdy tr
usuń wszystkie nowe linie.

Aby dopasować blok dwóch lub więcej linii, istnieją 3 podstawowe opcje:
(1) Użyj polecenia "N", aby dodać następny wiersz do przestrzeni wzorca;
(2) Użyj polecenia 'H' co najmniej dwa razy, aby dodać bieżącą linię
do przestrzeni przytrzymania, a następnie pobrać linie z przestrzeni przytrzymania
w tym celu należy użyć polecenia x, g lub G; lub (3) użyć zakresów adresów (patrz sekcja 3.3 powyżej)
aby dopasować linie pomiędzy dwoma podanymi adresami.

Wybory (1) i (2) umieszczą \n w przestrzeni wzorca, gdzie
może być adresowany zgodnie z życzeniem ('s/ABC\nxyz/alphabet/g'). Jeden przykład
o użyciu "N" do usunięcia a blok linii pojawia się w sekcji 4.13
("Jak usunąć blok konkretnych kolejnych linii?"). To
przykład można zmodyfikować, zmieniając polecenie delete na coś
w tym celu należy wykonać następujące czynności:]} lub " S " (substytut).

Choice (3) nie umieści \ n w przestrzeni wzorca, ale robi
dopasuj blok kolejnych linii, więc może być tak, że nie
nawet trzeba \n, aby znaleźć to, co szukasz. Od GNU sed
wersja 3.02.80 obsługuje teraz tę składnię:

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

Oprócz tradycyjnego ' / stąd/, / tam / {...} 'range
adresów, możliwe jest całkowite uniknięcie użycia \N.

Krótsza alternatywa awk:

awk 1 ORS=' '

Wyjaśnienie

Program awk zbudowany jest z reguł, które składają się z warunkowych bloków kodu, tj.:

condition { code-block }

Jeśli blok kodu jest pominięty, używana jest wartość domyślna: { print $0 }. Tak więc, {[3] } jest interpretowany jako warunek prawdziwy i {[4] } jest wykonywany dla każdej linii.

Kiedy awk odczytuje dane wejściowe, dzieli je na rekordy na podstawie wartości RS (Separator rekordów), która domyślnie jest znakiem nowej linii, więc awk będzie domyślnie analizuje linię wejściową. Podział polega również na oddzieleniu RS od rekordu wejściowego.

Teraz, podczas drukowania rekordu, ORS (Separator rekordu wyjściowego) jest dołączany do niego, domyślnie jest ponownie nowy wiersz. Tak więc zmieniając ORS na spację wszystkie nowe linie są zamieniane na spacje.

Gnu sed posiada opcję -z dla rozdzielonych null rekordów (linii). Możesz po prostu zadzwonić:

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

Wersja Perla działa zgodnie z oczekiwaniami.

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

Jak zaznaczono w komentarzach, warto zauważyć, że ta edycja jest w miejscu. -i.bak da ci kopię zapasową oryginalnego pliku przed zastąpieniem na wypadek, gdyby twojeWyrażenie regularne nie było tak inteligentne, jak myślałeś.

Kto potrzebuje sed? Oto sposób bash:

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

W celu zastąpienia wszystkich nowych linii spacjami za pomocą awk, bez wczytania całego pliku do pamięci:

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

Jeśli chcesz mieć ostatni nowy wiersz:

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

Możesz użyć znaku innego niż spacja:

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

tr '\n' ' ' 

Jest komendą.

Trzy rzeczy.

1. tr (lub cat, itp.) jest absolutnie niepotrzebny. (GNU) sed i (GNU) awk, Po połączeniu, mogą wykonać 99,9% dowolnego przetwarzania tekstu, którego potrzebujesz.

2. Stream !/ align = "left" / linear {[5] } jest edytorem liniowym. Nie jest. Zobacz sed wykład aby uzyskać więcej informacji na temat różnicy. Większość ludzi myli sed jako liniowy, ponieważ domyślnie nie jest zbyt chciwy w dopasowywaniu wzorców do prostych dopasowań - na przykład, gdy wykonując wyszukiwanie wzorców i zastępując je jednym lub dwoma znakami, domyślnie zastępuje je tylko przy pierwszym znalezionym dopasowaniu (o ile nie określono inaczej poleceniem globalnym). Nie byłoby nawet polecenia globalnego, gdyby było oparte na wierszach, a nie na strumieniach, ponieważ oceniałoby tylko linie na raz. Spróbuj uruchomić ed; zauważysz różnicę. ed jest bardzo przydatne, jeśli chcesz iterację nad określonymi liniami( np. w pętli for), ale większość razy będziesz po prostu chciał sed.

3. To powiedziawszy,

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

   Działa dobrze w GNU sed w wersji 4.2.1. Powyższe polecenie zastąpi wszystkie znaki nowej linii spacjami. Jest brzydki i trochę kłopotliwy do wpisania, ale działa dobrze. {}'s można pominąć, ponieważ są one zawarte tylko ze względów rozsądku.

Łatwe do zrozumienia rozwiązanie

$ echo 'foo
bar
baz


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

Wyjście:

foo
bar
baz

(has trailing newline)

Działa na Linuksie, OS X i BSD - nawet bez UTF-8 lub z gównianym terminalem.

1. Użyj tr, aby zamienić nowy wiersz na inny znak.

   NULL (\000 lub \x00) jest ładny, ponieważ nie potrzebuje wsparcia UTF-8 i prawdopodobnie nie będzie używany.

2. Użyj sed, aby dopasować NULL

3. Użyj tr, aby zamienić dodatkowe nowe linie, jeśli ich potrzebujesz

Odpowiedź z etykietą...

Jak mogę zastąpić nową linię (\n) za pomocą sed?

... nie działa w freebsd 7.2 W linii poleceń:

( echo foo ; echo bar ) | sed ':a;N;$!ba;s/\n/ /g'
sed: 1: ":a;N;$!ba;s/\n/ /g": unused label 'a;N;$!ba;s/\n/ /g'
foo
bar

Ale robi, jeśli umieścisz skrypt sed w pliku lub użyjesz -e do "zbudowania" skryptu sed...

> (echo foo; echo bar) | sed -e :a -e N -e '$!ba' -e 's/\n/ /g'
foo bar

Lub ...

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

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

Może sed W OS X jest podobny.

Możesz użyć xargs :

seq 10 | xargs

Lub

seq 10 | xargs echo -n

Dlaczego nie znalazłem prostego rozwiązania z awk?

awk '{printf $0}' file

printf wyświetli każdą linię bez nowych linii, jeśli chcesz oddzielić oryginalne linie spacją lub innymi:

awk '{printf $0 " "}' file

Nie jestem ekspertem, ale myślę, że w sed najpierw trzeba by dopisać następną linię do przestrzeni wzorca, używając "N". Z sekcji "Multiline Pattern Space" w "Advanced sed Commands" książki sed & awk (Dale Dougherty i Arnold Robbins; O ' Reilly 1997; strona 107 w podgląd):

Polecenie Multiline Next (N) tworzy wielowierszową przestrzeń wzorca, odczytując nową linię wejścia i dołączając ją do zawartości wzorca. Na oryginalna zawartość przestrzeni wzorca i nowej linii wejściowej są oddzielone znakiem nowej linii. Osadzony znak nowej linii może być dopasowany we wzorcach za pomocą sekwencji escape "\n". W wielowierszowej przestrzeni wzorcowej metacharakter " ^ " pasuje do pierwszego znaku przestrzeni wzorcowej, a nie znaków następujących po osadzonych znakach nowej linii. Podobnie, " $ " dopasowuje tylko końcową linię w przestrzeni wzorca, a nie osadzoną linię(y). Po wykonaniu następnej komendy sterowanie jest wtedy przekazywane do kolejnych komend w skrypcie.

From man sed:

[2addr]N

Dołącza następny wiersz wejścia do przestrzeni wzorca, używając osadzonego znaku nowej linii, aby oddzielić dołączony materiał od oryginalnej zawartości. Zauważ, że bieżący numer linii zmienia się.

Użyłem do przeszukiwania (wielu) źle sformatowanych plików dziennika, w których szukany ciąg może znaleźć się w "osieroconej" następnej linii.

Jeśli masz dość pecha, aby mieć do czynienia z zakończeniami linii windows, musisz usunąć \r i \n

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

W odpowiedzi na powyższe rozwiązanie "tr", w systemie Windows (prawdopodobnie używającym wersji TR Gnuwin32), proponowane rozwiązanie:

tr '\n' ' ' < input

Nie działa dla mnie, to albo błąd lub faktycznie zastąpić \n w/ " z jakiegoś powodu.

Używając innej funkcji tr, opcja "delete" - d zadziałała:

tr -d '\n' < input

Lub "\R\n "zamiast" \N "

Użyłem podejścia hybrydowego, aby ominąć nową linię, używając tr, aby zastąpić nowe linie tabulatorami, a następnie zastąpić tabulatorami, co tylko chcę. W tym przypadku, "
" ponieważ próbuję wygenerować przerwy HTML.

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

Kuloodporne rozwiązanie. Binary-data-safe i zgodne z POSIX, ale powolne.

POSIX sed wymaga wejścia zgodnie z plik tekstowy POSIX oraz linia POSIX definicje, więc NULL-bajty i zbyt długie linie nie są dozwolone i każda linia musi kończyć się znakiem nowej linii (włącznie z ostatnią linią). Utrudnia to wykorzystanie sed do przetwarzania dowolnych danych wejściowych.

Poniższe rozwiązanie pozwala uniknąć sed i zamiast tego konwertuje bajty wejściowe na kody ósemkowe, a następnie na bajtów ponownie, ale przechwytuje kod ósemkowy 012 (newline) i wypisuje zastępczy ciąg znaków w jego miejsce. O ile wiem, rozwiązanie jest zgodne z POSIX, więc powinno działać na wielu różnych platformach.

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

Dokumentacja odniesienia POSIX: sh , język poleceń powłoki , od , tr , grep , Czytaj , [, printf .

Obie read, [, i printf są wbudowane w co najmniej bash, ale to prawdopodobnie nie gwarantowane przez POSIX, więc na niektórych platformach może być tak, że każdy bajt wejściowy uruchomi jeden lub więcej nowych procesów, co spowolni działanie. Nawet w bash to rozwiązanie osiąga tylko około 50 kB / s, więc nie nadaje się do dużych plików.

W niektórych sytuacjach możesz zmienić RS na inny łańcuch lub znak. W ten sposób \N jest dostępne dla sub / gsub:

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

Moc skryptów powłoki polega na tym, że jeśli nie wiesz, jak to zrobić w jeden sposób, możesz to zrobić w inny sposób. I wiele razy masz więcej rzeczy do wzięcia pod uwagę niż zrobić kompleksowe rozwiązanie prostego problemu.

Przetwarzam MB, a nawet GB danych, a jedynym ograniczeniem, jakie znalazłem, jest rozmiar linii.

Znajduje i zastępuje za pomocą allowing \N

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

Marker

Staje się

# Marker Komentarz

Marker

Możesz użyć xargs - domyślnie zastąpi \n spacją.

Jednakże, to może mieć problemy, jeśli wejście ma jakikolwiek przypadek unterminated quote, np. jeśli znaki cudzysłowu w danej linii nie pasują.

Możesz również użyć tej metody

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

Wyjaśnienie

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.

przepływ:
Gdy pierwsza linia get z wejścia jest wykonywana exchange, więc 1 przechodzi do przestrzeni przytrzymującej, a \n do przestrzeni wzorcowej, a następnie dołącza przestrzeń przytrzymującą do przestrzeni wzorcowej, a następnie wykonuje się zastępowanie i usuwa przestrzeń wzorcową.
Podczas wymiany drugiej linii 2 przechodzi do przestrzeni przytrzymującej, a 1 do przestrzeni wzorcowej, a następnie G dodaje przestrzeń przytrzymującą do przestrzeni wzorcowej, następnie h Skopiuj do niego wzór i podstawiaj i usuwaj. Operacja ta jest kontynuowana do momentu osiągnięcia eof, a następnie wypisuje dokładny wynik.

Na Mac OS X (przy użyciu 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

Aby usunąć puste linie:

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

Użycie Awk:

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

Rozwiązaniem, które szczególnie lubię, jest dodanie całego pliku w przestrzeni przytrzymania i zastąpienie wszystkich nowych linii na końcu pliku:

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

Jednak ktoś powiedział mi, że przestrzeń zatrzymania może być skończona w niektórych implementacjach sed.

Zastąp nowe linie dowolnym ciągiem znaków, a także zastąp ostatnią nową linię

Czyste rozwiązania tr mogą zastąpić tylko pojedynczym znakiem, a czyste rozwiązania sed nie zastępują ostatniej nowej linii wejścia. Poniższe rozwiązanie rozwiązuje te problemy i wydaje się być bezpieczne dla danych binarnych (nawet z ustawieniami 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'

Wynik:

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

To sed wprowadza nowe linie po" normalnym " substytucji. Najpierw przycina znak nowej linii, następnie przetwarza zgodnie z instrukcjami, a następnie wprowadza nową linię.

Używając sed możesz zastąpić "koniec" linii (nie znak nowej linii) po przycięciu, wybranym ciągiem znaków dla każdej linii wejściowej; ale sed wyświetli różne linie. Na przykład, załóżmy, że chcesz zastąpić "koniec linii" przez "= = = " (bardziej ogólne niż zastąpienie pojedynczą spacją):

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

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

Aby zastąpić znak nowej linii ciągiem znaków, możesz, nieefektywnie, użyć tr , Jak wskazano wcześniej, aby zastąpić znaki nowej linii znakiem "Special char", a następnie użyć sed, Aby zastąpić ten znak specjalny ciągiem znaków, który chcesz.

Na przykład:

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~$

Inny GNU sed metoda, prawie taka sama jak Zsolt Botykai's answer , but this uses sed' s less-frequently used y (Transliteracja ) polecenie, które zapisuje jeden bajt kodu (końcowe g):

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

Można by mieć nadzieję, że y będzie działać szybciej niż s, (być może przy tr prędkościach, 20x szybciej), ale w GNU sed v4.2.2 y jest o 4% wolniej niż s.

Bardziej przenośny BSD sed Wersja:

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