Come filtrare i dati con Where-Object in PowerShell: la guida completa

PowerShell è un linguaggio di scripting e da riga di comando per l’amministrazione di sistema e l’automazione in Windows, nonché una componente essenziale negli strumenti di ogni amministratore o sviluppatore Windows. Filtrare l’output dei comandi PowerShell con Where-Object ti permette di individuare rapidamente i dati rilevanti da visualizzare, oppure di eseguire operazioni su un sottoinsieme di oggetti in base ai criteri di filtro che hai definito.

Questa guida spiega come usare Where-Object per filtrare oggetti e dati in PowerShell e include esempi pratici che puoi copiare e incollare nel tuo codice. Illustra inoltre gli aspetti legati alle prestazioni e le best practice per usare Where-Object nei tuoi script PowerShell.

💡 Puoi seguire questa procedura anche in formato video nella nostra guida: Come filtrare i dati con Where-Object in PowerShell.

Come funziona il cmdlet PowerShell Where-Object

Il CmdLet PowerShell Where-Object (un CmdLet è un comando PowerShell usato per l’automazione) filtra una raccolta di oggetti restituita da un comando, mantenendo solo quelli che corrispondono ai criteri di ricerca.

La sintassi e i parametri più utilizzati con Where-Object sono i seguenti:

[ Command ] | Where-Object [ -Property ] [ -Value ] [ Operator ]

Nota che:

• [ Command ] è il comando il cui output viene filtrato da Where-Object.
• [ -Property ] è la proprietà dell’oggetto da confrontare, fornita come stringa.
• [ -Value ] è il valore con cui confrontare la proprietà, fornito come oggetto o stringa.
• L’ultimo parametro è l’[ Operator ] di confronto da utilizzare: -eq (uguale a), -ne (diverso da), -gt (maggiore di), -lt (minore di), -ge (maggiore o uguale a), -le (minore o uguale a).

L’output viene inviato tramite pipe a Where-Object. Puoi consultare altre opzioni di sintassi nella documentazione di PowerShell. È anche possibile definire criteri di filtro più complessi tramite un blocco di codice, come mostrato negli esempi più avanti in questo articolo.

Esempi pratici di utilizzo di Where-Object per filtrare gli oggetti

Il modo migliore per capire come usare Where-Object è vederlo all’opera. Di seguito trovi diversi esempi semplici che mostrano l’uso di base con gli operatori di confronto integrati, oltre a un utilizzo avanzato che implementa criteri personalizzati nei blocchi di script. Questi esempi mostrano come filtrare in base a più valori, come usare le regex e come filtrare per data.

Seguono poi alcuni comandi PowerShell completi che usano Where-Object per eseguire attività di scripting comuni, come la pulizia dei file di log, l’individuazione dei processi con un elevato utilizzo di memoria, il filtraggio degli utenti di Active Directory e la ricerca nei registri degli eventi.

Filtrare un singolo valore

Questo esempio mostra come filtrare in base a un singolo valore con l’operatore di confronto -eq:

# Filtra i processi in esecuzione mantenendo quelli con nome ‘powershell’
Get-Process | Where-Object Name -eq ‘powershell’

Filtrare in base a più valori

Questo esempio mostra come filtrare in base a più valori. Filtra l’elenco dei processi in esecuzione restituito da Get-Process mantenendo quelli denominati “winlogon” ed “explorer” (entrambi dovrebbero essere in esecuzione per ogni utente connesso):

# Filtra i processi in esecuzione denominati ‘winlogon’ o ‘explorer’
$names = @('winlogon', 'explorer') # Definisce un array contenente i diversi valori di ricerca
Get-Process | Where-Object { $names -contains $_.Name }

Le parentesi graffe in questo esempio delimitano un blocco di script PowerShell che contiene una serie di espressioni. Nota anche l’uso di $_, una scorciatoia che rappresenta l’oggetto sottoposto a confronto. In questo caso serve a passare al confronto la proprietà Name dell’oggetto.

Usare le espressioni regolari

Where-Object può essere usato anche con gli array. Le regex permettono di filtrare qualsiasi tipo di oggetto e offrono un modo per aggiungere condizioni complesse basate sul contenuto delle stringhe:

# Filtra un array di indirizzi email mantenendo quelli di un dominio specifico
$emailAddresses = @("[email protected]", "[email protected]", "[email protected]") # Definisce un array di indirizzi email
$emailAddresses | Where-Object { $_ -match ‘@test.com$’ }

Nota che potresti usare anche il metodo Where() degli array, di cui parliamo più avanti in questo articolo.

Filtrare per data

Per i comandi che restituiscono oggetti con proprietà di tipo data, puoi filtrare usando gli oggetti DateTime restituiti da Get-Date:

# Trova i file nella directory corrente modificati negli ultimi 14 giorni
Get-ChildItem -Path . | Where-Object { $_.LastWriteTime -GT (Get-Date).AddDays(-14) }

Puoi anche filtrare tra due date fornendo un intervallo:

# Trova le voci del registro eventi di Windows dell’ultima settimana
$startDate = (Get-Date).AddDays(-7) # Nota l’uso di un numero negativo per impostare la data nel passato
$endDate = Get-Date
Get-EventLog -LogName Application | Where-Object { $_.TimeGenerated -ge $startDate -and $_.TimeGenerated -le $endDate }

Esempi avanzati con criteri personalizzati nei blocchi di script

Come mostrato negli esempi precedenti, i blocchi di script possono contenere più espressioni di confronto. Con Where-Object puoi applicare filtri più complessi fornendo più criteri e condizioni all’interno dei blocchi di script. Ecco alcuni esempi:

# Filtra i processi con utilizzo della CPU superiore al 75%
Get-Process | Where-Object { $_.CPU -gt 75 }
# Trova i servizi in esecuzione il cui nome inizia con ‘Win’
Get-Service | Where-Object { $_.Status -eq ‘Running’ -and $_.Name -like ‘Win*’ }
# Trova i file nella directory corrente più grandi di 3MB e modificati negli ultimi 30 giorni
Get-ChildItem -Path . | Where-Object { $_.Length -gt 3MB -and $_.LastWriteTime -gt (Get-Date).AddDays(-30) }

Esempi pratici di Where-Object nell’uso quotidiano

Oltre agli esempi precedenti, ecco altri comandi PowerShell spesso necessari per l’automazione e l’amministrazione di sistema:

# Trova i file .txt nella directory corrente
Get-ChildItem -Path . | Where-Object Extension -eq ‘.txt’
# Elimina i file di log in un determinato percorso più vecchi di 90 giorni
Get-ChildItem -Path ‘C:PathToLogs’ -Filter ‘*.log’ | Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-90) } | Remove-Item
# Elenca i processi che utilizzano più di 1000 MB di memoria
Get-Process | Where-Object { $_.WorkingSet -gt 1000MB } | Select-Object Name, WorkingSet
# Cerca gli utenti di Active Directory che appartengono a un gruppo specifico (marketing) e hanno una mansione specifica (Director)
Import-Module ActiveDirectory
Get-ADUser -Filter { MemberOf -eq ‘CN=Marketing,OU=Groups,DC=example,DC=com’ -and Title -eq ‘Director’ }
# Trova le voci del registro eventi di Windows che sono errori relativi a un’applicazione specifica (MyApplication)
Get-EventLog -LogName Application -EntryType Error | Where-Object { $_.Source -eq ‘MyApplication’ }

Nota in questo esempio l’uso combinato di Where-Object e Select-Object per estrarre i dati rilevanti dai risultati.

Differenze tra Where-Object e gli altri metodi di filtro

In PowerShell esistono diversi modi per filtrare i dati: alcuni pensati per gli oggetti, altri per il testo. Non si comportano allo stesso modo, quindi conviene scegliere quello più adatto a ogni scenario:

