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 - büyüktür
• -ge, -ige, -cge - büyüktür veya eşittir
• -lt, -ilt, -clt - küçüktür
• -le, -ile, -cle - küçüktür veya eşittir

Eşleşen

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

Yedek

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

Çevreleme

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

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. Bir karşılaştırma işlecini büyük/küçük harfe duyarlı hale getirmek için, sonrasına cekleyin-. Örneğin, -ceq büyük/küçük harfe duyarlı sürümüdür -eq. Büyük/küçük harfe duyarsızlığı açık hale getirmek için, sonrasını i-ekleyin. Örneğin, -ieq açıkça büyük/küçük harfe duyarlı olmayan sürümüdür -eq.

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ğer 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. Örneğin:

$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 Boole değeri döndürür
• işleç -replace , değiştirme sonucunu döndürür
• -match ve -notmatch işleçleri, ifadenin $Matches sol tarafı bir koleksiyon olmadığı sürece otomatik değişkeni de doldurur.

Eşitlik İşleçleri

-eq ve -ne

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

Ö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, dize '1.0' değeriyle 1karşılaştırılacak bir tamsayıya dönüştürülür. Bu örnek döndürür True.

PS> 1 -eq '1.0'
True

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

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 testinin sonucu False'tur çünkü bunlar farklı nesnelerdir. Benzer sınıflar oluşturmak için sınıfınızda System.IEquatable<T> uygulamanız gerekir. Aşağıdaki örnek, System.IEquatableT<ve Dosya ve > adlı iki özelliğe sahip bir MyFileInfoSet sınıfının kısmi uygulamasını gösterir. Equals() İki MyFileInfoSet nesnesinin Dosya ve Boyut özellikleri aynıysa yöntemi 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, eşitlik işlecinin sol tarafına yerleştirmeniz $null gerekir. Sağ tarafa koymak beklediğiniz şeyi yapmaz.

Örneğin, $a null öğeler içeren bir dizi olsun:

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

Null olmayan aşağıdaki testler $a .

$null -ne $a

True

Bununla birlikte, aşağıdakiler öğesindeki $atüm null öğeleri dosyalar:

$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ırma ş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 deyimler True döndürür.

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şlecidir >. 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.IComparable uygulayan 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. Bu tür sembollerin tümünü içeren bir kümeyi işlecine -gt besleyerek bunları 'a' ile karşılaştırır. Çı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 sonlandırıcı olmayan 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 aşağıdaki gibidir:

<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 ve -like-notlike işleçleri üyeleri dize olarak döndürür. tarafından -like koleksiyonun bir üyesi için döndürülen dize ve -notlike işlecinin karşılaştırma için kullandığı dizedir ve üye bir dizeye atanarak elde edilir.

-like ve -not likee

-likeve -notlike ile -eq-nebenzer şekilde davranır, ancak sağ taraf joker 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 ifadeleri kullanın. Normal ifadeler e-posta adresleri, UNC yolları veya biçimlendirilmiş telefon numaraları gibi karmaşık desenlerle eşleşebilir. Sağ taraftaki dize normal ifade kurallarına uymalıdır.

Not

Kötü tasarlanmış veya kötü amaçlı hazırlanmış normal ifadeler hizmet reddi koşulları oluşturabilir. Daha fazla bilgi için bu makalenin Normal ifade güvenliği bölümüne bakın.

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 sonuç TrueFalse-notmatchotomatik değişkenin üzerine yazılır. $Matches , her zaman eşleşmenin tamamını depolayan '0' adlı bir anahtara sahip olan bir Hashtable'dır. Normal ifade yakalama grupları içeriyorsa, $Matches her grup için ek anahtarlar içerir.

Karma tablo, eşleşen herhangi bir desenin $Matches yalnızca ilk geçtiği yeri içerir.

Ö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

Sonuç False olduğunda veya -match sonuç True olduğunda veya giriş bir koleksiyon olduğunda otomatik değişkenin -notmatch üzerine yazılmaz.$Matches Sonuç olarak, daha önce ayarlanan değeri veya $null değişken ayarlanmamışsa bu değeri içerir. Bu işleçlerden birini çağırdıktan sonra başvururken $Matches , değişkenin bir koşul deyimi kullanılarak geçerli işleç çağırması tarafından ayarlandığını 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

gibi -matchişleç, -replace belirtilen deseni bulmak için normal ifadeler kullanır. Ancak aksine -match, eşleşmeleri belirtilen başka bir değerle değiştirir.

Not

Kötü tasarlanmış veya kötü amaçlı hazırlanmış normal ifadeler hizmet reddi koşulları oluşturabilir. Daha fazla bilgi için bu makalenin Normal ifade güvenliği bölümüne bakın.

Normal ifadelerle değiştirme

Söz dizimi:

<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 dosya adı uzantılarını olarak .logdeğiştirir:

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

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

