PowerShell Write-Output: Il tuo compagno di output amichevole – techsyncer

Dì addio alla noiosa e prevedibile uscita dello script! Con il cmdlet PowerShell Write-Output, puoi aggiungere un tocco di creatività e personalità ai tuoi script PowerShell.

Il cmdlet Write-Output è uno strumento potente e un compagno perfetto per tutte le tue esigenze di automazione e gestione del sistema. E in questo tutorial, imparerai a massimizzare il potenziale del cmdlet Write-Output.

Pronto? Continua a leggere e scopri la magia del cmdlet Write-Output!

Prerequisiti

Questo tutorial sarà una dimostrazione pratica. Per seguirla, assicurati di avere un computer con PowerShell installato (preferibilmente l’ultima versione). Questo tutorial utilizza Windows 10 con PowerShell 7 installato.

Output di oggetti sulla console

Il cmdlet PowerShell Write-Output scrive gli oggetti sul flusso di output e visualizza l’output di un comando o un messaggio sulla console. Ma sarai sorpreso da come questo strumento rende l’output più significativo e prezioso.

Invece di visualizzare l’output nella console, utilizza il cmdlet Write-Output per personalizzare l’output. Il cmdlet Write-Output può emettere qualsiasi tipo di oggetto o dato, come stringhe, interi, array e persino oggetti complessi.

Esegui il comando seguente per emettere un messaggio Hello, World! sulla console.

Write-Output "Hello, World!”

Di seguito, puoi vedere la funzione più basilare del cmdlet Write-Output. Ma continua a leggere per imparare utilizzi più intermedi e avanzati di questo cmdlet.<>

Passaggio di Oggetti a un Altro Comando

Oltre a visualizzare l’output nella console, puoi utilizzare il comando Write-Output per inviare l’oggetto a un altro comando per ulteriori elaborazioni. Come? Utilizzando l’operatore di pipeline (|). La pipelining rende il comando Write-Output un comando utile e versatile per compiti di automazione e gestione di sistema.

Supponiamo che tu voglia vedere quale processo consuma la maggior parte delle risorse, come la CPU.

Esegui i comandi seguenti per eseguire le seguenti operazioni:

Recupera un elenco di tutti i processi (Get-Process) in esecuzione sul tuo sistema.
Inserire l’elenco nel flusso di dati, che viene poi passato al comando Sort-Object. L’operatore di flusso di dati consente di concatenare più comandi e di elaborare l’output di un comando come input per un altro.
Ordina l’elenco dei processi (Sort-Object) in base all’utilizzo della CPU in ordine -Discendente.

$processes = Get-Process
Write-Output $processes | Sort-Object CPU -Descending

Nota che puoi inserire qualsiasi comando di questo tutorial in uno script di PowerShell e eseguirlo.

L’elenco ordinato viene visualizzato nella console, come mostrato di seguito.

Output di oggetti con un formato personalizzato

Hai visto il formato di output di base del cmdlet Write-Output, che funziona bene. Ma se lo desideri, puoi anche generare oggetti con un formato personalizzato per aggiungere un tocco personale. Un formato personalizzato può essere utile quando desideri visualizzare proprietà specifiche di un oggetto o personalizzare l’aspetto dell’output.

Per generare un oggetto con un formato personalizzato, puoi utilizzare il cmdlet Format-Custom insieme al cmdlet Write-Output, come segue:

per creare il formato di output personalizzato e quindi inviare l’output del cmdlet Format-Custom al cmdlet Write-Output.<>

Esegui il comando seguente, che non produce output ma crea un oggetto (un hashtable) che contiene tre proprietà con i valori corrispondenti da visualizzare.

$object = [pscustomobject]@{
Property1 = "Value1"
Property2 = "Value2"
Property3 = "Value3"
}

Ora, esegui il comando sottostante per eseguire le seguenti operazioni:

Crea un formato personalizzato (Format-Table) per l’output (Write-Output) del tuo hashtable ($object). Le proprietà Property1, Property2 e Property3 sono impostate come colonne.
Regola le larghezze delle colonne (-AutoSize) per adattarle al contenuto.

$object | Format-Table -Property Property1, Property2, Property3 -AutoSize | Write-Output

