Come suddividere i comandi su più righe in PowerShell

1. Comando Multilinea di Windows PowerShell
2. Suddivisione di Lunghe Righe di Codice Utilizzando Operatori Specifici
3. Conclusione

Il codice leggibile comunica molto facilmente il suo scopo di funzionalità agli utenti. I nomi delle variabili e dei metodi dovrebbero avere convenzioni di denominazione adeguate per la leggibilità del codice.

Altri attributi che contribuiscono alla leggibilità del codice sono l’indentazione e lo stile di formattazione coerenti. Il comando multilinea di Windows PowerShell aiuta a suddividere le lunghe linee di comando in più istruzioni per la leggibilità.

In Windows PowerShell, i comandi multilinea possono essere facilmente creati utilizzando il carattere backtick per suddividere comandi lunghi o a riga singola in istruzioni multilinea.

Il carattere backtick viene utilizzato come una sorta di carattere di escape. Escapa il carattere di nuova linea e risulta in una continuazione della linea.

Questo articolo spiegherà l’importanza dei comandi multilinea di Windows PowerShell per suddividere lunghi comandi su più righe.

Comando Multilinea di Windows PowerShell

Per suddividere un lungo comando in più righe, utilizza il carattere backtick per romperlo in più righe.

Ad esempio, vogliamo ottenere le informazioni sullo spazio libero del disco sul computer locale. Sfortunatamente, lo script per ottenere questa informazione specifica è un comando esteso, rendendolo difficile da leggere e gestire.

Esempio di Codice:

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

Potrebbe sembrare che la sintassi sia divisa in questo articolo, ma quando copiata nell’interfaccia della riga di comando, l’esempio sopra è un lungo script in una sola riga.

Possiamo facilmente suddividere lunghi comandi in più righe utilizzando i caratteri backtick di Windows PowerShell per una interruzione di riga in un dato comando.

Esempio di Codice:

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

Nel nostro codice, utilizziamo i backtick come caratteri di continuazione della linea in PowerShell per migliorare la leggibilità suddividendo un lungo comando su più righe. Cominciamo con Get-WmiObject -Class win32_logicaldisk, che recupera informazioni sui dischi logici sul sistema.

Il backtick alla fine di questa riga indica che il comando continua nella riga successiva. Quindi, canalizziamo (|) l’output in Format-Table, un cmdlet che formatta l’output come una tabella.

Qui, scegliamo specificamente di visualizzare DeviceId e MediaType. Per le proprietà Size e FreeSpace, utilizziamo campi calcolati (notati dalla sintassi @{n = "Name"; e = { Expression }}).

All’interno di questi campi calcolati, utilizziamo nuovamente i backtick per la continuazione della linea. Le espressioni utilizzano [Math]::Round($*.Size / 1GB, 2) e [Math]::Round($*.FreeSpace / 1GB, 2) per convertire la dimensione e lo spazio libero da byte a gigabyte e arrotondarli a due decimali, rispettivamente.

Suddividendo questo comando complesso con i backtick, rendiamo lo script più gestibile e il suo intento più chiaro, aiutando sia nella manutenzione che nella leggibilità.

Output:

La struttura del codice è facilmente leggibile e facile da mantenere in Windows PowerShell utilizzando il comando multilinea. Tuttavia, il carattere backtick non è solitamente raccomandato perché è difficile da leggere e invita a bug.

Quindi, abbiamo un metodo alternativo per spezzare lunghe righe di codice.

Suddivisione di Lunghe Righe di Codice Utilizzando Operatori Specifici

PowerShell è intuitivo quando si tratta di continuazione della linea. Determinati operatori e strutture di sintassi segnalano inherentemente all’interprete che un comando si estende su più righe.

Questo è particolarmente utile in script complessi in cui la leggibilità può influenzare significativamente la facilità di manutenzione e comprensione.

Suddivisione di Lunghe Righe di Codice Utilizzando Pipeline (|)

Di solito, ottieni una continuazione automatica della linea quando un comando non può essere completato sintatticamente in quel punto.

