about_Quoting_Rules
Descripción breve
Describe las reglas para usar comillas simples y dobles en PowerShell.
Descripción larga
Al analizar, PowerShell primero busca interpretar la entrada como una expresión. Pero cuando se encuentra una invocación de comando, el análisis continúa en modo de argumento. Los argumentos no numéricos sin comillas se tratan como cadenas. Si tiene argumentos que contienen espacios, como rutas de acceso, debe incluir esos valores de argumento entre comillas. Para obtener más información sobre el análisis de argumentos, vea la sección Modo de argumento de about_Parsing.
Las comillas se usan para especificar una cadena literal. Puede incluir una cadena entre comillas simples (') o comillas dobles (").
Las comillas también se usan para crear una cadena aquí. Una cadena aquí es una cadena entre comillas simples o dobles en la que las comillas se interpretan literalmente. Una cadena aquí puede abarcar varias líneas. Todas las líneas de una cadena aquí se interpretan como cadenas, aunque no estén entre comillas.
En los comandos de los equipos remotos, las comillas definen las partes del comando que se ejecutan en el equipo remoto. En una sesión remota, las comillas también determinan si las variables de un comando se interpretan primero en el equipo local o en el equipo remoto.
Nota:
PowerShell trata comillas inteligentes, también denominadas comillas tipográficas o cursivas, como comillas normales para las cadenas. No use comillas inteligentes para incluir cadenas. Al escribir cadenas que contienen comillas inteligentes, siga las instrucciones de la sección Incluir caracteres de comillas en una sección de cadena de este documento. Para obtener más información sobre las comillas inteligentes, vea la sección Citas inteligentes en el artículo de Wikipedia Comillas en inglés.
Cadenas entre comillas dobles
Una cadena entre comillas dobles es una cadena expandible . Los nombres de variable precedidos por un signo de dólar ($) se reemplazan por el valor de la variable antes de que la cadena se pase al comando para su procesamiento.
Por ejemplo:
$i = 5
"The value of $i is $i."
La salida de este comando es:
The value of 5 is 5.
Además, en una cadena entre comillas dobles, se evalúan las expresiones y el resultado se inserta en la cadena. Por ejemplo:
"The value of $(2+3) is 5."
La salida de este comando es:
The value of 5 is 5.
Solo las referencias de variables básicas se pueden incrustar directamente en una cadena expandible. Las referencias de variables que usan la indexación de matriz o el acceso a miembros deben incluirse en una subexpresión. Por ejemplo:
"PS version: $($PSVersionTable.PSVersion)"
PS version: 5.1.22621.4111
Para separar un nombre de variable de los caracteres posteriores de la cadena, escríbalo entre llaves ({}). Esto es especialmente importante si el nombre de la variable va seguido de dos puntos (:). PowerShell considera todo lo que hay entre y $ un : especificador de ámbito, lo que normalmente provoca un error en la interpretación. Por ejemplo, "$HOME: where the heart is." produce un error, pero "${HOME}: where the heart is." funciona según lo previsto.
Para evitar la sustitución de un valor de variable en una cadena entre comillas dobles, use el carácter de retroceso (`), que es el carácter de escape de PowerShell.
En el ejemplo siguiente, el carácter de retroceso que precede a la primera $i variable impide que PowerShell reemplace el nombre de la variable por su valor.
Por ejemplo:
$i = 5
"The value of `$i is $i."
La salida de este comando es:
The value of $i is 5.
Cadenas entre comillas únicas
Una cadena entre comillas simples es una cadena textual . La cadena se pasa al comando exactamente al escribirla. No se realiza ninguna sustitución. Por ejemplo:
$i = 5
'The value of $i is $i.'
La salida de este comando es:
The value $i is $i.
Del mismo modo, no se evalúan las expresiones de cadenas entre comillas únicas. Se interpretan como literales de cadena. Por ejemplo:
'The value of $(2+3) is 5.'
La salida de este comando es:
The value of $(2+3) is 5.
Incluir caracteres de comillas en una cadena
Para que las comillas dobles aparezcan en una cadena, incluya toda la cadena entre comillas simples. Por ejemplo:
'As they say, "live and learn."'
La salida de este comando es:
As they say, "live and learn."
También puede incluir una cadena entre comillas simples en una cadena entre comillas dobles. Por ejemplo:
"As they say, 'live and learn.'"
La salida de este comando es:
As they say, 'live and learn.'
O bien, doble las comillas alrededor de una frase entre comillas dobles. Por ejemplo:
"As they say, ""live and learn."""
La salida de este comando es:
As they say, "live and learn."
Para incluir una comilla simple en una cadena entre comillas simples, use una segunda comilla simple consecutiva. Por ejemplo:
'don''t'
La salida de este comando es:
don't
Para forzar a PowerShell a interpretar literalmente una comilla doble, use un carácter de barra diagonal inversa. Esto impide que PowerShell interprete la comilla como delimitador de cadena. Por ejemplo:
"Use a quotation mark (`") to begin a string."
'Use a quotation mark (`") to begin a string.'
Dado que el contenido de las cadenas entre comillas simples se interpreta literalmente, el carácter de retroceso se trata como un carácter literal y se muestra en la salida.
Use a quotation mark (") to begin a string.
Use a quotation mark (`") to begin a string.
Dado que PowerShell interpreta comillas inteligentes, como ‘, ’, “y ”, como comillas normales, también es necesario que se escapen las comillas inteligentes.
Por ejemplo:
"Double ““smart quotation marks`” must be escaped in a double-quoted string."
'Single ‘‘smart quotation marks’’ must be escaped in a single-quoted string.'
Double “smart quotation marks” must be escaped in a double-quoted string.
Single ‘smart quotation marks’ must be escaped in a single-quoted string.
Cadenas aquí
Las reglas de comillas para las cadenas aquí son ligeramente diferentes.
Una cadena here-string es una cadena entre comillas simples o dobles entre signos (@). Las comillas dentro de una cadena aquí se interpretan literalmente.
Una cadena aquí:
- abarca varias líneas
- comienza con la marca de apertura seguida de una nueva línea
- termina con una nueva línea seguida de la marca de cierre
- incluye cada línea entre las marcas de apertura y cierre como parte de una sola cadena.
Al igual que las cadenas normales, las variables se reemplazan por sus valores en cadenas aquí entre comillas dobles. En cadenas aquí entre comillas simples, las variables no se reemplazan por sus valores.
Puede usar aquí cadenas para cualquier texto, pero son especialmente útiles para los siguientes tipos de texto:
- Texto que contiene comillas literales
- Varias líneas de texto, como el texto de un bloque HTML o XML
- Texto de ayuda de un script o documento de función
Una cadena aquí puede tener cualquiera de los siguientes formatos, donde <Enter> representa el salto de línea o el carácter oculto de nueva línea que se agrega al presionar la tecla ENTRAR .
Comillas dobles:
@"<Enter>
<string> [string] ...<Enter>
"@
Comillas simples:
@'<Enter>
<string> [string] ...<Enter>
'@
Nota:
El carácter de nueva línea final forma parte de la marca de cierre. No se agrega a la cadena aquí.
Una cadena aquí contiene todo el texto entre las marcas de apertura y cierre. En la cadena aquí, todas las comillas se interpretan literalmente. Por ejemplo:
@"
For help, type "get-help"
"@
La salida de este comando es:
For help, type "get-help"
El uso de una cadena aquí puede simplificar el uso de una cadena en un comando. Por ejemplo:
@"
Use a quotation mark, like ' or ", to begin a string.
"@
La salida de este comando es:
Use a quotation mark, like ' or ", to begin a string.
En cadenas aquí entre comillas simples, las variables se interpretan literalmente y se reproducen exactamente. Por ejemplo:
@'
The $profile variable contains the path
of your PowerShell profile.
'@
La salida de este comando es:
The $profile variable contains the path
of your PowerShell profile.
En cadenas aquí entre comillas dobles, las variables se reemplazan por sus valores. Por ejemplo:
@"
Even if you have not created a profile,
the path of the profile file is:
$profile.
"@
La salida de este comando es:
Even if you have not created a profile,
the path of the profile file is:
C:\Users\User1\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1.
Las cadenas aquí se usan normalmente para asignar varias líneas a una variable. Por ejemplo, la siguiente cadena asigna una página de XML a la variable $page.
$page = [XML] @"
<command:command xmlns:maml="http://schemas.microsoft.com/maml/2004/10"
xmlns:command="http://schemas.microsoft.com/maml/dev/command/2004/10"
xmlns:dev="http://schemas.microsoft.com/maml/dev/2004/10">
<command:details>
<command:name>
Format-Table
</command:name>
<maml:description>
<maml:para>Formats the output as a table.</maml:para>
</maml:description>
<command:verb>format</command:verb>
<command:noun>table</command:noun>
<dev:version></dev:version>
</command:details>
...
</command:command>
"@
Las cadenas aquí también son un formato cómodo para la entrada al ConvertFrom-StringData cmdlet, que convierte las cadenas aquí en tablas hash.
Para obtener más información, vea ConvertFrom-StringData.
Nota:
PowerShell permite que las cadenas entre comillas dobles o simples abarquen varias líneas sin usar la @ sintaxis de las cadenas aquí. Sin embargo, la sintaxis completa de la cadena aquí es el uso preferido.
Interpretación de cadenas expandibles
Las cadenas expandidas no tienen necesariamente el mismo aspecto que la salida predeterminada que ve en la consola.
Las colecciones, incluidas las matrices, se convierten en cadenas colocando un único espacio entre las representaciones de cadena de los elementos. Se puede especificar un separador diferente estableciendo la variable $OFSde preferencia . Para obtener más información, consulte la variable de $OFS preferencia.
Las instancias de cualquier otro tipo se convierten en cadenas mediante una llamada al ToString() método , que puede no proporcionar una representación significativa. Por ejemplo:
"hashtable: $(@{ key = 'value' })"
hashtable: System.Collections.Hashtable
Para obtener la misma salida que en la consola, use una subexpresión en la que canalice a Out-String. Aplique el Trim() método si desea quitar las líneas vacías iniciales y finales.
"hashtable:`n$((@{ key = 'value' } | Out-String).Trim())"
hashtable:
Name Value
---- -----
key value
La configuración de referencia cultural afecta a la interpretación de cadenas
Los ToString() métodos usan las opciones de referencia cultural configuradas actualmente para convertir valores en cadenas. Por ejemplo, la referencia cultural de la siguiente sesión de PowerShell se establece en de-DE. Cuando el ToString() método convierte el valor de $x en una cadena, usa una coma (,) para el separador decimal. Además, el ToString() método convierte la fecha en una cadena con el formato adecuado para la configuración regional alemana.
PS> Get-Culture
LCID Name DisplayName
---- ---- -----------
1031 de-DE German (Germany)
PS> $x = 1.2
PS> $x.ToString()
1,2
PS> (Get-Date 2024-03-19).ToString()
19.03.2024 00:00:00
Sin embargo, PowerShell usa la referencia cultural invariable al interpretar expresiones de cadena expandibles.
PS? "$x"
1.2
PS> "$(Get-Date 2024-03-19)"
03/19/2024 00:00:00
Pasar cadenas entre comillas a comandos externos
Algunos comandos nativos esperan argumentos que contienen caracteres de comillas. PowerShell interpreta la cadena entrecomillada antes de pasarla al comando externo. Esta interpretación quita los caracteres de comillas externas.
Para obtener más información sobre este comportamiento, consulte el artículo about_Parsing .
