Formateo de cadenas en PowerShell: Domina los fundamentos

El tipo de cadena es probablemente la variable más popular en PowerShell. No creo que haya escrito un script que no contenga al menos una cadena. Las cadenas son excelentes para definir un conjunto simple de caracteres como un nombre de computadora, la ruta de un archivo de texto, una ruta de clave de registro, una URL, etc. Expandiendo variables dentro de cadenas y utilizando las capacidades de formato de cadena de PowerShell, puedes hacer prácticamente cualquier cosa.

Las cadenas se definen encerrando uno o más caracteres entre comillas simples o dobles, como:

$Url = 'http:\\www.bing.com'
$FilePath = 'C:\thisissomefile.txt'

Definir cadenas de esta manera es directa, pero pronto te encontrarás necesitando obtener el valor de una variable dentro de cadenas.

Por ejemplo, tal vez tienes un script con un parámetro ComputerName y en tu script, necesitas concatenar un prefijo estándar como SRV- como se muestra a continuación.

$ComputerName = 'URANUS'
$ComputerName = "SRV-$ComputerName"

El valor de la variable $ComputerName es ahora SRV-URANUS, pero encerrar $ComputerName dentro de la cadena con comillas dobles es solo una forma de insertar variables en cadenas. Hay algunas formas diferentes de hacerlo. Veamos dos ejemplos.

Expandir Cadenas

El primer método es probable que ya estés familiarizado con él, se llama expandir cadenas, o simplemente expandir variables dentro de cadenas existentes. Esta es la forma más común de hacer que el valor de una variable aparezca en una cadena.

Para hacer esto, es necesario colocar la variable dentro de una cadena con comillas dobles. Las comillas simples no funcionarán porque tratan todos los caracteres literalmente.

Por ejemplo, tal vez necesite especificar la ruta de un archivo. Conozco la ruta de la carpeta base, pero aún no conozco el nombre real del archivo. Podría crear una variable llamada $FullPath e ingresar estáticamente la ruta de la carpeta, pero hacer que el nombre del archivo sea una variable.

PS> $FileName = 'MyFile.txt'
PS> $FullPath = "C:\Folder\subfolder\$FileName"
PS> $FullPath
C:\Folder\subfolder\MyFile.txt

¿Y si necesita especificar una propiedad de objeto dentro de una cadena? Esto se ve un poco diferente. En este caso, necesito rodear la propiedad con paréntesis y anteponer un signo de dólar al principio. Esto se llama operador de subexpresión. Esto le dice a PowerShell que expanda primero el valor.

PS> $File = Get-Item -Path 'C:\MyFile.txt'
PS> $FullPath = "C:\Folder\subfolder\$($File.Name)"
PS> $FullPath
C:\Folder\subfolder\MyFile.txt

Expandir cadenas es muy común, pero ¿qué pasa si tiene una cadena más complicada?

Usando el Operador de Formato de Cadena de PowerShell

Otra manera de asegurarse de que los valores de las variables se inserten en sus cadenas es a través del operador de formato de PowerShell (-f).

Usando el operador de formato, no tiene que colocar la variable o la propiedad dentro de una cadena rodeada por comillas dobles. Puede crear una cadena entre comillas simples y especificar las variables que se insertarán en esa cadena fuera de ella, como se muestra a continuación.

PS> $File = Get-Item -Path 'C:\MyFile.txt'
PS> 'C:\Folder\subfolder\{0}' -f $File.Name
C:\Folder\subfolder\MyFile.txt

Puede ver que tiene el mismo efecto exacto. Aunque esta vez no tuvo que usar comillas dobles ni preocuparse por encerrar la propiedad del objeto entre paréntesis y otro signo de dólar. Se ve un poco más limpio pero podría ser más difícil de entender. El uso del operador de formato le obliga a reemplazar {0} con $File.Name en su mente.

Para agregar otras variables, simplemente incrementa tus etiquetas en 1 y continúa agregando variables separadas por comas al operador de formato. Mientras la posición del índice del operador de formato coincida con la posición en la etiqueta de cadena, puedes agregar tantas referencias como desees.

PS> $File = Get-Item -Path 'C:\MyFile.txt'
PS> $SubFolderName = 'folder1'
PS> 'C:\Folder\subfolder\{0}\{1}' -f $SubFolderName, $File.Name
C:\Folder\subfolder\folder1\MyFile.txt

Cuándo usar el operador de formato

I usually prefer to place variables inside of the string and expand them because I don’t have to match an index with a value. However, there are exceptions, as in the case of special characters that must be escaped.

Por ejemplo, digamos que necesitas ejecutar una utilidad de línea de comandos que requiere que le pases un nombre de archivo. Esta ruta de archivo puede contener espacios, por lo que necesitarás encerrar esa referencia entre comillas dobles. Sin esas comillas dobles, utility.exe no podría interpretar correctamente el argumento del archivo.

Utility.exe -file "C:\Program Files\SomeFolder\a subfolder here"

Ahora, digamos que quieres hacer esto en un script de PowerShell. Si estás usando cadenas expansivas, se vería un poco desordenado porque debes usar un acento grave para escapar las comillas dobles.

$FileName = 'C:\Program Files\SomeFolder\a subfolder here'
Start-Process -FilePath 'utility.exe' -Args "`"$FileName`""

Ahora, obtengamos el mismo resultado con el operador de formato.

$FileName = 'C:\Program Files\SomeFolder\a subfolder here'
$Args = '"{0}"' -f $FileName
Start-Process -FilePath 'utility.exe' -Args $Args

I don’t have to use any escape characters. This may seem like a simple example but as soon as you come across large strings that require a lot of escaping you will soon see the real benefit of using the format operator!

Resumen

La próxima vez que te encuentres teniendo que sustituir variables dentro de una cadena, piensa en qué método sería más legible. Te ahorrará tiempo a largo plazo.

Para obtener más publicaciones relacionadas con el trabajo con cadenas, asegúrate de revisar La Subcadena de PowerShell: Encontrar una cadena dentro de una cadena y Variables de PowerShell en Cadenas.