Cómo dividir órdenes en múltiples líneas en PowerShell

1. Comando de varias líneas de Windows PowerShell
2. Rompiendo líneas largas de código utilizando operadores específicos
3. Conclusión

El código legible comunica muy fácilmente su propósito de funcionalidad a los usuarios. Los nombres de las variables y los nombres de los métodos deben tener convenciones de nomenclatura adecuadas para la legibilidad del código.

Otros atributos que contribuyen a la legibilidad del código son la indentación y el estilo de formato consistentes. El comando de varias líneas de Windows PowerShell ayuda a dividir líneas de comando largas en múltiples declaraciones para mejorar la legibilidad.

En Windows PowerShell, los comandos de varias líneas se pueden crear fácilmente utilizando el carácter de comillas invertidas para dividir comandos largos o de una sola línea en declaraciones de varias líneas.

El carácter de comillas invertidas se utiliza como una especie de carácter de escape. Escapa el carácter de nueva línea y resulta en continuación de línea.

Este artículo explicará la importancia de los comandos de varias líneas de Windows PowerShell para dividir comandos largos en múltiples líneas.

Comando de varias líneas de Windows PowerShell

Para dividir un comando largo en múltiples líneas, usa el carácter de comillas invertidas para romperlo en varias líneas.

Por ejemplo, queremos obtener la información del espacio libre en disco en la computadora local. Desafortunadamente, el script para obtener esta información específica es un comando extenso, lo que dificulta su lectura y gestión.

Código de ejemplo:

Get-WmiObject -Class win32_logicaldisk | Format-Table DeviceId, MediaType, @{n = "Size"; e = { [math]::Round($_.Size / 1GB, 2) } }, @{n = "FreeSpace"; e = { [math]::Round($_.FreeSpace / 1GB, 2) } }

Puede parecer que la sintaxis está dividida en este artículo, pero cuando se copia en la interfaz de línea de comandos, el ejemplo anterior es un script de una sola línea muy largo.

Podemos fácilmente dividir comandos largos en múltiples líneas utilizando los caracteres de comillas invertidas de Windows PowerShell para un salto de línea en un comando dado.

Código de ejemplo:

Get-WmiObject -Class win32_logicaldisk `
| Format-Table DeviceId, `MediaType, @{n = "Size"; e = { [Math]::Round($_.Size / 1GB, 2) } }, `
@{n = "FreeSpace"; e = { [Math]::Round($_.FreeSpace / 1GB, 2) } }

En nuestro código, utilizamos comillas invertidas como caracteres de continuación de línea en PowerShell para mejorar la legibilidad al dividir un comando largo a través de múltiples líneas. Comenzamos con Get-WmiObject -Class win32_logicaldisk, que obtiene información sobre discos lógicos en el sistema.

La comilla invertida al final de esta línea indica que el comando continúa en la siguiente línea. Luego, pasamos (|) la salida a Format-Table, un cmdlet que formatea la salida como una tabla.

Aquí, elegimos mostrar específicamente DeviceId y MediaType. Para las propiedades Size y FreeSpace, utilizamos campos calculados (notados por la sintaxis @{n = "Name"; e = { Expression }}).

Dentro de estos campos calculados, utilizamos comillas invertidas nuevamente para continuar la línea. Las expresiones utilizan [Math]::Round($*.Size / 1GB, 2) y [Math]::Round($*.FreeSpace / 1GB, 2) para convertir el tamaño y el espacio libre de bytes a gigabytes y redondearlos a dos decimales, respectivamente.

Al descomponer este comando complejo con comillas invertidas, hacemos que el script sea más manejable y su intención más clara, ayudando tanto en su mantenimiento como en su legibilidad.

Salida:

La estructura del código es fácilmente legible y fácil de mantener en Windows PowerShell utilizando el comando de varias líneas. Sin embargo, el carácter de comillas invertidas no suele ser recomendado porque el carácter es difícil de leer e invita a errores.

Por lo tanto, tenemos un método alternativo para romper líneas largas de código.

Rompiendo líneas largas de código utilizando operadores específicos

PowerShell es intuitivo cuando se trata de continuación de línea. Ciertos operadores y estructuras de sintaxis señalan inherentemente al intérprete que un comando abarca múltiples líneas.

Esto es particularmente útil en scripts complejos donde la legibilidad puede impactar significativamente la facilidad de mantenimiento y comprensión.

Rompiendo líneas largas de código utilizando tuberías (|)

Por lo general, obtienes continuación de línea automática cuando un comando no se puede completar sintácticamente en ese momento.

Un ejemplo sería comenzar un nuevo elemento de tubería (|). La tubería funcionará sin problemas ya que, después del operador de tubería, el comando no se puede completar ya que falta otro elemento de tubería.

Entonces, lo que hace nuestro intérprete es buscar el siguiente elemento de tubería en la siguiente línea de comandos.

Código de ejemplo:

Get-Process |
    Where-Object { $_.ProcessName -like "powershell" } |
    Select-Object Id, ProcessName, CPU

En nuestro script, comenzamos con Get-Process, que recupera todos los procesos que están actualmente en ejecución. La salida de Get-Process se envía luego a Where-Object, donde filtramos los procesos cuyo nombre incluye powershell.

Esto se logra utilizando el operador -like en un bloque de script {} para coincidir con los nombres de los procesos.

Después de esto, enviamos los resultados filtrados a Select-Object. Aquí, especificamos que solo queremos retener el Id, ProcessName y el uso de CPU de estos procesos filtrados.

Al usar la tubería, hemos desglosado efectivamente el comando en partes manejables, cada una en una línea separada. Esto no solo hace que nuestro script sea más legible, sino que también simplifica la depuración y futuras modificaciones.

Salida:

Rompiendo líneas largas de código utilizando comas (,)

Una coma (,) también funcionará en algunos contextos, como el operador de tubería.

En ciertos contextos, como dentro de un comando o bloque de script, el operador de coma también puede servir como un señalizador de continuación de línea. Esto es especialmente útil al formatear comandos o al pasar una lista de elementos.

Código de ejemplo:

Get-EventLog -LogName Application -Newest 5 |
    Format-Table TimeGenerated, 
    EntryType, 
    Source, 
    @{n = 'Message'; e = { $_.Message.Split("`n")[0] } }

