เกี่ยวกับตัวดำเนินการเปรียบเทียบ

คำอธิบายสั้น ๆ

ตัวดำเนินการเปรียบเทียบใน PowerShell สามารถเปรียบเทียบสองค่าหรือกรององค์ประกอบของคอลเลกชันกับค่าอินพุตได้

คำอธิบายยาว

ตัวดำเนินการเปรียบเทียบทำให้คุณสามารถเปรียบเทียบค่าหรือค้นหาค่าที่ตรงกับรูปแบบที่ระบุได้ PowerShell มีตัวดำเนินการเปรียบเทียบต่อไปนี้:

ความเท่าเทียมกัน

• -eq, -ieq, -ceq - เท่ากับ
• -ne, -ine, -cne - ไม่เท่ากับ
• -gt, -igt, -cgt - มากกว่า
• -ge, -ige, -cge - มากกว่าหรือเท่ากับ
• -lt, -ilt, -clt - น้อยกว่า
• -le, -ile, -cle - น้อยกว่าหรือเท่ากับ

การจับคู่

• -like, -ilike, -clike - สตริงตรงกับรูปแบบไวด์การ์ด
• -notlike, -inotlike, -cnotlike - สตริงไม่ตรงกับรูปแบบไวด์การ์ด
• -match, -imatch, -cmatch - สตริงตรงกับรูปแบบ regex
• -notmatch, -inotmatch, -cnotmatch - สตริงไม่ตรงกับรูปแบบ regex

การแทนที่

• -replace, -ireplace, -creplace - แทนที่สตริงที่ตรงกับรูปแบบ regex

การควบคุม

• -contains, -icontains, -ccontains - คอลเลกชันประกอบด้วยค่า
• -notcontains, -inotcontains, -cnotcontains - คอลเลกชันไม่มีค่า
• -in - ค่าอยู่ในคอลเลกชัน
• -notin - ค่าไม่ได้อยู่ในคอลเลกชัน

ประเภท

• -is - วัตถุทั้งสองเป็นประเภทเดียวกัน
• -isnot - ออบเจ็กต์ไม่ใช่ประเภทเดียวกัน

คุณสมบัติทั่วไป

การเปรียบเทียบสตริงจะคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ เว้นแต่คุณจะใช้ตัวดำเนินการที่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ หากต้องการให้ตัวดำเนินการเปรียบเทียบคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ให้เพิ่ม c หลัง - ตัวอย่างเช่น -ceq เป็นเวอร์ชันที่คำนึงถึงตัวพิมพ์เล็กและใหญ่ของ -eq หากต้องการทำให้การพิจารณาตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ชัดเจน ให้เพิ่ม i หลัง - ตัวอย่างเช่น -ieq เป็นเวอร์ชันที่ไม่คำนึงถึงขนาดตัวพิมพ์ของ -eq

การเปรียบเทียบสตริงใช้ InvariantCulture สำหรับการเปรียบเทียบทั้งแบบคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ การเปรียบเทียบอยู่ระหว่างจุดโค้ดยูนิโค้ดและไม่ใช้การเรียงลำดับเฉพาะวัฒนธรรม ผลลัพธ์จะเหมือนกันโดยไม่คำนึงถึงวัฒนธรรมในปัจจุบัน

เมื่อค่าทางซ้ายมือในนิพจน์การเปรียบเทียบเป็นค่าสเกลาร์ ตัวดำเนินการจะส่งกลับค่า บูลีน เมื่อค่าทางซ้ายในนิพจน์เป็นคอลเลกชัน ตัวดำเนินการจะส่งกลับองค์ประกอบของคอลเลกชันที่ตรงกับค่าทางขวาของนิพจน์ ค่าทางขวาจะถือเป็นอินสแตนซ์ซิงเกิลตันเสมอ แม้ว่าจะเป็นคอลเล็กชันก็ตาม ตัวดำเนินการเปรียบเทียบไม่สามารถเปรียบเทียบคอลเลกชันกับคอลเลกชันได้อย่างมีประสิทธิภาพ

