about_Comparison_Operators
Rövid leírás
A PowerShell összehasonlító operátorai összehasonlíthatják a gyűjtemény két értékét, vagy szűrhetik a gyűjtemény elemeit egy bemeneti értékhez.
Hosszú leírás
Az összehasonlító operátorok segítségével összehasonlíthatja az értékeket, vagy megkeresheti a megadott mintáknak megfelelő értékeket. A PowerShell a következő összehasonlító operátorokat tartalmazza:
Egyenlőség
-eq,-ieq,-ceq- egyenlő-ne, ,-ine-cne- nem egyenlő-gt, ,-igt-cgt- nagyobb, mint-ge,-ige--cgenagyobb vagy egyenlő-lt,-ilt,-clt- kisebb, mint-le,-ile--clekisebb vagy egyenlő
Megfelelő
-like, ,-ilike-clike- a sztring egyezik a helyettesítő karaktermintával-notlike,-inotlike--cnotlikea sztring nem egyezik a helyettesítő karaktermintával-match, ,-imatch-cmatch- a sztring egyezik a regex mintával-notmatch,-inotmatch--cnotmatcha sztring nem egyezik a regex mintával
Csere
-replace, ,-ireplace-creplace- regex mintának megfelelő sztringeket cserél le
Elszigetelés
-contains,-icontains,-ccontains- a gyűjtemény egy értéket tartalmaz-notcontains,-inotcontains,-cnotcontains- a gyűjtemény nem tartalmaz értéket-in- az érték egy gyűjteményben van-notin- az érték nem gyűjteményben található
Típus
-is- mindkét objektum azonos típusú-isnot- az objektumok nem azonosak
Gyakori funkciók
A sztring-összehasonlítások nem érzékenyek a kis- és nagybetűkre, kivéve, ha a kis- és nagybetűket megkülönböztető operátort használja. Az összehasonlító operátor kis- és nagybetűk megkülönböztetéséhez adjon hozzá egyc.- Ilyen például -ceq a kis- és nagybetűk megkülönböztetése -eq.
A kis- és nagybetűk érzéketlenségének explicitvá tétele érdekében adjon hozzá egy utójelet i-. Például -ieq a kifejezetten kis- és nagybetűket nem érzékelyítő verziója -eq.
A sztring-összehasonlítások az InvariantCulture függvényt használják a kis- és nagybetűk megkülönböztetése szempontjából is. Az összehasonlítások Unicode-kódpontok között vannak, és nem használnak kultúraspecifikus rendezési sorrendet. Az eredmények a jelenlegi kultúrától függetlenül azonosak.
Ha egy operátor bemenete skaláris érték, az operátor logikai értéket ad vissza. Ha a bemenet gyűjtemény, az operátor a gyűjtemény azon elemeit adja vissza, amelyek megfelelnek a kifejezés jobb oldali értékének. Ha a gyűjteményben nincsenek egyezések, az összehasonlító operátorok üres tömböt adnak vissza. Példa:
$a = (1, 2) -eq 3
$a.GetType().Name
$a.Count
Object[]
0
Van néhány kivétel:
- Az elszigetelési és típus-operátorok mindig logikai értéket adnak vissza
- Az
-replaceoperátor visszaadja a csere eredményét - Az
-matchés-notmatchaz operátorok is feltöltik az$Matchesautomatikus változót, kivéve, ha a kifejezés bal oldala gyűjtemény.
Egyenlőségi operátorok
-eq és -ne
Ha a bal oldal skaláris, akkor igaz értéket ad vissza, -eq ha a jobb oldal egyenértékű, -eq ellenkező esetben hamis értéket ad vissza. -neaz ellenkezőjét teszi; Hamis értéket ad vissza, ha mindkét oldal egyenértékű; -ne ellenkező esetben igaz értéket ad vissza.
Példa:
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
Ha a bal oldali gyűjtemény, azokat a tagokat adja vissza, -eq amelyek megfelelnek a jobb oldalnak, és -ne kiszűri őket.
Példa:
1,2,3 -eq 2 # Output: 2
"abc", "def" -eq "abc" # Output: abc
"abc", "def" -ne "abc" # Output: def
Ezek az operátorok a gyűjtemény összes elemét feldolgozzák. Példa:
"zzz", "def", "zzz" -eq "zzz"
zzz
zzz
Az egyenlőség operátor különböző típusú objektumokat hasonlíthat össze. Fontos tisztában lenni azzal, hogy az összehasonlítás jobb oldalán lévő érték átalakítható a bal oldali érték típusára az összehasonlításhoz.
A sztring '1.0' például egész számmá alakul az értékhez 1viszonyítva. Ez a példa ad Truevissza .
PS> 1 -eq '1.0'
True
Ebben a példában az érték 1 sztringgé alakul, és sztringgel '1.0'lesz összehasonlítva. Ez a példa ad Falsevissza .
PS> '1.0' -eq 1
False
Az egyenlőségi operátorok két objektumot is elfogadnak, nem csak skalárt vagy gyűjteményt. Az összehasonlítási eredmény azonban nem garantáltan értelmezhető a végfelhasználó számára. Az alábbi példa a problémát mutatja be.
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
Ebben a példában két azonos tulajdonságokkal rendelkező objektumot hoztunk létre. Az egyenlőségi teszt eredménye azonban hamis , mert különböző objektumok. Hasonló osztályok létrehozásához a System.IEquatable T-t> kell implementálnia <az osztályban. Az alábbi példa egy Olyan MyFileInfoSet osztály részleges implementálását mutatja be, amely a System.IEquatable<T-t> implementálja, és két tulajdonsággal rendelkezik: Fájl és Méret. A Equals() metódus igaz értéket ad vissza, ha két MyFileInfoSet objektum fájl- és mérettulajdonsága megegyezik.
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
Az tetszőleges objektumok összehasonlítására jól látható példa, ha kiderül, hogy null értékűek-e. Ha azonban meg kell határoznia, hogy egy változó az-e $null, az egyenlőség operátor bal oldalán kell elhelyeznie $null . A jobb oldalon való elhelyezés nem azt teszi, amit vársz.
Tegyük fel például, hogy $a egy null elemet tartalmazó tömb:
$a = 1, 2, $null, 4, $null, 6
Az alábbi tesztek nem null értékűek $a .
$null -ne $a
True
A következők azonban az összes null elemet eltávolítják a következőből $a:
$a -ne $null # Output: 1, 2, 4, 6
1
2
4
6
-gt, -ge, -lt és -le
-gt, -ge, -ltés -le nagyon hasonlóan viselkedik. Ha mindkét oldal skaláris, a két oldal összehasonlítása alapján igaz vagy hamis értéket adnak vissza:
| Operátor | Igaz értéket ad vissza, ha... |
|---|---|
-gt |
A bal oldal nagyobb |
-ge |
A bal oldal nagyobb vagy egyenlő |
-lt |
A bal oldal kisebb |
-le |
A bal oldal kisebb vagy egyenlő |
Az alábbi példákban minden utasítás igaz értéket ad vissza.
8 -gt 6 # Output: True
8 -ge 8 # Output: True
6 -lt 8 # Output: True
8 -le 8 # Output: True
Feljegyzés
A legtöbb programozási nyelvben a nagyobb, mint az >operátor. A PowerShellben ezt a karaktert használja az átirányításhoz. További részletekért lásd: about_Redirection.
Ha a bal oldali gyűjtemény, ezek az operátorok összehasonlítják a gyűjtemény egyes részeit a jobb oldalival. A logikájuktól függően megtartják vagy elvetik a tagot.
Példa:
$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
Ezek az operátorok a System.IComparable-t implementáló osztályokkal működnek együtt.
Példák:
# 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'
Az alábbi példa azt mutatja be, hogy az amerikai QWERTY billentyűzeten nincs olyan szimbólum, amely az "a" után lesz rendezve. Egy olyan készletet táplál, amely az összes ilyen szimbólumot tartalmazza az operátor számára, -gt hogy összehasonlítsa őket az "a"-sel. A kimenet egy üres tömb.
$a=' ','`','~','!','@','#','$','%','^','&','*','(',')','_','+','-','=',
'{','}','[',']',':',';','"','''','\','|','/','?','.','>',',','<'
$a -gt 'a'
# Output: Nothing
Ha az operátorok két oldala nem összehasonlítható, akkor ezek az operátorok nem végződő hibát okoznak.
Egyező operátorok
Az egyező operátorok (-like, , és -match-notmatch) megkeresik azokat az elemeket, -notlikeamelyek megfelelnek egy adott mintának, vagy nem egyeznek. A minta -like-notlike egy helyettesítő kifejezés (amely tartalmaz *, ?és [ ]), és -match-notmatch elfogadja a reguláris kifejezést (Regex).
A szintaxis a következő:
<string[]> -like <wildcard-expression>
<string[]> -notlike <wildcard-expression>
<string[]> -match <regular-expression>
<string[]> -notmatch <regular-expression>
Ha az operátorok bemenete skaláris érték, logikai értéket adnak vissza.
Ha a bemenet értékgyűjtemény, a rendszer a gyűjtemény minden elemét karakterláncmá alakítja összehasonlítás céljából. Az -match operátorok -notmatch az egyező és a nem egyező tagokat is visszaadják. Az és -notlike az -like operátorok azonban sztringként adják vissza a tagokat. A gyűjtemény -like-notlike egy tagjának visszaadott sztring az összehasonlításhoz használt operátor, amelyet a rendszer a tag sztringre történő kiosztásával nyer ki.
-like és -notlike
-like és -notlike hasonlóan viselkedik, -eq mint és -ne, de a jobb oldalon lehet egy sztring, amely helyettesítő karaktereket tartalmaz.
Példa:
"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
-egyezés és -nem egyezés
-match és -notmatch használjon reguláris kifejezéseket a bal oldali értékek mintázatának kereséséhez. A reguláris kifejezések olyan összetett mintákat is tartalmazhatnak, mint az e-mail-címek, az UNC-elérési utak vagy a formázott telefonszámok. A jobb oldali sztringnek meg kell felelnie a reguláris kifejezések szabályainak .
Skaláris példák:
# 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
Ha a bemenet gyűjtemény, az operátorok a gyűjtemény egyező tagjait adják vissza.
Példák gyűjteményre:
"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 és -notmatch támogatja a regex rögzítési csoportokat. Minden alkalommal, amikor skaláris bemeneten futnak, és az eredmény Igaz, vagy az -notmatch eredmény hamis, felülírják az $Matches automatikus változót.-match $Matches egy olyan kivonatoló, amely mindig rendelkezik egy "0" nevű kulccsal, amely a teljes egyezést tárolja.
Ha a reguláris kifejezés rögzítési csoportokat tartalmaz, az $Matches egyes csoportokhoz további kulcsokat is tartalmaz.
Fontos megjegyezni, hogy a $Matches kivonatoló csak az egyező minták első előfordulását tartalmazza.
Példa:
$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
Ha az -match eredmény hamis, vagy az -notmatch eredmény Igaz, vagy ha a bemenet gyűjtemény, a rendszer nem írja felül az $Matches automatikus változót. Következésképpen a korábban beállított értéket fogja tartalmazni, vagy $null ha a változó nincs beállítva. Amikor az egyik operátor meghívása után hivatkozik $Matches , fontolja meg annak ellenőrzését, hogy a változót az aktuális operátor meghívása állította-e be egy feltételutasítás használatával.
Példa:
if ("<version>1.0.0</version>" -match '<version>(.*?)</version>') {
$Matches
}
További részletekért lásd: about_Regular_Expressions és about_Automatic_Variables.
Csere operátor
Csere normál kifejezésekkel
-replace Az operátor például -matchnormál kifejezésekkel keresi meg a megadott mintát. Ezzel ellentétben -matchazonban egy másik megadott értékre cseréli a találatokat.
Szintaxis:
<input> -replace <regular-expression>, <substitute>
Az operátor egy érték egészét vagy egy részét a megadott értékre cseréli reguláris kifejezések használatával. Az operátort számos felügyeleti feladathoz használhatja, például fájlok átnevezésével. A következő parancs például az összes .txt fájl fájlnévkiterjesztését a következőre .logmódosítja:
Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace '\.txt$','.log' }
Alapértelmezés szerint az -replace operátor nem érzékeny a kis- és nagybetűkre. A kis- és nagybetűk megkülönböztetéséhez használja a következőt -creplace: . A kis- és nagybetűk megkülönböztetéséhez használja a következőt -ireplace: .
Példák:
"book" -ireplace "B", "C" # Case insensitive
"book" -creplace "B", "C" # Case-sensitive; hence, nothing to replace
Cook
book
A PowerShell 7.2-től kezdve, amikor az operátori utasítás bal oldali operandusa -replace nem sztring, az operandus sztringgé alakul.
A PowerShell nem érzéketlen sztringátalakítást végez.
Ha például a kultúra francia (fr) értékre van állítva, akkor az érték 1.2 kultúraérzékeny sztring-konvertálása.1,2
A PowerShell 7.2 előtt:
PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
12
A PowerShell 7.2-ben és újabb verzióiban:
PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
1.2
Reguláris kifejezések helyettesítése
A reguláris kifejezések használatával dinamikusan lecserélheti a szöveget rögzítési csoportok és helyettesítések használatával. A rögzítési csoportok a sztringben a <substitute> dollárjel ($) karakterrel hivatkozhatók a csoportazonosító előtt.
Az alábbi példában DomainName\Username az -replace operátor egy felhasználónevet fogad el, és formátumra Username@DomainName konvertálja:
$SearchExp = '^(?<DomainName>[\w-.]+)\\(?<Username>[\w-.]+)$'
$ReplaceExp = '${Username}@${DomainName}'
'Contoso.local\John.Doe' -replace $SearchExp, $ReplaceExp
John.Doe@Contoso.local
Figyelmeztetés
A $ karakter szintaktikai szerepkörökhöz tartozik a PowerShellben és a reguláris kifejezésekben is:
- A PowerShellben a kettős idézőjelek között változókat jelöl ki, és alexpressziós operátorként működik.
- Regex keresési sztringekben a sor végét jelöli.
- Regex helyettesítési sztringekben rögzített csoportokat jelöl. Ügyeljen arra, hogy a reguláris kifejezéseket egyetlen idézőjel közé helyezze, vagy szúrjon be eléjük egy háttérjelet (
`).
Példa:
$1 = 'Goodbye'
'Hello World' -replace '(\w+) \w+', "$1 Universe"
# Output: Goodbye Universe
'Hello World' -replace '(\w+) \w+', '$1 Universe'
# Output: Hello Universe
$$ a Regex egy literálist $jelöl. Ez $$ a helyettesítési sztringben egy literális $ értéket tartalmaz az eredményül kapott cserében. Példa:
'5.72' -replace '(.+)', '$ $1' # Output: $ 5.72
'5.72' -replace '(.+)', '$$$1' # Output: $5.72
'5.72' -replace '(.+)', '$$1' # Output: $1
További információ: about_Regular_Expressions és helyettesítések a reguláris kifejezésekben.
Helyettesítés gyűjteményben
Ha az <input>-replace operátor egy gyűjtemény, a PowerShell a gyűjtemény minden értékére alkalmazza a cserét. Példa:
"B1","B2","B3","B4","B5" -replace "B", 'a'
a1
a2
a3
a4
a5
Csere szkriptblokkokkal
A PowerShell 6-os és újabb verzióiban az -replace operátor egy szkriptblokkot is elfogad, amely végrehajtja a cserét. A szkriptblokk minden egyezéshez egyszer fut.
Szintaxis:
<String> -replace <regular-expression>, {<Script-block>}
A szkriptblokkon belül használja az $_ automatikus változót a lecserélt szöveghez és más hasznos információkhoz való hozzáféréshez. Ennek a változónak az osztálytípusa System.Text.RegularExpressions.Match.
Az alábbi példa a három számjegyből álló sorozatokat lecseréli a karakteregyenértékekre. A szkriptblokk minden lecserélendő három számjegyből álló készlethez fut.
"072101108108111" -replace "\d{3}", {return [char][int]$_.Value}
Hello
Elszigetelési operátorok
Az elszigetelési operátorok (-contains, , -notcontainsés -in-notin) hasonlóak az egyenlőségi operátorokhoz, azzal a kivétellel, hogy mindig logikai értéket adnak vissza, még akkor is, ha a bemenet gyűjtemény. Ezek az operátorok az első egyezés észlelésekor leállnak az összehasonlítással, míg az egyenlőségi operátorok az összes bemeneti tagot kiértékelik. Egy nagyon nagy gyűjteményben ezek az operátorok gyorsabban térnek vissza, mint az egyenlőségi operátorok.
-contains and -notcontains
Szintaxis:
<Collection> -contains <scalar-object>
<Collection> -notcontains <scalar-object>
Ezek az operátorok azt jelzik, hogy egy készlet tartalmaz-e egy bizonyos elemet. -containsIgaz értéket ad vissza, ha a jobb oldali (skaláris objektum) egyezik a készlet egyik elemével. -notcontains Hamis értéket ad vissza.
Példák:
"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
Összetettebb példák:
$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
"ContosoDHCP","ContosoWSUS"
$thisComputer = "ContosoDC2"
$DomainServers -contains $thisComputer
# Output: True
Ha a jobb oldali operandus gyűjtemény, ezek az operátorok sztringre konvertálják az értéket, mielőtt összehasonlítanák a bal oldali gyűjteménysel.
$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 és -notin
Szintaxis:
<scalar-object> -in <Collection>
<scalar-object> -notin <Collection>
Az -in és -notin operátorok a PowerShell 3-ban lettek bevezetve az operátorok és -notcontains az -contains operátorok szintaktikai fordítottjaként. -inIgaz értéket ad vissza, ha a bal oldali <scalar-object> elem megegyezik a gyűjtemény egyik elemével. -notinHamis értéket ad vissza.
Az alábbi példák ugyanazt teszik, mint a példák, de a példákat -contains-notcontains a következővel -in-notin és helyette írják.
"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
Összetettebb példák:
$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
"ContosoDHCP","ContosoWSUS"
$thisComputer = "ContosoDC2"
$thisComputer -in $DomainServers
# Output: True
Ha a bal oldali operandus gyűjtemény, ezek az operátorok sztringre konvertálják az értéket, mielőtt összehasonlítanák a jobb oldali gyűjteménysel.
$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
Típus összehasonlítása
A típus-összehasonlító operátorok (-is és -isnot) segítségével állapítható meg, hogy egy objektum egy adott típus-e.
Szintaxis:
<object> -is <type-reference>
<object> -isnot <type-reference>
Példa:
$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
Lásd még
Visszajelzés
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ: https://aka.ms/ContentUserFeedback.
Visszajelzés küldése és megtekintése a következőhöz: