about_Quoting_Rules
Descripción breve
Describe las reglas para usar comillas simples y dobles en PowerShell.
Descripción larga
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 las 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 comandos para 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.
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 simples se pueden incrustar directamente en una cadena expandible. Las referencias de variables que usan la indexación de matrices o el acceso a miembros se deben incluir en una subexpresión. Por ejemplo:
"PS version: $($PSVersionTable.PSVersion)"
PS version: 7.1.4
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 interposición inversa (`), que es el carácter de escape de PowerShell.
En el ejemplo siguiente, el carácter de acento posterior 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 simples
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 simples. 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 con 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 que PowerShell interprete literalmente una comilla doble, use un carácter de acento trasero. 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 acento trasero 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.
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í con comillas dobles. En las cadenas aquí entre comillas simples, las variables no se reemplazan por sus valores.
Puede usar cadenas aquí 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 (') to begin a string.
"@
La salida de este comando es:
Use a quotation mark (') 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 suelen usar para asignar varias líneas a una variable. Por ejemplo, la siguiente cadena aquí 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 here-strings también son un formato práctico para la entrada al ConvertFrom-StringData cmdlet , que convierte las cadenas here-strings 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 de cadena aquí completa es el uso preferido.
Interpretación de cadenas expandibles
Las cadenas expandidas no tienen necesariamente el mismo aspecto que la salida predeterminada que se 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
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 .