• Where-Object: filtra le raccolte di oggetti inviate tramite pipe al comando, mantenendo solo gli oggetti corrispondenti.
• Select-Object: permette inoltre di filtrare le proprietà degli oggetti, restituendo ad esempio una raccolta di oggetti includendo però solo la proprietà “name” di ciascuno.
• Metodo Where() degli array: filtra gli array in base alle condizioni fornite.
• Parametro Filter: alcuni cmdlet includono un parametro -Filter per effettuare ricerche nel proprio output.

Aspetti da considerare per le prestazioni quando filtri i dati

Il filtraggio dei dati può essere un’attività che richiede molte risorse. I comandi PowerShell, soprattutto quando interagiscono con database o con Active Directory, possono restituire anche migliaia di record, e usare Where-Object per elaborare e filtrare ciascuno di essi non è il modo più efficiente di cercare in grandi insiemi di dati.

Molti comandi PowerShell includono un parametro -Filter ottimizzato per le ricerche con quel comando specifico. Se è disponibile un parametro -Filter, è consigliabile usarlo per ridurre il più possibile i dati prima di passarli a Where-Object.

Ad esempio, se lavori con i dati di Active Directory usando il Get-ADUser, e vuoi ottenere l’elenco degli utenti di un determinato reparto per poi eseguire azioni diverse in base alla loro mansione, dovresti usare -Filter per limitare i risultati al reparto desiderato. Puoi poi usare Where-Object per eseguire azioni in base alla mansione su un elenco di oggetti più ridotto.

Se il tuo script PowerShell impiega troppo tempo a completarsi e sospetti che la causa sia un comando contenente Where-Object, puoi valutarne le prestazioni con il cmdlet Measure-Command, che misura il tempo necessario al completamento del comando.

Best practice ed errori frequenti nell’uso di Where-Object in PowerShell

Ci sono alcuni errori frequenti in cui si incorre usando Where-Object, che puoi evitare seguendo queste best practice:

• “Filtra a sinistra”: usa il parametro -Filter specifico del cmdlet o altri parametri di ricerca il prima possibile nei tuoi comandi PowerShell (cioè il più a sinistra possibile nel comando) per massimizzare l’efficienza.
• Usa Select-Object per escludere le proprietà non necessarie: migliora le prestazioni quando lavori con grandi quantità di dati (che non puoi filtrare in altro modo con le funzioni specifiche del cmdlet).
• Mantieni la semplicità: evita condizioni complesse nei blocchi di script e scomponi il lavoro ove possibile, per migliorare le prestazioni e semplificare il debug.
• Usa correttamente gli operatori di confronto: assicurati di aver capito cosa fanno i tuoi parametri di filtro e i blocchi di script, così da evitare risultati inattesi.
• Mantieni leggibili i tuoi script: puoi usare ? come alias di Where-Object per accorciare i comandi e renderli più leggibili. Usa anche spazi e indentazione per mantenere il codice ben formattato e facile da leggere, e aggiungi commenti che spieghino cosa deve fare ogni riga del tuo script PowerShell (nel caso tu debba riprenderlo dopo mesi o anni per modificarlo e non ricordi più lo scopo di un comando).

Per facilitare il debug dei comandi Where-Object, puoi usare il parametro comune di PowerShell verbose per stampare informazioni dettagliate sull’operazione in corso. Ad esempio:

$VerbosePreference = "Continue"
Get-Process | Where-Object { $_.CPU -gt 75 } -Verbose

È consigliabile usare anche i blocchi try-catch per gestire in modo pulito gli errori imprevisti.

Filtrare i dati con Where-Object di PowerShell ti permette di visualizzare le informazioni rilevanti restituite dai cmdlet, cercare file e processi e ordinare i risultati di qualsiasi comando PowerShell che restituisca oggetti, inclusi gli strumenti per lavorare con Active Directory. Per scoprire come Where-Object può aiutarti nelle attività ripetitive di amministrazione di sistema, dai un’occhiata al nostro tutorial su come usare PowerShell per l’automazione.