หากไม่มีรายการที่ตรงกันในคอลเลกชัน ตัวดำเนินการเปรียบเทียบจะส่งกลับอาร์เรย์ว่าง ตัวอย่างเช่น:

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

Object[]
0

มีข้อยกเว้นบางประการ:

• ตัวดำเนินการบรรจุและประเภทส่งคืนค่า บูลีน เสมอ
• ตัวดำเนินการ -replace ส่งคืนผลลัพธ์การแทนที่
• ตัวดำเนินการ -match และ -notmatch ยังเติมตัวแปรอัตโนมัติ $Matches อีกด้วย เว้นแต่ด้านซ้ายของนิพจน์จะเป็นคอลเล็กชัน

ตัวดำเนินการที่เท่าเทียมกัน

<รหัส>-eq และ -ne

เมื่อด้านซ้ายมือเป็นสเกลาร์ -eq จะส่งกลับค่า True หากทางด้านขวามือเทียบเท่ากัน มิฉะนั้น -eq จะส่งกลับ เท็จ -ne ทำสิ่งที่ตรงกันข้าม จะส่งกลับ เท็จ เมื่อทั้งสองฝ่ายเท่ากัน มิฉะนั้น -ne จะส่งกลับ True

ตัวอย่าง :

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

เมื่อด้านซ้ายมือเป็นคอลเลกชัน -eq จะส่งกลับสมาชิกที่ตรงกับด้านขวามือ ในขณะที่ -ne จะกรองออก

ตัวอย่าง :

1,2,3 -eq 2             # Output: 2
"abc", "def" -eq "abc"  # Output: abc
"abc", "def" -ne "abc"  # Output: def

ตัวดำเนินการเหล่านี้ประมวลผลองค์ประกอบทั้งหมดของคอลเลกชัน ตัวอย่าง:

"zzz", "def", "zzz" -eq "zzz"

zzz
zzz

ตัวดำเนินการความเท่าเทียมกันสามารถเปรียบเทียบวัตถุประเภทต่างๆ ได้ สิ่งสำคัญคือต้องเข้าใจว่าค่าทางด้านขวามือของการเปรียบเทียบสามารถแปลงเป็นประเภทของค่าด้านซ้ายมือสำหรับการเปรียบเทียบได้

ตัวอย่างเช่น สตริง '1.0' จะถูกแปลงเป็นจำนวนเต็มเพื่อเปรียบเทียบกับค่า 1 ตัวอย่างนี้ส่งคืน True

PS> 1 -eq '1.0'
True

ในตัวอย่างนี้ ค่า 1 จะถูกแปลงเป็นสตริงที่จะเปรียบเทียบกับสตริง '1.0' ตัวอย่างนี้ส่งคืน False

PS> '1.0' -eq 1
False

ตัวดำเนินการความเท่าเทียมกันยอมรับสองวัตถุใดๆ ไม่ใช่แค่สเกลาร์หรือคอลเลกชัน แต่ไม่รับประกันว่าผลการเปรียบเทียบจะมีความหมายต่อผู้ใช้ปลายทาง ตัวอย่างต่อไปนี้แสดงให้เห็นถึงปัญหา

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

ในตัวอย่างนี้ เราได้สร้างวัตถุสองชิ้นที่มีคุณสมบัติเหมือนกัน แต่ผลการทดสอบความเท่าเทียมกันกลับ เท็จ เนื่องจากเป็นวัตถุที่แตกต่างกัน หากต้องการสร้างคลาสที่เปรียบเทียบได้ คุณจะต้องใช้ System.IEquatable ในคลาสของคุณ ตัวอย่างต่อไปนี้สาธิตการใช้งานบางส่วนของคลาส MyFileInfoSet ที่ใช้ System.IEquatable และมีคุณสมบัติสองประการ ได้แก่ ไฟล์ และ ขนาด เมธอด Equals() ส่งคืน True หากคุณสมบัติ File และ Size ของอ็อบเจ็กต์ MyFileInfoSet สองรายการเหมือนกัน

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

ตัวอย่างที่โดดเด่นของการเปรียบเทียบวัตถุใดๆ คือการดูว่าวัตถุนั้นเป็นโมฆะหรือไม่ แต่ถ้าคุณต้องการตรวจสอบว่าตัวแปรเป็น $null หรือไม่ คุณต้องใส่ $null ทางด้านซ้ายมือของตัวดำเนินการความเท่าเทียมกัน การวางไว้ทางขวามือไม่ได้เป็นไปตามที่คุณคาดหวัง

ตัวอย่างเช่น ให้ $a เป็นอาร์เรย์ที่มีองค์ประกอบว่าง:

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

การทดสอบต่อไปนี้ว่า $a ไม่เป็นโมฆะ

$null -ne $a

True

อย่างไรก็ตาม ไฟล์ต่อไปนี้จะกรององค์ประกอบว่างทั้งหมดออกจาก $a:

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

1
2
4
6

<รหัส>-gt, -ge, -lt และ -le

-gt, -ge, -lt และ -le มีพฤติกรรมคล้ายกันมาก เมื่อทั้งสองฝ่ายเป็นสเกลาร์ ก็จะส่งกลับค่า จริง หรือ เท็จ ขึ้นอยู่กับว่าทั้งสองข้างเปรียบเทียบกันอย่างไร:

-gt

ด้านซ้ายมือมีขนาดใหญ่กว่า

-ge

ด้านซ้ายมือมีค่ามากกว่าหรือเท่ากัน

-lt

ด้านซ้ายจะเล็กกว่า

-le

ด้านซ้ายจะเล็กกว่าหรือเท่ากัน

ในตัวอย่างต่อไปนี้ คำสั่งทั้งหมดจะส่งกลับ True

8 -gt 6  # Output: True
8 -ge 8  # Output: True
6 -lt 8  # Output: True
8 -le 8  # Output: True

เมื่อด้านซ้ายมือเป็นคอลเลกชัน ตัวดำเนินการเหล่านี้จะเปรียบเทียบสมาชิกของคอลเลกชันแต่ละรายการกับด้านขวามือ ขึ้นอยู่กับตรรกะ พวกเขาอาจเก็บหรือละทิ้งสมาชิก

ตัวอย่าง :

$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

ตัวดำเนินการเหล่านี้ทำงานกับคลาสใดๆ ที่ใช้ System.IComparable

ตัวอย่าง:

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

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าไม่มีสัญลักษณ์บนแป้นพิมพ์ QWERTY อเมริกันที่ถูกจัดเรียงตามหลัง 'a' โดยจะป้อนชุดที่มีสัญลักษณ์ดังกล่าวทั้งหมดไปยังตัวดำเนินการ -gt เพื่อเปรียบเทียบกับ 'a' ผลลัพธ์เป็นอาร์เรย์ว่าง

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

หากตัวดำเนินการทั้งสองด้านไม่สามารถเปรียบเทียบได้อย่างสมเหตุสมผล ตัวดำเนินการเหล่านี้จะทำให้เกิดข้อผิดพลาดที่ไม่สิ้นสุด

โอเปอเรเตอร์ที่ตรงกัน

โอเปอเรเตอร์ที่ตรงกัน (-like, -notlike, -match และ -notmatch) ค้นหาองค์ประกอบที่ตรงกันหรือ ไม่ตรงกับรูปแบบที่ระบุ รูปแบบของ -like และ -notlike เป็นนิพจน์ไวด์การ์ด (ประกอบด้วย *, ? และ [ ]) ในขณะที่ -match และ -notmatch ยอมรับนิพจน์ทั่วไป (Regex)

ไวยากรณ์คือ:

<string[]> -like    <wildcard-expression>
<string[]> -notlike <wildcard-expression>
<string[]> -match    <regular-expression>
<string[]> -notmatch <regular-expression>

เมื่ออินพุตของโอเปอเรเตอร์เหล่านี้เป็นค่าสเกลาร์ ก็จะส่งกลับค่า บูลีน

