Como dividir comandos em várias linhas no PowerShell

1. Comando de Várias Linhas do Windows PowerShell
2. Quebrando Longas Linhas de Código Usando Operadores Específicos
3. Conclusão

Código legível comunica muito facilmente seu propósito funcional aos usuários. Nomes de variáveis e nomes de métodos devem ter convenções de nomenclatura adequadas para a legibilidade do código.

Outros atributos que contribuem para a legibilidade do código são a indentação consistente e o estilo de formatação. O comando de várias linhas do Windows PowerShell ajuda a dividir longas linhas de comando em várias declarações para legibilidade.

No Windows PowerShell, comandos de várias linhas podem ser facilmente criados usando o caractere backtick para dividir longos comandos ou comandos de uma única linha em declarações de várias linhas.

O caractere backtick é usado como uma espécie de caractere de escape. Ele escapa o caractere de nova linha e resulta na continuação da linha.

Este artigo explicará a importância dos comandos de várias linhas do Windows PowerShell para dividir comandos longos em várias linhas.

Comando de Várias Linhas do Windows PowerShell

Para dividir um comando longo em várias linhas, use o caractere backtick para quebrá-lo em várias linhas.

Por exemplo, queremos obter informações sobre o espaço livre em disco no computador local. Infelizmente, o script para obter essa informação específica é um comando extenso, tornando difícil a leitura e o gerenciamento.

Código de Exemplo:

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) } }

Pode parecer que a sintaxe está dividida neste artigo, mas quando copiado para a interface de linha de comando, o exemplo acima é um script de uma linha muito longa.

Podemos facilmente dividir longos comandos em várias linhas usando os caracteres backtick do Windows PowerShell para uma quebra de linha em um comando dado.

Código de Exemplo:

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) } }

Em nosso código, utilizamos backticks como caracteres de continuação de linha no PowerShell para melhorar a legibilidade, dividindo um comando longo em várias linhas. Começamos com Get-WmiObject -Class win32_logicaldisk, que busca informações sobre discos lógicos no sistema.

O backtick no final desta linha indica que o comando continua na próxima linha. Em seguida, direcionamos (|) a saída para Format-Table, um cmdlet que formata a saída como uma tabela.

Aqui, escolhemos especificamente exibir DeviceId e MediaType. Para as propriedades Size e FreeSpace, utilizamos campos calculados (notados pela sintaxe @{n = "Name"; e = { Expression }}).

Dentro desses campos calculados, empregamos novamente backticks para a continuação da linha. As expressões usam [Math]::Round($*.Size / 1GB, 2) e [Math]::Round($*.FreeSpace / 1GB, 2) para converter o tamanho e o espaço livre de bytes para gigabytes e arredondá-los a duas casas decimais, respectivamente.

Ao quebrar esse comando complexo com backticks, tornamos o script mais gerenciável e sua intenção mais clara, ajudando tanto em sua manutenção quanto na legibilidade.

Saída:

A estrutura do código é facilmente legível e fácil de manter no Windows PowerShell usando o comando de várias linhas. No entanto, o caractere backtick não é geralmente recomendado porque o caractere é difícil de ler e convida a bugs.

Portanto, temos um método alternativo para quebrar longas linhas de código.

Quebrando Longas Linhas de Código Usando Operadores Específicos

PowerShell é intuitivo quando se trata de continuação de linha. Certos operadores e estruturas de sintaxe sinalizam inerentemente ao interpretador que um comando se estende por várias linhas.

Isso é particularmente útil em scripts complexos onde a legibilidade pode impactar significativamente a facilidade de manutenção e compreensão.

Quebrando Longas Linhas de Código Usando Pipeline (|)

Normalmente, você recebe a continuação automática da linha quando um comando não pode ser concluído sintaticamente naquele ponto.

Um exemplo seria começar um novo elemento de pipeline (|). O pipeline funcionará sem problemas, pois, após o operador de pipeline, o comando não pode ser concluído, uma vez que está faltando outro elemento de pipeline.

Portanto, o que nosso interpretador faz é procurar o próximo elemento de pipeline na linha de comando seguinte.

Código de Exemplo:

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

Em nosso script, começamos com Get-Process, que recupera todos os processos que estão atualmente em execução. A saída de Get-Process é então direcionada para Where-Object, onde filtramos os processos cujo nome inclui powershell.

Isso é alcançado usando o operador -like em um bloco de script {} para corresponder aos nomes dos processos.

Após isso, passamos os resultados filtrados para Select-Object. Aqui, especificamos que queremos reter apenas o Id, ProcessName e o uso de CPU desses processos filtrados.

Ao usar o pipeline, conseguimos efetivamente quebrar o comando em partes gerenciáveis, cada uma em uma linha separada. Isso não só torna nosso script mais legível, mas também simplifica a depuração e futuras modificações.

Saída:

Quebrando Longas Linhas de Código Usando Vírgula (,)

Uma vírgula (,) também funcionará em alguns contextos, como no operador de pipeline.

Em certos contextos, como dentro de um comando ou bloco de script, o operador vírgula também pode servir como um sinal de continuação de linha. Isso é especialmente útil na formatação de comandos ou ao passar uma lista de itens.

Código de Exemplo:

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

Em nosso script, usamos Get-EventLog para buscar as 5 entradas mais recentes do log de Aplicação. Essa saída é direcionada para Format-Table para formatação.

Em seguida, usamos o método da vírgula para listar as propriedades que queremos na tabela: TimeGenerated, EntryType, Source e uma expressão personalizada para Message. A expressão personalizada para Message usa uma propriedade calculada (@{n='Message'; e= { $_.Message.Split("n")[0] } }) para exibir apenas a primeira linha da mensagem, melhorando a legibilidade.

Ao dividir este comando em várias linhas usando vírgulas, tornamos o script mais legível, especialmente ao lidar com múltiplas propriedades ou expressões complexas.

Saída:

Quebrando Longas Linhas de Código Usando Chaves ({})

Além disso, as chaves ({}) ao definir blocos de script permitirão a continuação da linha diretamente. Elas são indispensáveis em cenários que envolvem loops, declarações condicionais ou ao passar um bloco de comandos para cmdlets.

Código de Exemplo:

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

Começamos obtendo uma lista de todos os processos usando o cmdlet Get-Process. O pipeline então passa esses processos para Where-Object, onde um bloco de script filtra processos com um conjunto de trabalho maior que 100MB.

Os processos restantes são passados para outro bloco de script em ForEach-Object, que extrai e exibe seus nomes. O uso de chaves para blocos de script permite um fluxo de dados claro, conciso e funcional através do pipeline.

Saída:

Conclusão

Ao longo deste artigo, exploramos vários métodos para melhorar a legibilidade dos scripts do PowerShell. A legibilidade é crucial para a fácil compreensão e manutenção de scripts, especialmente no Windows PowerShell, onde os scripts podem frequentemente se tornar longos e complexos.

Começamos discutindo a prática comum de usar o caractere backtick para comandos de várias linhas, que, embora eficaz, às vezes pode levar a problemas de legibilidade e potenciais bugs devido à sua natureza sutil.

No entanto, o PowerShell oferece métodos mais intuitivos para quebrar longas linhas de código, que exploramos em seguida. O uso de operadores específicos como o pipeline (|), vírgula (,), e chaves ({}) oferece uma abordagem mais legível e gerenciável para a escrita de scripts.

Esses métodos não só melhoram a estrutura visual do código, mas também aprimoram o fluxo lógico, tornando os scripts mais fáceis de depurar e modificar.