Aracılığıyla paylaş

Karşılaştırma_Operatörleri_Hakkında

Kısa açıklama

PowerShell'deki karşılaştırma işleçleri iki değeri karşılaştırabilir veya bir koleksiyonun öğelerini bir giriş değeriyle karşılaştırabilir.

Uzun açıklama

Karşılaştırma işleçleri, değerleri karşılaştırmanıza veya belirtilen desenlerle eşleşen değerleri bulmanıza olanak sağlar. PowerShell aşağıdaki karşılaştırma işleçlerini içerir:

eşitlik

  • -eq, -ieq, -ceq - eşittir
  • -ne, -ine, -cne - eşit değil
  • -gt, -igt, -cgt - daha büyük
  • -ge, -ige, -cge - büyüktür veya eşittir
  • -lt, -ilt, -clt - daha azdır
  • -le, -ile, -cle - küçük veya eşit

ile eşleşen

  • -like, -ilike, -clike - dizgi joker karakter deseni ile eşleşir
  • -notlike, -inotlike, -cnotlike - dize joker karakter deseni ile eşleşmiyor
  • -match, -imatch, -cmatch - dize regex deseni ile eşleşir
  • -notmatch, -inotmatch, -cnotmatch - dize regex deseni ile eşleşmiyor

Değiştirme

  • -replace, -ireplace, -creplace - bir regex deseni ile eşleşen dizeleri bulur ve değiştirir

Kapsama

  • -contains, -icontains, -ccontains - koleksiyon bir değer içeriyor
  • -notcontains, -inotcontains, -cnotcontains - koleksiyon bir değer içermiyor
  • -in, -iin, -cin - değer bir koleksiyonda
  • -notin, -inotin, -cnotin - değer koleksiyonda değil

Tür

  • -is - her iki nesne de aynı türdedir
  • -isnot - nesneler aynı türde değil

Ortak özellikler

Açık büyük/küçük harfe duyarlı işlecini kullanmadığınız sürece dize karşılaştırmaları büyük/küçük harfe duyarlı değildir. Karşılaştırma işlecini büyük/küçük harfe duyarlı hale getirmek için csonrasına bir - ekleyin. Örneğin, -ceq, -eq'in büyük/küçük harfe duyarlı sürümüdür. Büyük/küçük harf duyarsızlığını açık hale getirmek için i'den sonra bir - ekleyin. Örneğin, -ieq açıkça büyük/küçük harfe duyarlı olmayan -eqsürümüdür.

Dize karşılaştırmaları hem büyük/küçük harfe duyarlı hem de büyük/küçük harfe duyarlı olmayan karşılaştırmalar için InvariantCulture kullanır. Karşılaştırmalar unicode kod noktaları arasındadır ve kültüre özgü harmanlama sıralamasını kullanmaz. Sonuçlar geçerli kültürden bağımsız olarak aynıdır.

Karşılaştırma ifadesindeki soldaki değer bir skaler değeri olduğunda, işleç bir Boole değeri döndürür. İfadedeki soldaki değer bir koleksiyon olduğunda işleç, koleksiyonun ifadenin sağındaki değerle eşleşen öğelerini döndürür. Sağ taraftaki değerler, koleksiyon olsalar bile her zaman tekil örnekler olarak değerlendirilir. Karşılaştırma işleçleri koleksiyonları koleksiyonlar ile etkili bir şekilde karşılaştıramaz.

Koleksiyonda eşleşme yoksa, karşılaştırma işleçleri boş bir dizi döndürür. Mesela:

$a = (1, 2) -eq 3
$a.GetType().Name
$a.Count

Object[]
0

Birkaç özel durum vardır:

  • Kapsama ve tür işleçleri her zaman bir Boolean değeri döndürür.
  • -replace işleci değiştirme sonucunu döndürür
  • -match ve -notmatch işleçleri, ifadenin sol tarafı bir koleksiyon olmadığı sürece $Matches otomatik değişkenini de doldurur.

Eşitlik İşleçleri

-eq ve -ne

