คุณจะรวมบรรทัดทั้งหมดที่ลงท้ายด้วยอักขระเครื่องหมายทับขวาได้อย่างไร

การใช้เครื่องมือบรรทัดคำสั่งทั่วไปเช่น sed หรือ awk เป็นไปได้หรือไม่ที่จะรวมบรรทัดทั้งหมดที่ลงท้ายด้วยอักขระที่กำหนดเช่นแบ็กสแลช?

ตัวอย่างเช่นให้ไฟล์:

foo bar \
bash \
baz
dude \
happy

ฉันต้องการเอาท์พุทนี้:

foo bar bash baz
dude happy

โซลูชัน sed ที่สั้นและง่ายกว่า:

sed  '
: again
/\\$/ {
    N
    s/\\\n//
    t again
}
' textfile

หรือหนึ่งซับถ้าใช้ GNU sed:

sed ':x; /\\$/ { N; s/\\\n//; tx }' textfile

มันอาจเป็นเรื่องง่ายที่สุดสำหรับ perl (เนื่องจาก perl เหมือน sed และ awk ฉันหวังว่ามันจะเป็นที่ยอมรับของคุณ):

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

นี่คือวิธีแก้ปัญหา awk หากบรรทัดลงท้ายด้วย a \ให้ถอดเครื่องหมายแบ็กสแลชและพิมพ์บรรทัดโดยไม่ต้องขึ้นบรรทัดใหม่ มิฉะนั้นพิมพ์บรรทัดด้วยการขึ้นบรรทัดใหม่

awk '{if (sub(/\\$/,"")) printf "%s", $0; else print $0}'

นอกจากนี้ยังไม่ได้แย่เกินไปในการนั่งดู แต่ awk นั้นอ่านง่ายขึ้น

นี่ไม่ใช่คำตอบเช่นนี้ sedมันเป็นปัญหาที่เกี่ยวกับด้านข้าง

โดยเฉพาะฉันต้องใช้sedคำสั่งGilles แยกเป็นชิ้น ๆ เพื่อที่จะเข้าใจมัน ... ฉันเริ่มเขียนบันทึกลงไปแล้วคิดว่ามันอาจจะมีประโยชน์สำหรับคนที่นี่ ...

ดังนั้นนี่คือ ... สคริปต์ sed ของ Gilles ในรูปแบบเอกสาร :

#!/bin/bash
#######################################
sed_dat="$HOME/ztest.dat"
while IFS= read -r line ;do echo "$line" ;done <<'END_DAT' >"$sed_dat"
foo bar \
bash \
baz
dude \
happy
yabba dabba 
doo
END_DAT

#######################################
sedexec="$HOME/ztest.sed"
while IFS= read -r line ;do echo "$line" ;done <<'END-SED' >"$sedexec"; \
sed  -nf "$sedexec" "$sed_dat"

  s/\\$//        # If a line has trailing '\', remove the '\'
                 #    
  t'Hold-append' # branch: Branch conditionally to the label 'Hold-append'
                 #         The condition is that a replacement was made.
                 #         The current pattern-space had a trailing '\' which  
                 #         was replaced, so branch to 'Hold-apend' and append 
                 #         the now-truncated line to the hold-space
                 #
                 # This branching occurs for each (successive) such line. 
                 #
                 # PS. The 't' command may be so named because it means 'on true' 
                 #     (I'm not sure about this, but the shoe fits)  
                 #
                 # Note: Appending to the hold-space introduces a leading '\n'   
                 #       delimiter for each appended line
                 #  
                 #   eg. compare the hex dump of the follow 4 example commands:  
                 #       'x' swaps the hold and patten spaces
                 #
                 #       echo -n "a" |sed -ne         'p' |xxd -p  ## 61 
                 #       echo -n "a" |sed -ne     'H;x;p' |xxd -p  ## 0a61
                 #       echo -n "a" |sed -ne   'H;H;x;p' |xxd -p  ## 0a610a61
                 #       echo -n "a" |sed -ne 'H;H;H;x;p' |xxd -p  ## 0a610a610a61

   # No replacement was made above, so the current pattern-space
   #   (input line) has a "normal" ending.

   x             # Swap the pattern-space (the just-read "normal" line)
                 #   with the hold-space. The hold-space holds the accumulation
                 #   of appended  "stripped-of-backslah" lines

   G             # The pattern-space now holds zero to many "stripped-of-backslah" lines
                 #   each of which has a preceding '\n'
                 # The 'G' command Gets the Hold-space and appends it to 
                 #   the pattern-space. This append action introduces another
                 #   '\n' delimiter to the pattern space. 

   s/\n//g       # Remove all '\n' newlines from the pattern-space

   p             # Print the pattern-space

   s/.*//        # Now we need to remove all data from the pattern-space
                 # This is done as a means to remove data from the hold-space 
                 #  (there is no way to directly remove data from the hold-space)

   x             # Swap the no-data pattern space with the hold-space
                 # This leaves the hold-space re-initialized to empty...
                 # The current pattern-space will be overwritten by the next line-read

   b             # Everything is ready for the next line-read. It is time to make 
                 # an unconditional branch  the to end of process for this line
                 #  ie. skip any remaining logic, read the next line and start the process again.

  :'Hold-append' # The ':' (colon) indicates a label.. 
                 # A label is the target of the 2 branch commands, 'b' and 't'
                 # A label can be a single letter (it is often 'a')
                 # Note;  'b' can be used without a label as seen in the previous command 

    H            # Append the pattern to the hold buffer
                 # The pattern is prefixed with a '\n' before it is appended

