about_Comparison_Operators

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 dizelerin yerini alır

Çevreleme

  • -contains, -icontains, -ccontains - koleksiyonu bir değer içeriyor
  • -notcontains, -inotcontains, -cnotcontains - koleksiyonu bir değer içermiyor
  • -in - değer bir koleksiyonda
  • -notin - değer bir 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. Bir karşılaştırma işlecini büyük/küçük harfe duyarlı hale getirmek için, sonrasına -ekleyinc. Ö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.

bir işlecin girişi skaler bir değer olduğunda, işleç bir Boole değeri döndürür. Giriş bir koleksiyon olduğunda işleç, ifadenin sağındaki değerle eşleşen koleksiyonun öğelerini döndürür. 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 -ne True dö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, 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.IEquatable<T> uygulayan ve Dosya ve Boyut 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 -notlike deseni -like 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

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

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ç True olduğunda veya -notmatch sonuç False olduğunda otomatik değişkenin $Matches ü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 -notmatch sonuç True olduğunda veya giriş bir koleksiyon olduğunda otomatik değişkenin $Matches üzerine yazılmaz.-match 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

Normal ifadelerle değiştirme

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.

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

Betik bloğuyla 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 -notcontains işleçlerinin -contains sağlam tersini olarak kullanıma sunulmuştur. -insol taraf <scalar-object> koleksiyondaki öğelerden biriyle eşleştiğinde True döndürür. -notinbunun yerine False döndürür.

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