Diferencia entre comillas simples y dobles en Bash

En Bash, ¿cuáles son las diferencias entre comillas simples ( '') y comillas dobles ( "")?

Las comillas simples no interpolan nada, pero las comillas dobles sí. Por ejemplo: variables, comillas inversas, ciertos \escapes, etc.

Ejemplo:

$ echo "$(echo "upg")"
upg
$ echo '$(echo "upg")'
$(echo "upg")

El manual de Bash tiene esto que decir:

3.1.2.2 Cotizaciones individuales

Incluir caracteres entre comillas simples ( ') conserva el valor literal de cada carácter dentro de las comillas. Una comilla simple no puede aparecer entre comillas simples, incluso cuando esté precedida por una barra invertida.

3.1.2.3 Cotizaciones dobles

Encerrar caracteres entre comillas dobles ( ") preserva el valor literal de todos los caracteres dentro de las comillas, con la excepción de $, `, \, y, cuando se habilita la expansión de historia, !. Los caracteres $y `conservan su significado especial entre comillas dobles (consulte Expansiones de Shell ). La barra invertida mantiene su significado especial sólo cuando es seguida por uno de los siguientes caracteres: $, `, ",\o nueva línea. Entre comillas dobles, se eliminan las barras diagonales inversas seguidas por uno de estos caracteres. Las barras invertidas que preceden a los caracteres sin un significado especial no se modifican. Una comilla doble puede estar entre comillas dobles precediéndola con una barra invertida. Si está habilitado, la expansión del historial se realizará a menos que una que !aparezca entre comillas dobles se escape usando una barra invertida. La barra invertida que precede al !no se elimina.

Los parámetros especiales *y @tienen un significado especial cuando están entre comillas dobles (consulte Expansión de parámetros de Shell ).

La respuesta aceptada es genial. Estoy haciendo una tabla que ayuda a una rápida comprensión del tema. La explicación involucra una variable simple aasí como una matriz indexada arr.

Si ponemos

a=apple      # a simple variable
arr=(apple)  # an indexed array with a single element

y luego echola expresión en la segunda columna, obtendríamos el resultado / comportamiento mostrado en la tercera columna. La cuarta columna explica el comportamiento.

 # | Expression  | Result      | Comments
---+-------------+-------------+--------------------------------------------------------------------
 1 | "$a" | apple | variables are expanded inside "" 2 | '$a'        | $a | variables are not expanded inside '' 3 | "'$a'"      | 'apple'     | '' has no special meaning inside ""
 4 | '"$a"' | "$a"        | "" is treated literally inside ''
 5 | '\''        | **invalid** | can not escape a ' within ''; use "'" or $'\'' (ANSI-C quoting) 6 | "red$arocks"| red         | $arocks does not expand $a; use ${a}rocks to preserve $a
 7 | "redapple$" | redapple$   | $ followed by no variable name evaluates to $
 8 | '\"'        | \"          | \ has no special meaning inside ''
 9 | "\'"        | \'          | \' is interpreted inside "" but has no significance for '
10 | "\""        | "           | \" is interpreted inside ""
11 | "*"         | *           | glob does not work inside "" or ''
12 | "\t\n"      | \t\n        | \t and \n have no special meaning inside "" or ''; use ANSI-C quoting
13 | "`echo hi`" | hi          | `` and $() are evaluated inside "" 14 | '`echo hi`' | `echo hi` | `` and $() are not evaluated inside ''
15 | '${arr[0]}' | ${arr[0]}   | array access not possible inside ''
16 | "${arr[0]}" | apple | array access works inside "" 17 | $'$a\'' | $a'         | single quotes can be escaped inside ANSI-C quoting
18 | "$'\t'" | $'\t'       | ANSI-C quoting is not interpreted inside ""
19 | '!cmd'      | !cmd        | history expansion character '!' is ignored inside ''
20 | "!cmd"      | cmd args    | expands to the most recent command matching "cmd"
21 | $'!cmd'     | !cmd        | history expansion character '!' is ignored inside ANSI-C quotes
---+-------------+-------------+--------------------------------------------------------------------

Ver también:

• Citas ANSI-C con $''- GNU Bash Manual
• Traducción local con $""- GNU Bash Manual
• Una fórmula de tres puntos para cotizaciones

Si te refieres a lo que sucede cuando haces eco de algo, las comillas simples literalmente harán eco de lo que tienes entre ellas, mientras que las comillas dobles evaluarán las variables entre ellas y generarán el valor de la variable.

Por ejemplo, este

#!/bin/sh
MYVAR=sometext
echo "double quotes gives you $MYVAR" echo 'single quotes gives you $MYVAR'

dará esto:

double quotes gives you sometext
single quotes gives you $MYVAR

Otros lo explicaron muy bien y solo quieren dar con ejemplos sencillos.

Se pueden usar comillas simples alrededor del texto para evitar que el shell interprete caracteres especiales. Los signos de dólar, espacios, ampersands, asteriscos y otros caracteres especiales se ignoran cuando se incluyen entre comillas simples.

$ echo 'All sorts of things are ignored in single quotes, like $ & * ; |.' 

Dará esto:

All sorts of things are ignored in single quotes, like $ & * ; |.

Lo único que no se puede poner entre comillas simples es una comilla simple.

Las comillas dobles actúan de manera similar a las comillas simples, excepto que las comillas dobles aún permiten que el shell interprete los signos de dólar, las comillas inversas y las barras diagonales inversas. Ya se sabe que las barras invertidas evitan que se interprete un solo carácter especial. Esto puede resultar útil entre comillas dobles si es necesario utilizar un signo de dólar como texto en lugar de como variable. También permite que las comillas dobles se escapen para que no se interpreten como el final de una cadena entre comillas.

$ echo "Here's how we can use single ' and double \" quotes within double quotes"

Dará esto:

Here's how we can use single ' and double " quotes within double quotes

También puede observarse que el apóstrofe, que de otro modo se interpretaría como el comienzo de una cadena entre comillas, se ignora entre comillas dobles. Sin embargo, las variables se interpretan y sustituyen por sus valores entre comillas dobles.

$ echo "The current Oracle SID is $ORACLE_SID"

Dará esto:

The current Oracle SID is test

Las comillas inversas son totalmente diferentes a las comillas simples o dobles. En lugar de utilizarse para evitar la interpretación de caracteres especiales, las comillas inversas en realidad fuerzan la ejecución de los comandos que encierran. Una vez que se ejecutan los comandos adjuntos, su salida se sustituye por las comillas inversas en la línea original. Esto quedará más claro con un ejemplo.

$ today=`date '+%A, %B %d, %Y'` $ echo $today 

Dará esto:

Monday, September 28, 2015 

Existe una clara distinción entre el uso de ' 'y " ".

Cuando ' 'se usa alrededor de cualquier cosa, no se realiza ninguna "transformación o traducción". Está impreso como está.

Con " ", todo lo que rodea, se "traduce o transforma" en su valor.

Por traducción / transformación me refiero a lo siguiente: Todo lo que esté entre comillas simples no se "traducirá" a sus valores. Se considerarán entre comillas. Ejemplo:, a=23luego echo '$a'producirá $aen salida estándar. Considerando echo "$a"que producirá 23en salida estándar.

Dado que esta es la respuesta de facto cuando se trata de comillas bash, agregaré un punto más que se perdió en las respuestas anteriores, cuando se trata de los operadores aritméticos en el shell.

El bashshell admite dos formas de realizar operaciones aritméticas, una definida por el letcomando incorporado y el $((..))operador. El primero evalúa una expresión aritmética, mientras que el segundo es más una declaración compuesta.

Es importante entender que la expresión aritmética usada con se letsomete a expansión de nombre de ruta de división de palabras como cualquier otro comando de shell. Por lo tanto, es necesario hacer una cita y un escape adecuados.

Vea este ejemplo al usar let

let 'foo = 2 + 1'
echo $foo
3

El uso de comillas simples aquí está absolutamente bien aquí, ya que aquí no hay necesidad de expansiones de variables, considere un caso de

bar=1
let 'foo = $bar + 1'

fallaría miserablemente, ya que las $barcomillas simples inferiores no se expandirían y necesita ser entre comillas dobles como

let 'foo = '"$bar"' + 1'

Esta debe ser una de las razones por las $((..))que siempre se debe considerar el uso excesivo let. Porque en su interior, los contenidos no están sujetos a la división de palabras. El ejemplo anterior usando letse puede escribir simplemente como

(( bar=1, foo = bar + 1 ))

Recuerde siempre usar $((..))sin comillas simples

Aunque $((..))se puede usar con comillas dobles, no tiene ningún propósito, ya que el resultado no puede contener un contenido que necesite comillas dobles. Solo asegúrese de que no esté citado individualmente.

printf '%d\n' '$((1+1))' -bash: printf: $((1+1)): invalid number
printf '%d\n' $((1+1)) 2 printf '%d\n' "$((1+1))"
2

Puede ser en algunos casos especiales de uso del $((..))operador dentro de una sola cadena entre comillas, debe interpolar las comillas de manera que el operador se deje sin comillas o entre comillas dobles. Por ejemplo, considere un caso, cuando está tratando de usar el operador dentro de una curldeclaración para pasar un contador cada vez que se realiza una solicitud, haga

curl http://myurl.com --data-binary '{"requestCounter":'"$((reqcnt++))"'}'

Observe el uso de comillas dobles anidadas dentro, sin las cuales la cadena literal $((reqcnt++))se pasa al requestCountercampo.