Un esempio sarebbe iniziare un nuovo elemento della pipeline (|). La pipeline funzionerà senza problemi poiché, dopo l’operatore della pipeline, il comando non può essere completato poiché manca di un altro elemento della pipeline.

Quindi, ciò che il nostro interprete fa è cercare il prossimo elemento della pipeline nella riga di comando successiva.

Esempio di Codice:

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

Nel nostro script, iniziamo con Get-Process, che recupera tutti i processi attualmente in esecuzione. L’output di Get-Process viene poi canalizzato in Where-Object, dove filtriamo i processi il cui nome include powershell.

Questo viene realizzato utilizzando l’operatore -like in un blocco di script {} per abbinare i nomi dei processi.

Successivamente, canalizziamo i risultati filtrati in Select-Object. Qui, specifichiamo che vogliamo conservare solo Id, ProcessName e utilizzo della CPU di questi processi filtrati.

Utilizzando la pipeline, abbiamo effettivamente suddiviso il comando in parti gestibili, ognuna su una riga separata. Questo non solo rende il nostro script più leggibile ma semplifica anche il debug e le future modifiche.

Output:

Suddivisione di Lunghe Righe di Codice Utilizzando Virgola (,)

Una virgola (,) funzionerà anche in alcuni contesti, come l’operatore pipeline.

In determinati contesti, come all’interno di un comando o di un blocco di script, l’operatore virgola può anche servire da segnale di continuazione della linea. Questo è particolarmente utile nella formattazione dei comandi o quando si passa un elenco di elementi.

Esempio di Codice:

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

Nel nostro script, utilizziamo Get-EventLog per recuperare le 5 voci più recenti dal registro App. Questo output viene canalizzato in Format-Table per la formattazione.

Utilizziamo quindi il metodo della virgola per elencare le proprietà che vogliamo nella tabella: TimeGenerated, EntryType, Source e un’espressione personalizzata per Message. L’espressione personalizzata per Message utilizza una proprietà calcolata (@{n='Message'; e= { $_.Message.Split("n")[0] } }) per visualizzare solo la prima riga del messaggio, migliorando la leggibilità.

Suddividendo questo comando in più righe utilizzando virgole, abbiamo reso lo script più leggibile, specialmente quando si trattava di più proprietà o espressioni complesse.

Output:

Suddivisione di Lunghe Righe di Codice Utilizzando Braces Curvi ({})

Inoltre, le parentesi graffe ({}) quando si definiscono blocchi di script permetteranno la continuazione della linea direttamente. Sono indispensabili in scenari che coinvolgono cicli, dichiarazioni condizionali, o quando si passa un blocco di comandi a cmdlet.

Esempio di Codice:

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

Iniziamo ottenendo un elenco di tutti i processi utilizzando il cmdlet Get-Process. La pipeline poi passa questi processi a Where-Object, dove un blocco di script filtra i processi con un set di lavoro superiore a 100MB.

I processi sopravvissuti vengono passati a un altro blocco di script in ForEach-Object, che estrae e restituisce i loro nomi. L’uso delle parentesi graffe per i blocchi di script consente un flusso chiaro, conciso e funzionale dei dati attraverso la pipeline.

Output:

Conclusione

Nel corso di questo articolo, abbiamo esplorato vari metodi per migliorare la leggibilità degli script di PowerShell. La leggibilità è cruciale per una facile comprensione e manutenzione degli script, soprattutto in Windows PowerShell, dove gli script possono spesso diventare lunghi e complessi.

Abbiamo iniziato discutendo la pratica comune di utilizzare il carattere backtick per i comandi multilinea, che, pur essendo efficace, può talvolta portare a problemi di leggibilità e potenziali bug a causa della sua natura sottile.

Tuttavia, PowerShell offre metodi più intuitivi per spezzare lunghe righe di codice, che abbiamo approfondito successivamente. L’uso di operatori specifici come la pipeline (|), la virgola (,) e le parentesi graffe ({}) offre un approccio più leggibile e mantenibile alla scrittura degli script.

Questi metodi non solo migliorano la struttura visiva del codice ma migliorano anche il flusso logico, rendendo gli script più facili da debug e modificare.