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ő

Egyező

-like, -ilike, -clike – a karakterlánc egyezik a helyettesítő mintával
-notlike, -inotlike, -cnotlike – a karakterlánc nem egyezik a helyettesítő mintával
-match, -imatch, -cmatch – a sztring egyezik a regex mintával
-notmatch, -inotmatch, -cnotmatch – a karakterlánc nem egyezik a reguláris kifejezés mintával

Csere

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

Korlátozás

-contains, -icontains, -ccontains – gyűjtemény egy értéket tartalmaz
-notcontains, -inotcontains, -cnotcontains – 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 karakterlánc-összehasonlítások nem érzékenyek a kis- és nagybetűkre, kivéve, ha kifejezetten a nagy- és kisbetűkre érzékeny operátort használ. Az összehasonlító operátor kis- és nagybetű-érzékennyé tételéhez adja hozzá a c-t a -után. Például a -ceq a -eqkis- és nagybetűkre érzékeny verziója. A kis- és nagybetűk iránti érzékenység explicit kifejezése érdekében adjon hozzá egy i a -után. A -ieq például a -eqkifejezetten kis- és nagybetűknek nem érzéketlen verziója.

A sztring-összehasonlítások a InvariantCulture használják, függetlenül attól, hogy kis- és nagybetűérzékenyek-e. 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 egy 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 jobboldali értékek mindig egyetlen példányként vannak kezelve, még akkor is, ha azok 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éldául:

$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 ad vissza
A -replace operátor a csere eredményét adja vissza
A -match és -notmatch 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 oldali kifejezés skaláris, -eqIgaz értéket ad vissza, ha a jobb oldali kifejezés egyenértékű, ellenkező esetben -eqHamisértéket ad vissza. -ne az ellenkezőjét teszi; hamis ad vissza, ha mindkét oldal egyenértékű; ellenkező esetben -neIgazad 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

Amikor a bal oldali egy gyűjtemény, -eq azokat a tagokat adja vissza, amelyek megegyeznek a jobb oldali tagokkal, míg -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 '1.0' sztring például egész számmá alakul, amely összehasonlítható a 1értékével. Ez a példa Truead vissza.

PS> 1 -eq '1.0'
True

Ebben a példában a 1 értéket a rendszer sztringgé alakítja, amely a '1.0'sztringhez hasonlítható. Ez a példa Falsead vissza.

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 ezek különböző objektumok. Hasonló osztályok létrehozásához implementálnia kell System.IEquatable<T> az osztályban. Az alábbi példa bemutatja a MyFileInfoSet osztály részleges implementálását, amely megvalósítja a System.IEquatable<T> interfészt, és két tulajdonsággal rendelkezik: File és Size. A Equals() metódus Igaz 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 meg kell azonban határoznia, hogy egy változó $null-e, akkor az egyenlőség operátor bal oldalán kell elhelyeznie $null. A jobb oldalon való elhelyezés nem azt teszi, amit vársz.

Például legyen $a null elemet tartalmazó tömb:

$a = 1, 2, $null, 4, $null, 6

Az alábbi tesztek ellenőrzik, hogy $a nem null értékű-e.

$null -ne $a

True

A következők minden null elemet azonban eltávolítanak a $a-ból:

$a -ne $null # Output: 1, 2, 4, 6

-gt, -ge, -lt és -le

-gt, -ge, -ltés -le hasonlóan viselkednek. Ha mindkét oldal skaláris, igaz vagy hamis értéket adnak vissza a két oldal összehasonlításától függően.

Operátor	Igazat 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 kijelentés Igazad eredményként.

8 -gt 6  # Output: True
8 -ge 8  # Output: True
6 -lt 8  # Output: True
8 -le 8  # Output: True

Jegyzet

A legtöbb programozási nyelvben a nagyobb mint operátor >. A PowerShellben ezt a karaktert használja az átirányításhoz. További részletekért lásd: about_Redirection.

Amikor a bal oldalon egy gyűjtemény van, ezek az operátorok a gyűjtemény minden elemét összehasonlítják 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.IComparableimplementálható 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. Az összes ilyen szimbólumot tartalmazó készletet a -gt operátornak adhatja meg, 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, -notlike, -matchés -notmatch) olyan elemeket találnak, amelyek 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, akkor egy 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. A -match operátor minden egyező tagot, míg a -notmatch operátor minden nem egyező tagot ad vissza. A -like és -notlike operátorok azonban a tagokat sztringként adják vissza. A sztring, amelyet a gyűjtemény egy tagja számára a -like és a -notlike visszaad, az a sztring, amelyet az operátor az összehasonlításhoz használt, és a tag sztringgé való átkonvertálásával nyerik.

-like és -notlike

-like és -notlike hasonlóan viselkedik, mint -eq és -ne, de a jobb oldalon lehet, hogy egy helyettesítő karaktereket tartalmazó karakterlánc található.

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 -notmatch

-match és -notmatch használjon reguláris kifejezéseket a minta kereséséhez a bal oldali értékekben. 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 és a szabályok követelményeinek.

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.

Gyűjteményi példák:

