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 interpolarán nada, pero las comillas dobles lo harán. Por ejemplo: variables, backticks, 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

La inclusión de caracteres entre comillas simples ( ' ) conserva el valor literal de cada carácter dentro de las comillas. Es posible que una comilla simple no se produzca entre comillas simples, incluso cuando esté precedida por una barra diagonal inversa.

3.1.2.3 Cotizaciones dobles

La inclusión de caracteres entre comillas dobles ( " ) conserva el valor literal de todos los caracteres dentro de las comillas, con la excepción de $ , ` , \ y, cuando se habilita la expansión del historial, ! . Los caracteres $ y ` conservan su significado especial dentro del doble comillas (vea Expansiones de Shell ). La barra invertida conserva su significado especial solo cuando es seguida por uno de los siguientes caracteres: $ , ` , " , \ o newline. Dentro de las comillas dobles, se eliminan las barras invertidas que son seguidas por uno de estos caracteres. Las barras diagonales anteriores a los caracteres sin un significado especial quedan sin modificar. Una comilla doble puede citarse entre comillas dobles precediéndola con una barra diagonal inversa. Si está habilitado, la expansión del historial se realizará a menos que an ! aparecer entre comillas dobles se escapa utilizando una barra diagonal inversa. La barra invertida que precede al ! no se elimina

Los parámetros especiales * y @ tienen un significado especial cuando están entre comillas dobles (ver Expansión del parámetro de la carcasa ).

Si te estás refiriendo a lo que sucede cuando haces eco de algo, las comillas simples reflejarán literalmente 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, esto

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

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

Si establecemos

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

y luego echo la expresión en la segunda columna, obtendríamos el resultado / comportamiento que se muestra 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 "" 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 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" ---+-------------+-------------+-------------------------------------------------------------------- 

Ver también:

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

Otros explicaron muy bien y solo quieren dar con ejemplos simples.

Se pueden usar comillas simples alrededor del texto para evitar que el intérprete interprete caracteres especiales. Los signos de dólar, espacios, símbolos, asteriscos y otros caracteres especiales se ignoran cuando se incluyen dentro de 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 intérprete interprete los signos de dólar, las comillas inversas y las diagonales inversas. Ya se sabe que las barras invertidas evitan que se interprete un único carácter especial. Esto puede ser útil entre comillas dobles si un signo de dólar debe usarse como texto en lugar de para una variable. También permite que se escapen las comillas dobles para que no se interpreten como el final de una cadena entrecomillada.

 $ 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 se puede notar que el apóstrofo, 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 con sus valores entre comillas dobles.

 $ echo "The current Oracle SID is $ORACLE_SID" 

Dará esto:

 The current Oracle SID is test 

Las comillas posteriores son completamente diferentes a las comillas simples o dobles. En lugar de usarse para evitar la interpretación de caracteres especiales, las comillas posteriores fuerzan la ejecución de los comandos que encierran. Después de ejecutar los comandos incluidos, su salida se sustituye en lugar de las comillas posteriores en la línea original. Esto será más claro con un ejemplo.

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

Dará esto:

 Monday, September 28, 2015 

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

Cuando ' ' se usa alrededor de cualquier cosa, no hay una ‘transformación o traducción’ hecha. Está impreso como está.

Con " " , lo que sea que esté cerca, se “traduce o transforma” en su valor.

Por traducción / transformación me refiero a lo siguiente: cualquier cosa dentro de las comillas simples no será “traducida” a sus valores. Se tomarán como están dentro de las citas. Ejemplo: a=23 , luego echo '$a' producirá $a en salida estándar. Mientras que echo "$a" producirá 23 en salida estándar.