En nuestro script, utilizamos Get-EventLog para obtener las 5 entradas más nuevas del registro de la Aplicación. Esta salida se envía a Format-Table para formatear.

Luego, utilizamos el método de coma para enumerar las propiedades que queremos en la tabla: TimeGenerated, EntryType, Source y una expresión personalizada para Message. La expresión personalizada para Message utiliza una propiedad calculada (@{n='Message'; e= { $_.Message.Split("n")[0] } }) para mostrar solo la primera línea del mensaje, mejorando la legibilidad.

Al dividir este comando en múltiples líneas usando comas, hemos hecho que el script sea más legible, especialmente al tratar con múltiples propiedades o expresiones complejas.

Salida:

Rompiendo líneas largas de código utilizando llaves ({})

Además, las llaves ({}) al definir bloques de script permitirán la continuación de línea directamente. Son indispensables en escenarios que implican bucles, declaraciones condicionales o al pasar un bloque de comandos a cmdlets.

Código de ejemplo:

$processes = Get-Process
$filteredProcesses = $processes | Where-Object {
    $_.WorkingSet -gt 100MB
} | ForEach-Object {
    $_.ProcessName
}
$filteredProcesses

Comenzamos obteniendo una lista de todos los procesos usando el cmdlet Get-Process. La tubería luego pasa estos procesos a Where-Object, donde un bloque de script filtra los procesos con un conjunto de trabajo mayor a 100MB.

Los procesos resultantes se pasan a otro bloque de script en ForEach-Object, que extrae y muestra sus nombres. El uso de llaves para los bloques de script permite un flujo de datos claro, conciso y funcional a través de la tubería.

Salida:

Conclusión

A lo largo de este artículo, hemos explorado varios métodos para mejorar la legibilidad de los scripts de PowerShell. La legibilidad es crucial para una fácil comprensión y mantenimiento de los scripts, especialmente en Windows PowerShell, donde los scripts pueden volverse largos y complejos.

Comenzamos hablando de la práctica común de usar el carácter de comillas invertidas para comandos de varias líneas, que, aunque efectiva, a veces puede llevar a problemas de legibilidad y potenciales errores debido a su naturaleza sutil.

Sin embargo, PowerShell ofrece métodos más intuitivos para romper líneas largas de código, que analizamos posteriormente. El uso de operadores específicos como la tubería (|), la coma (,) y las llaves ({}) ofrece un enfoque más legible y mantenible para escribir scripts.

Estos métodos no solo mejoran la estructura visual del código, sino que también mejoran el flujo lógico, haciendo que los scripts sean más fáciles de depurar y modificar.