Compare-Object
Confronta due set di oggetti.
Sintassi
Compare-Object
[-ReferenceObject] <PSObject[]>
[-DifferenceObject] <PSObject[]>
[-SyncWindow <Int32>]
[-Property <Object[]>]
[-ExcludeDifferent]
[-IncludeEqual]
[-PassThru]
[-Culture <String>]
[-CaseSensitive]
[<CommonParameters>]Descrizione
Il Compare-Object cmdlet confronta due set di oggetti. Un set di oggetti è il riferimento e l'altro set di oggetti è la differenza.
Compare-Object verifica la presenza di metodi disponibili per il confronto di un intero oggetto. Se non riesce a trovare un metodo appropriato, chiama i metodi ToString() degli oggetti di input e confronta i risultati della stringa. È possibile specificare una o più proprietà da usare per il confronto. Quando vengono fornite proprietà, il cmdlet confronta solo i valori di tali proprietà.
Il risultato del confronto indica se un valore della proprietà è presente solo nell'oggetto riferimento (<=) o solo nell'oggetto differenza (=>). Se viene usato il parametro IncludeEqual , (==) indica che il valore si trova in entrambi gli oggetti.
Se il riferimento o gli oggetti differenza sono Null ($null), Compare-Object genera un errore di terminazione.
Alcuni esempi usano lo splatting per ridurre la lunghezza della riga degli esempi di codice. Per altre informazioni, vedere about_Splatting.
Esempio
Esempio 1: confrontare il contenuto di due file di testo
In questo esempio viene confrontato il contenuto di due file di testo. Nell'esempio vengono usati i due file di testo seguenti, con ogni valore in una riga separata.
Testfile1.txtcontiene i valori: cane, scoiattolo e uccello.Testfile2.txtcontiene i valori: gatto, uccello e racoon.
L'output visualizza solo le righe diverse tra i file. Testfile1.txt è l'oggetto di riferimento (<=) ed Testfile2.txtè l'oggetto differenza (=>). Le righe con contenuto visualizzato in entrambi i file non vengono visualizzate.
Compare-Object -ReferenceObject (Get-Content -Path C:\Test\Testfile1.txt) -DifferenceObject (Get-Content -Path C:\Test\Testfile2.txt)
InputObject SideIndicator
----------- -------------
cat =>
racoon =>
dog <=
squirrel <=Esempio 2: confrontare ogni riga di contenuto ed escludere le differenze
In questo esempio viene utilizzato il parametro ExcludeDifferent per confrontare ogni riga di contenuto in due file di testo.
A partire da PowerShell 7.1, quando si usa il parametro ExcludeDifferent , IncludeEqual viene dedotto e l'output contiene solo righe contenute in entrambi i file, come illustrato da SideIndicator (==).
$objects = @{
ReferenceObject = (Get-Content -Path C:\Test\Testfile1.txt)
DifferenceObject = (Get-Content -Path C:\Test\Testfile2.txt)
}
Compare-Object @objects -ExcludeDifferent
InputObject SideIndicator
----------- -------------
bird ==Esempio 3- Mostra la differenza quando si usa il parametro PassThru
In genere, restituisce Compare-Object un tipo PSCustomObject con le proprietà seguenti:
- InputObject confrontato
- Proprietà SideIndicator che mostra l'oggetto di input a cui appartiene l'output
Quando si utilizza il parametro PassThru, il tipo dell'oggetto non viene modificato ma l'istanza dell'oggetto restituito ha un elemento NoteProperty denominato SideIndicator aggiunto. SideIndicator mostra a quale oggetto di input appartiene l'output.
Gli esempi seguenti illustrano i diversi tipi di output.
$a = $True
Compare-Object -IncludeEqual $a $a
(Compare-Object -IncludeEqual $a $a) | Get-Member
InputObject SideIndicator
----------- -------------
True ==
TypeName: System.Management.Automation.PSCustomObject
Name MemberType Definition
---- ---------- ----------
Equals Method bool Equals(System.Object obj)
GetHashCode Method int GetHashCode()
GetType Method type GetType()
ToString Method string ToString()
InputObject NoteProperty System.Boolean InputObject=True
SideIndicator NoteProperty string SideIndicator===
Compare-Object -IncludeEqual $a $a -PassThru
(Compare-Object -IncludeEqual $a $a -PassThru) | Get-Member
True
TypeName: System.Boolean
Name MemberType Definition
---- ---------- ----------
CompareTo Method int CompareTo(System.Object obj), int CompareTo(bool value), int IComparable.CompareTo(Syst
Equals Method bool Equals(System.Object obj), bool Equals(bool obj), bool IEquatable[bool].Equals(bool ot
GetHashCode Method int GetHashCode()
GetType Method type GetType()
GetTypeCode Method System.TypeCode GetTypeCode(), System.TypeCode IConvertible.GetTypeCode()
ToBoolean Method bool IConvertible.ToBoolean(System.IFormatProvider provider)
ToByte Method byte IConvertible.ToByte(System.IFormatProvider provider)
ToChar Method char IConvertible.ToChar(System.IFormatProvider provider)
ToDateTime Method datetime IConvertible.ToDateTime(System.IFormatProvider provider)
ToDecimal Method decimal IConvertible.ToDecimal(System.IFormatProvider provider)
ToDouble Method double IConvertible.ToDouble(System.IFormatProvider provider)
ToInt16 Method short IConvertible.ToInt16(System.IFormatProvider provider)
ToInt32 Method int IConvertible.ToInt32(System.IFormatProvider provider)
ToInt64 Method long IConvertible.ToInt64(System.IFormatProvider provider)
ToSByte Method sbyte IConvertible.ToSByte(System.IFormatProvider provider)
ToSingle Method float IConvertible.ToSingle(System.IFormatProvider provider)
ToString Method string ToString(), string ToString(System.IFormatProvider provider), string IConvertible.To
ToType Method System.Object IConvertible.ToType(type conversionType, System.IFormatProvider provider)
ToUInt16 Method ushort IConvertible.ToUInt16(System.IFormatProvider provider)
ToUInt32 Method uint IConvertible.ToUInt32(System.IFormatProvider provider)
ToUInt64 Method ulong IConvertible.ToUInt64(System.IFormatProvider provider)
TryFormat Method bool TryFormat(System.Span[char] destination, [ref] int charsWritten)
SideIndicator NoteProperty string SideIndicator===Quando si usa PassThru, viene restituito il tipo di oggetto originale (System.Boolean). Si noti che l'output visualizzato dal formato predefinito per gli oggetti System.Boolean non visualizza la proprietà SideIndicator . Tuttavia, l'oggetto System.Boolean restituito ha aggiunto NoteProperty.
Esempio 4- Confrontare due oggetti semplici usando le proprietà
In questo esempio vengono confrontate due stringhe diverse con la stessa lunghezza.
Compare-Object -ReferenceObject 'abc' -DifferenceObject 'xyz' -Property Length -IncludeEqual
Length SideIndicator
------ -------------
3 ==Esempio 5 - Confronto di oggetti complessi tramite proprietà
In questo esempio viene illustrato il comportamento durante il confronto di oggetti complessi. In questo esempio vengono archiviati due oggetti di processo diversi per istanze diverse di PowerShell. Entrambe le variabili contengono oggetti processo con lo stesso nome. Quando gli oggetti vengono confrontati senza specificare il parametro Property , il cmdlet considera gli oggetti uguali. Si noti che il valore di InputObject corrisponde al risultato del metodo ToString(). Poiché la classe System.Diagnostics.Process non dispone dell'interfaccia IComparable , il cmdlet converte gli oggetti in stringhe e quindi confronta i risultati.
PS> Get-Process pwsh
NPM(K) PM(M) WS(M) CPU(s) Id SI ProcessName
------ ----- ----- ------ -- -- -----------
101 123.32 139.10 35.81 11168 1 pwsh
89 107.55 66.97 11.44 17600 1 pwsh
PS> $a = Get-Process -Id 11168
PS> $b = Get-Process -Id 17600
PS> $a.ToString()
System.Diagnostics.Process (pwsh)
PS> $b.ToString()
System.Diagnostics.Process (pwsh)
PS> Compare-Object $a $b -IncludeEqual
InputObject SideIndicator
----------- -------------
System.Diagnostics.Process (pwsh) ==
PS> Compare-Object $a $b -Property ProcessName, Id, CPU
ProcessName Id CPU SideIndicator
----------- -- --- -------------
pwsh 17600 11.4375 =>
pwsh 11168 36.203125 <=Quando si specificano le proprietà da confrontare, il cmdlet mostra le differenze.
Esempio 6 - Confronto di oggetti complessi che implementano IComparable
Se l'oggetto implementa IComparable, il cmdlet cerca modi per confrontare gli oggetti. Se gli oggetti sono tipi diversi, l'oggetto Difference viene convertito nel tipo di ReferenceObject quindi confrontato.
In questo esempio viene confrontata una stringa con un oggetto TimeSpan . Nel primo caso, la stringa viene convertita in timeSpan in modo che gli oggetti siano uguali.
Compare-Object ([TimeSpan]"0:0:1") "0:0:1" -IncludeEqual
InputObject SideIndicator
----------- -------------
00:00:01 ==
Compare-Object "0:0:1" ([TimeSpan]"0:0:1")
InputObject SideIndicator
----------- -------------
00:00:01 =>
0:0:1 <=Nel secondo caso, timeSpan viene convertito in una stringa in modo che l'oggetto sia diverso.
Parametri
-CaseSensitive
Indica che nei confronti è rilevante la distinzione tra maiuscole e minuscole.
| Tipo: | SwitchParameter |
| Posizione: | Named |
| Valore predefinito: | False |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-Culture
Specifica le impostazioni cultura da usare per i confronti.
| Tipo: | String |
| Posizione: | Named |
| Valore predefinito: | None |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-DifferenceObject
Specifica gli oggetti confrontati con gli oggetti di riferimento .
| Tipo: | PSObject[] |
| Posizione: | 1 |
| Valore predefinito: | None |
| Necessario: | True |
| Accettare l'input della pipeline: | True |
| Accettare caratteri jolly: | False |
-ExcludeDifferent
Indica che questo cmdlet visualizza solo le caratteristiche degli oggetti confrontati uguali. Le differenze tra gli oggetti vengono eliminate.
Utilizzare ExcludeDifferent con IncludeEqual per visualizzare solo le righe che corrispondono tra gli oggetti riferimento e differenza .
Se excludeDifferent viene specificato senza IncludeEqual, non è presente alcun output.
| Tipo: | SwitchParameter |
| Posizione: | Named |
| Valore predefinito: | False |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-IncludeEqual
IncludeEqual visualizza le corrispondenze tra gli oggetti di riferimento e di differenza.
Per impostazione predefinita, l'output include anche le differenze tra gli oggetti di riferimento e di differenza.
| Tipo: | SwitchParameter |
| Posizione: | Named |
| Valore predefinito: | False |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-PassThru
Quando si usa il parametro PassThru , Compare-Object omette il wrapper PSCustomObject intorno agli oggetti confrontati e restituisce gli oggetti diversi, invariati.
| Tipo: | SwitchParameter |
| Posizione: | Named |
| Valore predefinito: | False |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-Property
Specifica una matrice di proprietà degli oggetti riferimento e differenza da confrontare.
Il valore del parametro Property può essere una nuova proprietà calcolata. La proprietà calcolata può essere un blocco di script o una tabella hash. Le coppie chiave-valore valide sono:
- Espressione -
<string>o<script block>
Per altre informazioni, vedere about_Calculated_Properties.
| Tipo: | Object[] |
| Posizione: | Named |
| Valore predefinito: | None |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-ReferenceObject
Specifica una matrice di oggetti utilizzati come riferimento per il confronto.
| Tipo: | PSObject[] |
| Posizione: | 0 |
| Valore predefinito: | None |
| Necessario: | True |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
-SyncWindow
Specifica il numero di oggetti adiacenti che Compare-Object controllano durante la ricerca di una corrispondenza in una raccolta di oggetti. Compare-Object esamina gli oggetti adiacenti quando non trova l'oggetto nella stessa posizione in una raccolta. Il valore predefinito è [Int32]::MaxValue, ovvero Compare-Object esamina l'intera raccolta di oggetti.
Quando si utilizzano raccolte di grandi dimensioni, il valore predefinito potrebbe non essere efficiente, ma è accurato. La specifica di un valore inferiore per SyncWindow può migliorare le prestazioni, ma potrebbe avere un'accuratezza inferiore.
| Tipo: | Int32 |
| Posizione: | Named |
| Valore predefinito: | [Int32]::MaxValue |
| Necessario: | False |
| Accettare l'input della pipeline: | False |
| Accettare caratteri jolly: | False |
Input
È possibile inviare un oggetto verso il basso nella pipeline al parametro DifferenceObject .
Output
None
Per impostazione predefinita, questo cmdlet non restituisce alcun output quando ReferenceObject e DifferenceObject sono uguali.
Quando gli oggetti sono diversi, questo cmdlet esegue il wrapping degli oggetti diversi in un wrapper PSCustomObject con una proprietà SideIndicator per fare riferimento alle differenze.
Quando si usa il parametro IncludeEqual e gli oggetti sono gli stessi, il cmdlet restituisce gli oggetti di cui è stato eseguito il wrapping in un PSCustomObject con la proprietà SideIndicator impostata su ==.
Quando si utilizza il parametro PassThru, il tipo dell'oggetto non viene modificato ma l'istanza dell'oggetto restituito ha un elemento NoteProperty denominato SideIndicator aggiunto. SideIndicator mostra a quale oggetto di input appartiene l'output.
Note
PowerShell include gli alias seguenti per Compare-Object:
- Windows:
comparediff
Quando si usa il parametro PassThru , l'output visualizzato nella console potrebbe non includere la proprietà SideIndicator . La visualizzazione formato predefinita per l'output del tipo di oggetto da Compare-Object non include la proprietà SideIndicator . Per altre informazioni, vedere l'esempio 3 in questo articolo.
