tentang_Operator_Perbandingan

Deskripsi singkat

Operator perbandingan di PowerShell dapat membandingkan dua nilai atau menyaring elemen koleksi berdasarkan 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 pola wildcard
-notlike, -inotlike, -cnotlike - string tidak cocok dengan pola wildcard
-match, -imatch, -cmatch - string cocok dengan pola regex
-notmatch, -inotmatch, -cnotmatch - string tidak cocok dengan pola regex

Penggantian

-replace, , -ireplace-creplace - menemukan dan mengganti string yang cocok dengan pola regex

Penahanan

-contains, -icontains, -ccontains - koleksi berisi sebuah nilai
-notcontains, -inotcontains, -cnotcontains - koleksi tidak mengandung nilai
-in, -iin, -cin - nilai adalah bagian dari sebuah koleksi
-notin, -inotin, -cnotin - nilai tidak ada dalam koleksi

Tipe

-is - kedua objek memiliki jenis yang sama
-isnot - objek bukan tipe yang sama

Fitur umum

Perbandingan string tidak sensitif terhadap huruf besar/kecil kecuali Anda menggunakan operator peka huruf besar/kecil secara eksplisit. Untuk membuat operator perbandingan peka huruf besar/kecil, tambahkan c setelah -. Misalnya, -ceq adalah versi sensitif huruf besar/kecil dari -eq. Untuk membuat ketidakpekaan huruf besar/kecil menjadi eksplisit, tambahkan i setelah -. Misalnya, -ieq adalah versi -eqyang dengan jelas tidak peka huruf besar/kecil.

Perbandingan-perbandingan string menggunakan InvariantCulture untuk perbandingan yang sensitif terhadap huruf besar/kecil dan yang tidak sensitif terhadap huruf besar/kecil. Perbandingan dilakukan antara titik kode Unicode dan tidak menggunakan urutan pengurutan khusus budaya. Hasilnya sama terlepas dari budaya saat ini.

Saat nilai sebelah kiri dalam ekspresi perbandingan adalah nilai skalar, operator mengembalikan nilai Boolean. Saat nilai sebelah kiri dalam ekspresi adalah koleksi, operator mengembalikan elemen koleksi yang cocok dengan nilai kanan ekspresi. Nilai di sisi kanan selalu diperlakukan sebagai instance tunggal, bahkan ketika mereka adalah koleksi. Operator perbandingan tidak dapat membandingkan antara sesama koleksi secara efektif.

Jika tidak ada kecocokan dalam koleksi, operator perbandingan mengembalikan array kosong. Misalnya:

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

Object[]
0

Ada beberapa pengecualian:

Operator pembatasan dan jenis selalu mengembalikan nilai Boolean
Operator -replace mengembalikan hasil penggantian
Operator -match dan -notmatch juga mengisi variabel otomatis $Matches kecuali bagian kiri dari ekspresi tersebut adalah sebuah koleksi.

Operator Kesetaraan

-eq dan -ne

Saat sisi kiri bernilai skalar, -eq mengembalikan True jika sisi kanannya setara, jika tidak, -eq mengembalikan False. -ne melakukan sebaliknya; mengembalikan False ketika kedua belah pihak 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 berupa koleksi, -eq mengembalikan anggota yang sesuai dengan sisi kanan, sedangkan -ne mengeluarkannya.

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, tidak terbatas hanya pada 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 False karena mereka adalah 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.IEquatableT dan memiliki dua properti, File dan Size. Metode mengembalikan True jika properti File dan Ukuran 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 $null, Anda harus meletakkan $null di sisi kiri operator kesetaraan. Meletakkannya di sisi kanan tidak menghasilkan hasil yang Anda harapkan.

Misalnya, biarkan $a menjadi array yang berisi elemen null:

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

Pengujian berikut memastikan bahwa $a tidak null.

$null -ne $a

True

Namun, berikut ini menyaring semua elemen null dari $a:

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

-gt, -ge, -lt, dan -le

-gt, -ge, -lt, dan -le ber perilaku yang sangat mirip. Ketika kedua sisi adalah skalar, mereka mengembalikan True atau False tergantung pada bagaimana kedua sisi dibandingkan.

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

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

Nota

Dalam sebagian besar bahasa pemrograman, operator lebih besar dari adalah >. Di PowerShell, karakter ini digunakan untuk pengalihan. Untuk detailnya, lihat about_Redirection.

Ketika bagian kiri adalah himpunan, operator ini membandingkan setiap anggota himpunan tersebut dengan bagian 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 operator -gt untuk membandingkannya dengan 'a'. Outputnya adalah array kosong.

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

Jika dua sisi operator tidak cukup sebanding, operator ini menimbulkan kesalahan yang tidak dapat diakhiri.

Operator yang cocok