END-SED
#######

เครื่องมือบรรทัดคำสั่งทั่วไปอีกอย่างหนึ่งedซึ่งโดยปกติแล้วจะทำการแก้ไขไฟล์ในสถานที่ดังนั้นจึงไม่มีการแก้ไขสิทธิ์อนุญาตไฟล์ (สำหรับข้อมูลเพิ่มเติมเกี่ยวกับedดูการแก้ไขไฟล์ด้วยโปรแกรมแก้ไขข้อความ ed จากสคริปต์ )

str='
foo bar \
bash 1 \
bash 2 \
bash 3 \
bash 4 \
baz
dude \
happy
xxx
vvv 1 \
vvv 2 \
CCC
'

# We are using (1,$)g/re/command-list and (.,.+1)j to join lines ending with a '\'
# ?? repeats the last regex search.
# replace ',p' with 'wq' to edit files in-place
# (using Bash and FreeBSD ed on Mac OS X)
cat <<-'EOF' | ed -s <(printf '%s' "$str")
H
,g/\\$/s///\
.,.+1j\
??s///\
.,.+1j
,p
EOF

การใช้ความจริงที่ว่าreadในเปลือกจะตีความแบ็กสแลชเมื่อใช้โดยไม่-r:

$ while IFS= read line; do printf '%s\n' "$line"; done <file
foo bar bash baz
dude happy

โปรดทราบว่าสิ่งนี้จะตีความแบ็กสแลชอื่น ๆในข้อมูลด้วย

โซลูชัน (r) แบบง่ายที่โหลดไฟล์ทั้งหมดในหน่วยความจำ:

sed -z 's/\\\n//g' file                   # GNU sed 4.2.2+.

หรือสั้น ๆ ซึ่งใช้งานได้กับความเข้าใจ (ผลลัพธ์) บรรทัด (ไวยากรณ์ GNU):

sed ':x;/\\$/{N;bx};s/\\\n//g' file

หนึ่งบรรทัด (ไวยากรณ์ POSIX):

sed -e :x -e '/\\$/{N;bx' -e '}' -e 's/\\\n//g' file

หรือใช้ awk (หากไฟล์ใหญ่เกินไปที่จะใส่ในหน่วยความจำ):

awk '{a=sub(/\\$/,"");printf("%s%s",$0,a?"":RS)}' file

รุ่น Mac ที่ใช้โซลูชั่น @Giles จะมีลักษณะเช่นนี้

sed ':x
/\\$/{N; s|\\'$'\\n||; tx
}' textfile

โดยที่ความแตกต่างหลักคือวิธีการขึ้นบรรทัดใหม่และการรวมใด ๆ เพิ่มเติมลงในหนึ่งบรรทัดแบ่ง

คุณสามารถใช้ cpp ได้ แต่มันสร้างบรรทัดว่างบางส่วนที่รวมเอาท์พุทและการแนะนำบางอย่างที่ฉันลบด้วย sed - บางทีมันสามารถทำได้ด้วย cpp-flag และตัวเลือกเช่นกัน:

echo 'foo bar \
bash \
baz
dude \
happy' | cpp | sed 's/# 1 .*//;/^$/d'
foo bar bash baz
dude happy