¿Cómo puedes combinar todas las líneas que terminan con un carácter de barra diagonal inversa?

Usando una herramienta de línea de comando común como sed o awk, ¿es posible unir todas las líneas que terminan con un carácter dado, como una barra invertida?

Por ejemplo, dado el archivo:

foo bar \
bash \
baz
dude \
happy

Me gustaría obtener esta salida:

foo bar bash baz
dude happy

Una solución sed más corta y simple:

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

o una línea si usa GNU sed:

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

Posiblemente sea más fácil con perl (dado que perl es como sed y awk, espero que sea aceptable para usted):

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

Aquí hay una solución awk. Si una línea termina con a \, retire la barra diagonal inversa e imprima la línea sin nueva línea de terminación; de lo contrario, imprima la línea con una nueva línea final.

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

Tampoco es tan malo en sed, aunque awk es obviamente más legible.

Esta no es una respuesta como tal. Es un tema secundario sobresed .

Específicamente, necesitaba tomar Gilles sed separar el comando de pieza por pieza para entenderlo ... Comencé a escribir algunas notas sobre él, y luego pensé que podría ser útil aquí para alguien ...

así que aquí está ... el script sed de Gilles en formato documentado :

#!/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
#######

Sin embargo, sería otra herramienta de línea de comando común ed, que por defecto modifica los archivos en su lugar y, por lo tanto, deja los permisos de los archivos sin modificar (para obtener más información, edconsulte Edición de archivos con el editor de texto ed desde scripts )

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

Usando el hecho de que readen el shell interpretará barras invertidas cuando se usa sin -r:

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

Tenga en cuenta que esto también interpretará cualquier otra barra diagonal inversa en los datos.

Una solución simple (r) que carga todo el archivo en la memoria:

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

O uno todavía corto que funciona entendiendo líneas (salida) (sintaxis GNU):

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

En una línea (sintaxis POSIX):

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

O use awk (si el archivo es demasiado grande para caber en la memoria):

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

La versión de Mac basada en la solución @Giles se vería así

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

Donde la diferencia principal es cómo se representan las nuevas líneas, y la combinación de más en una línea lo divide

Puede usar cpp, pero produce algunas líneas vacías donde fusionó la salida, y alguna introducción que elimino con sed; tal vez también se puede hacer con cpp-flags y opciones:

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