Operator yang cocok (-like, -notlike, -match, dan -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, setiap item dalam koleksi dikonversi ke string untuk perbandingan. Operator -match dan -notmatch mengembalikan masing-masing anggota yang cocok dan tidak cocok. Namun, operator -like dan -notlike mengembalikan anggota sebagai string. String yang dikembalikan untuk anggota koleksi dengan -like dan -notlike adalah string yang digunakan operator untuk perbandingan dan diperoleh dengan mengonversi anggota ke string.

-seperti dan -notlike

-like dan -notlike bertindak mirip dengan -eq dan -ne, tetapi sisi kanan dapat berupa string yang berisi karakter pengganti dengan.

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

Untuk hasil terbaik, sisi -like kanan operator dan -notlike harus berupa string harfiah yang berisi ekspresi kartubebas. PowerShell meneruskan ekspresi kartubebas ke pengurai ekspresi kartubebas. Untuk mencocokkan salah satu karakter kartubebas (*, , atau ?), Anda harus melepaskannya dengan karakter backtick ([ ]`). Misalnya, untuk mencocokkan literal ?, gunakan `? dalam ekspresi kartubebas. Jika Anda menggunakan ekspresi string yang dapat diperluas PowerShell memperluas string sebelum meneruskannya ke pengurai kartubebas, yang mengakibatkan karakter yang tidak dilewati dikirim sebagai wildcard.

# 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 dan -notmatch

-match dan -notmatch menggunakan 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 ekspresi reguler aturan.

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 kumpulan, operator mengembalikan anggota yang cocok dari kumpulan 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 mereka dijalankan dengan input skalar, dan menghasilkan hasil -matchTrue, atau menghasilkan hasil -notmatchFalse, mereka menimpa variabel otomatis $Matches. $Matches merupakan Hashtable yang selalu memiliki kunci bernama '0', yang menyimpan seluruh kecocokan. Jika ekspresi reguler berisi grup tangkapan, $Matches berisi kunci tambahan untuk setiap grup.

Penting untuk dicatat bahwa hashtable $Matches 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 hasil dari -matchFalse, atau hasil dari -notmatchTrue, atau ketika input berupa koleksi, maka variabel otomatis $Matches 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 rinciannya, lihat about_Regular_Expressions dan about_Automatic_Variables.

Operator pengganti

Penggantian dengan ekspresi reguler

Seperti -match, operator -replace menggunakan ekspresi reguler untuk menemukan pola yang ditentukan. Tetapi tidak seperti -match, ini menggantikan padanan dengan nilai yang telah ditentukan.

Sintaksis:

<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 file .txt menjadi .log:

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

Secara default, operator -replace 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 pernyataan operator -replace bukan string, operand tersebut dikonversi menjadi string. PowerShell melakukan konversi string tanpa memperhatikan budaya.

Misalnya, jika pengaturan lokal Anda diatur ke Prancis (fr), konversi string yang peka budaya dari nilai 1.2 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 dengan ekspresi reguler

Dimungkinkan juga untuk menggunakan ekspresi reguler untuk mengganti teks secara dinamis menggunakan grup tangkapan, dan penggantian. Grup pengambilan dapat direferensikan dalam string <substitute> menggunakan karakter tanda dolar ($) sebelum pengidentifikasi grup.

Dalam contoh berikut, operator -replace menerima nama pengguna dalam bentuk DomainName\Username dan mengonversi ke format Username@DomainName:

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

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

John.Doe@Contoso.local

Peringatan

Karakter $ memiliki peran sintaktik dalam PowerShell dan ekspresi reguler:

Di PowerShell, di antara tanda kutip ganda, ia menunjuk variabel dan bertindak sebagai operator sub-ekspresi.
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.

Misalnya:

$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 $harfiah . Gunakan $$ dalam string pengganti untuk memasukkan $ sebagai teks literal dalam hasil penggantian. Misalnya:

'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

Saat <input> ke operator -replace adalah koleksi, PowerShell menerapkan penggantian ke setiap nilai dalam koleksi. Misalnya:

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

Penggantian dengan blok skrip

Di PowerShell 6 dan yang lebih baru, -replace operator juga menerima blokir skrip yang melakukan penggantian. Blok skrip berjalan sekali untuk setiap kecocokan.

Sintaksis:

<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 System.Text.RegularExpressions.Match.

Contoh berikut menggantikan setiap urutan tiga digit dengan karakter yang setara. Blokir skrip berjalan untuk setiap set tiga digit yang perlu diganti.

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

Hello

Operator penahanan

Operator penahanan (, , , dan ) mirip dengan operator kesetaraan, kecuali bahwa mereka 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

Sintaksis:

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

Operator ini memberi tahu apakah satu set menyertakan elemen tertentu. -contains mengembalikan 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

Sintaksis:

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

Operator -in dan -notin diperkenalkan di PowerShell 3 sebagai kebalikan sintetis operator -contains dan -notcontains. -in mengembalikan True saat sisi kiri <scalar-object> cocok dengan salah satu elemen dalam koleksi. -notin mengembalikan False sebagai gantinya.

Contoh berikut melakukan hal yang sama seperti contoh untuk -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.

Sintaksis:

<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

Apakah halaman ini membantu?

Last updated on 2026-01-18

Bagikan melalui

tentang_Operator_Perbandingan

Deskripsi singkat

Deskripsi panjang

Fitur umum

Operator Kesetaraan

-eq dan -ne

-gt, -ge, -lt, dan -le

Operator yang cocok

-seperti dan -notlike

-match dan -notmatch

Operator pengganti

Penggantian dengan ekspresi reguler

Substitusi dengan ekspresi reguler

Mengganti dalam koleksi

Penggantian dengan blok skrip

Operator penahanan

-contains dan -notcontains

-in dan -notin

Perbandingan jenis

Lihat juga

Saran dan Komentar

Sumber Daya Tambahan: