about_Comparison_Operators

Deskripsi singkat

Operator perbandingan di PowerShell dapat membandingkan dua nilai atau memfilter elemen koleksi dengan nilai input.

Deskripsi panjang

Operator perbandingan memungkinkan Anda membandingkan nilai atau menemukan nilai yang cocok dengan pola tertentu. PowerShell menyertakan operator perbandingan berikut:

Persamaan

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

Matching

  • -like, , -ilike-clike - string cocok dengan pola kartubebas
  • -notlike, , -inotlike-cnotlike - string tidak cocok dengan pola kartubebas
  • -match, , -imatch-cmatch - string cocok dengan pola regex
  • -notmatch, , -inotmatch-cnotmatch - string tidak cocok dengan pola regex

Pengganti

  • -replace, -ireplace, -creplace - menggantikan 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.

Ketika 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 -replace mengembalikan hasil penggantian
  • Operator -match dan -notmatch juga mengisi $Matches variabel otomatis kecuali sisi kiri ekspresi adalah koleksi.

Operator kesetaraan

-eq dan -ne

Saat sisi kiri bernilai skalar, -eq mengembalikan True jika sisi kanan sama persis, jika tidak, -eq mengembalikan False. -ne melakukan kebalikannya; mengembalikan False ketika kedua sisi cocok; 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 berada 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 menjadi string untuk dibandingkan dengan string '1.0'. Contoh ini mengembalikan False.

PS> '1.0' -eq 1
False

Operator kesetaraan menerima dua objek apa pun, bukan hanya skalar atau koleksi. Tetapi hasil perbandingan tidak dijamin bermakna bagi pengguna akhir. Contoh berikut menunjukkan masalahnya.

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 mengembalikan Equals()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 dari 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 ber perilaku sangat mirip. Ketika kedua sisi bernila skalar, keduanya mengembalikan True atau False tergantung pada perbandingan kedua belah pihak:

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 satu set yang berisi semua simbol tersebut ke -gt operator untuk membandingkannya dengan 'a'. Outputnya adalah array kosong.

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

Jika kedua sisi operator tidak sebanding secara wajar, operator ini menimbulkan kesalahan yang tidak mengakhiri proses.

Operator yang cocok

Operator yang cocok (-like, -notlike, , -matchdan -notmatch) menemukan elemen yang cocok atau tidak cocok dengan pola yang ditentukan. 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, operator mengembalikan anggota yang cocok. Jika tidak ada kecocokan dalam koleksi, operator mengembalikan array kosong.

-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 koleksi yang cocok.

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 dijalankan 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 -matchFalse, atau -notmatch hasilnya 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, ia 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

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 sintaksis dalam PowerShell dan ekspresi reguler:

  • Di PowerShell, di antara tanda kutip ganda, ia 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

$$ dalam Regex menunjukkan harfiah $. Ini $$ dalam string pengganti untuk menyertakan harfiah $ 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> Saat 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.

Sintaks:

<Collection> -contains <Test-object>
<Collection> -notcontains <Test-object>
<Test-object> -in <Collection>
<Test-object> -notin <Collection>

-contains dan -notcontains

Operator ini memberi tahu apakah satu set menyertakan elemen tertentu. -contains mengembalikan True saat sisi kanan (objek pengujian) cocok dengan salah satu elemen dalam set. -notcontains mengembalikan False sebagai gantinya. Ketika objek pengujian adalah koleksi, operator ini menggunakan kesetaraan referensi, yaitu mereka memeriksa apakah salah satu elemen set adalah instans yang sama dari objek pengujian.

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

$a = "abc", "def"
"abc", "def", "ghi" -contains $a # Output: False
$a, "ghi" -contains $a           # Output: True

-in dan -notin

Operator -in dan -notin diperkenalkan di PowerShell 3 sebagai kebalikan sintaks dari -contains operator dan -notcontains . -in mengembalikan True saat sisi <test-object> kiri cocok dengan salah satu elemen dalam set. -notin mengembalikan False sebagai gantinya. Ketika objek pengujian adalah set, operator ini menggunakan kesetaraan referensi untuk memeriksa apakah salah satu elemen set adalah instans yang sama dari objek pengujian.

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

$a = "abc", "def"
$a -in "abc", "def", "ghi" # Output: False
$a -in $a, "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