Làm cách nào tôi có thể thay thế một dòng mới ("\n ") bằng khoảng trắng (" ") bằng sedlệnh?

Tôi đã thử không thành công:

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

Làm thế nào để tôi sửa nó?

Sử dụng giải pháp này với GNU sed:

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

Điều này sẽ đọc toàn bộ tệp trong một vòng lặp, sau đó thay thế (các) dòng mới bằng một khoảng trắng.

Giải trình:

1. Tạo nhãn thông qua :a.
2. Nối dòng hiện tại và dòng tiếp theo vào không gian mẫu thông qua N.
3. Nếu chúng ta ở trước dòng cuối cùng, hãy phân nhánh đến nhãn đã tạo $!ba( $!có nghĩa là không thực hiện trên dòng cuối cùng vì sẽ có một dòng mới cuối cùng).
4. Cuối cùng, sự thay thế thay thế mọi dòng mới bằng một khoảng trắng trên không gian mẫu (là toàn bộ tệp).

Đây là cú pháp tương thích đa nền tảng hoạt động với BSD và OS X sed(theo nhận xét @Benjie ):

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

Như bạn có thể thấy, sử dụng sedcho vấn đề đơn giản này là vấn đề. Đối với một giải pháp đơn giản và đầy đủ xem câu trả lời này .

sedđược dự định sẽ được sử dụng trên đầu vào dựa trên dòng. Mặc dù nó có thể làm những gì bạn cần.

Một lựa chọn tốt hơn ở đây là sử dụng trlệnh như sau:

tr '\n' ' ' < input_filename

hoặc xóa hoàn toàn các ký tự dòng mới:

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

hoặc nếu bạn có phiên bản GNU (với các tùy chọn dài)

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

Trả lời nhanh

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

1. : a tạo nhãn 'a'
2. N nối dòng tiếp theo vào không gian mẫu
3. $! nếu không phải là dòng cuối cùng , ba nhánh (đi đến) nhãn 'a'
4. s thay thế , / \ n / regex cho dòng mới , / / bởi một khoảng trắng , / g khớp toàn cục (càng nhiều lần càng tốt)

sed sẽ lặp qua bước 1 đến 3 cho đến khi đến dòng cuối cùng, nhận được tất cả các dòng vừa với không gian mẫu trong đó sed sẽ thay thế tất cả các ký tự \ n

Lựa chọn thay thế

Tất cả các lựa chọn thay thế, không giống như sed sẽ không cần phải đến dòng cuối cùng để bắt đầu quá trình

với bash , chậm

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

với perl , sed -like tốc độ

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

với tr , nhanh hơn sed , chỉ có thể thay thế bằng một ký tự

tr '\n' ' ' < file

với dán , tốc độ giống như tr , chỉ có thể thay thế bằng một ký tự

paste -s -d ' ' file

với awk , tốc độ như tr

awk 1 ORS=' ' file

Thay thế khác như "echo $ (<file)" là chậm, chỉ hoạt động trên các tệp nhỏ và cần xử lý toàn bộ tệp để bắt đầu quá trình.

Câu trả lời dài từ sed FAQ 5.10

5.10. Tại sao tôi không thể khớp hoặc xóa một dòng mới bằng cách sử dụng
chuỗi thoát \ n ? Tại sao tôi không thể kết hợp 2 dòng trở lên bằng \ n?

\ N sẽ không bao giờ khớp với dòng mới ở cuối dòng vì
dòng mới luôn bị loại bỏ trước khi dòng được đặt vào
không gian mẫu. Để có được 2 hoặc nhiều dòng vào không gian mẫu, hãy sử dụng
lệnh 'N' hoặc một cái gì đó tương tự (chẳng hạn như 'H; ...; g;').

Sed hoạt động như thế này: sed đọc từng dòng một, cắt
bỏ dòng mới kết thúc, đặt những gì còn lại vào không gian mẫu nơi
tập lệnh sed có thể xử lý hoặc thay đổi nó, và khi không gian mẫu
được in, sẽ thêm một dòng mới vào thiết bị xuất chuẩn (hoặc vào một tập tin). Nếu
không gian mẫu bị xóa hoàn toàn hoặc một phần với 'd' hoặc 'D',
dòng mới sẽ không được thêm vào trong các trường hợp như vậy. Do đó, các kịch bản như

  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         

sẽ KHÔNG BAO GIỜ hoạt động, bởi vì dòng mới theo dõi được loại bỏ trước khi
dòng được đưa vào không gian mẫu. Để thực hiện các tác vụ trên,
thay vào đó hãy sử dụng một trong các tập lệnh sau:

  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          

Do các phiên bản của sed khác với GNU sed có giới hạn về kích thước của
bộ đệm mẫu, nên tiện ích 'tr' của Unix được ưu tiên ở đây.
Nếu dòng cuối cùng của tệp chứa một dòng mới, GNU sed sẽ thêm
dòng mới đó vào đầu ra nhưng xóa tất cả các dòng khác, trong khi tr sẽ
xóa tất cả các dòng mới.

Để khớp một khối gồm hai hoặc nhiều dòng, có 3 lựa chọn cơ bản:
(1) sử dụng lệnh 'N' để thêm dòng Tiếp theo vào không gian mẫu;
(2) sử dụng lệnh 'H' ít nhất hai lần để nối dòng hiện tại
vào không gian Giữ, sau đó truy xuất các dòng từ không gian giữ
bằng x, g hoặc G; hoặc (3) sử dụng phạm vi địa chỉ (xem phần 3.3, ở trên)
để khớp các dòng giữa hai địa chỉ được chỉ định.

Các lựa chọn (1) và (2) sẽ đặt \ n vào không gian mẫu, tại đó nó
có thể được xử lý theo ý muốn ('s / ABC \ nXYZ / alph / g'). Một ví dụ
về việc sử dụng 'N' để xóa một khối các dòng xuất hiện trong phần 4.13
("Làm cách nào để xóa một khối các dòng liên tiếp cụ thể ?").
Ví dụ này có thể được sửa đổi bằng cách thay đổi lệnh xóa thành một thứ
khác, như 'p' (in), 'i' (insert), 'c' (thay đổi), 'a' (chắp thêm)
hoặc 's' (thay thế) .

Choice (3) sẽ không chấm \ n vào không gian mô hình, nhưng nó không
phù hợp với một khối dòng liên tiếp, vì vậy nó có thể là bạn không
còn cần \ n để tìm thấy những gì bạn đang tìm kiếm. Do GNU sed
phiên bản 3.02.80 hiện hỗ trợ cú pháp này:

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

ngoài các
địa chỉ phạm vi '/ từ đây /, / đến đó / {...}' truyền thống , có thể tránh hoàn toàn việc sử dụng \ n.

Một thay thế awk ngắn hơn:

awk 1 ORS=' '

Giải trình

Một chương trình awk được xây dựng từ các quy tắc bao gồm các khối mã có điều kiện, nghĩa là:

condition { code-block }

Nếu khối mã bị bỏ qua, mặc định được sử dụng : { print $0 }. Do đó, điều 1này được hiểu là một điều kiện thực sự và print $0được thực thi cho mỗi dòng.

Khi awkđọc đầu vào, nó sẽ phân tách nó thành các bản ghi dựa trên giá trị của RS(Dấu tách bản ghi), theo mặc định là một dòng mới, do đó awktheo mặc định sẽ phân tích cú pháp dòng đầu vào. Việc chia tách cũng liên quan đến việc tước khỏi RSbản ghi đầu vào.

Bây giờ, khi in một bản ghi, ORS(Dấu tách bản ghi đầu ra) được thêm vào nó, mặc định lại là một dòng mới. Vì vậy, bằng cách thay đổi ORSthành một không gian, tất cả các dòng mới được thay đổi thành không gian.

gnu sed có một tùy chọn -zcho các bản ghi (dòng) null. Bạn chỉ có thể gọi:

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

Các Perl phiên bản hoạt động theo cách bạn mong đợi.

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

Như đã chỉ ra trong các bình luận, đáng chú ý là điều này chỉnh sửa tại chỗ. -i.baksẽ cung cấp cho bạn bản sao lưu của tệp gốc trước khi thay thế trong trường hợp biểu thức thông thường của bạn không thông minh như bạn nghĩ.

Ai cần sed? Đây là bashcách:

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

Để thay thế tất cả các dòng mới bằng khoảng trắng bằng awk, mà không cần đọc toàn bộ tệp vào bộ nhớ:

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

Nếu bạn muốn một dòng mới cuối cùng:

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