Creating a custom format for an object output

In alternativa, puoi utilizzare il cmdlet Format-List con Write-Output per emettere l’oggetto come elenco di coppie chiave-valore.

$object | Format-List -Property Property1, Property2, Property3 | Write-Output

Outputting the object as a list of property-value pairs

Passare un oggetto raccolta come singola entità

Per impostazione predefinita, Write-Output invia ciascun elemento della raccolta attraverso il pipeline separatamente, un processo chiamato enumerazione. Ma puoi impedire questo comportamento aggiungendo il parametro -NoEnumerate, passando l’intero oggetto della raccolta come singola entità.

Per vedere come funziona il parametro -NoEnumerate, segui questi passaggi:

Esegui i comandi sottostanti per eseguire le seguenti operazioni:

Dichiara un array di $numbers da uno a tre (1,2,3).

Conta il numero di oggetti (Measure-Object) passati attraverso la pipeline.
Write-Output dell’oggetto di misurazione ($numbers).

Senza il parametro NoEnumerate, Measure-Object restituisce una contabilità di tre (3), poiché ogni elemento dell’array $numbers è stato enumerato e passato singolarmente attraverso il pipeline.

# Dichiara un array
$numbers = 1,2,3
# Restituisce la contabilità degli oggetti passati attraverso il pipeline
Write-Output $numbers | Measure-Object

Ora, esegui i seguenti comandi per visualizzare la contabilità degli oggetti passati attraverso il pipeline.

Ma poiché hai aggiunto il parametro -NoEnumerate, il cmdlet Measure-Object tratta l’oggetto come un’entità singola, restituendo una contabilità di uno (1).

# Dichiara un array
$numbers = 1,2,3
# Restituisce la contabilità degli oggetti come un'entità singola passata attraverso il pipeline
Write-Output -NoEnumerate $numbers | Measure-Object

Outputting object count as a single entity

Includere il comando Write-Output tra parentesi (cioè, (Write-Output 1,2,3)) forzerà l’enumerazione a verificarsi indipendentemente dal parametro -NoEnumerate.

Creazione di un sistema di menu e prompt di input

Un altro ottimo utilizzo del cmdlet Write-Output è la creazione di un sistema di menu con uno script PowerShell che richiede all’utente un input.

Crea un file .ps1 con il tuo editor di testo/codice preferito, popola il codice sottostante e salva il file. Puoi nominare il file come preferisci, ma la scelta di questo tutorial è myoutput.ps1.

Il codice sottostante utilizza un ciclo per richiedere continuamente all’utente di selezionare un’opzione da un elenco di opzioni fino a quando l’utente seleziona l’opzione Esci.

# Inizializza la variabile $exit a $false
$exit = $false

# Avvia un ciclo che si ripeterà finché l'utente seleziona l'opzione "Esci"
while (!$exit) {

  # Mostra all'utente un elenco di opzioni
  Write-Output "Please select from the following options:"
  Write-Output "1. Option 1"
  Write-Output "2. Option 2"
  Write-Output "3. Option 3"
  Write-Output "4. Exit"

  # Chiedi all'utente di fare una selezione
  $selection = Read-Host

  # Utilizza uno statement switch per eseguire codici diversi in base alla selezione dell'utente
  switch ($selection) {
    1 {
      # Se l'utente seleziona l'opzione 1, mostra un messaggio e fai qualcosa per l'opzione 1
      Write-Output "You selected Option 1."
      # Fai qualcosa per l'opzione 1
    }
    2 {
      # Se l'utente seleziona l'opzione 2, mostra un messaggio e fai qualcosa per l'opzione 2
      Write-Output "You selected Option 2."
      # Fai qualcosa per l'opzione 2
    }
    3 {
      # Se l'utente seleziona l'opzione 3, mostra un messaggio e fai qualcosa per l'opzione 3
      Write-Output "You selected Option 3."
      # Fai qualcosa per l'opzione 3
    }
    4 {
      # Se l'utente seleziona l'opzione 4, imposta $exit a $true per uscire dal ciclo
      $exit = $true
    }
  }
}

Ora, esegui lo script (myoutput.ps1) dalla directory di lavoro.