'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ámogatják a regex rögzítési csoportokat. Minden alkalommal, amikor skaláris bemeneten futnak, és az -match eredmény Igaz, vagy a -notmatch eredmény Hamis, felülírják a $Matches automatikus változót. $Matches egy hasítótábla, amely mindig rendelkezik egy '0' nevű kulccsal, ami a teljes egyezést tárolja. Ha a reguláris kifejezés rögzítési csoportokat tartalmaz, a $Matches minden csoporthoz további kulcsokat tartalmaz.

Fontos megjegyezni, hogy a $Matches hash tábla 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 a -match eredménye Hamis, vagy a -notmatch eredménye Igaz, vagy ha a bemenet gyűjtemény, a $Matches automatikus változó nem lesz felülírva. 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-ra, fontolja meg annak ellenőrzését, hogy a változót az aktuális operátor meghívása állította-e be feltételes kifejezés használatával.

Példa:

if ('<version>1.0.0</version>' -match '<version>(.*?)</version>') {
    $Matches
}

A részletekért lásd: about_Regular_Expressions és about_Automatic_Variables.

Csere operátor

Csere normál kifejezésekkel

A -match-hez hasonlóan a -replace operátor is használ reguláris kifejezéseket a megadott minta megkereséséhez. A -matchellentétben azonban a találatokat egy másik megadott értékre cseréli.

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. Például az alábbi parancs az összes .txt fájl fájlnévkiterjesztését .log-re változtatja.

Get-ChildItem *.txt | Rename-Item -NewName { $_.Name -replace '\.txt$','.log' }

Alapértelmezés szerint a -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 -creplace. A kis- és nagybetűk megkülönböztetéséhez használja a -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 kezdődően, amikor egy -replace operátori utasítás bal oldali operandusa nem sztring, az operandus sztringgé alakul. A PowerShell kultúra-független sztringátalakítást végez.

Ha például a kultúra francia (fr) értékre van állítva, a 1.2 érték kulturálisan érzékeny sztringkonverziója 1,2lesz.

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 csoportokra a <substitute> sztringben hivatkozhatunk a csoportazonosító előtt elhelyezett dollárjel ($) karakterrel.

Az alábbi példában a -replace operátor egy felhasználónevet fogad el DomainName\Username formájában, és Username@DomainName formátumra 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 Mind a PowerShellben, mind a reguláris kifejezésekben:

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 idézőjelek közé helyezze, vagy szúrjon be eléjük egy háttérjelet (`).

Például:

$1 = 'Goodbye'

'Hello World' -replace '(\w+) \w+', "$1 Universe"
# Output: Goodbye Universe

'Hello World' -replace '(\w+) \w+', '$1 Universe'
# Output: Hello Universe

A $$ a reguláris kifejezésben egy literális $-et jelent. Ez a $$ a helyettesítési sztringben egy literális $ belefoglalására szolgál a cserébe. Például:

'5.72' -replace '(.+)', '$ $1' # Output: $ 5.72
'5.72' -replace '(.+)', '$$$1' # Output: $5.72
'5.72' -replace '(.+)', '$$1'  # Output: $1

További részletekért lásd: about_Regular_Expressions és Helyettesítések reguláris kifejezésekben.

Helyettesítés egy gyűjteményben

Amikor a <input> egy gyűjtemény, amely a -replace operátorhoz kapcsolódik, a PowerShell a csere műveletet alkalmazza a gyűjtemény minden értékére. Például:

'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, -inés -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. -contains visszaadja Igaz, ha a jobboldali érték (skaláris objektum) megegyezik a halmaz valamelyik 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 az értéket annak sztring-reprezentációjára konvertálják, mielőtt összehasonlítanák a bal oldali gyűjteménnyel.

$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

-be- és -notin

Szintaxis:

<scalar-object> -in <Collection>
<scalar-object> -notin <Collection>

A -in és -notin operátorokat a PowerShell 3-ban vezették be a -contains és -notcontains operátorok szintaktikai fordítottjaként. -in Igaz értéket ad vissza, ha a bal oldali <scalar-object> egyezik a gyűjtemény valamelyik elemével. A(z) helyett Hamist ad vissza .

Az alábbi példák ugyanazt teszik, mint a -contains és -notcontains példái, de ehelyett -in és -notin vannak megírva.

'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 egy gyűjtemény, ezek az operátorok az egyes értékeket sztringre konvertálják, mielőtt összehasonlítanák a jobb oldali gyűjteménnyel.

$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

Hasznosnak találta ezt az oldalt?

Last updated on 2026-01-18

az összehasonlító operátorokról

Rövid leírás

Hosszú leírás

Gyakori funkciók

Egyenlőségi operátorok

-eq és -ne

-gt, -ge, -lt és -le

Egyező operátorok

-like és -notlike

-egyezés és -notmatch

Csere operátor

Csere normál kifejezésekkel

Reguláris kifejezések helyettesítése

Helyettesítés egy gyűjteményben

Csere szkriptblokkkal

Elszigetelési operátorok

-tartalmazza és -notcontains

-be- és -notin

Típus összehasonlítása

Lásd még

Visszajelzés

További források