Sol taraf skaler olduğunda, sağ taraf eşdeğerse -eq True döndürür, aksi takdirde -eqFalsedöndürür. -ne tersini yapar; her iki taraf da eşdeğer olduğunda False döndürür; aksi takdirde, -neTruedöndürür.

Örnek:

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

Sol taraf bir koleksiyon olduğunda, -eq sağ tarafla eşleşen üyeleri döndürürken, -ne bunları filtreler.

Örnek:

1,2,3 -eq 2             # Output: 2
'abc', 'def' -eq 'abc'  # Output: abc
'abc', 'def' -ne 'abc'  # Output: def

Bu işleçler koleksiyonun tüm öğelerini işler. Örnek:

'zzz', 'def', 'zzz' -eq 'zzz'

zzz
zzz

Eşitlik işleci farklı türlerdeki nesneleri karşılaştırabilir. Karşılaştırmanın sağ tarafındaki değerin karşılaştırma için sol taraftaki değerin türüne dönüştürülebileceğini anlamak önemlidir.

Örneğin, '1.0' dizesi 1değeriyle karşılaştırılacak bir tamsayıya dönüştürülür. Bu örnek Truedöndürür.

PS> 1 -eq '1.0'
True

Bu örnekte, 1 değeri '1.0'dizesiyle karşılaştırılacak bir dizeye dönüştürülür. Bu örnek Falsedöndürür.

PS> '1.0' -eq 1
False

Eşitlik işleçleri yalnızca bir skaler veya koleksiyon değil iki nesneyi kabul eder. Ancak karşılaştırma sonucunun son kullanıcı için anlamlı olacağı garanti edilemez. Aşağıdaki örnekte sorun gösterilmektedir.

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

Bu örnekte, aynı özelliklere sahip iki nesne oluşturduk. Ancak eşitlik testi sonucu, farklı nesneler oldukları için False. Benzer sınıflar oluşturmak için sınıfınızda System.IEquatable<T> uygulamanız gerekir. Aşağıdaki örnekte, uygulayan ve iki özelliği olan < sınıfının kısmen uygulanması gösterilmektedir: > ve Boyut. yöntemi, myFileInfoSet iki nesnenin Dosya ve Boyut özellikleri aynıysa True döndürür.

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

Rastgele nesneleri karşılaştırmanın önemli bir örneği, bunların null olup olmadığını bulmaktır. Ancak bir değişkenin $nullolup olmadığını belirlemeniz gerekiyorsa, $null eşitlik işlecinin sol tarafına yerleştirmeniz gerekir. Sağ tarafa koymak beklediğiniz şeyi yapmaz.

Örneğin, $a null öğeler içeren bir dizi olmasına izin verin:

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

Aşağıdaki test $a'ın null olmadığını kontrol eder.

$null -ne $a

True

Ancak, aşağıdakiler $a'dan tüm null öğeleri filtreler:

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

1
2
4
6

-gt, -ge, -lt ve -le

-gt, -ge, -ltve -le çok benzer şekilde davranır. İki taraf da skaler olduğunda, iki tarafın karşılaştırılma şekline bağlı olarak True veya False döndürür.

Operatör Şu durumlarda True döndürür:...
-gt Sol taraf daha büyük
-ge Sol taraf büyüktür veya eşittir
-lt Sol taraf daha küçük
-le Sol taraf daha küçük veya eşittir

Aşağıdaki örneklerde tüm ifadeler Truegeri döner.

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

Not

Çoğu programlama dilinde büyüktür işleci >. PowerShell'de bu karakter yeniden yönlendirme için kullanılır. Ayrıntılar için bkz. about_Redirection.

Sol taraf bir koleksiyon olduğunda, bu işleçler koleksiyonun her üyesini sağ tarafla karşılaştırır. Mantığına bağlı olarak, üyeyi tutar veya atarlar.

Örnek:

$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

Bu işleçler, System.IComparableuygulayan tüm sınıflarla çalışır.

Örnekler:

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

