Utilizzo dell'output di comando
Si applica a: Exchange Server 2013
Exchange Management Shell offre diversi metodi per formattare l'output di comando. In questa sezione vengono descritti i seguenti argomenti:
Formattazione dei dati Consente di controllare le modalità di formattazione dei dati visualizzati utilizzando i cmdlet Format-List, Format-Table e Format-Wide.
Generazione dei dati Consente di determinare se l'output dei dati viene generato nella finestra della console di Shell o in un file, utilizzando i cmdlet Out-Host e Out-File. In questo argomento è incluso uno script di esempio per l'output dei dati in Microsoft Internet Explorer.
Filtro dei dati È possibile filtrare i dati mediante uno dei metodi indicati di seguito:
Filtro sul lato server, disponibile in alcuni cmdlet.
Filtro sul lato client, disponibile in tutti i cmdlet eseguendo il piping dei risultati di un comando al cmdlet Where-Object.
Per utilizzare la funzionalità descritta in questo argomento, è necessario avere familiarità con i concetti riportati di seguito:
Formattazione dei dati
Se si utilizzano i cmdlet di formattazione alla fine della pipeline, è possibile ignorare la formattazione predefinita per controllare i dati visualizzati e la relativa modalità di visualizzazione. I cmdlet di formattazione sono Format-List, Format-Table e Format-Wide. A ciascuno è associato uno stile di output distinto e diverso dagli altri cmdlet di formattazione.
Format-List
Il cmdlet Format-List riceve l'input dalla pipeline e genera un elenco in colonna verticale di tutte le proprietà specifiche di ciascun oggetto. È possibile specificare le proprietà da visualizzare usando il parametro Property . Se il cmdlet Format-List viene eseguito senza alcun parametro specifico, vengono generate tutte le proprietà. Il cmdlet Format-List consente di andare a capo automaticamente, invece di troncare le righe. L'utilizzo del cmdlet Format-List si rivela utile per ignorare l'output predefinito di un cmdlet consentendo di recuperare informazioni aggiuntive o più dettagliate.
Ad esempio, quando si esegue il cmdlet Get-Mailbox, è possibile visualizzare solo un numero limitato di informazioni nel formato della tabella. Se si esegue il piping dell'output del cmdlet Get-Mailbox al cmdlet Format-List e si aggiungono i parametri relativi alle informazioni aggiuntive o più dettagliate che si desidera visualizzare, è possibile generare l'output desiderato.
È inoltre possibile specificare un carattere jolly "*" con un nome parziale della proprietà. Se si include un carattere jolly, è possibile applicare delle corrispondenze tra più proprietà senza che sia necessario digitare singolarmente tutti i nomi delle proprietà. Ad esempio, Get-Mailbox | Format-List -Property Email* restituisce tutte le proprietà che iniziano con Email.
Negli esempi seguenti sono illustrate le diverse modalità di visualizzazione degli stessi dati restituiti dal cmdlet Get-Mailbox.
Get-Mailbox TestUser1
Name Alias ServerName ProhibitSendQuota
---- ----- ---------- ---------------
TestUser1 TestUser1 mbx unlimited
Nel primo esempio, il cmdlet Get-Mailbox viene eseguito senza una specifica formattazione, pertanto l'output predefinito è in formato di tabella e contiene un insieme predeterminato di proprietà.
Get-Mailbox TestUser1 | Format-List -Property Name,Alias,EmailAddresses
Name : TestUser1
Alias : TestUser1
EmailAddresses : {SMTP:TestUser1@contoso.com}
Nel secondo esempio, l'output del cmdlet Get-Mailbox viene reindirizzato al cmdlet Format-List insieme a proprietà specifiche. È evidente che il formato e il contenuto dell'output sono significativamente diversi.
Get-Mailbox TestUser1 | Format-List -Property Name, Alias, Email*
Name : Test User
Alias : TestUser1
EmailAddresses : {SMTP:TestUser1@contoso.com}
EmailAddressPolicyEnabled : True
Nell'ultimo esempio, l'output del cmdlet Get-Mailbox viene inviato tramite pipe al cmdlet Format-List , come nel secondo esempio. Tuttavia, nell'ultimo esempio viene usato un carattere jolly per trovare la corrispondenza con tutte le proprietà che iniziano con Email.
Se più di un oggetto viene trasmesso al cmdlet Format-List, tutte le proprietà specificate per un oggetto sono visualizzate e raggruppate per oggetto. L'ordine di visualizzazione dipende dal parametro predefinito per il cmdlet. Il parametro predefinito è il parametro Name o Identity . Ad esempio, quando si esegue il cmdlet Get-Childitem, l'ordine di visualizzazione predefinito restituisce i nomi file in ordine alfabetico. Per modificare questo comportamento, è necessario chiamare il cmdlet Format-List , insieme al parametro GroupBy , e il nome di un valore di proprietà in base al quale si vuole raggruppare l'output. Ad esempio, il seguente comando consente di elencare tutti i file in una directory e poi di raggrupparli per estensione.
Get-Childitem | Format-List Name,Length -GroupBy Extension
Extension: .xml
Name : Config_01.xml
Length : 5627
Name : Config_02.xml
Length : 3901
Extension: .bmp
Name : Image_01.bmp
Length : 746550
Name : Image_02.bmp
Length : 746550
Extension: .txt
Name : Text_01.txt
Length : 16822
Name : Text_02.txt
Length : 9835
In questo esempio, il cmdlet Format-List ha raggruppato gli elementi in base alla proprietà Extension specificata dal parametro GroupBy . È possibile utilizzare il parametro GroupBy con qualsiasi proprietà valida per gli oggetti nel flusso della pipeline.
Format-Table
Il cmdlet Format-Table consente di visualizzare gli elementi in un formato di tabella con intestazioni di etichetta e colonne di dati delle proprietà. Per impostazione predefinita, molti cmdlet, ad esempio i cmdlet Get-Process e Get-Service , usano il formato di tabella per l'output. I parametri per il cmdlet Format-Table includono i parametri Properties e GroupBy . Questi parametri funzionano esattamente come con il cmdlet Format-List .
Il cmdlet Format-Table usa anche il parametro Wrap . Questo parametro consente la visualizzazione completa di lunghe righe di informazioni sulle proprietà anziché il troncamento alla fine di una riga. Per vedere come viene usato il parametro Wrap per visualizzare le informazioni restituite, confrontare l'output del comando Get-Command nei due esempi seguenti.
Nel primo esempio, quando viene usato il cmdlet Get-Command per visualizzare le informazioni sui comandi sul cmdlet Get-Process , le informazioni per la proprietà Definition vengono troncate.
Get-Command Get-Process | Format-Table Name,Definition
Name Definition
---- ----------
get-process get-process [[-ProcessName] String[]...
Nel secondo esempio il parametro Wrap viene aggiunto al comando per forzare la visualizzazione del contenuto completo della proprietà Definition .
Get-Command Get-Process | Format-Table Name,Definition -Wrap
Get-Process Get-Process [[-Name] <String[]>] [-Comp
uterName <String[]>] [-Module] [-FileVe
rsionInfo] [-Verbose] [-Debug] [-ErrorA
ction <ActionPreference>] [-WarningActi
on <ActionPreference>] [-ErrorVariable
<String>] [-WarningVariable <String>] [
-OutVariable <String>] [-OutBuffer <Int
32>]
Get-Process -Id <Int32[]> [-ComputerNam
e <String[]>] [-Module] [-FileVersionIn
fo] [-Verbose] [-Debug] [-ErrorAction <
ActionPreference>] [-WarningAction <Act
ionPreference>] [-ErrorVariable <String
>] [-WarningVariable <String>] [-OutVar
iable <String>] [-OutBuffer <Int32>]
Get-Process [-ComputerName <String[]>]
[-Module] [-FileVersionInfo] -InputObje
ct <Process[]> [-Verbose] [-Debug] [-Er
rorAction <ActionPreference>] [-Warning
Action <ActionPreference>] [-ErrorVaria
ble <String>] [-WarningVariable <String
>] [-OutVariable <String>] [-OutBuffer
<Int32>]
Come per il cmdlet Format-List , è anche possibile specificare un carattere jolly "*" con un nome di proprietà parziale. Se si include un carattere jolly, è possibile applicare delle corrispondenze tra più proprietà senza digitare singolarmente tutti i nomi delle proprietà.
Format-Wide
Il cmdlet Format-Wide consente un controllo più semplice dell'output rispetto agli altri cmdlet di formattazione. Per impostazione predefinita, il cmdlet Format-Wide tenta di visualizzare in una riga di output quante più colonne possibili dei valori proprietà. L'aggiunta di parametri consente di controllare il numero di colonne e di stabilire come utilizzare lo spazio di output.
Nell'utilizzo più basilare, l'esecuzione del cmdlet Format-Wide senza alcun parametro restituisce l'output in tutte le colonne che la pagina può contenere. Ad esempio, se si esegue il cmdlet Get-Childitem e si esegue il piping del relativo output al cmdlet Format-Wide, le informazioni verranno visualizzate come segue:
Get-ChildItem | Format-Wide
Directory: FileSystem::C:\WorkingFolder
Config_01.xml Config_02.xml
Config_03.xml Config_04.xml
Config_05.xml Config_06.xml
Config_07.xml Config_08.xml
Config_09.xml Image_01.bmp
Image_02.bmp Image_03.bmp
Image_04.bmp Image_05.bmp
Image_06.bmp Text_01.txt
Text_02.txt Text_03.txt
Text_04.txt Text_05.txt
Text_06.txt Text_07.txt
Text_08.txt Text_09.txt
Text_10.txt Text_11.txt
Text_12.txt
In genere, l'esecuzione del cmdlet Get-Childitem senza alcun parametro comporta la visualizzazione dei nomi di tutti i file nella directory in una tabella di proprietà. In questo esempio, eseguendo il piping dell'output del cmdlet Get-Childitem al cmdlet Format-Wide, l'output viene visualizzato in due colonne di nomi. È importante notare che è possibile visualizzare solo un tipo di proprietà alla volta, specificato da un nome proprietà posto di seguito al cmdlet Format-Wide. Se si aggiunge il parametro Autosize , l'output viene modificato da due colonne a un numero di colonne uguale alla larghezza dello schermo.
Get-ChildItem | Format-Wide -AutoSize
Directory: FileSystem::C:\WorkingFolder
Config_01.xml Config_02.xml Config_03.xml Config_04.xml Config_05.xml
Config_06.xml Config_07.xml Config_08.xml Config_09.xml Image_01.bmp
Image_02.bmp Image_03.bmp Image_04.bmp Image_05.bmp Image_06.bmp
Text_01.txt Text_02.txt Text_03.txt Text_04.txt Text_05.txt
Text_06.txt Text_07.txt Text_08.txt Text_09.txt Text_10.txt
Text_11.txt Text_12.txt
In questo esempio, la tabella è ordinata in cinque colonne invece che in due. Il parametro Column offre un maggiore controllo consentendo di specificare il numero massimo di colonne per visualizzare le informazioni come indicato di seguito:
Get-ChildItem | Format-Wide -Column 4
Directory: FileSystem::C:\WorkingFolder
Config_01.xml Config_02.xml Config_03.xml Config_04.xml
Config_05.xml Config_06.xml Config_07.xml Config_08.xml
Config_09.xml Image_01.bmp Image_02.bmp Image_03.bmp
Image_04.bmp Image_05.bmp Image_06.bmp Text_01.txt
Text_02.txt Text_03.txt Text_04.txt Text_05.txt
Text_06.txt Text_07.txt Text_08.txt Text_09.txt
Text_10.txt Text_11.txt Text_12.txt
In questo esempio, il numero di colonne è stato impostato su quattro utilizzando il parametro Column.
Generazione dei dati
Cmdlet Out-Host e Out-File
Il cmdlet Out-Host è un cmdlet predefinito non visualizzato alla fine della pipeline. Dopo l'applicazione di tutte le formattazioni, il cmdlet Out-Host invia l'output finale alla finestra di console per la visualizzazione. Non è necessario eseguire esplicitamente il cmdlet Out-Host poiché rappresenta l'output predefinito. È possibile ignorare l'invio dell'output alla finestra di console eseguendo il cmdlet Out-File per ultimo nel comando. Il cmdlet Out-File, quindi, scrive l'output nel file specificato nel comando come nell'esempio illustrato di seguito:
Get-ChildItem | Format-Wide -Column 4 | Out-File c:\OutputFile.txt
In questo esempio il cmdlet Out-File scrive le informazioni visualizzate nel comando Get-ChildItem | Format-Wide -Column 4 in un file denominato OutputFile.txt. È anche possibile reindirizzare l'output della pipeline a un file usando l'operatore di reindirizzamento, ovvero la parentesi quadra quadra destra ( > ). Per accodare l'output della pipeline di un comando a un file esistente senza sostituire il file originale, usare le doppie parentesi graffe ( >> ), come nell'esempio seguente:
Get-ChildItem | Format-Wide -Column 4 >> C:\OutputFile.txt
In questo esempio, l'output del cmdlet Get-Childitem viene inviato tramite pipe al cmdlet Format-Wide per la formattazione e quindi scritto alla fine del OutputFile.txt file. Si noti che se il OutputFile.txt file non esistesse, l'uso delle doppie parentesi quadre a destra ( >> ) creerebbe il file.
Per altre informazioni sulle pipeline, vedere about_Pipelines.
Per ulteriori informazioni sulla sintassi utilizzata nell'esempio precedente, vedere Syntax.
Visualizzazione dei dati in Internet Explorer
Per la flessibilità e la facilità dell'esecuzione script in Exchange Management Shell, è possibile prelevare i dati restituiti dai comandi e formattarli e generarli in moltissimi modi.
Nell'esempio illustrato di seguito, è descritto come utilizzare uno script semplice per generare i dati restituiti da un comando e visualizzarli in Internet Explorer. Lo script preleva gli oggetti transitati tramite la pipeline, apre una finestra di Internet Explorer e visualizza i dati in Internet Explorer:
$Ie = New-Object -Com InternetExplorer.Application
$Ie.Navigate("about:blank")
While ($Ie.Busy) { Sleep 1 }
$Ie.Visible = $True
$Ie.Document.Write("$Input")
# If the previous line doesn't work on your system, uncomment the line below.
# $Ie.Document.IHtmlDocument2_Write("$Input")
$Ie
Per usare questo script, salvarlo nella C:\Program Files\Microsoft\Exchange Server\V15\Scripts directory del computer in cui verrà eseguito lo script. Assegnare al file Out-Ie.ps1il nome . Dopo aver salvato il file, è possibile utilizzare lo script come un cmdlet normale.
Nota
Per essere eseguiti in Exchange 2013, gli script devono essere aggiunti a un ruolo di gestione senza ambito e devono essere assegnati al ruolo direttamente o tramite un gruppo del ruolo di gestione. Per altre informazioni, vedere Informazioni sui ruoli di gestione.
Lo Out-Ie script presuppone che i dati ricevuti siano HTML validi. Per convertire in HTML i dati che si desiderano visualizzare, è necessario eseguire il piping dei risultati del comando al cmdlet ConvertTo-Html. È quindi possibile inviare i risultati del comando tramite pipe allo Out-Ie script. Nel seguente esempio viene descritto come visualizzare un elenco directory in una finestra di Internet Explorer:
Get-ChildItem | Select Name,Length | ConvertTo-Html | Out-Ie
Filtro dei dati
Shell consente l'accesso a un grande numero di informazioni sui server, sulle cassette postali, su Active Directory e su altri oggetti dell'organizzazione. L'accesso a tali informazioni consente una comprensione migliore dell'ambiente, ma le informazioni potrebbero essere eccessive. Shell consente di controllare queste informazioni e di restituire solo i dati che si desidera visualizzare utilizzando un filtro. Sono disponibili i tipi di filtro indicati di seguito:
Filtro lato server: il filtro lato server accetta il filtro specificato nella riga di comando e lo invia al server Exchange su cui si esegue la query. Tale server elabora la query e restituisce solo i dati che corrispondono al filtro specificato.
Il filtro sul lato server viene eseguito solo su oggetti in cui è possibile restituire decine o centinaia di migliaia di risultati. Pertanto, solo i cmdlet di gestione dei destinatari, ad esempio il cmdlet Get-Mailbox , e i cmdlet di gestione delle code, ad esempio il cmdlet Get-Queue , supportano il filtro sul lato server. Questi cmdlet supportano il parametro Filter . Questo parametro accetta l'espressione di filtro specificata e la invia al server per l'elaborazione.
Filtro lato client: il filtro lato client viene eseguito sugli oggetti nella finestra della console locale in cui si sta lavorando. Quando si usa il filtro lato client, il cmdlet recupera tutti gli oggetti corrispondenti all'attività eseguita nella finestra della console locale. La shell accetta quindi tutti i risultati restituiti, applica il filtro sul lato client a tali risultati e restituisce solo i risultati corrispondenti al filtro. Tutti i cmdlet supportano il filtro lato client. Questo viene richiamato inviando tramite pipe i risultati di un comando al cmdlet Where-Object .
Filtro sul lato server
L'implementazione del filtro sul lato server è specifica del cmdlet in cui è supportata. Il filtro sul lato server è abilitato solo su proprietà specifiche degli oggetti restituiti. Per ulteriori informazioni, vedere la Guida per i seguenti cmdlet:
| Get-ActiveSyncDevice | Get-ActiveSyncDeviceClass | Get-CASMailbox | Get-Contact | Get-DistributionGroup |
| Get-DynamicDistributionGroup | Get-Group | Get-Mailbox | Get-MailboxStatistics | Get-MailContact |
| Get-MailPublicFolder | Get-MailUser | Get-Message | Get-MobileDevice | Get-Queue |
| Get-QueueDigest | Get-Recipient | Get-RemoteMailbox | Get-RoleGroup | Get-SecurityPrincipal |
| Get-StoreUsageStatistics | Get-UMMailbox | Get-User | Get-UserPhoto | Remove-Message |
| Resume-Message | Resume-Queue | Retry-Queue | Suspend-Message | Suspend-Queue |
Filtro sul lato client
Il filtro lato client può essere usato con qualsiasi cmdlet. Questa funzionalità include i cmdlet che supportano anche il filtro sul lato server. Come descritto in precedenza in questo argomento, il filtro lato client accetta tutti i dati restituiti da un comando precedente nella pipeline e, a sua volta, restituisce solo i risultati corrispondenti al filtro specificato. Il cmdlet Where-Object esegue questo filtro. Può essere abbreviato in Dove.
Una volta che i dati passano attraverso la pipeline, il cmdlet Where li riceve dall'oggetto precedente, li filtra e li passa su un altro oggetto. Il filtro si basa su un blocco di script definito nel comando Where. Il blocco di script filtra i dati in base alle proprietà e ai valori dell'oggetto.
Il cmdlet Clear-Host viene utilizzato per cancellare la finestra di console. In questo esempio, è possibile trovare tutti gli alias definiti per il cmdlet Clear-Host se si esegue il comando indicato di seguito:
Get-Alias | Where {$_.Definition -eq "Clear-Host"}
CommandType Name Definition
----------- ---- ----------
Alias clear clear-host
Alias cls clear-host
Il cmdlet Get-Alias e il comando Where operano insieme per restituire l'elenco di alias definiti solo per il cmdlet Clear-Host. Nella seguente tabella vengono descritti tutti gli elementi del comando Where utilizzato nell'esempio.
Elementi del comando Where
| Elemento | Descrizione |
|---|---|
{ } |
Le parentesi graffe racchiudono il blocco di script che definisce il filtro. |
$_ |
Questa variabile speciale attiva e associa automaticamente gli oggetti nella pipeline. |
Definition |
La Definition proprietà è la proprietà degli oggetti pipeline correnti che archivia il nome della definizione dell'alias. Quando Definition viene utilizzato con la $_ variabile , un punto viene prima del nome della proprietà. |
-eq |
Questo operatore di confronto, corrispondente a "uguale a", è utilizzato per specificare che è necessario che i risultati corrispondano esattamente al valore proprietà fornito nell'espressione. |
| "Clear-Host" | In questo esempio, "Clear-Host" indica il valore per il quale il comando sta eseguendo l'analisi. |
Nell'esempio, gli oggetti restituiti dal cmdlet Get-Alias rappresentano tutti gli alias definiti nel sistema. Anche se non è possibile visualizzarli dalla riga di comando, gli alias sono raccolti e passano al cmdlet Where attraverso la pipeline. Il cmdlet Where utilizza le informazioni nel blocco di script per applicare un filtro agli oggetti alias.
La variabile $speciale _represents gli oggetti passati. La $_variabile viene avviata automaticamente dalla shell ed è associata all'oggetto pipeline corrente. Per altre informazioni su questa variabile speciale, vedere Variabili della shell.
Utilizzando la notazione "dot" standard (object.property), la Definition proprietà viene aggiunta per definire la proprietà esatta dell'oggetto da valutare. L'operatore -eq di confronto confronta quindi il valore di questa proprietà con "Clear-Host". Solo gli oggetti con la Definition proprietà che corrispondono a questo criterio vengono passati alla finestra della console per l'output. Per altre informazioni sugli operatori di confronto, vedere Operatori di confronto.
Dopo che il comando Where ha filtrato gli oggetti restituiti dal cmdlet Get-Alias, è possibile eseguire il piping degli oggetti filtrati a un altro comando. Il comando successivo elabora solo gli oggetti filtrati restituiti dal comando Where.