Condividi tramite


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.