Aşağıdaki örnek, Amerikan QWERTY klavyesinde 'a' sonrasında sıralanan bir simge olmadığını gösterir. Tüm bu simgeleri içeren bir kümeyi , 'a' ile karşılaştırmak için -gt işlecine besler. Çıkış boş bir dizidir.

$a=' ','`','~','!','@','#','$','%','^','&','*','(',')','_','+','-','=',
   '{','}','[',']',':',';','"','''','\','|','/','?','.','>',',','<'
$a -gt 'a'
# Output: Nothing

İşleçlerin iki tarafı makul bir şekilde karşılaştırılamazsa, bu işleçler sonlanmayan bir hata oluşturur.

Eşleşen işleçler

Eşleşen işleçler (-like, -notlike, -matchve -notmatch) belirtilen desenle eşleşen veya eşleşmeyen öğeleri bulur. ve -like deseni -notlike bir joker karakter ifadesidir (, *ve ?) [ ]ve -match-notmatch normal ifadeyi (regex) kabul eder.

Söz dizimi şöyledir:

<string[]> -like    <wildcard-expression>
<string[]> -notlike <wildcard-expression>
<string[]> -match    <regular-expression>
<string[]> -notmatch <regular-expression>

Bu işleçlerin girişi skaler bir değer olduğunda, Boole değeri döndürür.

Giriş bir değer koleksiyonu olduğunda, koleksiyondaki her öğe karşılaştırma için bir dizeye dönüştürülür. -match ve -notmatch işleçleri sırasıyla eşleşen ve eşleşmeyen üyeleri döndürür. Ancak, -like ve -notlike işleçleri üyeleri string olarak döndürür. -like ve -notlike tarafından koleksiyonun bir üyesi için döndürülen dize, işlecin karşılaştırma için kullandığı dizedir ve üye bir dizeye dönüştürülerek elde edilir.

-like ve -notlike

ve ve gibi davranır, ancak sağ tarafjoker karakter içeren bir dize olabilir.

Örnek:

'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

En iyi sonuçlar için ve -like işleçlerinin -notlike sağ tarafı joker karakter ifadesini içeren bir dize değişmez değeri olmalıdır. PowerShell joker karakter ifadesini joker karakter ifade ayrıştırıcısına geçirir. Joker karakterlerden birini (*, ?veya [ ]) eşleştirmek için, karakterden bir ters köşe (`) karakteriyle çıkmalısınız. Örneğin, değişmez değerle ?eşleştirmek için joker karakter ifadesinde kullanın `? . Genişletilebilir bir dize ifadesi kullanırsanız PowerShell, dizeyi joker karakter ayrıştırıcısına geçirmeden önce genişletir ve bu da sıralanmamış karakterlerin joker karakter olarak gönderilmesine neden olur.

# 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

-match ve -notmatch

-match ve -notmatch, sol taraftaki değerlerde desen aramak için normal ifadeler kullanır. Normal ifadeler e-posta adresleri, UNC yolları veya biçimlendirilmiş telefon numaraları gibi karmaşık desenlerle eşleşebilir. Sağ taraftaki dize, düzenli ifadelerinin kurallarına uymalıdır.

Skaler örnekler:

# 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

Giriş bir koleksiyonsa, işleçler bu koleksiyonun eşleşen üyelerini döndürür.

Koleksiyon örnekleri:

'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 ve -notmatch regex yakalama gruplarını destekler. Skaler giriş üzerinde her çalıştırıldığında ve -match sonucu Trueveya -notmatch sonucu Falseolduğunda, $Matches otomatik değişkenin üzerine yazılır. $Matches, her zaman eşleşmenin tamamını depolayan '0' adlı bir anahtara sahip olan bir Hashtable. Normal ifade yakalama grupları içeriyorsa, $Matches her grup için ek anahtarlar içerir.

$Matches hashtable'ının eşleşen desenlerin yalnızca ilk oluşumunu içerdiğini unutmayın.

Örnek:

$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

-match sonucu Falseolduğunda veya -notmatch sonucu Trueolduğunda veya giriş bir koleksiyon olduğunda, $Matches otomatik değişkenin üzerine yazılmaz. Sonuç olarak, daha önce ayarlanan değeri veya değişken ayarlanmamışsa $null içerir. Bu işleçlerden birini çağırdıktan sonra $Matches'a başvururken, değişkenin geçerli işleç çağrısı tarafından ayarlandığını bir koşul ifadesi kullanarak doğrulamayı göz önünde bulundurun.

Örnek:

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

Ayrıntılar için bkz. about_Regular_Expressions ve about_Automatic_Variables.

Değiştirme işleci

Normal ifadelerle değiştirme

-matchgibi -replace işleci de belirtilen deseni bulmak için normal ifadeler kullanır. Ancak -matchaksine, eşleşmeleri belirtilen başka bir değerle değiştirir.

Sözdizimi:

<input> -replace <regular-expression>, <substitute>

işleci, normal ifadeleri kullanarak bir değerin tamamını veya bir bölümünü belirtilen değerle değiştirir. işlecini, dosyaları yeniden adlandırma gibi birçok yönetim görevi için kullanabilirsiniz. Örneğin, aşağıdaki komut tüm .txt dosyalarının dosya adı uzantılarını .logolarak değiştirir:

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

Varsayılan olarak, -replace işleci büyük/küçük harfe duyarlı değildir. -creplace'ı büyük/küçük harfe duyarlı hale getirmek için kullanın. Bunu açıkça büyük/küçük harfe duyarsız hale getirmek için -ireplacekullanın.

Örnekler:

'book' -ireplace 'B', 'C' # Case insensitive
'book' -creplace 'B', 'C' # Case-sensitive; hence, nothing to replace

Cook
book

PowerShell 7.2'den itibaren, bir -replace operatör ifadesindeki sol operant bir dize değilse, bu operant bir dizeye dönüştürülür. PowerShell kültüre duyarsız bir dize dönüştürme işlemi yapar.

Örneğin, kültürünüz Fransızca (fr) olarak ayarlandıysa, 1.2 değerinin kültüre duyarlı şekilde dizeye dönüştürülmesi 1,2olur.

PowerShell 7.2'nin öncesinde:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
12

PowerShell 7.2 ve sonraki sürümlerde:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
1.2

Normal ifade değiştirmeleri

Normal ifadelerle yakalama gruplarını ve değiştirmeleri kullanarak metni dinamik olarak değiştirmek de mümkündür. Yakalama gruplarına <substitute> dizesinde, grup tanımlayıcıdan önceki dolar işareti ($) karakteri kullanılarak başvurulabilir.

Aşağıdaki örnekte, -replace işleci DomainName\Username biçiminde bir kullanıcı adı kabul eder ve Username@DomainName biçimine dönüştürür:

$SearchExp = '^(?<DomainName>[\w-.]+)\\(?<Username>[\w-.]+)$'
$ReplaceExp = '${Username}@${DomainName}'

'Contoso.local\John.Doe' -replace $SearchExp, $ReplaceExp

John.Doe@Contoso.local

Uyarı

$ karakteri hem PowerShell hem de normal ifadelerde söz dizimsel rollere sahiptir:

  • PowerShell'de çift tırnak işaretleri arasında değişkenleri belirler ve bir alt ifade işleci olarak görev yapar.
  • Regex arama dizelerinde satırın sonunu belirtir.
  • Regex değiştirme dizelerinde, bu yakalanan grupları belirtir. Normal ifadelerinizi tek tırnak işaretleri arasına koyduğunuzdan veya önüne bir backtick (`) karakteri eklediğinizden emin olun.

Mesela:

$1 = 'Goodbye'

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

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

Regex'teki $$ değişmez değer $belirtir. Bu, yerine koyma dizesinde elde edilen değişime gerçek bir $$ dahil etmek ve değişmez değer $ eklemek içindir. Mesela:

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

Daha fazla bilgi edinmek için bkz. about_Regular_Expressions ve Normal İfadelerde Değiştirme.

Koleksiyonda değiştirme

<input> bir koleksiyon olarak -replace işleci ile kullanıldığında, PowerShell bu değişikliği koleksiyondaki her bir değere uygular. Mesela:

'B1','B2','B3','B4','B5' -replace 'B', 'a'
a1
a2
a3
a4
a5

Scriptblock ile değiştirme

PowerShell 6 ve sonraki sürümlerde işleç, -replace değiştirme işlemini gerçekleştiren bir betik bloğunu da kabul eder. Betik bloğu her eşleşme için bir kez çalışır.

Sözdizimi:

<String> -replace <regular-expression>, {<Script-block>}

Betik bloğunda $_ , değiştirilen giriş metnine ve diğer yararlı bilgilere erişmek için otomatik değişkeni kullanın. Bu değişkenin sınıf türü System.Text.RegularExpressions.Match.

Aşağıdaki örnek, üç basamaklık her bir sırayı karakter eşdeğerleriyle değiştirir. Betik bloğu, değiştirilmesi gereken her üç basamak kümesi için çalışır.

'072101108108111' -replace '\d{3}', {return [char][int]$_.Value}

Hello

Kapsama işleçleri

Kapsama işleçleri (-contains, -notcontains, -inve -notin), giriş bir koleksiyon olsa bile her zaman Boole değeri döndürmeleri dışında eşitlik işleçlerine benzer. Bu işleçler ilk eşleşmeyi algıladıklarında karşılaştırmayı durdururken, eşitlik işleçleri tüm giriş üyelerini değerlendirir. Çok büyük bir koleksiyonda, bu işleçler eşitlik işleçlerinden daha hızlı sonuç verir.

-contains ve -notcontains

Sözdizimi:

<Collection> -contains <scalar-object>
<Collection> -notcontains <scalar-object>

Bu işleçler bir kümenin belirli bir öğe içerip içermediğini söyler. sağ taraf (skaler nesne) kümedeki öğelerden biriyle eşleştiğinde True döndürür. -notcontains bunun yerine False döndürür.

Örnekler:

'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

Daha karmaşık örnekler:

$DomainServers = 'ContosoDC1', 'ContosoDC2', 'ContosoFileServer',
                 'ContosoDNS', 'ContosoDHCP', 'ContosoWSUS'
$thisComputer  = 'ContosoDC2'

$DomainServers -contains $thisComputer
# Output: True

Sağ taraftaki işlenen bir koleksiyon olduğunda, bu işleçler sağ taraftaki işlenenin değerini, sol taraftaki koleksiyonla karşılaştırmadan önce dize gösterimine dönüştürür.

$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 ve -notin

Sözdizimi:

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

-in ve -notin işleçleri, -contains ve -notcontains işleçlerinin tam tersi olarak PowerShell 3'te kullanıma sunulmuştur. -in, sol taraftaki koleksiyondaki öğelerden biriyle eşleştiğinde <scalar-object> döndürür. -notin bunun yerine False döndürür.

Aşağıdaki örnekler, -contains ve -notcontains örnekleriyle aynı işlemi yapar, ancak bunun yerine -in ve -notin ile yazılır.

'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

Daha karmaşık örnekler:

$DomainServers = 'ContosoDC1', 'ContosoDC2', 'ContosoFileServer',
                 'ContosoDNS', 'ContosoDHCP', 'ContosoWSUS'
$thisComputer  = 'ContosoDC2'

$thisComputer -in $DomainServers
# Output: True

Sol taraftaki işlenen bir koleksiyon olduğunda, bu işleçler değeri sağ taraftaki koleksiyonla karşılaştırmadan önce dize gösterimine dönüştürür.

$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ür karşılaştırması

Tür karşılaştırma işleçleri (-is ve -isnot), bir nesnenin belirli bir tür olup olmadığını belirlemek için kullanılır.

Sözdizimi:

<object> -is <type-reference>
<object> -isnot <type-reference>

Örnek:

$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

Ayrıca bakınız

  • Last updated on