Escapar de una variable para usar como contenido de otro script

Esta pregunta no se trata de cómo escribir un literal de cadena con escape correcto. No pude encontrar ninguna pregunta relacionada que no se trata de cómo escapar de las variables para el consumo directo dentro de un script o por otros programas.

Mi objetivo es habilitar un script para generar otros scripts. Esto se debe a que las tareas en los scripts generados se ejecutarán en cualquier lugar de 0 a n veces en otra máquina, y los datos a partir de los cuales se generan pueden cambiar antes de ejecutarse (nuevamente), por lo que realizar las operaciones directamente, a través de una red no trabajo.

Dada una variable conocida que puede contener caracteres especiales como comillas simples, necesito escribirla como un literal de cadena completamente escapado, por ejemplo, una variable que foocontenga bar'bazdebería aparecer en el script generado como:

qux='bar'\''baz'

que se escribiría agregando "qux=$foo_esc"a las otras líneas del guión. Lo hice usando Perl así:

foo_esc="'`perl -pe 's/('\'')/\\1\\\\\\1\\1/g' <<<"$foo"`'"

Pero esto parece una exageración.

No he tenido éxito en hacerlo solo con bash. He intentado muchas variaciones de estos:

foo_esc="'${file//\'/\'\\\'\'}'"
foo_esc="'${file//\'/'\\''}'"

pero aparecen barras diagonales adicionales en la salida (cuando lo hago echo "$foo"), o causan un error de sintaxis (esperando una entrada adicional si se realiza desde el shell).

Bash tiene una opción de expansión de parámetros para exactamente este caso :

${parameter@Q}La expansión es una cadena que es el valor del parámetro citado en un formato que se puede reutilizar como entrada.

Entonces en este caso:

foo_esc="${foo@Q}"

Esto es compatible con Bash 4.4 y versiones posteriores. También hay varias opciones para otras formas de expansión y para generar específicamente declaraciones de asignación completas ( @A).

Bash proporciona una printforden interna con el %qespecificador de formato, que realiza shell de escape para que, incluso en (<4.0) versiones anteriores de Bash:

printf '[%q]\n' "Ne'er do well"
# Prints [Ne\'er\ do\ well]

printf '[%q]\n' 'Sneaky injection $( whoami ) `ls /root`'
# Prints [Sneaky\ injection\ \$\(\ whoami\ \)\ \`ls\ /root\`]

Este truco también se puede usar para devolver matrices de datos de una función:

function getData()
{
  printf '%q ' "He'll say hi" 'or `whoami`' 'and then $( byebye )'
}

declare -a DATA="( $( getData ) )"
printf 'DATA: [%q]\n' "${DATA[@]}"
# Prints:
# DATA: [He\'ll\ say\ hi]
# DATA: [or\ \`whoami\`]
# DATA: [and\ then\ \$\(\ byebye\ \)]

Tenga en cuenta que el Bash printfincorporado es diferente de la printfutilidad que viene incluida con la mayoría de los sistemas operativos tipo Unix. Si, por alguna razón, el printfcomando invoca la utilidad en lugar de la integrada, siempre puede ejecutarla builtin printf.

Supongo que no hice RTFM. Se puede hacer así:

q_mid=\'\\\'\'
foo_esc="'${foo//\'/$q_mid}'"

Luego echo "$foo_esc"da lo esperado'bar'\''baz'

Cómo lo estoy usando realmente es con una función:

function esc_var {
    local mid_q=\'\\\'\'
    printf '%s' "'${1//\'/$mid_q}'"
}

...

foo_esc="`esc_var "$foo"`"

Modificando esto para usar la printfsolución integrada de Dejay:

function esc_vars {
    printf '%q' "$@"
}

Hay varias soluciones para citar un valor var:

1. alias
   En la mayoría de los shells (donde está disponible el alias) (excepto csh, tcsh y probablemente otros como csh):

   $ alias qux=bar\'baz
   $ alias qux
   qux='bar'\''baz'

   Sí, esto funciona en muchos shdepósitos similares a guiones o cenizas.

2. establecer
   también en la mayoría de conchas (de nuevo, no CSH):

   $ qux=bar\'baz
   $ set | grep '^qux='
   qux='bar'\''baz'

3. composición tipográfica
   en algunos shells (ksh, bash y zsh al menos):

   $ qux=bar\'baz
   $ typeset -p qux
   typeset qux='bar'\''baz'             # this is zsh, quoting style may
                                        # be different for other shells.

4. exportar
   primero hacer:

   export qux=bar\'baz

   Luego use:
   ksh export -p | grep 'qux=' bash export -p | grep 'qux='
   zsh export -p qux

5. se puede utilizar comillas
   bash echo "${qux@Q}"
   zsh echo "${(qq)qux}" # de una a cuatro q.