Om jämförelseoperatorer
Kort beskrivning
Beskriver de operatorer som jämför värden i PowerShell.
Lång beskrivning
Med jämförelseoperatorer kan du ange villkor för att jämföra värden och hitta värden som matchar angivna mönster. Om du vill använda en jämförelseoperator anger du de värden som du vill jämföra tillsammans med en operator som separerar dessa värden.
PowerShell innehåller följande jämförelseoperatorer:
| Typ | Operatorer | Description |
|---|---|---|
| Likhet | -Eq | lika med |
| -Ne | är inte lika med | |
| -Gt | större än | |
| -ge | större än eller lika med | |
| -Lt | mindre än | |
| -Le | mindre än eller lika med | |
| Matching | -like | Returnerar true när strängen matchar jokertecken |
| Mönster | ||
| -notlike | Returnerar sant när strängen inte matchar | |
| jokerteckenmönster | ||
| -Matcha | Returnerar true när strängen matchar regex | |
| Mönster; $matches innehåller matchande strängar | ||
| -notmatch | Returnerar sant när strängen inte matchar | |
| regex-mönster; $matches innehåller matchning | ||
| strängar | ||
| Behållare | -Innehåller | Returnerar true när referensvärdet finns |
| i en samling | ||
| -notcontains | Returnerar true när referensvärdet inte är | |
| som finns i en samling | ||
| -I | Returnerar true när testvärdet finns i en | |
| samling | ||
| -notin | Returnerar true när testvärdet inte finns | |
| i en samling | ||
| Ny funktion | -Ersätta | Ersätter ett strängmönster |
| Typ | -Är | Returnerar sant om båda objekten är samma |
| typ | ||
| -isnot | Returnerar sant om objekten inte är samma | |
| typ |
Som standard är alla jämförelseoperatorer skiftlägesokänsliga. Om du vill göra en jämförelseoperator skiftlägeskänslig föregår du operatornamnet med en c. Den skiftlägeskänsliga versionen av -eq är -ceqtill exempel . Om du vill göra skiftlägeskänsligheten explicit föregår du operatorn med en i. Den uttryckligen skiftlägeskänsliga versionen av -eq är -ieqtill exempel .
När indata till en operator är ett skalärt värde returnerar jämförelseoperatorer ett booleskt värde. När indata är en samling värden returnerar jämförelseoperatorerna eventuella matchande värden. Om det inte finns några matchningar i en samling returnerar jämförelseoperatorerna en tom matris.
PS> (1, 2 -eq 3).GetType().FullName
System.Object[]
Undantagen är inneslutningsoperatorerna, Operatorerna In och typoperatorerna, som alltid returnerar ett booleskt värde.
Anteckning
Om du behöver jämföra ett värde $null med bör du placera $null på vänster sida av jämförelsen. När du jämför med $null ett objekt[] är resultatet Falskt eftersom jämförelseobjektet är en matris. När du jämför en matris $nullmed filtrerar jämförelsen bort alla $null värden som lagras i matrisen. Exempel:
PS> $null -ne $null, "hello"
True
PS> $null, "hello" -ne $null
hello
Likhetsoperatorer
Likhetsoperatorerna (-eq, -ne) returnerar värdet TRUE eller matchar när ett eller flera av indatavärdena är identiska med det angivna mönstret. Hela mönstret måste matcha ett helt värde.
Exempel:
-Eq
Beskrivning: Lika med. Innehåller ett identiskt värde.
Exempel:
PS> 2 -eq 2
True
PS> 2 -eq 3
False
PS> 1,2,3 -eq 2
2
PS> "abc" -eq "abc"
True
PS> "abc" -eq "abc", "def"
False
PS> "abc", "def" -eq "abc"
abc
-Ne
Beskrivning: Inte lika med. Innehåller ett annat värde.
Exempel:
PS> "abc" -ne "def"
True
PS> "abc" -ne "abc"
False
PS> "abc" -ne "abc", "def"
True
PS> "abc", "def" -ne "abc"
def
-Gt
Beskrivning: Större än.
Exempel:
PS> 8 -gt 6
True
PS> 7, 8, 9 -gt 8
9
Anteckning
Detta bör inte förväxlas med >, operatorn större än i många andra programmeringsspråk. I PowerShell > används för omdirigering. Mer information finns i About_redirection.
-ge
Beskrivning: Större än eller lika med.
Exempel:
PS> 8 -ge 8
True
PS> 7, 8, 9 -ge 8
8
9
-Lt
Beskrivning: Mindre än.
Exempel:
PS> 8 -lt 6
False
PS> 7, 8, 9 -lt 8
7
-Le
Beskrivning: Mindre än eller lika med.
Exempel:
PS> 6 -le 8
True
PS> 7, 8, 9 -le 8
7
8
Matchande operatorer
Operatorerna like (-like och -notlike) hittar element som matchar eller inte matchar ett angivet mönster med jokerteckenuttryck.
Syntax:
<string[]> -like <wildcard-expression>
<string[]> -notlike <wildcard-expression>
Matchningsoperatorerna (-match och -notmatch) hittar element som matchar eller inte matchar ett angivet mönster med hjälp av reguljära uttryck.
Matchningsoperatorerna fyller i den $Matches automatiska variabeln när indata (argumentet på vänster sida) till operatorn är ett enda skalärt objekt. När indata är skalär -match returnerar operatorerna och -notmatch ett booleskt värde och anger värdet för den $Matches automatiska variabeln till de matchade komponenterna i argumentet.
Syntax:
<string[]> -match <regular-expression>
<string[]> -notmatch <regular-expression>
-like
Beskrivning: Matcha med jokertecknet (*).
Exempel:
PS> "PowerShell" -like "*shell"
True
PS> "PowerShell", "Server" -like "*shell"
PowerShell
-notlike
Beskrivning: Matchar inte med jokertecknet (*).
Exempel:
PS> "PowerShell" -notlike "*shell"
False
PS> "PowerShell", "Server" -notlike "*shell"
Server
-Matcha
Beskrivning: Matchar en sträng med reguljära uttryck. När indata är skalär fyller den i den $Matches automatiska variabeln.
Om indata är en samling -match returnerar operatorerna och -notmatch matchande medlemmar i samlingen, men operatorn fyller inte i variabeln $Matches .
Följande kommando skickar till exempel en samling strängar till operatorn -match . Operatorn -match returnerar objekten i samlingen som matchar. Den fyller inte i den $Matches automatiska variabeln.
PS> "Sunday", "Monday", "Tuesday" -match "sun"
Sunday
PS> $Matches
PS>
Följande kommando skickar däremot en enda sträng till operatorn -match . Operatorn -match returnerar ett booleskt värde och fyller i den $Matches automatiska variabeln. Den $Matches automatiska variabeln är en hashtable. Om ingen gruppering eller avbildning används fylls bara en nyckel i.
Nyckeln 0 representerar all text som matchades. Mer information om hur du grupperar och samlar in med reguljära uttryck finns i about_Regular_Expressions.
PS> "Sunday" -match "sun"
True
PS> $Matches
Name Value
---- -----
0 Sun
Observera att hashtabellen $Matches endast innehåller den första förekomsten av matchande mönster.
PS> "Banana" -match "na"
True
PS> $Matches
Name Value
---- -----
0 na
Viktigt
Nyckeln 0 är ett heltal. Du kan använda valfri Hashtable-metod för att komma åt det lagrade värdet.
PS> "Good Dog" -match "Dog"
True
PS> $Matches[0]
Dog
PS> $Matches.Item(0)
Dog
PS> $Matches.0
Dog
Operatorn -notmatch fyller i den $Matches automatiska variabeln när indata är skalär och resultatet är Falskt, att det, när den identifierar en matchning.
PS> "Sunday" -notmatch "rain"
True
PS> $matches
PS>
PS> "Sunday" -notmatch "day"
False
PS> $matches
Name Value
---- -----
0 day
-notmatch
Beskrivning: Matchar inte en sträng. Använder reguljära uttryck. När indata är skalär fyller den i den $Matches automatiska variabeln.
Exempel:
PS> "Sunday" -notmatch "sun"
False
PS> $matches
Name Value
---- -----
0 sun
PS> "Sunday", "Monday" -notmatch "sun"
Monday
Inneslutningsoperatorer
Inneslutningsoperatorerna (-contains och -notcontains) liknar likhetsoperatorerna. Inneslutningsoperatorerna returnerar dock alltid ett booleskt värde, även om indata är en samling.
Till skillnad från likhetsoperatorerna returnerar inneslutningsoperatorerna också ett värde så snart de identifierar den första matchningen. Likhetsoperatorerna utvärderar alla indata och returnerar sedan alla matchningar i samlingen.
-Innehåller
Beskrivning: Inneslutningsoperator. Anger om en samling referensvärden innehåller ett enda testvärde. Returnerar alltid ett booleskt värde. Returnerar endast TRUE när testvärdet exakt matchar minst ett av referensvärdena.
När testvärdet är en samling använder operatorn Contains referensjämlikhet. Den returnerar endast TRUE när ett av referensvärdena är samma instans av testvärdeobjektet.
I en mycket stor samling returnerar operatorn -contains resultat snabbare än operatorn lika med.
Syntax:
<Reference-values> -contains <Test-value>
Exempel:
PS> "abc", "def" -contains "def"
True
PS> "Windows", "PowerShell" -contains "Shell"
False #Not an exact match
# Does the list of computers in $DomainServers include $ThisComputer?
PS> $DomainServers -contains $thisComputer
True
PS> "abc", "def", "ghi" -contains "abc", "def"
False
PS> $a = "abc", "def"
PS> "abc", "def", "ghi" -contains $a
False
PS> $a, "ghi" -contains $a
True
-notcontains
Beskrivning: Inneslutningsoperator. Anger om en samling referensvärden innehåller ett enda testvärde. Returnerar alltid ett booleskt värde. Returnerar TRUE när testvärdet inte är en exakt matchning för minst ett av referensvärdena.
När testvärdet är en samling använder NotContains-operatorn referensjämlikhet.
Syntax:
<Reference-values> -notcontains <Test-value>
Exempel:
PS> "Windows", "PowerShell" -notcontains "Shell"
True #Not an exact match
# Get cmdlet parameters, but exclude common parameters
function get-parms ($cmdlet)
{
$Common = "Verbose", "Debug", "WarningAction", "WarningVariable",
"ErrorAction", "ErrorVariable", "OutVariable", "OutBuffer"
$allparms = (Get-Command $Cmdlet).parametersets |
foreach {$_.Parameters} |
foreach {$_.Name} | Sort-Object | Get-Unique
$allparms | where {$Common -notcontains $_ }
}
# Find unapproved verbs in the functions in my module
PS> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS> $myVerbs | where {$ApprovedVerbs -notcontains $_}
ForEach
Sort
Tee
Where
-I
Beskrivning: I operator. Anger om ett testvärde visas i en samling referensvärden. Returnera alltid som booleskt värde. Returnerar endast TRUE när testvärdet exakt matchar minst ett av referensvärdena.
När testvärdet är en samling använder In-operatorn referensjämlikhet. Den returnerar endast TRUE när ett av referensvärdena är samma instans av testvärdeobjektet.
Operatorn -in introducerades i PowerShell 3.0.
Syntax:
<Test-value> -in <Reference-values>
Exempel:
PS> "def" -in "abc", "def"
True
PS> "Shell" -in "Windows", "PowerShell"
False #Not an exact match
PS> "Windows" -in "Windows", "PowerShell"
True #An exact match
PS> "Windows", "PowerShell" -in "Windows", "PowerShell", "ServerManager"
False #Using reference equality
PS> $a = "Windows", "PowerShell"
PS> $a -in $a, "ServerManager"
True #Using reference equality
# Does the list of computers in $DomainServers include $ThisComputer?
PS> $thisComputer -in $domainServers
True
-notin
Beskrivning: Anger om ett testvärde visas i en samling referensvärden. Returnerar alltid ett booleskt värde. Returnerar TRUE när testvärdet inte är en exakt matchning för minst ett av referensvärdena.
När testvärdet är en samling använder In-operatorn referensjämlikhet. Den returnerar endast TRUE när ett av referensvärdena är samma instans av testvärdeobjektet.
Operatorn -notin introducerades i PowerShell 3.0.
Syntax:
<Test-value> -notin <Reference-values>
Exempel:
PS> "def" -notin "abc", "def"
False
PS> "ghi" -notin "abc", "def"
True
PS> "Shell" -notin "Windows", "PowerShell"
True #Not an exact match
PS> "Windows" -notin "Windows", "PowerShell"
False #An exact match
# Find unapproved verbs in the functions in my module
PS> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS> $MyVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS> $MyVerbs | where {$_ -notin $ApprovedVerbs}
ForEach
Sort
Tee
Where
Ersättningsoperator
Operatorn -replace ersätter hela eller delar av ett värde med det angivna värdet med hjälp av reguljära uttryck. Du kan använda operatorn -replace för många administrativa uppgifter, till exempel att byta namn på filer. Följande kommando ändrar till exempel filnamnstilläggen för alla .txt filer till .log:
Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace '\.txt$','.log' }
Syntaxen för operatorn -replace är följande, där <original> platshållaren representerar de tecken som ska ersättas och <substitute> platshållaren representerar de tecken som ska ersätta dem:
<input> <operator> <original>, <substitute>
Som standard är operatorn -replace skiftlägesokänslig. Om du vill göra det skiftlägeskänsligt använder du -creplace. Om du vill göra det uttryckligen skiftlägesokänsligt använder du -ireplace.
Överväg följande exempel:
PS> "book" -replace "B", "C"
Cook
"book" -ireplace "B", "C"
Cook
"book" -creplace "B", "C"
book
Du kan också använda reguljära uttryck för att dynamiskt ersätta text med hjälp av insamlingsgrupper och ersättningar. Mer information finns i about_Regular_Expressions.
ScriptBlock-ersättningar
Från och med PowerShell 6 kan du använda ett ScriptBlock-argument för ersättningstexten . ScriptBlock körs för varje matchning som finns i indatasträngen.
I ScriptBlock använder du den $_ automatiska variabeln för att referera till det aktuella objektet System.Text.RegularExpressions.Match . Match-objektet ger dig åtkomst till den aktuella indatatexten som ersätts, samt annan användbar information.
Det här exemplet ersätter varje sekvens med tre decimaler med teckenmotsvarigheten. ScriptBlock körs för varje uppsättning med tre decimaler som måste ersättas.
PS> "072101108108111" -replace "\d{3}", {[char][int]$_.Value}
Hello
Typjämförelse
Typjämförelseoperatorerna (-is och -isnot) används för att avgöra om ett objekt är en viss typ.
-Är
Syntax:
<object> -is <type reference>
Exempel:
PS> $a = 1
PS> $b = "1"
PS> $a -is [int]
True
PS> $a -is $b.GetType()
False
-isnot
Syntax:
<object> -isnot <type reference>
Exempel:
PS> $a = 1
PS> $b = "1"
PS> $a -isnot $b.GetType()
True
PS> $b -isnot [int]
True