sentencias - Diferencia entre comillas simples y dobles en Bash
sentencias de control en shell script (5)
Hay una clara distinción entre el uso de '' '' y " " .
Cuando se usa '' '' alrededor de cualquier cosa, no se realiza una "transformación o traducción". Se imprime como es.
Con " " , lo que sea que rodee, 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 se "traducirá" a sus valores. Serán tomadas ya que están dentro de comillas. Ejemplo: a=23 , entonces echo ''$a'' producirá $a en la salida estándar. Mientras que echo "$a" producirá 23 en la salida estándar.
En Bash, ¿cuáles son las diferencias entre comillas simples ( '''' ) y comillas dobles ( "" )?
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 a , así como una matriz indexada arr .
Si nos ponemos
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 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 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:
- Cotización ANSI-C con
$''''- GNU Bash Manual - Traducción regional con
$""- GNU Bash Manual - Una fórmula de tres puntos para citas
Las comillas simples no interpolarán nada, pero las comillas dobles lo harán. Por ejemplo: variables, comillas invertidas, 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. Una comilla simple puede no aparecer entre comillas simples, incluso cuando está precedida por una barra invertida.Los caracteres que figuran entre comillas dobles (
") conservan 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 de dobles comillas (vea Expansiones de Shell ). La barra invertida retiene su significado especial solo cuando está seguida por uno de los siguientes caracteres:$,`,",/o nueva línea. En las comillas dobles, se eliminan las barras invertidas seguidas por uno de estos caracteres. Las barras invertidas que preceden a los caracteres sin un significado especial se dejan sin modificar. Una comilla doble se puede citar entre comillas dobles precediéndola con una barra invertida. Si está habilitado, la expansión del historial se realizará a menos que aparezca un!apareciendo entre comillas dobles se escapa mediante una barra invertida. La barra invertida que precede a la!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 ).
Otros explicaron muy bien y solo quieren dar con ejemplos simples.
Se pueden usar comillas simples alrededor del texto para evitar que el shell interprete cualquier carácter especial. Los signos de dólar, espacios, símbolos, asteriscos y otros caracteres especiales se ignoran cuando se incluyen entre comillas simples.
$ echo ''All sorts of things are ignored in single quotes, like $ & * ; |.''
Le 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 invertidas. Ya se sabe que las barras invertidas impiden que se interprete un solo 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 las comillas dobles se escapen 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"
Le 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. Las variables, sin embargo, se interpretan y se sustituyen con sus valores entre comillas dobles.
$ echo "The current Oracle SID is $ORACLE_SID"
Le dará esto:
The current Oracle SID is test
Las cotizaciones posteriores 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 obligan a la ejecución de los comandos que encierran. Una vez que se ejecutan los comandos adjuntos, su salida se sustituye en lugar de las comillas en la línea original. Esto será más claro con un ejemplo.
$ today=`date ''+%A, %B %d, %Y''`
$ echo $today
Le dará esto:
Monday, September 28, 2015
Si te refieres a lo que sucede cuando haces eco de algo, las comillas simples harán eco literalmente de lo que tienes entre ellos, 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''
le dará esto:
double quotes gives you sometext
single quotes gives you $MYVAR