Bạn có thể sử dụng một ký tự khác ngoài không gian:

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

tr '\n' ' ' 

là mệnh lệnh.

Đơn giản và dễ sử dụng.

Ba thứ.

1. tr(hoặc cat, v.v.) là hoàn toàn không cần thiết. (GNU) sedvà (GNU) awk, khi được kết hợp, có thể thực hiện 99,9% bất kỳ xử lý văn bản nào bạn cần.

2. stream! = dòng dựa. edlà một biên tập viên dựa trên dòng. sedkhông phải. Xem bài giảng sed để biết thêm thông tin về sự khác biệt. Hầu hết mọi người nhầm lẫn sedlà dựa trên dòng vì theo mặc định, nó không tham lam trong việc khớp mẫu của nó cho các kết quả khớp SIMPLE - ví dụ, khi thực hiện tìm kiếm mẫu và thay thế bằng một hoặc hai ký tự, theo mặc định, nó chỉ thay thế cho kết quả khớp đầu tiên nó tìm thấy (trừ khi có quy định khác bởi lệnh toàn cầu). Thậm chí sẽ không có lệnh toàn cầu nếu nó dựa trên dòng thay vì dựa trên STREAM, bởi vì nó sẽ chỉ đánh giá các dòng tại một thời điểm. Hãy thử chạy ed; bạn sẽ nhận thấy sự khác biệt edlà khá hữu ích nếu bạn muốn lặp lại các dòng cụ thể (chẳng hạn như trong một vòng lặp for), nhưng hầu hết các lần bạn sẽ chỉ muốn sed.

3. Điều đó đang được nói,

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

   chỉ hoạt động tốt trong sedphiên bản GNU 4.2.1. Lệnh trên sẽ thay thế tất cả các dòng mới bằng dấu cách. Nó xấu và hơi cồng kềnh khi gõ, nhưng nó hoạt động tốt. Có {}thể bỏ qua, vì chúng chỉ được bao gồm vì lý do tỉnh táo.

Câu trả lời với: một nhãn ...

Làm cách nào tôi có thể thay thế một dòng mới (\ n) bằng sed?

... không hoạt động trong freebsd 7.2 trên dòng lệnh:

(echo foo; thanh echo) | sed ': a; N; $! ba; s / \ n / / g'
sed: 1: ": a; N; $! ba; s / \ n / / g": nhãn không sử dụng 'a; N; $! ba; s / \ n / / g'
foo
quán ba

Nhưng nếu bạn đặt tập lệnh sed vào một tập tin hoặc sử dụng -e để "xây dựng" tập lệnh sed ...

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

hoặc là ...

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

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

Có lẽ sed trong OS X cũng tương tự.

Giải pháp dễ hiểu

Tôi đã có vấn đề này. Yếu tố chính là tôi cần giải pháp để hoạt động trên BSD (Mac OS X) và GNU's (Linux và Cygwin ) sedvà tr:

$ echo 'foo
bar
baz


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

Đầu ra:

foo
bar
baz

(có dòng mới)

Nó hoạt động trên Linux, OS X và BSD - ngay cả khi không có hỗ trợ UTF-8 hoặc với thiết bị đầu cuối tào lao.

1. Sử dụng trđể trao đổi dòng mới với một nhân vật khác.

   NULL( \000hoặc \x00) là tốt vì nó không cần hỗ trợ UTF-8 và nó không có khả năng được sử dụng.

2. Sử dụng sedđể phù hợp vớiNULL

3. Sử dụng trđể trao đổi lại các dòng mới nếu bạn cần chúng

Bạn có thể sử dụng xargs :

seq 10 | xargs

hoặc là

seq 10 | xargs echo -n