Örnekler:

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

Cook
book

PowerShell 7.2 sürümünden başlayarak, işleç -replace deyimindeki sol işlenen bir dize olmadığında, bu işlenen 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, değerin 1.2 kültüre duyarlı dize dönüştürmesi olur 1,2.

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

Yakalama gruplarını ve değiştirmeleri kullanarak metni dinamik olarak değiştirmek için normal ifadeler kullanmak da mümkündür. Yakalama gruplarına, grup tanımlayıcısı <substitute> öncesinde dolar işareti ($) karakteri kullanılarak dizede başvurulabilir.

Aşağıdaki örnekte, -replace işleç biçiminde DomainName\Username bir kullanıcı adı kabul eder ve biçimine Username@DomainName 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ı

Karakterin $ hem PowerShell hem de normal ifadelerde söz dizimsel rolleri vardır:

• 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 yakalanan grupları belirtir. Normal ifadelerinizi tek tırnak işaretleri arasına koyduğunuzdan veya önüne bir backtick (`) karakteri eklediğinizden emin olun.

Örneğin:

$1 = 'Goodbye'

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

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

$$ Regex'te bir değişmez değer $belirtir. Sonuçta elde edilen değişime değişmez değer $$ eklemek için değiştirme dizesinde bunu $ kullanın. Örneğin:

'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 . Normal İfadelerde about_Regular_Expressions ve Değiştirmeler.

Koleksiyonda değiştirme

<input> -replace işleci bir koleksiyon olduğunda PowerShell, koleksiyondaki her değere yenisini uygular. Örneğin:

'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öz dizimi:

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

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) eşitlik işleçlerine benzer, ancak giriş bir koleksiyon olsa bile her zaman boole değeri döndürürler. Bu işleçler ilk eşleşmeyi algılar algılamaz 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ı döndürür.

-contains ve -notcontains

Söz dizimi:

<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. -containssağ 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 değeri 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öz dizimi:

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

-in ve -notin işleçleri PowerShell 3'te ve -contains işleçlerinin -notcontains sağlam tersini olarak kullanıma sunulmuştur. -insol taraf koleksiyondaki öğelerden biriyle eşleştiğinde True<scalar-object>. -notinbunun yerine False döndürür.

Aşağıdaki örnekler, örneklerin yaptığı ve -contains için -notcontains aynı şeyi yapar, ancak bunun yerine ve -in ile -notin 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öz dizimi:

<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

Normal ifade güvenliği

Normal ifade desenini eşleştirmek için gereken karşılaştırma işlemlerinin sayısı, desen iç içe isteğe bağlı niceleyiciler içerdiğinde espcecially olarak çok sayıda değişim yapısı içeriyorsa katlanarak artabilir. Örneğin, normal ifade deseni ^(a+)+$ bir veya daha fazla "a" karakteri içeren tam bir dizeyle eşleşecek şekilde tasarlanmıştır. Normal ifade altyapısının, eşleşmenin başarısız olduğu sonucuna varabilmesi ve iç içe geçmiş parantezlerin veriler aracılığıyla birçok ek yol oluşturduğu sonucuna varabilmesi için normal ifadeyi kullanarak tüm olası yolları izlemesi gerekir.

Uyarı

Kötü amaçlı bir kullanıcı, ReDoS saldırısı olarak da bilinen Hizmet Reddi saldırısına neden olan normal ifadelere giriş sağlayabilir.

ReDoS senaryolarına karşı savunmak için zaman aşımı belirten nesneler oluşturun [regex] . Regex altyapısı, zaman sınırını aştığında eşleşme aramasını sonlandırır. Örneğin, aşağıdaki kod 2 saniyelik zaman aşımına sahip bir regex nesnesi oluşturur:

$pattern = '^(a+)+$'
$regexOptions = 'None'
$matchTimeout = [timespan]::FromSeconds(2)
$regex = [regex]::new($pattern, $regexOptions, $matchTimeout)
$regex.IsMatch('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaX')

2 saniye sonra regex altyapısı aramayı sonlandırır ve aşağıdaki hatayı döndürür:

MethodInvocationException: Exception calling "IsMatch" with "1" argument(s):
"The Regex engine has timed out while trying to match a pattern to an input
string. This can occur for many reasons, including very large inputs or
excessive backtracking caused by nested quantifiers, back-references and other
factors."

Sınıf ve regex performansı hakkında [regex] daha fazla bilgi için aşağıdaki makalelere bakın:

• System.Text.RegularExpressions.Regex
• .NET normal ifadelerde geri izleme

Ayrıca bakınız

• Booleans_Hakkında
• Operatörler_Hakkında
• düzenli_ifadeler_hakkında
• Joker Karakterler Hakkında
• Nesne Karşılaştır
• ForEach-Object
• Nerede-Nesne