about_Comparison_Operators
Kort beskrivning
Jämförelseoperatorerna i PowerShell kan antingen jämföra två värden eller filtrera element i en samling med ett indatavärde.
Lång beskrivning
Med jämförelseoperatorer kan du jämföra värden eller hitta värden som matchar angivna mönster. PowerShell innehåller följande jämförelseoperatorer:
Jämställdhet
-eq,-ieq,-ceq- är lika med-ne,-ine,-cne- är inte lika med-gt,-igt,-cgt- större än-ge,-ige,-cge- större än eller lika med-lt,-ilt,-clt- mindre än-le,-ile,-cle- mindre än eller lika med
Matchning
-like,-ilike,-clike- sträng matchar jokerteckenmönster-notlike,-inotlike,-cnotlike- strängen matchar inte jokerteckenmönstret-match,-imatch,-cmatch- sträng matchar regex-mönster-notmatch,-inotmatch,-cnotmatch– strängen matchar inte regex-mönster
Ersättning
-replace,-ireplace,-creplace- ersätter strängar som matchar ett regex-mönster
Inneslutning
-contains,-icontains,-ccontains- samlingen innehåller ett värde-notcontains,-inotcontains,-cnotcontains– samlingen innehåller inget värde-in- värdet finns i en samling-notin- värdet finns inte i en samling
Typ
-is– båda objekten är av samma typ-isnot– objekten är inte av samma typ
Vanliga funktioner
Strängjämförelser är skiftlägeskänsliga om du inte använder den explicita skiftlägeskänsliga operatorn. Om du vill göra en jämförelseoperator skiftlägeskänslig lägger du till en c efter -. Är till exempel -ceq den skiftlägeskänsliga versionen av -eq.
Om du vill göra skiftlägeskänslighet explicit lägger du till en i efter -. Är till exempel -ieq den uttryckligen skiftlägeskänsliga versionen av -eq.
Strängjämförelser använder InvariantCulture för både skiftlägeskänsliga och skiftlägesokänsliga jämförelser. Jämförelserna är mellan unicode-kodpunkter och använder inte kulturspecifik sorteringsordning. Resultaten är desamma oavsett aktuell kultur.
När indata för en operator är ett skalärt värde returnerar operatorn ett booleskt värde. När indata är en samling returnerar operatorn elementen i samlingen som matchar uttryckets högra värde. Om det inte finns några matchningar i samlingen returnerar jämförelseoperatorerna en tom matris. Till exempel:
$a = (1, 2) -eq 3
$a.GetType().Name
$a.Count
Object[]
0
Det finns några undantag:
- Operatorerna containment och typ returnerar alltid ett booleskt värde
- Operatorn
-replacereturnerar ersättningsresultatet - Operatorerna
-matchoch-notmatchfyller även i den$Matchesautomatiska variabeln såvida inte den vänstra sidan av uttrycket är en samling.
Likhetsoperatorer
-eq och -ne
När den vänstra sidan är skalär -eq , returnerar Sant om den högra sidan är likvärdig, annars -eq returnerar False. -ne gör motsatsen. den returnerar False när båda sidor är likvärdiga. Annars -ne returneras True.
Exempel:
2 -eq 2 # Output: True
2 -eq 3 # Output: False
"abc" -eq "abc" # Output: True
"abc" -eq "abc", "def" # Output: False
"abc" -ne "def" # Output: True
"abc" -ne "abc" # Output: False
"abc" -ne "abc", "def" # Output: True
När den vänstra sidan är en samling -eq returnerar de medlemmar som matchar den högra sidan, samtidigt -ne som de filtreras bort.
Exempel:
1,2,3 -eq 2 # Output: 2
"abc", "def" -eq "abc" # Output: abc
"abc", "def" -ne "abc" # Output: def
Dessa operatorer bearbetar alla element i samlingen. Exempel:
"zzz", "def", "zzz" -eq "zzz"
zzz
zzz
Likhetsoperatorn kan jämföra objekt av olika typer. Det är viktigt att förstå att värdet till höger i jämförelsen kan konverteras till typen av det vänstra värdet för jämförelse.
Strängen '1.0' konverteras till exempel till ett heltal för att jämföras med värdet 1. Det här exemplet returnerar True.
PS> 1 -eq '1.0'
True
I det här exemplet konverteras värdet 1 till en sträng som ska jämföras med strängen '1.0'. Det här exemplet returnerar False.
PS> '1.0' -eq 1
False
Likhetsoperatorerna accepterar två objekt, inte bara en skalär eller samling. Men jämförelseresultatet är inte garanterat meningsfullt för slutanvändaren. I följande exempel visas problemet.
class MyFileInfoSet {
[String]$File
[Int64]$Size
}
$a = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$b = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$a -eq $b
False
I det här exemplet skapade vi två objekt med identiska egenskaper. Ändå är likhetstestresultatet Falskt eftersom de är olika objekt. Om du vill skapa jämförbara klasser måste du implementera System.IEquatable<T> i din klass. I följande exempel visas den partiella implementeringen av en MyFileInfoSet-klass som implementerar System.IEquatable<T> och har två egenskaper, Fil och storlek. Metoden Equals() returnerar True om egenskaperna Arkiv och Storlek för två MyFileInfoSet-objekt är desamma.
class MyFileInfoSet : System.IEquatable[Object] {
[String]$File
[Int64]$Size
[bool] Equals([Object] $obj) {
return ($this.File -eq $obj.File) -and ($this.Size -eq $obj.Size)
}
}
$a = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$b = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$a -eq $b
True
Ett framträdande exempel på att jämföra godtyckliga objekt är att ta reda på om de är null. Men om du behöver avgöra om en variabel är $nullmåste du lägga $null till vänster i likhetsoperatorn. Att lägga det på höger sida gör inte vad du förväntar dig.
Låt till $a exempel vara en matris som innehåller null-element:
$a = 1, 2, $null, 4, $null, 6
Följande tester är $a inte null.
$null -ne $a
True
Följande filer ut alla null-element från $a:
$a -ne $null # Output: 1, 2, 4, 6
1
2
4
6
-gt, -ge, -lt och -le
-gt, -ge, -ltoch -le beter sig på liknande sätt. När båda sidor är skalär returnerar de Sant eller Falskt beroende på hur de två sidorna jämför:
| Operator | Returnerar Sant när... |
|---|---|
-gt |
Den vänstra sidan är större |
-ge |
Vänster sida är större eller lika med |
-lt |
Den vänstra sidan är mindre |
-le |
Den vänstra sidan är mindre eller lika med |
I följande exempel returnerar alla instruktioner True.
8 -gt 6 # Output: True
8 -ge 8 # Output: True
6 -lt 8 # Output: True
8 -le 8 # Output: True
Kommentar
I de flesta programmeringsspråk är >operatorn större än . I PowerShell används det här tecknet för omdirigering. Mer information finns i about_Redirection.
När den vänstra sidan är en samling jämför dessa operatorer varje medlem i samlingen med höger sida. Beroende på deras logik behåller eller tar de bort medlemmen.
Exempel:
$a=5, 6, 7, 8, 9
Write-Output "Test collection:"
$a
Write-Output "`nMembers greater than 7"
$a -gt 7
Write-Output "`nMembers greater than or equal to 7"
$a -ge 7
Write-Output "`nMembers smaller than 7"
$a -lt 7
Write-Output "`nMembers smaller than or equal to 7"
$a -le 7
Test collection:
5
6
7
8
9
Members greater than 7
8
9
Members greater than or equal to 7
7
8
9
Members smaller than 7
5
6
Members smaller than or equal to 7
5
6
7
Dessa operatorer fungerar med alla klasser som implementerar System.IComparable.
Exempel:
# Date comparison
[DateTime]'2001-11-12' -lt [DateTime]'2020-08-01' # True
# Sorting order comparison
'a' -lt 'z' # True; 'a' comes before 'z'
'macOS' -ilt 'MacOS' # False
'MacOS' -ilt 'macOS' # False
'macOS' -clt 'MacOS' # True; 'm' comes before 'M'
Följande exempel visar att det inte finns någon symbol på ett amerikanskt QWERTY-tangentbord som sorteras efter "a". Den matar en uppsättning som innehåller alla sådana symboler till operatorn -gt för att jämföra dem med "a". Utdata är en tom matris.
$a=' ','`','~','!','@','#','$','%','^','&','*','(',')','_','+','-','=',
'{','}','[',']',':',';','"','''','\','|','/','?','.','>',',','<'
$a -gt 'a'
# Output: Nothing
Om de två sidorna av operatörerna inte är rimligt jämförbara uppstår ett icke-avslutande fel för dessa operatorer.
Matchande operatorer
Matchande operatorer (-like, -notlike, -matchoch -notmatch) hittar element som matchar eller inte matchar ett angivet mönster. Mönstret för -like och är ett jokerteckenuttryck (som innehåller *, ?och [ ]), medan -match och -notmatch accepterar ett reguljärt uttryck (Regex-notlike).
Syntax:
<string[]> -like <wildcard-expression>
<string[]> -notlike <wildcard-expression>
<string[]> -match <regular-expression>
<string[]> -notmatch <regular-expression>
När indata för dessa operatorer är ett skalärt värde returnerar de ett booleskt värde.
När indata är en samling värden konverteras varje objekt i samlingen till en sträng för jämförelse. Operatorerna -match och -notmatch returnerar matchande respektive icke-matchande medlemmar. Operatorerna -like och -notlike returnerar dock medlemmarna som strängar. Strängen som returneras för en medlem i samlingen av -like och -notlike är strängen som operatorn använde för jämförelsen och hämtas genom att användaren castas till en sträng.
-like och -notlike
-like och -notlike beter sig på samma sätt som -eq och -ne, men den högra sidan kan vara en sträng som innehåller jokertecken.
Exempel:
"PowerShell" -like "*shell" # Output: True
"PowerShell" -notlike "*shell" # Output: False
"PowerShell" -like "Power?hell" # Output: True
"PowerShell" -notlike "Power?hell" # Output: False
"PowerShell" -like "Power[p-w]hell" # Output: True
"PowerShell" -notlike "Power[p-w]hell" # Output: False
"PowerShell", "Server" -like "*shell" # Output: PowerShell
"PowerShell", "Server" -notlike "*shell" # Output: Server
-match och -notmatch
-match och -notmatch använd reguljära uttryck för att söka efter mönster i värdena på vänster sida. Reguljära uttryck kan matcha komplexa mönster som e-postadresser, UNC-sökvägar eller formaterade telefonnummer. Strängen på höger sida måste följa reglerna för reguljära uttryck.
Skalära exempel:
# Partial match test, showing how differently -match and -like behave
"PowerShell" -match 'shell' # Output: True
"PowerShell" -like 'shell' # Output: False
# Regex syntax test
"PowerShell" -match '^Power\w+' # Output: True
'bag' -notmatch 'b[iou]g' # Output: True
Om indata är en samling returnerar operatorerna matchande medlemmar i samlingen.
Samlingsexempel:
"PowerShell", "Super PowerShell", "Power's hell" -match '^Power\w+'
# Output: PowerShell
"Rhell", "Chell", "Mel", "Smell", "Shell" -match "hell"
# Output: Rhell, Chell, Shell
"Bag", "Beg", "Big", "Bog", "Bug" -match 'b[iou]g'
#Output: Big, Bog, Bug
"Bag", "Beg", "Big", "Bog", "Bug" -notmatch 'b[iou]g'
#Output: Bag, Beg
-match och -notmatch stöder regex capture-grupper. Varje gång de körs på skalär indata och -match resultatet är Sant, eller -notmatch om resultatet är Falskt, skriver de över den $Matches automatiska variabeln. $Matches är en hashtable som alltid har en nyckel med namnet "0", som lagrar hela matchningen.
Om det reguljära uttrycket innehåller insamlingsgrupper innehåller det $Matches ytterligare nycklar för varje grupp.
Observera att hashtabellen $Matches endast innehåller den första förekomsten av matchande mönster.
Exempel:
$string = 'The last logged on user was CONTOSO\jsmith'
$string -match 'was (?<domain>.+)\\(?<user>.+)'
$Matches
Write-Output "`nDomain name:"
$Matches.domain
Write-Output "`nUser name:"
$Matches.user
True
Name Value
---- -----
domain CONTOSO
user jsmith
0 was CONTOSO\jsmith
Domain name:
CONTOSO
User name:
jsmith
När resultatet är Falskt eller resultatet är Sant, eller när indata är en samling, skrivs inte den $Matches automatiska variabeln över.-notmatch-match Därför innehåller den det tidigare angivna värdet, eller $null om variabeln inte har angetts. När du refererar efter att $Matches ha anropat en av dessa operatorer bör du kontrollera att variabeln har angetts av den aktuella operatorns anrop med hjälp av en villkorsinstrukation.
Exempel:
if ("<version>1.0.0</version>" -match '<version>(.*?)</version>') {
$Matches
}
Mer information finns i about_Regular_Expressions och about_Automatic_Variables.
Ersättningsoperator
Ersättning med reguljära uttryck
Precis som -matchanvänder operatorn -replace reguljära uttryck för att hitta det angivna mönstret. Men till skillnad från -matchersätter den matchningarna med ett annat angivet värde.
Syntax:
<input> -replace <regular-expression>, <substitute>
Operatorn 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 för många administrativa uppgifter, till exempel 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' }
Som standard är operatorn -replace skiftlägeskänslig. Om du vill göra det skiftlägeskänsligt använder du -creplace. Om du vill göra det uttryckligen skiftlägeskänsligt använder du -ireplace.
Exempel:
"book" -ireplace "B", "C" # Case insensitive
"book" -creplace "B", "C" # Case-sensitive; hence, nothing to replace
Cook
book
Från och med PowerShell 7.2 konverteras operanden till en sträng när den vänstra operanden i en -replace operator-instruktion inte är en sträng.
PowerShell utför en kulturokänslig strängkonvertering.
Om din kultur till exempel är inställd på franska (fr) är 1,2den kulturkänsliga strängkonverteringen av värdet 1.2 .
Före PowerShell 7.2:
PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
12
I PowerShell 7.2 och senare:
PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
1.2
Ersättningar för reguljära uttryck
Du kan också använda reguljära uttryck för att dynamiskt ersätta text med hjälp av insamlingsgrupper och ersättningar. Avbildningsgrupper kan refereras i strängen <substitute> med hjälp av dollartecknet ($) före gruppidentifieraren.
I följande exempel accepterar operatorn -replace ett användarnamn i form av DomainName\Username och konverterar till Username@DomainName formatet:
$SearchExp = '^(?<DomainName>[\w-.]+)\\(?<Username>[\w-.]+)$'
$ReplaceExp = '${Username}@${DomainName}'
'Contoso.local\John.Doe' -replace $SearchExp, $ReplaceExp
John.Doe@Contoso.local
Varning
Tecknet $ har syntaktiska roller i både PowerShell och reguljära uttryck:
- I PowerShell, mellan dubbla citattecken, anger den variabler och fungerar som en underuttrycksoperator.
- I Regex-söksträngar anger den slutet av raden.
- I Regex-ersättningssträngar anges insamlade grupper. Se till att antingen placera dina reguljära uttryck mellan enkla citattecken eller infoga ett backtick-tecken (
`) före dem.
Till exempel:
$1 = 'Goodbye'
'Hello World' -replace '(\w+) \w+', "$1 Universe"
# Output: Goodbye Universe
'Hello World' -replace '(\w+) \w+', '$1 Universe'
# Output: Hello Universe
$$ i Regex anger en literal $. Detta $$ i ersättningssträngen för att inkludera en literal $ i den resulterande ersättningen. Till exempel:
'5.72' -replace '(.+)', '$ $1' # Output: $ 5.72
'5.72' -replace '(.+)', '$$$1' # Output: $5.72
'5.72' -replace '(.+)', '$$1' # Output: $1
Mer information finns i about_Regular_Expressions och ersättningar i reguljära uttryck.
Ersätta i en samling
När operatorn <input> för operatorn -replace är en samling tillämpar PowerShell ersättningen på varje värde i samlingen. Till exempel:
"B1","B2","B3","B4","B5" -replace "B", 'a'
a1
a2
a3
a4
a5
Ersättning med ett skriptblock
I PowerShell 6 och senare accepterar operatorn -replace också ett skriptblock som utför ersättningen. Skriptblocket körs en gång för varje matchning.
Syntax:
<String> -replace <regular-expression>, {<Script-block>}
I skriptblocket använder du den $_ automatiska variabeln för att komma åt indatatexten som ersätts och annan användbar information. Den här variabelns klasstyp är System.Text.RegularExpressions.Match.
I följande exempel ersätts varje sekvens med tre siffror med teckenmotsvarigheterna. Skriptblocket körs för varje uppsättning med tre siffror som måste ersättas.
"072101108108111" -replace "\d{3}", {return [char][int]$_.Value}
Hello
Inneslutningsoperatorer
Inneslutningsoperatorerna (-contains, -notcontains, -inoch -notin) liknar likhetsoperatorerna, förutom att de alltid returnerar ett booleskt värde, även när indata är en samling. Dessa operatorer slutar jämföra så snart de upptäcker den första matchningen, medan likhetsoperatorerna utvärderar alla indatamedlemmar. I en mycket stor samling returnerar dessa operatorer snabbare än likhetsoperatorerna.
-contains och -notcontains
Syntax:
<Collection> -contains <scalar-object>
<Collection> -notcontains <scalar-object>
Dessa operatorer anger om en uppsättning innehåller ett visst element. -contains returnerar Sant när den högra sidan (scalar-object) matchar ett av elementen i uppsättningen. -notcontains returnerar False i stället.
Exempel:
"abc", "def" -contains "def" # Output: True
"abc", "def" -notcontains "def" # Output: False
"Windows", "PowerShell" -contains "Shell" # Output: False
"Windows", "PowerShell" -notcontains "Shell" # Output: True
"abc", "def", "ghi" -contains "abc", "def" # Output: False
"abc", "def", "ghi" -notcontains "abc", "def" # Output: True
Mer komplexa exempel:
$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
"ContosoDHCP","ContosoWSUS"
$thisComputer = "ContosoDC2"
$DomainServers -contains $thisComputer
# Output: True
När operand på höger sida är en samling konverterar dessa operatorer värdet till dess strängrepresentation innan de jämför det med samlingen på vänster sida.
$a = "abc", "def"
"abc", "def", "ghi" -contains $a # Output: False
# The following statements are equivalent
$a, "ghi" -contains $a # Output: True
"$a", "ghi" -contains $a # Output: True
"abc def", "ghi" -contains $a # Output: True
-in och -notin
Syntax:
<scalar-object> -in <Collection>
<scalar-object> -notin <Collection>
Operatorerna -in och -notin introducerades i PowerShell 3 som syntaktisk omvänd av operatorerna -contains och -notcontains . -in returnerar Sant när den vänstra sidan <scalar-object> matchar ett av elementen i samlingen. -notin returnerar False i stället.
Följande exempel gör samma sak som exemplen för -contains och -notcontains gör, men de skrivs med -in och -notin i stället.
"def" -in "abc", "def" # Output: True
"def" -notin "abc", "def" # Output: False
"Shell" -in "Windows", "PowerShell" # Output: False
"Shell" -notin "Windows", "PowerShell" # Output: True
"abc", "def" -in "abc", "def", "ghi" # Output: False
"abc", "def" -notin "abc", "def", "ghi" # Output: True
Mer komplexa exempel:
$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
"ContosoDHCP","ContosoWSUS"
$thisComputer = "ContosoDC2"
$thisComputer -in $DomainServers
# Output: True
När operand på vänster sida är en samling konverterar dessa operatorer värdet till dess strängrepresentation innan de jämför det med samlingen på höger sida.
$a = "abc", "def"
$a -in "abc", "def", "ghi" # Output: False
# The following statements are equivalent
$a -in $a, "ghi" # Output: True
$a -in "$a", "ghi" # Output: True
$a -in "abc def", "ghi" # Output: True
Typjämförelse
Typjämförelseoperatorerna (-is och -isnot) används för att avgöra om ett objekt är en viss typ.
Syntax:
<object> -is <type-reference>
<object> -isnot <type-reference>
Exempel:
$a = 1
$b = "1"
$a -is [int] # Output: True
$a -is $b.GetType() # Output: False
$b -isnot [int] # Output: True
$a -isnot $b.GetType() # Output: True
Se även
Feedback
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i: https://aka.ms/ContentUserFeedback.
Skicka och visa feedback för