az összehasonlító operátorokról

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- -cge nagyobb vagy egyenlő
• -lt, -ilt, -clt - kisebb, mint
• -le, -ile- -cle kisebb vagy egyenlő

Megfelelő

• -like, , -ilike-clike - a sztring egyezik a helyettesítő karaktermintával
• -notlike, -inotlike- -cnotlike a sztring nem egyezik a helyettesítő karaktermintával
• -match, , -imatch-cmatch - a sztring egyezik a regex mintával
• -notmatch, -inotmatch- -cnotmatch a sztring nem egyezik a regex mintával

Helyettesítés

• -replace, , -ireplace-creplace - megkeresi és lecseréli a regex mintának megfelelő sztringeket

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, -iin, -cin – az érték egy gyűjteményben található
• -notin, -inotin, -cnotin – 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 az összehasonlító kifejezés bal oldali értéke skaláris érték, az operátor logikai értéket ad vissza. Ha a kifejezés bal oldali értéke gyűjtemény, az operátor a gyűjtemény azon elemeit adja vissza, amelyek megfelelnek a kifejezés jobb oldali értékének. A jobb oldali értékek mindig egyetlen példányként vannak kezelve, még akkor is, ha gyűjtemények. Az összehasonlító operátorok nem tudják hatékonyan összehasonlítani a gyűjteményeket a gyűjteményekkel.

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 -replace operátor visszaadja a csere eredményét
• Az -match és -notmatch az operátorok is feltöltik az $Matches automatikus 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ű, ellenkező esetben hamis-eqvissza. -neaz ellenkezőjét teszi; Hamis értéket ad vissza, ha mindkét oldal egyenértékű; ellenkező esetben igaz-nevissza.

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<>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 -notlike-match) megkeresik azokat az elemeket, -notmatchamelyek 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 regex regex kifejezést.

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 -like az -notlike 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

A legjobb eredmény érdekében az operátorok jobb -like oldalán -notlike egy helyettesítő karaktert tartalmazó sztringkonstansnak kell lennie. A PowerShell átadja a helyettesítő kifejezést a helyettesítő kifejezés elemzőjének. A helyettesítő karakterek (*vagy ?[ ]) egyikének egyezéséhez egy háttérkarakterek (`) karakterrel kell feloldania. Ha például egy konstansnak ?egyezik, használja `? a helyettesítő karaktert. Ha kibontható karakterlánc-kifejezést használ, a PowerShell kibontja a sztringet, mielőtt átadnák a helyettesítő karakterelemzőnek, ami azt eredményezi, hogy a kód nélküli karakterek helyettesítő karakterekként lesznek elküldve.

# Escaped literals in an expandable string
PS> "f`?`?"
f??
# Escaped literals in a literal string
PS> 'f`?`?'
f`?`?
# Comparison containing 2 wildcards
PS> 'f??' -like 'f??'
True
PS> 'for' -like 'f??'
True
# Comparison containing literal '?' characters
PS> 'f??' -like 'f`?`?'
True
PS> 'for' -like 'f`?`?'
False

-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 -match eredmény hamis, felülírják az -notmatch automatikus változót.$Matches $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

-match Az operátor például -replacenormá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 -replace az DomainName\Username 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 szkriptblokkkal

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 három számjegyből álló készletnél fut, amelyet cserélni kell.

'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.

-tartalmazza és -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 -contains az -notcontains 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

• a_Booleanokról
• a_Operátorokról
• a reguláris kifejezésekről
• a Wildcards fájlról
• Objektum összehasonlítása
• ForEach-objektum
• Ahol-objektum