เมื่ออินพุตเป็นชุดของค่า แต่ละรายการในคอลเลกชันจะถูกแปลงเป็นสตริงเพื่อการเปรียบเทียบ ตัวดำเนินการ -match และ -notmatch ส่งคืนสมาชิกที่ตรงกันและไม่ตรงกันตามลำดับ อย่างไรก็ตาม ตัวดำเนินการ -like และ -notlike จะส่งคืนสมาชิกเป็นสตริง สตริงที่ส่งคืนสำหรับสมาชิกของคอลเลกชันโดย -like และ -notlike คือสตริงที่ตัวดำเนินการใช้สำหรับการเปรียบเทียบ และได้รับมาจากการส่งสมาชิกไปยังสตริง

-เหมือน และ -ไม่เหมือน

-like และ -notlike มีพฤติกรรมคล้ายกับ -eq และ -ne แต่ทางด้านขวามืออาจเป็น สตริงที่มีไวด์การ์ด

ตัวอย่าง :

"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 และ -notmatch ใช้นิพจน์ทั่วไปเพื่อค้นหารูปแบบในค่าด้านซ้ายมือ นิพจน์ทั่วไปสามารถจับคู่รูปแบบที่ซับซ้อน เช่น ที่อยู่อีเมล เส้นทาง UNC หรือหมายเลขโทรศัพท์ที่จัดรูปแบบ สตริงทางด้านขวาจะต้องเป็นไปตามกฎนิพจน์ทั่วไป

ตัวอย่างสเกลาร์:

# 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

หากอินพุตเป็นคอลเลกชัน ตัวดำเนินการจะส่งคืนสมาชิกที่ตรงกันของคอลเลกชันนั้น

ตัวอย่างคอลเลกชัน:

"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 และ -notmatch รองรับกลุ่มการบันทึก regex แต่ละครั้งที่ทำงานบนอินพุตสเกลาร์ และผลลัพธ์ -match เป็น True หรือผลลัพธ์ -notmatch เป็น False > จะเขียนทับตัวแปรอัตโนมัติ $Matches $Matches คือ Hashtable ที่มีคีย์ชื่อ '0' เสมอ ซึ่งจะเก็บการจับคู่ทั้งหมด หากนิพจน์ทั่วไปมีกลุ่มการจับ $Matches จะมีคีย์เพิ่มเติมสำหรับแต่ละกลุ่ม

สิ่งสำคัญที่ควรทราบก็คือแฮช $Matches มีเพียงรายการแรกของรูปแบบที่ตรงกันเท่านั้น

ตัวอย่าง :

$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

เมื่อผลลัพธ์ -match เป็น False หรือผลลัพธ์ -notmatch เป็น True หรือเมื่ออินพุตเป็น คอลเลกชัน ตัวแปรอัตโนมัติ $Matches จะไม่ถูกเขียนทับ ดังนั้นจะมีค่าที่ตั้งไว้ก่อนหน้านี้ หรือ $null หากไม่ได้ตั้งค่าตัวแปร เมื่ออ้างอิงถึง $Matches หลังจากเรียกใช้โอเปอเรเตอร์ตัวใดตัวหนึ่งเหล่านี้ ให้พิจารณาตรวจสอบว่าตัวแปรถูกกำหนดโดยการเรียกใช้โอเปอเรเตอร์ปัจจุบันโดยใช้คำสั่งเงื่อนไข

ตัวอย่าง :

if ("<version>1.0.0</version>" -match '<version>(.*?)</version>') {
    $Matches
}

สำหรับรายละเอียด โปรดดู about_Regular_Expressions และ about_Automatic_Variables

ผู้ปฏิบัติงานทดแทน

แทนที่ด้วยนิพจน์ทั่วไป

เช่นเดียวกับ -match ตัวดำเนินการ -replace จะใช้นิพจน์ทั่วไปเพื่อค้นหารูปแบบที่ระบุ แต่ต่างจาก -match ตรงที่จะแทนที่รายการที่ตรงกันด้วยค่าอื่นที่ระบุ

ไวยากรณ์ :

<input> -replace <regular-expression>, <substitute>