Tôi không phải là chuyên gia, nhưng tôi đoán sedtrước tiên bạn cần nối dòng tiếp theo vào không gian mẫu, sử dụng " N". Từ phần "Không gian mô hình đa dòng" trong "Advanced sed Commands" của cuốn sách sed & awk (Dale Dougherty và Arnold Robbins; O'Reilly 1997; trang 107 trong bản xem trước ):

Lệnh multiline Next (N) tạo ra một không gian mẫu multiline bằng cách đọc một dòng đầu vào mới và nối nó vào nội dung của không gian mẫu. Nội dung ban đầu của không gian mẫu và dòng đầu vào mới được phân tách bằng một dòng mới. Ký tự dòng mới được nhúng có thể được khớp trong các mẫu theo trình tự thoát "\ n". Trong không gian mẫu đa dòng, metacharacter "^" khớp với ký tự đầu tiên của không gian mẫu và không phải (các) ký tự theo sau bất kỳ dòng mới được nhúng nào. Tương tự, "$" chỉ khớp với dòng mới cuối cùng trong không gian mẫu và không phải bất kỳ dòng mới nào được nhúng. Sau khi lệnh Tiếp theo được thực thi, điều khiển sẽ được chuyển cho các lệnh tiếp theo trong tập lệnh.

Từ man sed:

[2addr] N

Nối dòng đầu vào tiếp theo vào không gian mẫu, sử dụng ký tự dòng mới được nhúng để tách tài liệu được nối với nội dung gốc. Lưu ý rằng số dòng hiện tại thay đổi.

Tôi đã sử dụng điều này để tìm kiếm (nhiều) tệp nhật ký được định dạng sai, trong đó chuỗi tìm kiếm có thể được tìm thấy trên dòng tiếp theo "mồ côi".

Tôi đã sử dụng một phương pháp lai để khắc phục điều mới bằng cách sử dụng tr để thay thế dòng mới bằng các tab, sau đó thay thế các tab bằng bất cứ thứ gì tôi muốn. Trong trường hợp này, "
" vì tôi đang cố gắng tạo các ngắt HTML.

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

Để đáp ứng với giải pháp "tr" ở trên, trên Windows (có thể sử dụng phiên bản tr của Gnuwin32), giải pháp được đề xuất:

tr '\n' ' ' < input

không hoạt động với tôi, nó sẽ bị lỗi hoặc thực sự thay thế \ nw / '' vì một số lý do.

Sử dụng một tính năng khác của tr, tùy chọn "xóa" -d đã hoạt động:

tr -d '\n' < input

hoặc '\ r \ n' thay vì '\ n'

Giải pháp chống đạn. Nhị phân dữ liệu an toàn và tuân thủ POSIX, nhưng chậm.

POSIX sed yêu cầu đầu vào theo tệp văn bản POSIX POSIX và dòng POSIX định nghĩa , do đó, NULL-byte và quá dài không được phép và mỗi dòng phải kết thúc bằng một dòng mới (bao gồm cả dòng cuối cùng). Điều này làm cho nó khó sử dụng sed để xử lý dữ liệu đầu vào tùy ý.

Giải pháp sau đây tránh sed và thay vào đó chuyển đổi các byte đầu vào thành mã bát phân rồi lại thành byte, nhưng chặn mã bát phân 012 (dòng mới) và đưa ra chuỗi thay thế thay cho nó. Theo như tôi có thể nói giải pháp là tuân thủ POSIX, vì vậy nó nên hoạt động trên nhiều nền tảng khác nhau.

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

Tài liệu tham khảo POSIX: sh , ngôn ngữ lệnh shell , od , tr , grep , đọc , [ , printf .

cả hai read,[ và printfđược tích hợp ít nhất là bash, nhưng điều đó có thể không được đảm bảo bởi POSIX, vì vậy trên một số nền tảng, có thể mỗi byte đầu vào sẽ bắt đầu một hoặc nhiều quy trình mới, điều này sẽ làm mọi thứ chậm lại. Ngay cả trong bash, giải pháp này chỉ đạt khoảng 50 kB / s, vì vậy nó không phù hợp với các tệp lớn.

Đã thử nghiệm trên Ubuntu (bash, dash và busybox), FreeBSD và OpenBSD.

Trong một số tình huống có thể bạn có thể thay đổi RSthành một số chuỗi hoặc ký tự khác. Bằng cách này, \ n có sẵn cho phụ / gsub:

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

Sức mạnh của kịch bản shell là nếu bạn không biết cách thực hiện theo một cách khác, bạn có thể thực hiện theo cách khác. Và nhiều khi bạn có nhiều điều cần tính đến hơn là đưa ra một giải pháp phức tạp cho một vấn đề đơn giản.

Về điều mà gawk chậm ... và đọc tệp vào bộ nhớ, tôi không biết điều này, nhưng đối với tôi, gawk dường như hoạt động với một dòng tại thời điểm đó và rất nhanh (không nhanh như một số người khác , nhưng thời gian để viết và kiểm tra cũng được tính).

Tôi xử lý MB và thậm chí GB dữ liệu và giới hạn duy nhất tôi tìm thấy là kích thước dòng.

Nếu bạn không may phải xử lý các kết thúc dòng windows, bạn cần xóa \rvà\n

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

Bạn có thể sử dụng xargs- nó sẽ thay thế \nbằng một khoảng trắng theo mặc định.

Tuy nhiên, nó sẽ có vấn đề nếu đầu vào của bạn có bất kỳ trường hợp nào unterminated quote, ví dụ: nếu dấu ngoặc kép trên một dòng nhất định không khớp.

Tìm và thay thế bằng cách sử dụng cho phép \ n

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

Đánh dấu

Trở thành

# Nhận xét đánh dấu

Đánh dấu

Tại sao tôi không tìm thấy một giải pháp đơn giản với awk?

awk '{printf $0}' file

printf sẽ in mọi dòng mà không có dòng mới, nếu bạn muốn tách các dòng gốc bằng một khoảng trắng hoặc khác:

awk '{printf $0 " "}' file

Trên Mac OS X (sử dụng sed FreeBSD):

# 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

Để xóa các dòng trống:

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

Sử dụng Awk:

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

Một giải pháp tôi đặc biệt thích là nối tất cả các tệp trong không gian giữ và thay thế tất cả các dòng mới ở cuối tệp:

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

Tuy nhiên, có người nói với tôi rằng không gian giữ có thể là hữu hạn trong một số triển khai sed.

Thay thế dòng mới bằng bất kỳ chuỗi nào và cũng thay thế dòng mới cuối cùng

Các trgiải pháp thuần túy chỉ có thể thay thế bằng một ký tự duy nhất và các sedgiải pháp thuần túy không thay thế dòng mới cuối cùng của đầu vào. Giải pháp sau đây khắc phục những sự cố này và dường như an toàn cho dữ liệu nhị phân (ngay cả với ngôn ngữ 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'

Kết quả:

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

Đó là sed giới thiệu các dòng mới sau khi thay thế "bình thường". Đầu tiên, nó cắt char dòng mới, sau đó nó xử lý theo hướng dẫn của bạn, sau đó nó giới thiệu một dòng mới.

Sử dụng sed, bạn có thể thay thế "phần cuối" của một dòng (không phải char dòng mới) sau khi được cắt, bằng một chuỗi bạn chọn, cho mỗi dòng đầu vào; nhưng, sed sẽ xuất ra các dòng khác nhau. Ví dụ: giả sử bạn muốn thay thế "cuối dòng" bằng "===" (tổng quát hơn thay thế bằng một khoảng trắng):

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

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

Để thay thế char dòng mới bằng chuỗi, bạn có thể, không hiệu quả, sử dụng tr , như được chỉ ra trước đó, để thay thế ký tự dòng mới bằng "char đặc biệt" và sau đó sử dụng sed để thay thế char đặc biệt đó bằng chuỗi bạn muốn .

Ví dụ:

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

Bạn cũng có thể sử dụng phương pháp này

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

Giải trình

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.

Luồng:
Khi dòng đầu tiên nhận được từ đầu vào, trao đổi được thực hiện, do đó, 1 sẽ giữ không gian và \ n đến không gian mẫu, sau đó nối không gian giữ vào không gian mẫu, sau đó thay thế được thực hiện và xóa không gian mẫu.
Trong quá trình trao đổi dòng thứ hai được thực hiện, 2 chuyển sang giữ không gian và 1 đến không gian mẫu, sau đó Gnối không gian giữ vào không gian mẫu, sau đó hsao chép mẫu vào đó và thay thế được thực hiện và xóa. Thao tác này được tiếp tục cho đến khi đạt được eof sau đó in kết quả chính xác.

Một phương thức GNU khác sed, gần giống như câu trả lời của Zsolt Botykai , nhưng phương thức này sử dụng lệnh ( phiên âm ) sedít được sử dụng hơn , giúp tiết kiệm một byte mã (theo dõi ):yg

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

Người ta hy vọng ysẽ chạy nhanh hơn s, (có lẽ ở trtốc độ, nhanh hơn 20 lần), nhưng trong GNU sed v4.2.2 y thì chậm hơn khoảng 4%s .

Phiên bản BSD di động khác sed:

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