Jämförelseoperatorer används för att jämföra värden och returnerar resultatet som ett booleskt värde, det vill säga $true eller $false. De används ofta i villkorssatser (if-satser) och loopar, där resultatet av jämförelsen avgör vilken kod som ska köras.
Det här gör skriptet mer dynamiskt och responsivt, eftersom det kan fatta beslut baserat på jämförelser mellan värden.

Vanliga jämförelseoperatorer

Exempel

1. Kontrollera om två värden är lika:

$result = (5 -eq 5)
Write-Output $result

• Här jämförs värdet 5 med 5. Eftersom de är lika returnerar jämförelsen $true.
• När kommandot Write-Output $result körs visas True som utdata.

2. Kontrollera om två värden inte är lika:

$result = (5 -ne 3)
Write-Output $result

• Operatorn -ne betyder inte lika med (eng. not equal).
• Här jämförs värdet 5 med 3. Eftersom de inte är lika returnerar jämförelsen $true.
• I PowerShell returnerar själva jämförelsen det booleska värdet $true, inte bara texten True.
• När du sedan skriver ut resultatet med Write-Output, visas värdet på skärmen som True (utan dollartecken och med stor bokstav).

3. Jämföra tal

$greater = (8 -gt 5)
Write-Output $greater

• Variabeln $greater skapas och tilldelas resultatet av jämförelsen (8 -gt 5).
• Operatorn -gt betyder större än och jämför om värdet till vänster är större än värdet till höger.
• Eftersom 8 är större än 5 returnerar jämförelsen $true.
• När kommandot Write-Output $greater körs visas True som utdata.

$greaterOrEqual = (8 -ge 8)
Write-Output $greaterOrEqual

• Variabeln $greaterOrEqual skapas och tilldelas resultatet av jämförelsen (8 -ge 8).
• Operatorn -ge betyder större än eller lika med och kontrollerar om värdet till vänster är större än eller lika med värdet till höger.
• Eftersom 8 är lika med 8 returnerar jämförelsen $true.
• När kommandot Write-Output $greaterOrEqual körs visas True som utdata.

4. Kontrollera om ett värde finns i en lista:

$list = 1, 2, 3, 4, 5
$result = ($list -contains 3)
Write-Output $result

• Variabeln $list skapas och tilldelas en lista (array) med värdena 1, 2, 3, 4, 5.
• Uttrycket ($list -contains 3) kontrollerar om listan innehåller värdet 3.
• Operatorn -contains returnerar $true om det högra värdet finns i listan till vänster.
• Eftersom talet 3 finns i listan returnerar jämförelsen $true.
• När kommandot Write-Output $result körs visas True som utdata.

5. Jämföra strängar med wildcards:

$text = "Hello World"
$result = ($text -like "Hello*")
Write-Output $result

• Variabel $text skapas och tilldelas en strängen ”Hello World”
• Uttrycket ($text -like ”Hello*”) jämför innehållet i variabeln $text med mönstret ”Hello*”
• * fungerar som ett wildcard och betyder att alla tecken som följer efter  ”Hello” accepteras, oavsett vad de är.
• Resultatet av jämförelse lagras i variabeln $result
• När kommandot Write-Output $result körs visas True som utdata.

Direkta jämförelser på kommandoraden

Du kan också jämföra direkt utan att använda variabler:

1 -lt 2

• Utdata: True

1 -le 2

• Utdata: True

Wildcards och -like

Operatorn -like stöder wildcards för flexibel mönster jämförelse:

• * – matchar noll eller flera tecken
• ? – matchar exakt ett tecken
• [a-f] – matchar ett tecken i intervallet a–f

Exempel:

"Hej" -like "h?j"        # True
"Hej" -like "h[d-f]j"    # True
"Hej" -like "h[a,f]j"    # False

• ”Hej” -like ”h?j” ger True
  • Frågetecknet ? ersätter ett valfritt tecken.
  • Eftersom bokstaven e passar in mellan h och j, returnerar jämförelsen $true.
• ”Hej” -like ”h[d-f]j” ger True
  • Hakparenteserna [d-f] anger ett intervall av tillåtna tecken, i detta fall d, e eller f.
  • Bokstaven e finns inom det intervallet, så jämförelsen returnerar $true.
• ”Hej” -like ”h[a,f]j” ger False
• Hakparenteserna [a,f] anger specifika tillåtna tecken (a eller f).
• Bokstaven e finns inte bland dessa, därför returnerar jämförelsen $false.

Case-sensitive och case-insensitive jämförelser

Som standard är jämförelser i PowerShell inte skiftlägeskänsliga (case-insensitive).
Det betyder att ”hej” och ”Hej” betraktas som lika.

Om du vill göra jämförelsen case-sensitive (skiftlägeskänslig), lägger du till ett c framför operatorn, till exempel -clike eller -ceq.

• -like Jämförelse utan hänsyn till stora/små bokstäver
• -clike Jämförelse med hänsyn till stora/små bokstäver

Exempel på case-sensitive jämförelser

1) Matchning av exakt ord

$text = "PowerShell is powerful"
$result = $text -clike "*Shell*"
Write-Output $result

• Variabeln $text skapas och tilldelas strängen ”PowerShell is powerful”.
• Uttrycket $text -clike ”Shell” jämför texten med mönstret ”Shell”.
• Operatorn -clike fungerar som -like, men är skiftlägeskänslig (case-sensitive).
• Mönstret *Shell* betyder att ordet Shell måste förekomma exakt med samma stora och små bokstäver.
• Eftersom texten innehåller ”Shell” med samma skiftläge returnerar jämförelsen $true.
• När kommandot Write-Output $result körs visas True som utdata.

2) Wildcards och case-sensitive

$fruit = "apple"
$result = $fruit -clike "*P*"
Write-Output $result

• Variabeln $fruit skapas och tilldelas strängen ”apple”.
• Uttrycket $fruit -clike ”P” jämför texten med mönstret ”P”.
• Operatorn -clike är skiftlägeskänslig (case-sensitive), vilket betyder att stora och små bokstäver måste matcha exakt.
• Eftersom texten ”apple” endast innehåller ett litet p och inte ett stort P, returnerar jämförelsen $false.
• När kommandot Write-Output $result körs visas False som utdata.

3) Del av ord

$sentence = "The quick brown fox"
$result = $sentence -clike "*Quick*"
Write-Output $result

• Variabeln $sentence skapas och tilldelas strängen ”The quick brown fox”.
• Uttrycket $sentence -clike ”Quick” jämför texten med mönstret ”Quick”.
• Operatorn -clike är skiftlägeskänslig (case-sensitive), vilket betyder att stora och små bokstäver måste stämma exakt.
• Eftersom ordet ”quick” i texten börjar med ett litet q, medan mönstret använder ett stort Q, matchar de inte. Jämförelsen returnerar därför $false.
• När kommandot Write-Output $result körs visas False som utdata.