Diferencia entre comillas simples y dobles en Bash


Respuestas:


580

Las comillas simples no interpolarán nada, pero las comillas dobles sí. 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 simples

Incluyendo 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 Comillas 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 (ver 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 invertidas seguidas por uno de estos caracteres. Las barras diagonales anteriores que no tienen un significado especial no se modifican. Una comilla doble se puede citar dentro de comillas dobles precediéndola con una barra diagonal inversa. Si está habilitado, la expansión del historial se realizará a menos que !se escape una comilla doble usando una barra invertida. La barra diagonal inversa que precede al !no se elimina.

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


41
Para cualquiera que no sepa lo que significa "interpolar": en.wikipedia.org/wiki/String_interpolation
Kolob Canyon

1
¿Qué pasa cuando está usando un git_promptgit que proporciona? Sugieren usarlo así PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ ', git prompt , de acuerdo con esto no debería funcionar. ¿Hay algo especial en las PS#variables? o por qué funciona si no está haciendo la interpolación.
ekiim

1
@ekiim Ese texto exacto se establece (sin cambios) en PS1. Intenta echo $PS1ver a qué me refiero. Pero PS1se evalúa antes de mostrarse (consulte la PROMPTINGsección en la página de manual de bash). Para probar esto, inténtalo PS1='$X'. No tendrás aviso. Luego, ejecute X=fooy de repente su mensaje es "foo" ( PS1se evaluó cuando se configuró en lugar de mostrarse , todavía no tendría ningún mensaje).
Adam Batkin

263

La respuesta aceptada es genial. Estoy haciendo una tabla que ayuda a comprender rápidamente el 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 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:


1
La respuesta aceptada dice al final, The special parameters * and @ have special meaning when in double quotesentonces, ¿cómo es que los "*"resultados *?
anddero

2
@ Karl-AnderoMere, porque no se expanden como parámetros en ese caso en absoluto. "$@"y "$*"son expansiones de parámetros. "@"y "*"no lo son
Charles Duffy

@CharlesDuffy ¡Gracias, tiene sentido ahora!
anddero

3
Número 9, echo "\'"me devuelve \'.
MaxGyver

@MaxGyver: gracias por señalarlo. He actualizado la respuesta.
codeforester

233

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, 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

11

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

Las comillas simples se pueden usar alrededor del texto para evitar que el intérprete interprete caracteres especiales. Los signos de dólar, espacios, signos de unión, 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 signos de dólar, comillas inversas y barras 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 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 se puede notar 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 con sus valores entre comillas dobles.

$ echo "The current Oracle SID is $ORACLE_SID"

Dará esto:

The current Oracle SID is test

Cotizaciones posteriores inversas son totalmente diferentes a las comillas simples o dobles. En lugar de usarse para evitar la interpretación de caracteres especiales, las comillas inversas en realidad fuerzan la ejecución de los comandos que encierran. Después de ejecutar los comandos adjuntos, su salida se sustituye en lugar de las comillas inversas 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 

3

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 " " lo que rodea, se "traduce o transforma" en su valor.

Por traducción / transformación quiero decir lo siguiente: Cualquier cosa dentro de las comillas simples no será "traducida" a sus valores. Se tomarán como están entre comillas. Ejemplo:, a=23luego echo '$a'producirá $aen salida estándar. Mientras echo "$a"que producirá 23en salida estándar.


1
¿Qué quieres decir con "traducción" o "transformación"?
Nico Haase

Esta respuesta es bastante confusa y no agrega nada sobre las buenas respuestas existentes.
codeforester

2
En mi opinión, esta fue una respuesta breve y concisa sin ser demasiado prolija que me fue fácil de comprender. Cuando dicen traducción / transformación, significan que las comillas dobles expandirán la variable donde las comillas simples no expandirán la variable.
B_e_n_n_y_

1
Sí, esta es la mejor respuesta. Esta debería ser la respuesta aceptada.
Jamey Kirby

3

Dado que esta es la respuesta de facto cuando se trata de citas en bash , agregaré un punto más perdido en las respuestas anteriores, cuando se trate 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 comprender que la expresión aritmética utilizada con se letexpande por división de palabras y nombre de ruta al igual que cualquier otro comando de shell. Por lo tanto, es necesario hacer una cita y un escape adecuados.

Vea este ejemplo cuando use let

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

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

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

fallaría miserablemente, ya que las $barcomillas simples no expandirían y deben ser citadas dos veces como

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

Esta debería ser una de las razones, $((..))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 letpuede simplemente escribirse como

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

Siempre recuerda usar $((..)) sin comillas simples

Aunque $((..))se puede usar con comillas dobles, no tiene ningún propósito, ya que no puede contener un contenido que necesite la comilla doble. Solo asegúrese de que no se cite solo.

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

En algunos casos especiales de uso del $((..))operador dentro de una sola cadena entre comillas, debe interpolar las comillas de manera que el operador quede sin comillas o entre comillas dobles. Por ejemplo, considere un caso, cuando intenta utilizar 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.


2
Charles Duffy es un buen caso aquí por citar doble $((...))también. Puede ser "un poco" paranoico y bastante improbable, IFS=0por ejemplo, pero ciertamente no es imposible :)
PesaEl

También existe la $[[...]]sintaxis heredada, pero tal vez tenías razón al olvidarla.
tripleee
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.