Komut satırını kullanarak bir satırsonunu (" \n") bir boşlukla (" ") nasıl değiştirebilirim sed?

Başarısız denedim:

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

Nasıl düzeltebilirim?

Bu çözümü GNU ile kullanın sed:

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

Bu, tüm dosyayı bir döngü içinde okuyacaktır, ardından yeni satırları bir boşlukla değiştirecektir.

Açıklama:

1. Yoluyla bir etiket oluşturun :a.
2. Geçerli ve sonraki satırı ile desen alanına ekleyin N.
3. Son satırdan önce olursak, oluşturulan etikete dallanır $!ba( $!son satırda bunu yapmamak anlamına gelir, çünkü son satırda bir son satır olmalıdır).
4. Son olarak, ikame her satırsonu model uzayındaki bir boşlukla değiştirir (dosyanın tamamıdır).

İşte BSD ve OS X'lerle çalışan platformlar arası uyumlu sözdizimi sed( @Benjie yorumuna göre ):

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

Gördüğünüz gibi, sedaksi takdirde bu basit problemi kullanmak sorunludur. Daha basit ve yeterli bir çözüm için bu cevaba bakınız .

sedhat tabanlı girişte kullanılmak üzere tasarlanmıştır. Gereksinim duyduğunuz her şeyi yapabilir.

Burada daha iyi bir seçenek, trkomutu aşağıdaki gibi kullanmaktır :

tr '\n' ' ' < input_filename

veya yeni satır karakterlerini tamamen kaldırın:

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

veya GNU sürümünüz varsa (uzun seçenekleriyle)

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

Hızlı cevap

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

1. : a 'a' etiketi oluştur
2. N desen uzayına sonraki satırı ekler
3. , $! son satır değilse , ba dalı (git) 'a' etiketi
4. s yerine , / \ n / regex yeni satır , / / boşluk , / g global eşleşme (olabildiğince çok)

sed, son satıra ulaşana kadar adım 1 ila 3 arasında döngü yapar ve tüm satırlar, sed'in tüm karakterlerin yerine geçeceği desen alanına sığdırır \ n

Alternatifler

Tüm alternatiflerin, sed'den farklı olarak , işleme başlamak için son satıra ulaşması gerekmeyecek

ile bash , yavaş

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

ile Perl , sed benzeri hızı

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

ile tr , daha hızlı sed , bir karakter yerine sadece

tr '\n' ' ' < file

ile macun , tr -like hız, bir karakter yerine sadece

paste -s -d ' ' file

ile awk'ın , tr benzeri hızlı

awk 1 ORS=' ' file

"Echo $ (<file)" gibi diğer alternatifler yavaştır, yalnızca küçük dosyalar üzerinde çalışır ve işleme başlamak için tüm dosyayı işlemesi gerekir.

Sed'den uzun cevap SSS 5.10

5.10. \ N Escape
dizisini kullanarak neden bir yeni satırı eşleştiremiyorum veya silemiyorum ? Neden \ n kullanarak 2 veya daha fazla satırı eşleştiremiyorum?

\ N hiçbir zaman satır sonundaki satırsonu ile eşleşmeyecektir, çünkü
satır
desen alanına yerleştirilmeden önce satırsonu her zaman çıkarılır . Desen alanına 2 veya daha fazla satır girmek için
, 'N' komutunu veya benzer bir şeyi kullanın ('H; ...; g;' gibi).

Sed şu şekilde çalışır: sed her seferinde bir satır okur, sondaki
yeni satırı keser
, sed komut dosyasının adresleyebileceği veya değiştirebileceği desen alanına kalanları koyar ve desen alanı
yazdırıldığında stdout'a yeni bir satır ekler (veya bir dosyaya). Eğer
model alanı tamamen veya kısmen 'd' ve 'D' ile silinmiş olan,
yeni satır olduğunu olmayan bu gibi durumlarda ilave edildi. Böylece, komut dosyaları

  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         