ตัวดำเนินการจะแทนที่ค่าทั้งหมดหรือบางส่วนด้วยค่าที่ระบุโดยใช้นิพจน์ทั่วไป คุณสามารถใช้โอเปอเรเตอร์สำหรับงานการดูแลระบบได้หลายอย่าง เช่น การเปลี่ยนชื่อไฟล์ ตัวอย่างเช่น คำสั่งต่อไปนี้จะเปลี่ยนนามสกุลไฟล์ของไฟล์ .txt ทั้งหมดเป็น .log:

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

ตามค่าเริ่มต้น ตัวดำเนินการ -replace จะไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ หากต้องการให้คำนึงถึงขนาดตัวพิมพ์ ให้ใช้ -creplace หากต้องการทำให้ไม่คำนึงถึงขนาดตัวพิมพ์ ให้ใช้ -ireplace

ตัวอย่าง:

"book" -ireplace "B", "C" # Case insensitive
"book" -creplace "B", "C" # Case-sensitive; hence, nothing to replace

Cook
book

เริ่มต้นใน PowerShell 7.2 เมื่อตัวถูกดำเนินการทางซ้ายในคำสั่งตัวดำเนินการ -replace ไม่ใช่สตริง ตัวถูกดำเนินการนั้นจะถูกแปลงเป็นสตริง PowerShell ทำการแปลงสตริงที่ไม่คำนึงถึงวัฒนธรรม

ตัวอย่างเช่น หากวัฒนธรรมของคุณตั้งค่าเป็นภาษาฝรั่งเศส (fr) การแปลงสตริงที่คำนึงถึงวัฒนธรรมของค่า 1.2 จะเป็น 1,2

ก่อน PowerShell 7.2:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
12

ใน PowerShell 7.2 และใหม่กว่า:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
1.2

การทดแทนนิพจน์ทั่วไป

นอกจากนี้ยังสามารถใช้นิพจน์ทั่วไปเพื่อแทนที่ข้อความแบบไดนามิกโดยใช้กลุ่มการจับและการแทนที่ กลุ่มการจับสามารถอ้างอิงได้ในสตริง <substitute> โดยใช้เครื่องหมายดอลลาร์ ($) ก่อนตัวระบุกลุ่ม

ในตัวอย่างต่อไปนี้ ตัวดำเนินการ -replace ยอมรับชื่อผู้ใช้ในรูปแบบ DomainName\Username และแปลงเป็นรูปแบบ Username@DomainName:

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

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

John.Doe@Contoso.local

ตัวอย่างเช่น:

$1 = 'Goodbye'

'Hello World' -replace '(\w+) \w+', "$1 Universe"
# Output: Goodbye Universe

'Hello World' -replace '(\w+) \w+', '$1 Universe'
# Output: Hello Universe

$$ ใน Regex หมายถึง $ ตามตัวอักษร $$ นี้ในสตริงการแทนที่เพื่อรวม $ ตามตัวอักษรในการแทนที่ผลลัพธ์ ตัวอย่างเช่น:

'5.72' -replace '(.+)', '$ $1' # Output: $ 5.72
'5.72' -replace '(.+)', '$$$1' # Output: $5.72
'5.72' -replace '(.+)', '$$1'  # Output: $1

หากต้องการเรียนรู้เพิ่มเติม โปรดดู about_Regular_Expressions และการทดแทนในนิพจน์ทั่วไป

ทดแทนในคอลเลกชัน

เมื่อ <input> ไปยังตัวดำเนินการ -replace เป็นคอลเลกชัน PowerShell จะใช้การแทนที่กับทุกค่าในคอลเลกชัน ตัวอย่างเช่น:

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

แทนที่ด้วยบล็อกสคริปต์

ใน PowerShell 6 และใหม่กว่า ตัวดำเนินการ -replace ยังยอมรับบล็อกสคริปต์ที่ทำการแทนที่ด้วย บล็อกสคริปต์จะทำงานหนึ่งครั้งสำหรับทุกการแข่งขัน

ไวยากรณ์ :

<String> -replace <regular-expression>, {<Script-block>}

ภายในบล็อกสคริปต์ ให้ใช้ตัวแปรอัตโนมัติ $_ เพื่อเข้าถึงข้อความอินพุตที่ถูกแทนที่และข้อมูลที่เป็นประโยชน์อื่นๆ ประเภทคลาสของตัวแปรนี้คือ System.Text.RegularExpressions.Match

