tentang_Operator_Perbandingan

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- -cmatch string cocok dengan pola regex
-notmatch, , -inotmatch-cnotmatch - string tidak cocok dengan pola regex

Suku Cadang Perangkat Keras

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

Penahanan

-contains, , -icontains-ccontains - koleksi berisi nilai
-notcontains, , -inotcontains-cnotcontains - koleksi tidak berisi nilai
-in, -iin, -cin - nilai ada dalam koleksi
-notin, -inotin, -cnotin - 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 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 tangan kanan selalu diperlakukan sebagai instans singleton, bahkan ketika mereka adalah koleksi. Operator perbandingan tidak dapat membandingkan koleksi secara efektif dengan koleksi.

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

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

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

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

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 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 lebih baru, -replace operator juga menerima blokir 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. Blokir 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. -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

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

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

-like dan -notlike

-match dan -notmatch

Operator pengganti

Penggantian dengan ekspresi reguler

Substitusi 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: