PowerShell Measure-Object: Una guida completa con esempi – techsyncer

Contare o calcolare proprietà numeriche degli oggetti, come caratteri, parole e righe negli oggetti stringa, può essere esasperante. Fortunatamente, il cmdlet Measure-Object di PowerShell è all’altezza del compito.

In questo tutorial, imparerai la potenza del cmdlet Measure-Object nell’automatizzare la misurazione delle proprietà degli oggetti in PowerShell.

Immergiti subito per migliorare le tue competenze nella misurazione degli oggetti!

Prerequisiti

Questo tutorial è una dimostrazione pratica. Per seguirlo, avrai bisogno di un sistema con PowerShell installato. Questo tutorial utilizza Windows 10 con PowerShell v7.

Conteggio di file e cartelle

Sapere il numero di file e cartelle in una directory può essere utile in vari scenari. Un esempio è quando hai bisogno di monitorare la dimensione di una cartella o verificare il numero di file in una directory.

Il cmdlet Measure-Object conta il numero di file e cartelle in una directory. Il conteggio esatto ti aiuta a gestire e ottimizzare meglio le risorse del sistema.

Per vedere come funziona il cmdlet Measure-Object nel conteggio di file e cartelle:

1. Apri PowerShell e esegui il seguente comando Get-ChildItem per contare e restituire il totale di file e cartelle collettivamente (Measure-Object) nella tua directory corrente.

Get-ChildItem | Measure-Object

L’output qui sotto indica 4852 file e cartelle nella directory corrente.

Counting the files and folders in the current directory

Forse desideri includere tutti i file e le sottodirectory nell’albero della directory in modo ricorsivo. In tal caso, aggiungi il parametro -Recurse, come mostrato di seguito. Get-ChildItem -Recurse | Measure-Object

2. Successivamente, esegui lo stesso comando di prima. Ma questa volta, aggiungi il parametro -Directory per contare solo le cartelle totali all’interno della directory di lavoro.

Get-ChildItem -Directory | Measure-Object

Come puoi vedere qui sotto, il conteggio totale è ora inferiore (135) poiché il comando ha contato solo le cartelle, escludendo tutti gli altri oggetti.

Counting the number of directories in the current directory

3. Ora, esegui il comando seguente per contare i file eseguibili (.exe) nella tua directory corrente.

Il parametro -Filter indica al cmdlet Get-ChildItem di filtrare i risultati e restituire solo i file con l’estensione specificata (ad esempio, *.txt, *.jpg, *.csv).

Get-ChildItem -Filter *.exe | Measure-Object

Counting the number of executable files in a directory

Misurare le dimensioni dei file

Misurare la lunghezza e le dimensioni degli oggetti può aiutare a gestire meglio il sistema poiché i file di grandi dimensioni influiscono sulle prestazioni del sistema. Oltre al conteggio delle proprietà, è possibile anche misurare la lunghezza e le dimensioni degli oggetti tramite il cmdlet Measure-Object.

Esegui il codice seguente per recuperare tutti i file nella directory corrente (Get-ChildItem) e visualizzare (Write-Host) le rispettive lunghezze in byte per impostazione predefinita.

Il codice di seguito restituisce ogni misurazione alla console, inclusi le dimensioni minime e massime dei file, la dimensione media dei file, la somma delle dimensioni dei file e il numero totale di file.

# Imposta la soglia per la dimensione media dei file
$threshold = 5000000 
# Misura la dimensione di ogni file nella directory corrente
$files = Get-ChildItem | Measure-Object -Property length -Minimum -Maximum -Sum -Average

Write-Host "Minimum file size: $($files.Minimum) bytes"
Write-Host "Maximum file size: $($files.Maximum) bytes"
Write-Host "Sum of file sizes: $($files.Sum) bytes"
Write-Host "Average file size: $($files.Average) bytes"
Write-Host "Total number of files: $($files.Count)"

# Verifica se la dimensione media dei file è superiore o inferiore alla soglia
if ($files.Average -ge $threshold) {
    # Se la dimensione media dei file è superiore alla soglia, riproduci un suono acuto
    [console]::beep(1000, 500)
} else {
    # Se la dimensione media dei file è inferiore alla soglia, riproduci un suono grave
    [console]::beep(500, 500)
}