ASLA işe yaramaz, çünkü çizgi desen alanına yerleştirilmeden önce sondaki satırsonu kaldırılır
. Yukarıdaki görevleri gerçekleştirmek için, aşağıdaki
komut dosyalarından birini kullanın:

  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          

GNU sed dışındaki sed sürümlerinin
desen tamponunun boyutu ile ilgili sınırları olduğundan , burada Unix 'tr' yardımcı programı tercih edilecektir.
Dosyanın son satırı bir satırsonu içeriyorsa, GNU sed
bu satırsonu çıktıya ekler ancak diğerlerini siler, tr ise
tüm satırları siler.

İki veya daha fazla satırlık bir bloğu eşleştirmek için 3 temel seçenek vardır:
(1) desen satırına Sonraki satırı eklemek için 'N' komutunu kullanın;
(2) geçerli satırı
Bekletme alanına eklemek için 'H' komutunu en az iki kez kullanın ve ardından çizgileri
x, g veya G ile bekletme alanından alın ; veya (3)
belirtilen iki adres arasındaki satırları eşleştirmek için adres aralıklarını kullanın (bkz. bölüm 3.3, yukarıdaki) .

Seçenekler (1) ve (2), desen alanına
istenen şekilde adreslenebilecek bir \ n yerleştirir ('s / ABC \ nXYZ / alphabet / g'). Bir
satır bloğunu silmek için 'N' kullanımına örnek olarak bölüm 4.13'te
(" Ardışık belirli satır bloğunu nasıl silebilirim ?") Görünür. Bu
örnek, delete komutunu
'p' (yazdır), 'i' (ekle), 'c' (değiştir), 'a' (ekle)
veya 's' (yerine) gibi başka bir şeye değiştirerek değiştirilebilir. .

Choice (3) bir \ n desen uzaya koymak olmaz, ancak o yok
o değil mi olabilir, böylece üst üste çizgilerin bir blok maç
bile gerek \ n aradığınızı bulmak için. GNU sed
sürüm 3.02.80 artık bu sözdizimini desteklediğinden:

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

geleneksel '/ buradan /, / oraya / {...}' aralık
adreslerine ek olarak, \ n kullanımından tamamen kaçınmak mümkün olabilir.

Daha kısa bir awk alternatifi:

awk 1 ORS=' '

açıklama

Bir awk programı, koşullu kod bloklarından oluşan kurallardan oluşur, yani:

condition { code-block }

Kod bloğu atlanırsa, varsayılan kullanılan geçerli: { print $0 }. Böylece, 1gerçek bir koşul olarak yorumlanır ve print $0her satır için yürütülür.

Ne zaman awkdeğerine kayıtlarına bunu böler girdi bazlı okurRS varsayılan olarak yeni satır (Tutanak Ayırıcı), böylece awkwill giriş ayrıştırma varsayılan olarak hat-bilge. Bölme ayrıca RSgiriş kaydından çıkarmayı da içerir .

Şimdi, bir kaydı yazdırırken, ORS(Çıktı Kayıt Ayırıcı) ona eklenir, varsayılan yine yeni satırdır. Böylece ORSbir boşluğa geçerek tüm yeni satırlar boşluk olarak değiştirilir.

gnu sed, -zboş ayrılmış kayıtlar (satırlar) için bir seçeneğe sahiptir . Sadece şunu arayabilirsiniz:

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

Perl sürümü beklenen şekilde çalışır.

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

Yorumlarda belirtildiği gibi, bu düzenlemenin yerinde olduğunu belirtmek gerekir. normal ifadenizin düşündüğünüz kadar akıllı olmaması -i.bakdurumunda, değiştirilmeden önce orijinal dosyanın yedeğini alırsınız.

Kimin ihtiyacı var sed? İşte bashyolu:

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

Tüm satırları belleğe okumadan awk kullanan boşluklarla değiştirmek için:

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

Son satırsonu istiyorsanız:

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

Boşluk dışında bir karakter kullanabilirsiniz:

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

tr '\n' ' ' 

komuttur.

Basit ve kullanımı kolaydır.

Üç şey.

1. tr(veya catvb.) kesinlikle gerekli değildir. (GNU) sedve (GNU) awkbirleştirildiğinde, ihtiyacınız olan metin işlemlerinin% 99,9'unu yapabilir.

2. stream! = satır tabanlı. edsatır tabanlı bir editördür. seddeğil. Fark hakkında daha fazla bilgi için sed dersine bakın . Çoğu kişi sedsatır tabanlı olmayı karıştırır , çünkü varsayılan olarak BASİT eşleşmeleri için desen eşleşmesinde çok açgözlü değildir - örneğin, desen araması yaparken ve bir veya iki karakterle değiştirirken, varsayılan olarak yalnızca ilk eşleşmenin yerine geçer bulur (global komut tarafından aksi belirtilmedikçe). STREAM tabanlı olmaktan ziyade satır tabanlı olsaydı küresel bir komut bile olmazdı, çünkü aynı anda sadece satırları değerlendirecekti. Koşmayı deneyin ed; farkı göreceksiniz. edbelirli satırlar (örneğin bir for-loop'ta) üzerinde yineleme yapmak istiyorsanız, ancak çoğu zaman istediğinizde oldukça kullanışlıdır sed.

3. Söyleniyor ki,

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

   GNU sed4.2.1 sürümünde gayet iyi çalışıyor . Yukarıdaki komut tüm yeni satırları boşluklarla değiştirecektir. Yazmak çirkin ve biraz hantal, ama gayet iyi çalışıyor. {}Onlar sadece aklı nedenlerle dahil ediyoruz olarak 'ler, dışarıda bırakılabilir.

İle cevap: bir etiket ...

Sed kullanarak bir satırsonu (\ n) nasıl değiştirebilirim?

... komut satırındaki freebsd 7.2'de çalışmaz:

(yankı foo; yankı çubuğu) | sed ': a; N; $! ba; s / \ n / / g'
sed: 1: ": a; N; $! ba; s / \ n / / g": kullanılmayan etiket 'a; N; $! ba; s / \ n / / g'
foo
bar

Eğer sed komut dosyasını bir dosyaya koyarsanız veya sed komut dosyasını "oluşturmak" için -e kullanırsanız ...

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

veya ...

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

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

Belki OS X'teki sed benzerdir.

Anlaması Kolay Çözüm

Bu sorunu yaşadım. En önemlisi BSD'ler (Mac OS X) ve GNU'lar (Linux ve Cygwin ) üzerinde çalışmak için çözüme ihtiyaç duymamdısed ve tr:

$ echo 'foo
bar
baz


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

Çıktı:

foo
bar
baz

(sondaki satırsonu vardır)

Linux, OS X ve BSD üzerinde çalışır - UTF-8 desteği olmadan veya crappy terminali ile bile .

1. Yeni trsatırı başka bir karakterle değiştirmek için kullanın .

   NULL( \000veya \x00) güzeldir, çünkü UTF-8 desteğine ihtiyaç duymaz ve kullanılması muhtemel değildir.

2. sedEşleştirmek için kullanınNULL

3. trİhtiyacınız olursa ekstra satırları değiştirmek için kullanın

Xargs kullanabilirsiniz :

seq 10 | xargs

veya

seq 10 | xargs echo -n

Ben uzman değilim ama sanırım sedilk önce desen alanına bir sonraki satırı eklemeniz gerekecek, " N" kullanarak bij . Sed & awk kitabının "Gelişmiş sed Komutları" bölümündeki "Çok Satırlı Desen Alanı" bölümünden (Dale Dougherty ve Arnold Robbins; O'Reilly 1997; önizlemede sayfa 107 ):

Çok satırlı Next (N) komutu, yeni bir girdi satırı okuyarak ve onu kalıp alanının içeriğine ekleyerek çok satırlı bir kalıp alanı oluşturur. Desen alanının orijinal içeriği ve yeni giriş çizgisi, yeni satırla ayrılır. Katıştırılmış yeni satır karakteri kaçış dizisi "\ n" ile desenlerle eşleştirilebilir. Çok satırlı bir desen alanında, "^" meta karakteri, herhangi bir gömülü yeni satırı / çizgiyi takip eden karakter (ler) ile değil, desen alanının ilk karakteriyle eşleşir. Benzer şekilde, "$", kalıp uzayındaki yalnızca son satırsonu ile eşleşir, gömülü satır (lar) ile aynı değildir. Sonraki komut yürütüldükten sonra, denetim komut dosyasında sonraki komutlara geçirilir.

Gönderen man sed:

[2addr] N-

Eklenen materyali orijinal içeriklerden ayırmak için katıştırılmış yeni satır karakteri kullanarak desen alanına bir sonraki girdi satırını ekleyin. Geçerli satır numarasının değiştiğini unutmayın.

Ben ettik bu kullanılan arama dizesi bir "yetim" sonraki satırda bulunabilir hangi kötü biçimlendirilmiş günlük dosyalarını, (çok sayıda) aramak için.

Yeni satırları sekmelerle değiştirmek için tr'i kullanarak satırları değiştirmek için hibrit bir yaklaşım kullandım, ardından sekmeleri istediğim şeyle değiştirdim. Bu durumda, "
" HTML sonları oluşturmaya çalışıyorum.

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

Yukarıdaki "tr" çözümüne yanıt olarak, Windows'ta (muhtemelen tr'in Gnuwin32 sürümünü kullanıyor), önerilen çözüm:

tr '\n' ' ' < input

benim için çalışmıyorsa, bir nedenden dolayı ya hata ya da aslında \ nw / '' yerine geçerdi.

Tr başka bir özelliğini kullanarak, "delete" seçeneği -d olsa da işe yaradı:

tr -d '\n' < input

veya '\ n' yerine '\ r \ n'

Kurşun geçirmez çözüm. İkili veri güvenli ve POSIX uyumlu, ancak yavaş.

POSIX sed , POSIX metin dosyasına ve POSIX satırına göre giriş gerektirir tanımlarına , bu nedenle NULL bayt ve çok uzun satırlara izin verilmez ve her satır bir satırsonu (son satır dahil) ile bitmelidir. Bu, sed'in rastgele giriş verilerinin işlenmesi için kullanılmasını zorlaştırır.

Aşağıdaki çözüm sed'den kaçınır ve bunun yerine girdi baytlarını sekizlik kodlara ve sonra tekrar baytlara dönüştürür, ancak sekizlik kodu 012'yi (satırsonu) durdurur ve yerine yeni bir dize çıkarır. Çözümün POSIX uyumlu olduğunu söyleyebildiğim kadarıyla çok çeşitli platformlarda çalışması gerekir.

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 referans belgeleri: sh , kabuk komut dili , od , tr , grep , read , [ , printf .

Hem read, [ve printfen azından bash gömmeler, ama bu muhtemelen bu yüzden bazı platformlarda her giriş bayt şeyler yavaşlatır, bir veya daha fazla yeni süreçler başlayacak olması olabilir, POSIX tarafından garanti edilmez. Bash'da bile bu çözüm sadece yaklaşık 50 kB / s'ye ulaştığından, büyük dosyalar için uygun değildir.

Ubuntu (bash, tire ve busybox), FreeBSD ve OpenBSD üzerinde test edildi.

Bazı durumlarda belki RSbaşka bir dizgiye veya karaktere geçebilirsiniz . Bu şekilde, \ n alt / gsub için kullanılabilir:

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

Kabuk kodlamanın gücü, bir şekilde nasıl yapılacağını bilmiyorsanız, başka bir şekilde yapabileceğinizdir. Ve çoğu zaman, basit bir soruna karmaşık bir çözüm yapmaktan daha fazla dikkate almanız gerekir.

Gawk'ın yavaş olduğu ve dosyayı belleğe okuduğu şeyle ilgili olarak, bunu bilmiyorum, ama bana göre gawk o sırada bir satırla çalışıyor gibi görünüyor ve çok hızlı (diğerlerinden o kadar hızlı değil) , ancak yazma ve test etme süresi de önemlidir).

MB ve hatta GB veri işliyorum ve bulduğum tek sınır satır boyutu.

Windows satır sonları ile uğraşmak için yeterince talihsiz iseniz \rve\n

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

Kullanabilirsiniz xargs- yerini alacak\n varsayılan olarak bir boşlukla .

Ancak, girdinizde herhangi bir durum unterminated quotevarsa, örneğin belirli bir satırdaki tırnak işaretleri uyuşmuyorsa sorun yaşayabilir .

Allow komutunu kullanarak bulur ve değiştirir \ n

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

İşaretleyici

Oluyor

# Marker Yorumu

İşaretleyici

Neden basit bir çözüm bulamadım awk?

awk '{printf $0}' file

printf orijinal satırları boşluk veya başka bir satırla ayırmak istiyorsanız, her satırı yeni satırlar olmadan yazdıracaktır:

awk '{printf $0 " "}' file

Mac OS X'te (FreeBSD sed kullanarak):

# 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

Boş satırları kaldırmak için:

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

Awk kullanma:

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

Özellikle sevdiğim bir çözüm, bekletme alanındaki tüm dosyaları eklemek ve dosyanın sonundaki tüm yeni satırları değiştirmek:

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

Ancak, birisi bana bazı boş uygulamalarda tutma alanının sonlu olabileceğini söyledi.

Yeni satırları herhangi bir dize ile değiştir ve son yeni satırı da değiştir

Saf trçözümler yalnızca tek bir karakterle değiştirilebilir ve saf sedçözümler, girdinin son satırsonunun yerini almaz. Aşağıdaki çözüm bu sorunları giderir ve ikili veriler (UTF-8 yerel ayarında bile) için güvenli gibi görünür:

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

Sonuç:

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

Bu sed olduğunu tanıtır "normal" oyuncu değişikliğinden sonra yeni hatlar. İlk olarak, yeni satır karakterini keser, daha sonra talimatlarınıza göre işler, sonra yeni bir satır sunar.

Sed kullanarak , her giriş satırı için, kesildikten sonra bir satırın "sonunu" (yeni satır karakterini değil) istediğiniz bir dizeyle değiştirebilirsiniz; ancak sed farklı satırlar çıkarır . Örneğin, "satır sonu" nu "===" (tek bir boşlukla değiştirmekten daha genel) ile değiştirmek istediğinizi varsayalım:

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

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

Dizeyle satır kömürü değiştirmek için, verimsiz olsa, kullanım olabilir tr , daha önce sivri, sonra kullanın "özel char" ile yeni satır-karakter değiştirip için sed istediğiniz dizeyle bu özel kömürü yerine .

Örneğin:

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

Bu yöntemi de kullanabilirsiniz

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

açıklama

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.

Akış:
İlk satır girişten alındığında, değişim yapılır, böylece 1 boşluk tutmaya gider ve \ n desen boşluğuna gelir, daha sonra tutma boşluğunu desen boşluğuna ekler ve sonra yerine koyma gerçekleştirilir ve desen boşluğunu siler.
İkinci satır değişimi yapılırken, 2 boşluk tutmaya gider ve 1 desen boşluğuna gelir, daha sonra Gtutma boşluğunu desen boşluğuna ekler, ardından hdeseni kopyalar ve yerine koyma yapılır ve silinir. Bu işleme eof değerine ulaşılana kadar devam edilir, ardından kesin sonuç yazdırılır.

Zsolt Botykai'nin cevabı ile hemen hemen aynı olan başka bir GNU sed yöntemi, ancak bu, bir bayt kod ( arkadaki) kaydedilensed daha az kullanılan y( harf çevirisi ) komutunu kullanır :g

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

Biri daha yhızlı s, belki de tr20x daha hızlı çalışır, ancak GNU sed v4.2.2'den y yaklaşık % 4 daha yavaş çalışır s.

Daha taşınabilir BSD sed sürümü:

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