./myoutput.ps1

Come mostrato di seguito, il messaggio associato alla tua selezione viene visualizzato quando scegli le opzioni 1, 2 o 3. Ma quando selezioni l’opzione 4, lo script termina.

Creating a menu system and input prompts

Visualizzare uno Splash Screen o un Messaggio di Benvenuto

Oltre a elencare le opzioni tra cui gli utenti possono scegliere, con Write-Output, è anche possibile visualizzare uno splash screen o un messaggio di benvenuto. Gli splash screen sofisticati fanno una buona impressione (professionale e curata) sullo script.

Sostituisci il codice nel tuo file myoutput.ps1 con quello di seguito, che visualizza uno splash screen (un banner di un messaggio di benvenuto) quando esegui il tuo script.

Puoi personalizzare lo splash screen modificando il testo e la formattazione del banner. Puoi aggiungere elementi aggiuntivi, come un logo o del testo, allo splash screen a piacere.

# Pulisci lo schermo
Clear-Host

# Visualizza lo splash screen utilizzando Write-Output
Write-Output "##############################################"
Write-Output "#                                            #"
Write-Output "#   Welcome to the SuperScript 3000!         #"
Write-Output "#                                            #"
Write-Output "##############################################"

Ora, esegui lo script e guarda come appare il tuo splash screen.

./myoutput.ps1

Displaying a splash screen or welcome message

Visualizzazione di una barra di avanzamento

Quando si eseguono script, un indicatore di avanzamento elimina l’ansia dell’utente riguardo se lo script sia in esecuzione o meno. Le barre di avanzamento possono essere utili per indicare all’utente l’avanzamento di uno script o di un’operazione a lunga durata. Fortunatamente, con il cmdlet Write-Output, è possibile creare una barra di avanzamento personalizzata.

Apri il tuo file myoutput.ps1 e aggiungi il codice seguente alla fine di quello esistente nel file dello script.

Il codice di seguito utilizza un ciclo while per iterare attraverso diverse fasi. In questo esempio, 100 fasi. Ogni iterazione del ciclo calcola la percentuale di fasi completate e visualizza una barra di avanzamento utilizzando Write-Output.

La barra di avanzamento viene creata utilizzando una combinazione dei seguenti operatori:

html>* – Ripete una stringa un numero specificato di volte
$() – Consente l’inclusione dell’output di un’espressione in una stringa.

Lo script mette in pausa (Start-Sleep) per 1 secondo per simulare il progresso prima di passare al passo successivo.

# Imposta il numero totale di passi per la barra di avanzamento
$steps = 100

# Inizializza il contatore per il passo corrente
$currentStep = 0

# Avvia un ciclo che verrà eseguito per il numero di passi
while ($currentStep -lt $steps) {
  # Incrementa il contatore del passo corrente
  $currentStep++

  # Calcola la percentuale di passi completati
  $percentComplete = [int] ($currentStep / $steps * 100)

  # Visualizza una barra di avanzamento utilizzando Write-Output
  Write-Output "Progress: [$("=" * $percentComplete)$(" " * ($steps-$percentComplete))] $percentComplete% complete"

  # Metti in pausa per 1 secondo per simulare il progresso
  Start-Sleep -Seconds 1
}

Ora, esegui lo script e osserva come funziona la barra di avanzamento.

./myoutput.ps1

Di seguito, puoi vedere la schermata di avvio insieme alla barra di avanzamento.

Conclusione

In questo tutorial, hai visto come Write-Output può facilmente produrre oggetti, tipi di dati e formati personalizzati. Inoltre, hai toccato l’uso dell’operatore di pipeline per inviare l’output ad altri comandi per ulteriore elaborazione.

Che tu stia scrivendo un semplice messaggio di output o complesse attività di automazione, Write-Output è uno strumento indispensabile per creare script PowerShell più informativi e professionali.

Con questa nuova conoscenza, perché non scrivere i tuoi output su diversi tipi di file, come file .txt e .xml? Indipendentemente dall’intento, le copie di output sono utili per risolvere problemi con il tuo sistema o le applicazioni. Il Write-Output e il cmdlet Out-File ti conferiscono il potere che non sapevi di avere.