Di seguito, è possibile vedere le dimensioni visualizzate in byte.

Forse incollare il codice nella console non fa al caso tuo. In tal caso, salva il codice in un file script di PowerShell e eseguilo.

Ora, esegui i seguenti comandi per ottenere un file nella directory corrente, in cui (Where-Object) la sua dimensione ($_.Length) è uguale (-eq) alla dimensione massima del file ($files.Maximum).

# Ottieni e salva il file della stessa dimensione di $files.Maximum
$max = Get-ChildItem | Where-Object -FilterScript {$_.Length -eq $files.Maximum}
# Mostra il valore della dimensione massima ($files.Maximum) e il file con quella dimensione
Write-Host "Maximum file size: $($files.Maximum) bytes `nFile: $max"

L’output sottostante mostra il nome del file più esteso nella directory corrente.

Misurazione del contenuto di un file di testo

Invece di misurare le dimensioni dei file, potresti avere bisogno di determinare il numero di righe, parole o caratteri in un file di testo. In tal caso, il cmdlet Measure-Object ha molti altri parametri per misurare il contenuto di un file di testo.

Esegui il codice seguente per eseguire le seguenti misurazioni sul contenuto del file di testo (Measure-Object) utilizzando le opzioni -Character, -Line e -Word, e stampa (Write-Host) le misurazioni.

Assicurati di modificare i valori delle variabili $file_path e $file_content con quelli desiderati.

# Definisci il percorso del file e il contenuto
$file_path = "C:\Temp\measure-object.txt"
$file_content = "One fish, two fishes, three fishes"

# Crea il file con il percorso e il contenuto definiti
Set-Content -Path $file_path -Value $file_content

# Misura il contenuto del file di testo
$measurements = Get-Content -Path $file_path | Measure-Object -Character -Line -Word

# Stampa le misurazioni sulla console
Write-Host "The file '$file_path' contains $($measurements.Lines) lines, $($measurements.Words) words, and $($measurements.Characters) characters."

Misurazione dei valori booleani

I valori booleani sono valori che possono essere solo veri o falsi. In PowerShell, i valori booleani vengono spesso utilizzati per controllare il flusso di uno script, determinare una condizione (vero o falso) o indicare il successo o il fallimento di un comando.

La misurazione dei valori booleani può essere utile in vari scenari, ad esempio:

Contare il numero di valori veri o falsi in un set di dati.
Determinare la percentuale di valori veri rispetto al numero totale di valori.

Queste informazioni possono aiutare a prendere decisioni corrette nel processo o nell’analisi dei dati.

Per vedere come funziona la misurazione dei valori booleani:

Esegui i seguenti comandi per conteggiare la somma dei valori booleani (valori veri di default) nell’array ($values).

# Definisci un array di valori booleani ($true e $false).
$values = $true,$false,$false,$true,$true,$true,$false,$false,$true
# Misura (conta) i valori booleani (valori veri di default).
$values | Measure-Object -Sum

Di seguito, il totale Count dei valori booleani è nove (9), mentre la Sum è cinque (5) poiché vengono contati solo i valori veri.

E per i valori falsi? Passa al passaggio successivo e esegui alcuni comandi aggiuntivi.

Counting the number of true values in an array

Ora, esegui il codice seguente per sottrarre la somma dei valori veri ($trueCount) dal conteggio totale dei valori booleani ($count). La differenza dall’equazione è il totale dei valori falsi ($falseCount).

# Ottieni il conteggio totale dei valori booleani in un array
$count = $values.Count
# Ottieni la somma dei valori veri
$trueCount = ($values | Measure-Object -Sum).Sum
# Sottrai la somma dei valori veri dal conteggio totale dei valori booleani
# per ottenere il totale dei valori falsi
$falseCount = $count - $trueCount
# Visualizza il conteggio totale dei valori veri e falsi
Write-Host "Number of true values: $trueCount"
Write-Host "Number of false values: $falseCount"

Se misurare i valori booleani è un compito quotidiano, puoi creare una funzione che puoi chiamare ogni volta per eseguire il compito.

