Vergleichen Sie zwei Arrays und erhalten Sie die Werte, die nicht üblich sind

Ich wollte eine kleine Logik, um den Inhalt von zwei Arrays zu vergleichen und mit Powershell den Wert zu erhalten, der unter ihnen nicht üblich ist

Beispiel wenn

$a1=@(1,2,3,4,5)
$b1=@(1,2,3,4,5,6)

$ c, das die Ausgabe ist, sollte mir den Wert " 6" geben, der die Ausgabe des ungewöhnlichen Werts zwischen beiden Arrays ist.

Kann mir jemand dabei helfen? Vielen Dank!

PS > $c = Compare-Object -ReferenceObject (1..5) -DifferenceObject (1..6) -PassThru
PS > $c
6

$a = 1..5
$b = 4..8

$Yellow = $a | Where {$b -NotContains $_}

$Yellowenthält alle Elemente in $aaußer denen, die in enthalten sind $b:

PS C:\> $Yellow
1
2
3

$Blue = $b | Where {$a -NotContains $_}

$Blueenthält alle Elemente in $baußer denen, die in enthalten sind $a:

PS C:\> $Blue
6
7
8

$Green = $a | Where {$b -Contains $_}

Nicht in Frage, aber trotzdem; Greenenthält die Elemente, die in beiden $aund enthalten sind $b.

PS C:\> $Green
4
5

_{Hinweis : Whereist ein Alias ​​von Where-Object. Alias ​​kann mögliche Probleme verursachen und die Wartung von Skripten erschweren.}

Nachtrag 12. Oktober 2019

Wie von @xtreampb und @ mklement0 kommentiert: Obwohl aus dem Beispiel in der Frage nicht ersichtlich, ist die Aufgabe, die die Frage impliziert (Werte "nicht gemeinsam"), die symmetrische Differenz zwischen den beiden Eingabesätzen (die Vereinigung von Gelb und Blau). .

Union

Der symmetrische Unterschied zwischen $aund $bkann wörtlich definiert werden als die Vereinigung von $Yellowund $Blue:

$NotGreen = $Yellow + $Blue

Welches ist ausgeschrieben:

$NotGreen = ($a | Where {$b -NotContains $_}) + ($b | Where {$a -NotContains $_})

Performance

Wie Sie vielleicht bemerken, gibt es in dieser Syntax einige (redundante) Schleifen: Alle Elemente in der Liste $adurchlaufen (verwenden Where) Elemente in der Liste $b(verwenden -NotConatins) und umgekehrt. Leider ist die Redundanz schwer zu vermeiden, da es schwierig ist, das Ergebnis jeder Seite vorherzusagen. Eine Hash-Tabelle ist normalerweise eine gute Lösung, um die Leistung redundanter Schleifen zu verbessern. Dazu definiere ich gerne die Frage neu: Holen Sie sich die Werte, die einmal in der Summe der Sammlungen erscheinen ( $a + $b) :

$Count = @{}
$a + $b | ForEach-Object {$Count[$_] += 1}
$Count.Keys | Where-Object {$Count[$_] -eq 1}

Wenn Sie die ForEachAnweisung anstelle des ForEach-ObjectCmdlets und die WhereMethode anstelle von verwenden, können Where-ObjectSie die Leistung um den Faktor 2,5 erhöhen:

$Count = @{}
ForEach ($Item in $a + $b) {$Count[$Item] += 1}
$Count.Keys.Where({$Count[$_] -eq 1})

LINQ

Aber Language Integrated Query (LINQ) leicht schlagen alle nativen Powershell und nativen .NET - Methoden (siehe auch High Performance Powershell mit LINQ und mklement0 Antwort für Can folgende Nested foreach - Schleife in Powershell vereinfacht werden? :

Um LINQ verwenden zu können, müssen Sie die Array-Typen explizit definieren:

[Int[]]$a = 1..5
[Int[]]$b = 4..8

Und benutze den [Linq.Enumerable]::Operator:

$Yellow   = [Int[]][Linq.Enumerable]::Except($a, $b)
$Blue     = [Int[]][Linq.Enumerable]::Except($b, $a)
$Green    = [Int[]][Linq.Enumerable]::Intersect($a, $b)
$NotGreen = [Int[]]([Linq.Enumerable]::Except($a, $b) + [Linq.Enumerable]::Except($b, $a))

Benchmark

Die Benchmark-Ergebnisse hängen stark von der Größe der Sammlungen und der Anzahl der tatsächlich freigegebenen Elemente ab. Als "Durchschnitt" gehe ich davon aus, dass die Hälfte jeder Sammlung mit der anderen geteilt wird.

Using             Time
Compare-Object    111,9712
NotContains       197,3792
ForEach-Object    82,8324
ForEach Statement 36,5721
LINQ              22,7091

Um einen guten Leistungsvergleich zu erhalten, sollten Caches gelöscht werden, indem beispielsweise eine neue PowerShell-Sitzung gestartet wird.

$a = 1..1000
$b = 500..1500

(Measure-Command {
    Compare-Object -ReferenceObject $a -DifferenceObject $b  -PassThru
}).TotalMilliseconds
(Measure-Command {
    ($a | Where {$b -NotContains $_}), ($b | Where {$a -NotContains $_})
}).TotalMilliseconds
(Measure-Command {
    $Count = @{}
    $a + $b | ForEach-Object {$Count[$_] += 1}
    $Count.Keys | Where-Object {$Count[$_] -eq 1}
}).TotalMilliseconds

(Measure-Command {
    $Count = @{}
    ForEach ($Item in $a + $b) {$Count[$Item] += 1}
    $Count.Keys.Where({$Count[$_] -eq 1})
}).TotalMilliseconds

[Int[]]$a = $a
[Int[]]$b = $b
(Measure-Command {
    [Int[]]([Linq.Enumerable]::Except($a, $b) + [Linq.Enumerable]::Except($b, $a))
}).TotalMilliseconds

Ansehen Compare-Object

Compare-Object $a1 $b1 | ForEach-Object { $_.InputObject }

Oder wenn Sie wissen möchten, wo das Objekt hingehört, schauen Sie sich SideIndicator an:

$a1=@(1,2,3,4,5,8)
$b1=@(1,2,3,4,5,6)
Compare-Object $a1 $b1

Versuchen:

$a1=@(1,2,3,4,5)
$b1=@(1,2,3,4,5,6)
(Compare-Object $a1 $b1).InputObject

Oder Sie können verwenden:

(Compare-Object $b1 $a1).InputObject

Die Reihenfolge spielt keine Rolle.

Ihre Ergebnisse sind nur dann hilfreich, wenn die Arrays zuerst sortiert werden. Um ein Array zu sortieren, führen Sie es über Sort-Object aus.

$x = @(5,1,4,2,3)
$y = @(2,4,6,1,3,5)

Compare-Object -ReferenceObject ($x | Sort-Object) -DifferenceObject ($y | Sort-Object)

Dies sollte helfen, verwendet einfache Hash-Tabelle.

$a1=@(1,2,3,4,5) $b1=@(1,2,3,4,5,6)


$hash= @{}

#storing elements of $a1 in hash
foreach ($i in $a1)
{$hash.Add($i, "present")}

#define blank array $c
$c = @()

#adding uncommon ones in second array to $c and removing common ones from hash
foreach($j in $b1)
{
if(!$hash.ContainsKey($j)){$c = $c+$j}
else {hash.Remove($j)}
}

#now hash is left with uncommon ones in first array, so add them to $c
foreach($k in $hash.keys)
{
$c = $c + $k
}