ตัวอย่างต่อไปนี้แทนที่แต่ละลำดับของตัวเลขสามหลักด้วยอักขระที่เทียบเท่ากัน บล็อกสคริปต์ทำงานสำหรับแต่ละชุดของตัวเลขสามหลักที่จำเป็นต้องเปลี่ยน

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

Hello

ผู้ปฏิบัติงานบรรจุ

ตัวดำเนินการบรรจุ (-contains, -notcontains, -in และ -notin) มีความคล้ายคลึงกับความเท่าเทียมกัน โอเปอเรเตอร์ ยกเว้นว่าจะส่งกลับค่า บูลีน เสมอ แม้ว่าอินพุตจะเป็นคอลเล็กชันก็ตาม ตัวดำเนินการเหล่านี้หยุดการเปรียบเทียบทันทีที่ตรวจพบการจับคู่แรก ในขณะที่ตัวดำเนินการเท่ากันจะประเมินสมาชิกอินพุตทั้งหมด ในคอลเลกชันที่มีขนาดใหญ่มาก ตัวดำเนินการเหล่านี้จะส่งคืนเร็วกว่าตัวดำเนินการความเท่าเทียม

-มี และ -ไม่มี

ไวยากรณ์ :

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

ตัวดำเนินการเหล่านี้จะบอกว่าชุดประกอบด้วยองค์ประกอบบางอย่างหรือไม่ -contains ส่งคืน True เมื่อทางด้านขวา (วัตถุสเกลาร์) ตรงกับองค์ประกอบใดองค์ประกอบหนึ่งในชุด -notcontains ส่งคืนค่า False แทน

ตัวอย่าง:

"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

ตัวอย่างที่ซับซ้อนมากขึ้น:

$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
                 "ContosoDHCP","ContosoWSUS"
$thisComputer  = "ContosoDC2"

$DomainServers -contains $thisComputer
# Output: True

เมื่อตัวถูกดำเนินการทางด้านขวามือเป็นคอลเลกชัน ตัวดำเนินการเหล่านี้จะแปลงค่าเป็นการแสดงสตริงก่อนที่จะเปรียบเทียบกับคอลเลกชันด้านซ้ายมือ

$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 และ -notin

ไวยากรณ์ :

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

ตัวดำเนินการ -in และ -notin ถูกนำมาใช้ใน PowerShell 3 เป็นการกลับทางวากยสัมพันธ์ของ -contains และ -notcontains ตัวดำเนินการ -in ส่งคืน True เมื่อด้านซ้าย <scalar-object> ตรงกับองค์ประกอบใดองค์ประกอบหนึ่งในคอลเลกชัน -notin ส่งคืน False แทน

ตัวอย่างต่อไปนี้ทำสิ่งเดียวกับตัวอย่างสำหรับ -contains และ -notcontains แต่เขียนด้วย -in และ -notin แทน

"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

ตัวอย่างที่ซับซ้อนมากขึ้น:

$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
                 "ContosoDHCP","ContosoWSUS"
$thisComputer  = "ContosoDC2"

$thisComputer -in $DomainServers
# Output: True

เมื่อตัวถูกดำเนินการทางด้านซ้ายเป็นคอลเลกชัน ตัวดำเนินการเหล่านี้จะแปลงค่าเป็นการแสดงสตริงก่อนที่จะเปรียบเทียบกับคอลเลกชันทางด้านขวามือ

$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

การเปรียบเทียบประเภท

ตัวดำเนินการเปรียบเทียบประเภท (-is และ -isnot) ใช้เพื่อพิจารณาว่าวัตถุเป็นประเภทเฉพาะหรือไม่

ไวยากรณ์ :

<object> -is <type-reference>
<object> -isnot <type-reference>

ตัวอย่าง :

$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

ดูเพิ่มเติม

• about_Booleans
• about_Operators
• about_Regular_Expressions
• about_Wildcards
• Compare-Object
• Foreach-Object
• Where-Object