Misurare gli hashtable

Gli hashtable in PowerShell (una collezione di coppie chiave-valore) ti consentono di memorizzare e recuperare dati in modo rapido ed efficiente. Se hai bisogno del numero di elementi in un hashtable o dei valori massimi e minimi, lascia che il cmdlet Measure-Object misuri i tuoi hashtable.

Esegui i comandi seguenti per trovare i valori -Minimum e -Maximum della proprietà Num nel tuo hashtable ($MyHastable).

# Crea un hashtable contenente tre hashtable, ciascuno con una proprietà Num.
$MyHashtable = @(@{Num=10}, @{Num=20}, @{Num=30})
# Misura la proprietà Num dell'hashtable per il minimo e il massimo.
$Stats = $MyHashtable | Measure-Object -Minimum -Maximum Num
# Mostra le misurazioni dell'hashtable
$Stats

Misurare le deviazioni standard

La revisione dei set di dati può essere dispersiva, ma non è necessario che lo sia. Misurare la deviazione standard è utile per capire la distribuzione dei valori del set di dati. È anche possibile identificare eventuali valori anomali o punti dati insoliti che influenzano i risultati.

La deviazione standard misura la variazione o la dispersione dei valori del set di dati rispetto al valore medio (media). Questa misura viene calcolata trovando la radice quadrata della varianza dei dati, che è la media delle differenze quadrate rispetto alla media.

Esegui il codice sottostante per calcolare e visualizzare la -Media e la -DeviazioneStandard di un array di numeri memorizzato nella variabile $Numbers.

# Definisci un array di numeri
$Numbers = 10, 20, 30, 40, 50

# Calcola la media e la deviazione standard dei numeri
$Average = ($Numbers | Measure-Object -Average).Average
$StdDev = ($Numbers | Measure-Object -StandardDeviation).StandardDeviation

# Visualizza i risultati
"Average: $Average"
"Standard deviation: $StdDev"

In statistica, la media misura la tendenza centrale, descrivendo il valore tipico o più rappresentativo di un set di dati.

La media viene calcolata aggiungendo tutti i numeri in un set di dati e dividendo per il numero totale di valori. In questo esempio, il set di dati è {10, 20, 30, 40, 50} con una somma di 150, e ci sono cinque numeri (5) nel set.

Di conseguenza, la media viene calcolata di seguito, ed è 30.

Average = (10 + 20 + 30 + 40 + 50) / 5 = 30

D’altra parte, la deviazione standard misura la dispersione di un set di dati. La deviazione standard viene calcolata nel seguente modo:

1. Find the difference between each data point and the average:
   10 - 30 = -20
   20 - 30 = -10
   30 - 30 = 0
   40 - 30 = 10
   50 - 30 = 20
   
2. Square each of these differences:
   (-20)^2 = 400
   (-10)^2 = 100
   0^2 = 0
   10^2 = 100
   20^2 = 400
   
3. Add up all the squared differences:
   400 + 100 + 0 + 100 + 400 = 1000
   
4. Divide the sum of squared differences by the total number of values:
   1000 / 5 = 200
   
5. Take the square root of the result:
   sqrt(200) = 14.142135623731
   
The standard deviation of this set of data is approximately 14.14. But 
in this case, the result is 15.8113883008419 
because of floating-point arithmetic limitations in computers.

Conclusione

Misurare i dati è un compito essenziale e il cmdlet PowerShell Measure-Object è uno strumento potente per completare il compito. In questo tutorial, hai imparato come misurare i dati in molti modi. Che tu stia lavorando con file, contenuti di file di testo, valori booleani, stringhe, array o tabelle hash, misurarli può fornire preziose informazioni.

Ora puoi facilmente calcolare i valori medi, massimi e minimi dei tuoi dati e misurare la variazione o la dispersione dei tuoi dati. Con queste funzionalità, puoi ottenere una comprensione più approfondita dei tuoi dati e prendere decisioni informate basate sulla tua analisi.

Con questa nuova conoscenza, perché non ampliare il tuo set di strumenti PowerShell e aggiungere Compare-Object al tuo arsenale?