script - Líneas de continuación de Bash

script linux ejemplos

Question

¿Cómo se usan las líneas de continuación de bash?

Me doy cuenta de que puedes hacer esto:

echo "continuation /
lines"
>continuation lines

Sin embargo, si tiene un código sangrado, no funciona tan bien:

    echo "continuation /
    lines"
>continuation     lines

Answer 1

Sin embargo, si tiene un código sangrado, no funciona tan bien:

    echo "continuation /
    lines"
>continuation     lines

Pruebe con comillas simples y concatenando las cadenas:

    echo ''continuation'' /
    ''lines''
>continuation lines

Nota: la concatenación incluye un espacio en blanco.

Answer 2

Aquí, los documentos con el terminador <<-HERE funcionan bien para cadenas de texto multilínea indentadas. Eliminará las pestañas iniciales del documento aquí.

cat <<-____HERE
    continuation
    lines
____HERE

Ver también http://ss64.com/bash/syntax-here.html

Si necesita preservar algunos, pero no todos, espacios en blanco iniciales, puede usar algo llke

sed ''s/^  //'' <<____HERE
    This has four leading spaces.
    Two of them will be removed by sed.
____HERE

Answer 3

Esto es lo que puede querer

$       echo "continuation"/
>       "lines"
continuation lines

Si esto crea dos argumentos para eco y usted solo quiere uno, entonces veamos la concatenación de cadenas. En bash, colocar dos cadenas una al lado de la otra se concatenan:

$ echo "continuation""lines"
continuationlines

Entonces, una línea de continuación sin sangría es una forma de dividir una cadena:

$ echo "continuation"/
> "lines"
continuationlines

Pero cuando se usa una sangría:

$       echo "continuation"/
>       "lines"
continuation lines

Obtiene dos argumentos porque esto ya no es una concatenación.

Si desea una sola cuerda que cruza líneas, mientras sangra pero no obtiene todos esos espacios, un enfoque que puede intentar es deshacerse de la línea de continuación y usar variables:

$ a="continuation"
$ b="lines"
$ echo $a$b
continuationlines

Esto le permitirá tener un código limpiamente sangrado a expensas de variables adicionales. Si convierte las variables en locales, no debería ser tan malo.

Answer 4

Me encontré con una situación en la que tuve que enviar un mensaje largo como parte de un argumento de comando y tuve que cumplir con la limitación de longitud de línea. Los comandos se ven algo como esto:

somecommand --message="I am a long message" args

La forma en que resolví esto es mover el mensaje como un documento aquí (como sugirió @tripleee). Pero un documento aquí se convierte en un stdin, por lo que debe leerse de nuevo, fui con el siguiente enfoque:

message=$(
    tr "/n" " " <<- END
        This is a
        long message
END
)
somecommand --message="$message" args

Esto tiene la ventaja de que $message se puede usar exactamente como la constante de cadena sin espacio en blanco adicional o saltos de línea.

Tenga en cuenta que las líneas de mensaje anteriores están precedidas por un carácter de tab , que el propio documento elimina (debido al uso de <<- ). Todavía hay saltos de línea al final, que luego se reemplazan por dd con espacios.

Tenga en cuenta también que si no elimina las nuevas líneas, aparecerán tal como están cuando se expande "$message" . En algunos casos, puede solucionar el problema eliminando las comillas dobles alrededor de $message , pero el mensaje ya no será un único argumento.

Answer 5

Probablemente esto no responda tu pregunta, pero de todos modos podrías encontrarlo útil.

El primer comando crea el script que se muestra con el segundo comando.

El tercer comando hace que el script sea ejecutable.

El cuarto comando proporciona un ejemplo de uso.

john@malkovich:~/tmp/so$ echo $''#!/usr/bin/env python/nimport textwrap, sys/n/ndef bash_dedent(text):/n    """Dedent all but the first line in the passed `text`."""/n    try:/n        first, rest = text.split("//n", 1)/n        return "//n".join([first, textwrap.dedent(rest)])/n    except ValueError:/n        return text  # single-line string/n/nprint bash_dedent(sys.argv[1])''  > bash_dedent
john@malkovich:~/tmp/so$ cat bash_dedent 
#!/usr/bin/env python
import textwrap, sys

def bash_dedent(text):
    """Dedent all but the first line in the passed `text`."""
    try:
        first, rest = text.split("/n", 1)
        return "/n".join([first, textwrap.dedent(rest)])
    except ValueError:
        return text  # single-line string

print bash_dedent(sys.argv[1])
john@malkovich:~/tmp/so$ chmod a+x bash_dedent
john@malkovich:~/tmp/so$ echo "$(./bash_dedent "first line
>     second line
>     third line")"
first line
second line
third line

Tenga en cuenta que si realmente desea utilizar este script, tiene más sentido mover el script ejecutable a ~/bin para que esté en su camino.

Consulte la referencia de python para obtener detalles sobre cómo funciona textwrap.dedent .

Si el uso de $''...'' o "$(...)" es confuso para usted, haga otra pregunta (una por construcción) si todavía no hay una. Sería bueno proporcionar un enlace a la pregunta que encuentre / solicite para que otras personas tengan una referencia vinculada.

Answer 6

Puedes usar arrays bash

$ str_array=("continuation"
             "lines")

entonces

$ echo "${str_array[*]}"
continuation lines

hay un espacio extra, porque (después del manual bash):

Si la palabra tiene comillas dobles, ${name[*]} expande a una sola palabra con el valor de cada miembro de la matriz separado por el primer carácter de la variable IFS

Así que configure IFS='''' para deshacerse del espacio extra

$ IFS=''''
$ echo "${str_array[*]}"
continuationlines

Answer 7

Simplemente puede separarlo con líneas nuevas (sin usar barras diagonales inversas) como se requiere dentro de la sangría de la siguiente manera y simplemente pelar nuevas líneas.

Ejemplo:

echo "continuation
of 
lines" | tr ''/n'' '' ''

O si se trata de una definición variable, newlines se convierte automáticamente en espacios. Por lo tanto, tira de espacios adicionales solo si corresponde.

x="continuation
of multiple
lines"
y="red|blue|
green|yellow"

echo $x # This will do as the converted space actually is meaningful
echo $y | tr -d '' '' # Stripping of space may be preferable in this case