Bash
Citando

Sintaxis

• \ C (cualquier caracter excepto una nueva linea)
• 'todo literal excepto comillas simples'; 'esto:' \ '' es una comilla simple '
• $ 'solo \\ y \' son especiales; \ n = nueva línea, etc. '
• "$ variable y otro texto; \" \\\ $ \ `son especiales"

Nuevas líneas y personajes de control.

Se puede incluir una nueva línea en una cadena de una sola cadena o entre comillas dobles. Tenga en cuenta que backslash-newline no produce una nueva línea, el salto de línea se ignora.

newline1='
'
newline2="
"
newline3=$'\n'
empty=\

echo "Line${newline1}break"
echo "Line${newline2}break"
echo "Line${newline3}break"
echo "No line break${empty} here"

Dentro de las cadenas de comillas en dólares, backslash-letter o backslash-octal se pueden usar para insertar caracteres de control, como en muchos otros lenguajes de programación.

echo $'Tab: [\t]'
echo $'Tab again: [\009]'
echo $'Form feed: [\f]'
echo $'Line\nbreak'

Comillas dobles para sustitución de variables y comandos.

Las sustituciones de variables solo deben usarse entre comillas dobles.

calculation='2 * 3'
echo "$calculation"         # prints 2 * 3
echo $calculation           # prints 2, the list of files in the current directory, and 3
echo "$(($calculation))"    # prints 6

Fuera de las comillas dobles, $var toma el valor de var , lo divide en partes delimitadas por espacios en blanco e interpreta cada parte como un patrón global (comodín). A menos que desee este comportamiento, siempre ponga $var entre comillas dobles: "$var" .

Lo mismo se aplica a las sustituciones de comandos: "$(mycommand)" es la salida de mycommand , $(mycommand) es el resultado de split + glob en la salida.

echo "$var"             # good
echo "$(mycommand)"     # good 
another=$var            # also works, assignment is implicitly double-quoted
make -D THING=$var      # BAD! This is not a bash assignment.
make -D THING="$var"    # good
make -D "THING=$var"    # also good

Las sustituciones de comandos tienen sus propios contextos de cita. Escribiendo sustituciones arbitrariamente anidados es fácil porque el analizador hará un seguimiento de la profundidad de anidación en lugar de avidez en busca de la primera " carácter El resaltador de sintaxis Stackoverflow analiza este mal, sin embargo, por ejemplo..:

echo "formatted text: $(printf "a + b = %04d" "${c}")" # “formatted text: a + b = 0000”

Los argumentos variables para una sustitución de comando también deben incluirse entre comillas dobles dentro de las expansiones:

echo "$(mycommand "$arg1" "$arg2")"

Citando texto literal

Todos los ejemplos en este párrafo imprimen la línea.

!"#$&'()*;<=>?  @[\]^`{|}~

Una barra invertida cita el siguiente carácter, es decir, el siguiente carácter se interpreta literalmente. La única excepción es una nueva línea: backslash-newline se expande a la cadena vacía.

echo \!\"\#\$\&\'\(\)\*\;\<\=\>\?\ \ \@\[\\\]\^\`\{\|\}\~

Todo el texto entre comillas simples (citas hacia adelante ' , también conocido como apóstrofe) se imprime literalmente. Incluso la barra invertida significa por sí misma, y ​​es imposible incluir una sola cita; en su lugar, puede detener la cadena literal, incluir una comilla simple literal con una barra diagonal inversa y volver a iniciar la cadena literal. Por lo tanto, la secuencia de 4 caracteres '\'' permite efectivamente incluir una comilla simple en una cadena literal.

echo '!"#$&'\''()*;<=>?  @[\]^`{|}~'
#          ^^^^

Dollar-single-quote inicia una cadena literal $'…' como muchos otros lenguajes de programación, donde la barra invertida cita el siguiente carácter.

echo $'!"#$&\'()*;<=>?  @[\\]^`{|}~'
#           ^^            ^^

Las comillas dobles " delimitan cadenas semi-literales donde solo los caracteres " \ $ y ` conservan su significado especial. Estos caracteres necesitan una barra invertida delante de ellos (tenga en cuenta que si la barra invertida va seguida de algún otro carácter, la barra invertida permanece). Las comillas dobles son útiles sobre todo cuando se incluye una variable o una sustitución de comando.

echo "!\"#\$&'()*;<=>?  @[\\]^\`{|}~"
#      ^^                 ^^  ^^
echo "!\"#\$&'()*;<=>?  @[\]^\`{|}~"
#      ^^                 ^  ^^      \[ prints \[

¡Interactivamente, ten cuidado con eso ! desencadena la expansión del historial entre comillas dobles: "!oops" busca un comando antiguo que contenga oops ; "\!oops" no hace expansión de historial pero mantiene la barra invertida. Esto no sucede en los scripts.

Diferencia entre comillas dobles y comillas simples

Propiedades que son comunes a ambos:

• Previene el globbing
• Previene la división de palabras

Ejemplos:

$ echo "!cat"
echo "cat file"
cat file
$ echo '!cat'
!cat
echo "\"'\""
"'"
$ a='var'
$ echo '$a'
$a
$ echo "$a"
var