about_Comparison_Operators
Deskripsi singkat
Operator perbandingan di PowerShell dapat membandingkan dua nilai atau elemen filter koleksi dengan nilai input.
Deskripsi panjang
Operator perbandingan memungkinkan Anda membandingkan nilai atau menemukan nilai yang cocok dengan pola yang ditentukan. PowerShell menyertakan operator perbandingan berikut:
Kesetaraan
-eq, ,-ieq-ceq- sama dengan-ne, ,-ine-cne- tidak sama dengan-gt, ,-igt-cgt- lebih besar dari-ge, ,-ige-cge- lebih besar dari atau sama dengan-lt, ,-ilt-clt- kurang dari-le, ,-ile-cle- kurang dari atau sama dengan
Pencocokan
-like, ,-ilike-clike- string cocok dengan pola kartubebas-notlike, ,-inotlike-cnotlike- string tidak cocok dengan pola kartubebas-match, ,-imatch--cmatchstring cocok dengan pola regex-notmatch, ,-inotmatch-cnotmatch- string tidak cocok dengan pola regex
Suku Cadang Perangkat Keras
-replace, ,-ireplace-creplace- mengganti string yang cocok dengan pola regex
Penahanan
-contains, ,-icontains-ccontains- koleksi berisi nilai-notcontains, ,-inotcontains-cnotcontains- koleksi tidak berisi nilai-in- nilai ada dalam koleksi-notin- nilai tidak ada dalam koleksi
Jenis
-is- kedua objek adalah jenis yang sama-isnot- objek bukan tipe yang sama
Fitur umum
Perbandingan string tidak peka huruf besar/kecil kecuali Anda menggunakan operator peka huruf besar/kecil eksplisit. Untuk membuat operator perbandingan peka huruf besar/kecil, tambahkan c setelah -. Misalnya, -ceq adalah versi peka huruf besar/kecil dari -eq.
Untuk membuat ketidakpekaan huruf besar/kecil menjadi eksplisit, tambahkan i setelah -. Misalnya, -ieq adalah versi yang tidak peka huruf besar/kecil secara eksplisit dari -eq.
Perbandingan string menggunakan InvariantCulture untuk perbandingan peka huruf besar/kecil dan tidak peka huruf besar/kecil. Perbandingannya antara titik kode unicode dan tidak menggunakan urutan kolamen khusus budaya. Hasilnya sama terlepas dari budaya saat ini.
Saat input operator adalah nilai skalar , operator mengembalikan nilai Boolean . Saat input adalah koleksi, operator mengembalikan elemen koleksi yang cocok dengan nilai kanan ekspresi. Jika tidak ada kecocokan dalam koleksi, operator perbandingan mengembalikan array kosong. Contohnya:
$a = (1, 2) -eq 3
$a.GetType().Name
$a.Count
Object[]
0
Ada beberapa pengecualian:
- Operator penahanan dan jenis selalu mengembalikan nilai Boolean
- Operator
-replacemengembalikan hasil penggantian - Operator
-matchdan-notmatchjuga mengisi$Matchesvariabel otomatis kecuali sisi kiri ekspresi adalah koleksi.
Operator Persamaan
-eq dan -ne
Ketika sisi kiri bernilai skalar, -eq mengembalikan True jika sisi kanan setara, jika tidak, -eq mengembalikan False. -ne melakukan kebalikannya; ini mengembalikan False ketika kedua sisi setara; jika tidak, -ne mengembalikan True.
Contoh:
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
Saat sisi kiri adalah koleksi, -eq mengembalikan anggota yang cocok dengan sisi kanan, sambil -ne memfilternya.
Contoh:
1,2,3 -eq 2 # Output: 2
"abc", "def" -eq "abc" # Output: abc
"abc", "def" -ne "abc" # Output: def
Operator ini memproses semua elemen koleksi. Contoh:
"zzz", "def", "zzz" -eq "zzz"
zzz
zzz
Operator kesetaraan dapat membandingkan objek dari berbagai jenis. Penting untuk dipahami bahwa nilai di sisi kanan perbandingan dapat dikonversi ke jenis nilai sisi kiri untuk perbandingan.
Misalnya, string '1.0' dikonversi menjadi bilangan bulat untuk dibandingkan dengan nilai 1. Contoh ini mengembalikan True.
PS> 1 -eq '1.0'
True
Dalam contoh ini, nilai 1 dikonversi ke string untuk dibandingkan dengan string '1.0'. Contoh ini mengembalikan False.
PS> '1.0' -eq 1
False
Operator kesetaraan menerima dua objek, bukan hanya skalar atau koleksi. Tetapi hasil perbandingan tidak dijamin bermakna bagi pengguna akhir. Contoh berikut menunjukkan masalah tersebut.
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
Dalam contoh ini, kami membuat dua objek dengan properti yang identik. Namun, hasil pengujian kesetaraan adalah False karena merupakan objek yang berbeda. Untuk membuat kelas yang sebanding, Anda perlu menerapkan System.IEquatable<T> di kelas Anda. Contoh berikut menunjukkan implementasi parsial kelas MyFileInfoSet yang mengimplementasikan System.IEquatable<T> dan memiliki dua properti, File dan Ukuran. Metode Equals() mengembalikan True jika properti File dan Ukuran dari dua objek MyFileInfoSet sama.
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
Contoh menonjol untuk membandingkan objek arbitrer adalah mencari tahu apakah objek tersebut null. Tetapi jika Anda perlu menentukan apakah variabel adalah $null, Anda harus meletakkan $null di sisi kiri operator kesetaraan. Meletakkannya di sisi kanan tidak melakukan apa yang Anda harapkan.
Misalnya, mari kita $a menjadi array yang berisi elemen null:
$a = 1, 2, $null, 4, $null, 6
Pengujian berikut yang $a tidak null.
$null -ne $a
True
Namun, berikut ini, filer keluar semua elemen null dari $a:
$a -ne $null # Output: 1, 2, 4, 6
1
2
4
6
-gt, -ge, -lt, dan -le
-gt, -ge, -lt, dan -le berulah sangat mirip. Ketika kedua belah pihak berukuran skalar, keduanya mengembalikan True atau False tergantung pada perbandingan kedua sisi:
| Operator | Mengembalikan True ketika... |
|---|---|
-gt |
Sisi kiri lebih besar |
-ge |
Sisi kiri lebih besar atau sama dengan |
-lt |
Sisi kiri lebih kecil |
-le |
Sisi kiri lebih kecil atau sama dengan |
Dalam contoh berikut, semua pernyataan mengembalikan True.
8 -gt 6 # Output: True
8 -ge 8 # Output: True
6 -lt 8 # Output: True
8 -le 8 # Output: True
Catatan
Dalam sebagian besar bahasa pemrograman, operator yang lebih besar dari adalah >. Di PowerShell, karakter ini digunakan untuk pengalihan. Untuk detailnya, lihat about_Redirection.
Ketika sisi kiri adalah koleksi, operator ini membandingkan setiap anggota koleksi dengan sisi kanan. Tergantung pada logika mereka, mereka menyimpan atau membuang anggota.
Contoh:
$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
Operator ini bekerja dengan kelas apa pun yang mengimplementasikan System.IComparable.
Contoh:
# 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'
Contoh berikut menunjukkan bahwa tidak ada simbol pada keyboard QWERTY Amerika yang diurutkan setelah 'a'. Ini memberi umpan set yang berisi semua simbol tersebut ke -gt operator untuk membandingkannya dengan 'a'. Outputnya adalah array kosong.
$a=' ','`','~','!','@','#','$','%','^','&','*','(',')','_','+','-','=',
'{','}','[',']',':',';','"','''','\','|','/','?','.','>',',','<'
$a -gt 'a'
# Output: Nothing
Jika dua sisi operator tidak sebanding secara wajar, operator ini menimbulkan kesalahan yang tidak mengakhiri.
Operator yang cocok
Operator yang cocok (-like, -notlike, , -matchdan -notmatch) menemukan elemen yang cocok atau tidak cocok dengan pola tertentu. Pola untuk -like dan -notlike adalah ekspresi kartubebas (berisi *, , ?dan [ ]), sementara -match dan -notmatch menerima ekspresi reguler (Regex).
Sintaksnya adalah:
<string[]> -like <wildcard-expression>
<string[]> -notlike <wildcard-expression>
<string[]> -match <regular-expression>
<string[]> -notmatch <regular-expression>
Ketika input operator ini adalah nilai skalar, mereka mengembalikan nilai Boolean .
Saat input adalah kumpulan nilai, setiap item dalam koleksi dikonversi ke string untuk perbandingan. Operator -match dan -notmatch mengembalikan masing-masing anggota yang cocok dan tidak cocok. Namun, -like operator dan -notlike mengembalikan anggota sebagai string. String yang dikembalikan untuk anggota koleksi oleh -like dan -notlike merupakan string yang digunakan operator untuk perbandingan dan diperoleh dengan mentransmisikan anggota ke string.
-like dan -notlike
-like dan -notlike berulah mirip dengan -eq dan -ne, tetapi sisi kanan bisa menjadi string yang berisi kartubebas.
Contoh:
"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 dan -notmatch
-match dan -notmatch gunakan ekspresi reguler untuk mencari pola di nilai sisi kiri. Ekspresi reguler dapat mencocokkan pola kompleks seperti alamat email, jalur UNC, atau nomor telepon yang diformat. String sisi kanan harus mematuhi aturan ekspresi reguler.
Contoh skalar:
# 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
Jika input adalah koleksi, operator mengembalikan anggota yang cocok dari koleksi tersebut.
Contoh koleksi:
"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 dan -notmatch mendukung grup pengambilan regex. Setiap kali berjalan pada input skalar, dan -match hasilnya adalah True, atau -notmatch hasilnya adalah False, mereka menimpa $Matches variabel otomatis. $Matches adalah Hashtable yang selalu memiliki kunci bernama '0', yang menyimpan seluruh kecocokan.
Jika ekspresi reguler berisi grup pengambilan, berisi $Matches kunci tambahan untuk setiap grup.
Penting untuk dicatat bahwa $Matches hashtable hanya berisi kemunculan pertama dari pola pencocokan apa pun.
Contoh:
$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
Ketika hasilnya -match False, atau hasilnya -notmatch adalah True, atau ketika input adalah koleksi, $Matches variabel otomatis tidak ditimpa. Akibatnya, itu akan berisi nilai yang ditetapkan sebelumnya, atau $null jika variabel belum ditetapkan. Saat mereferensikan $Matches setelah memanggil salah satu operator ini, pertimbangkan untuk memverifikasi bahwa variabel diatur oleh pemanggilan operator saat ini menggunakan pernyataan kondisi.
Contoh:
if ("<version>1.0.0</version>" -match '<version>(.*?)</version>') {
$Matches
}
Untuk detailnya, lihat about_Regular_Expressions dan about_Automatic_Variables.
Operator pengganti
Penggantian dengan ekspresi reguler
Seperti -match, -replace operator menggunakan ekspresi reguler untuk menemukan pola yang ditentukan. Tetapi tidak seperti -match, itu menggantikan kecocokan dengan nilai lain yang ditentukan.
Sintaks:
<input> -replace <regular-expression>, <substitute>
Operator mengganti semua atau sebagian nilai dengan nilai yang ditentukan menggunakan ekspresi reguler. Anda dapat menggunakan operator untuk banyak tugas administratif, seperti mengganti nama file. Misalnya, perintah berikut mengubah ekstensi nama file dari semua .txt file menjadi .log:
Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace '\.txt$','.log' }
Secara default, -replace operator tidak peka huruf besar/kecil. Untuk membuatnya peka huruf besar/kecil, gunakan -creplace. Untuk membuatnya secara eksplisit tidak peka huruf besar/kecil, gunakan -ireplace.
Contoh:
"book" -ireplace "B", "C" # Case insensitive
"book" -creplace "B", "C" # Case-sensitive; hence, nothing to replace
Cook
book
Dimulai di PowerShell 7.2, saat operand sebelah kiri dalam -replace pernyataan operator bukan string, operand tersebut dikonversi menjadi string.
PowerShell melakukan konversi string yang tidak peka budaya.
Misalnya, jika budaya Anda diatur ke Bahasa Prancis (fr), konversi nilai 1.2 string yang sensitif terhadap budaya adalah 1,2.
Sebelum PowerShell 7.2:
PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
12
Di PowerShell 7.2 dan yang lebih baru:
PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
1.2
Substitusi ekspresi reguler
Dimungkinkan juga untuk menggunakan ekspresi reguler untuk mengganti teks secara dinamis menggunakan menangkap grup, dan substitusi. Grup pengambilan dapat direferensikan dalam <substitute> string menggunakan karakter tanda dolar ($) sebelum pengidentifikasi grup.
Dalam contoh berikut, -replace operator menerima nama pengguna dalam bentuk DomainName\Username dan dikonversi ke Username@DomainName format :
$SearchExp = '^(?<DomainName>[\w-.]+)\\(?<Username>[\w-.]+)$'
$ReplaceExp = '${Username}@${DomainName}'
'Contoso.local\John.Doe' -replace $SearchExp, $ReplaceExp
John.Doe@Contoso.local
Peringatan
Karakter $ ini memiliki peran sintaktik dalam PowerShell dan ekspresi reguler:
- Di PowerShell, di antara tanda kutip ganda, powerShell menunjuk variabel dan bertindak sebagai operator subekspresi.
- Dalam string pencarian Regex, ini menunjukkan akhir baris.
- Dalam string substitusi Regex, ini menunjukkan grup yang diambil. Pastikan untuk menempatkan ekspresi reguler Anda di antara tanda kutip tunggal atau sisipkan karakter backtick (
`) di depannya.
Contohnya:
$1 = 'Goodbye'
'Hello World' -replace '(\w+) \w+', "$1 Universe"
# Output: Goodbye Universe
'Hello World' -replace '(\w+) \w+', '$1 Universe'
# Output: Hello Universe
$$ di Regex menunjukkan literal $. Ini $$ dalam string pengganti untuk menyertakan literal $ dalam penggantian yang dihasilkan. Contohnya:
'5.72' -replace '(.+)', '$ $1' # Output: $ 5.72
'5.72' -replace '(.+)', '$$$1' # Output: $5.72
'5.72' -replace '(.+)', '$$1' # Output: $1
Untuk mempelajari selengkapnya, lihat about_Regular_Expressions dan Substitusi dalam Ekspresi Reguler.
Mengganti dalam koleksi
<input> Ketika operator ke -replace adalah koleksi, PowerShell menerapkan penggantian ke setiap nilai dalam koleksi. Contohnya:
"B1","B2","B3","B4","B5" -replace "B", 'a'
a1
a2
a3
a4
a5
Penggantian dengan blok skrip
Di PowerShell 6 dan yang -replace lebih baru, operator juga menerima blok skrip yang melakukan penggantian. Blok skrip berjalan sekali untuk setiap kecocokan.
Sintaks:
<String> -replace <regular-expression>, {<Script-block>}
Dalam blok skrip, gunakan $_ variabel otomatis untuk mengakses teks input yang diganti dan informasi berguna lainnya. Jenis kelas variabel ini adalah System.Text.RegularExpressions.Match.
Contoh berikut menggantikan setiap urutan tiga digit dengan karakter yang setara. Blok skrip berjalan untuk setiap set tiga digit yang perlu diganti.
"072101108108111" -replace "\d{3}", {return [char][int]$_.Value}
Hello
Operator penahanan
Operator penahanan (-contains, -notcontains, -in, dan -notin) mirip dengan operator kesetaraan, kecuali bahwa operator selalu mengembalikan nilai Boolean , bahkan ketika input adalah koleksi. Operator ini berhenti membandingkan segera setelah mendeteksi kecocokan pertama, sedangkan operator kesetaraan mengevaluasi semua anggota input. Dalam koleksi yang sangat besar, operator ini mengembalikan lebih cepat daripada operator kesetaraan.
-contains dan -notcontains
Sintaks:
<Collection> -contains <scalar-object>
<Collection> -notcontains <scalar-object>
Operator ini memberi tahu apakah satu set menyertakan elemen tertentu. -containsmengembalikan True saat sisi kanan (objek skalar) cocok dengan salah satu elemen dalam set. -notcontains mengembalikan False sebagai gantinya.
Contoh:
"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
Contoh yang lebih kompleks:
$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
"ContosoDHCP","ContosoWSUS"
$thisComputer = "ContosoDC2"
$DomainServers -contains $thisComputer
# Output: True
Ketika operand sisi kanan adalah koleksi, operator ini mengonversi nilai ke representasi stringnya sebelum membandingkannya dengan koleksi sisi kiri.
$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 dan -notin
Sintaks:
<scalar-object> -in <Collection>
<scalar-object> -notin <Collection>
Operator -in dan -notin diperkenalkan di PowerShell 3 sebagai kebalikan syntactic dari -contains operator dan -notcontains . -inmengembalikan True saat sisi <scalar-object> kiri cocok dengan salah satu elemen dalam koleksi. -notin mengembalikan False sebagai gantinya.
Contoh berikut melakukan hal yang sama seperti contoh -contains dan -notcontains lakukan, tetapi ditulis dengan -in dan -notin sebagai gantinya.
"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
Contoh yang lebih kompleks:
$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
"ContosoDHCP","ContosoWSUS"
$thisComputer = "ContosoDC2"
$thisComputer -in $DomainServers
# Output: True
Ketika operand sisi kiri adalah koleksi, operator ini mengonversi nilai ke representasi stringnya sebelum membandingkannya dengan koleksi sisi kanan.
$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
Perbandingan jenis
Operator perbandingan jenis (-is dan -isnot) digunakan untuk menentukan apakah objek adalah jenis tertentu.
Sintaks:
<object> -is <type-reference>
<object> -isnot <type-reference>
Contoh:
$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
Lihat juga
Saran dan Komentar
Segera hadir: Sepanjang tahun 2024 kami akan menghentikan penggunaan GitHub Issues sebagai mekanisme umpan balik untuk konten dan menggantinya dengan sistem umpan balik baru. Untuk mengetahui informasi selengkapnya, lihat: https://aka.ms/ContentUserFeedback.
Kirim dan lihat umpan balik untuk