ค้นหาเว็บไซต์

PowerShell Where-Object - คู่มือฉบับสมบูรณ์

PowerShell Where-object เป็นคำสั่งที่สำคัญมากที่คุณมักใช้ในการกรองข้อมูลอย่างมีประสิทธิภาพ ช่วยให้ผู้ใช้สามารถกรองออบเจ็กต์จากคอลเลกชันตามเกณฑ์ที่ระบุ ซึ่งทำงานในลักษณะที่คล้ายคลึงกับคำสั่ง SQL 'WHERE' หรือวิธี LINQ ใน .NET ในบทช่วยสอนนี้ คุณจะได้เรียนรู้ทุกอย่างเกี่ยวกับ PowerShell Where-Object พร้อมตัวอย่าง

Where-Object ใน PowerShell คือคำสั่งที่ใช้ในการกรองออบเจ็กต์ตามคุณสมบัติหรือนิพจน์ ช่วยให้คุณสามารถระบุเงื่อนไขที่ออบเจ็กต์ต้องเป็นไปตาม โดยส่งคืนเฉพาะเงื่อนไขที่ตรงกับเกณฑ์เท่านั้น โดยทั่วไปแล้ว cmdlet นี้จะใช้ในไปป์ไลน์เพื่อปรับแต่งผลลัพธ์ของคำสั่ง ทำให้ง่ายต่อการทำงานกับข้อมูลที่คุณต้องการ

ทำความเข้าใจกับ Where-Object ใน PowerShell

Where-Object ใน PowerShell กรองวัตถุจากคอลเลกชันตามเงื่อนไขที่ระบุ มักใช้ในไปป์ไลน์เพื่อให้ผู้ใช้สามารถประมวลผลเฉพาะรายการที่ตรงตามเกณฑ์ที่กำหนดเท่านั้น

ไวยากรณ์สำหรับ Where-Object รวมถึงบล็อกสคริปต์ซึ่งมีการกำหนดเงื่อนไขสำหรับการกรองออบเจ็กต์ บล็อกสคริปต์สามารถมีเงื่อนไขได้ตั้งแต่หนึ่งเงื่อนไขขึ้นไป และเฉพาะออบเจ็กต์ที่ตรงตามเงื่อนไขทั้งหมดเท่านั้นที่จะถูกส่งผ่านไปป์ไลน์ ด้านล่างนี้เป็นตัวอย่างของไวยากรณ์:

Get-Process | Where-Object { $_.CPU -gt 100 }

ในตัวอย่างนี้ Get-Process จะสร้างรายการกระบวนการที่ทำงานอยู่ และ Where-Object จะกรองรายการนี้เพื่อส่งคืนเฉพาะกระบวนการที่ใช้เวลา CPU มากกว่า 100 หน่วย

ที่นี่คุณสามารถดูผลลัพธ์ได้ในภาพหน้าจอด้านล่าง:

ลักษณะสำคัญของ Where-Object:

  • การกรองประสิทธิภาพ: ด้วยการกรองออบเจ็กต์ทางด้านซ้ายของไปป์ไลน์ Where-Object จะปรับปรุงประสิทธิภาพโดยการลดปริมาณข้อมูลที่ส่งไปตามไปป์ไลน์
  • ความยืดหยุ่น: ยอมรับการแสดงออกที่ซับซ้อน ทำให้ผู้ใช้สามารถทำการกรองอย่างละเอียดและเหมาะสมที่สุด
  • ความสามารถรอบด้าน: สามารถใช้กับ PowerShell cmdlet ใดๆ ที่ส่งออกออบเจ็กต์ไปยังไปป์ไลน์

Where-Object มีบทบาทสำคัญในการเขียนสคริปต์ PowerShell ที่มีประสิทธิภาพ โดยเฉพาะอย่างยิ่งเมื่อจัดการชุดข้อมูลขนาดใหญ่หรือดำเนินการที่เกี่ยวข้องกับงานที่ต้องใช้ทรัพยากรมาก ความสามารถในการกรองตั้งแต่เนิ่นๆ (กรองซ้าย) ช่วยเพิ่มประสิทธิภาพสูงสุดโดยการลดจำนวนออบเจ็กต์ที่ส่งผ่านไปยัง cmdlets ที่ตามมาในไปป์ไลน์

การใช้งานพื้นฐานของ PowerShell Where-Object

Where-Object cmdlet ใน PowerShell เป็นคำสั่งที่ยืดหยุ่นและมีประสิทธิภาพซึ่งใช้ในการกรองออบเจ็กต์จากคอลเลกชันตามเงื่อนไขที่ระบุ โดยทั่วไปจะใช้ในไปป์ไลน์เพื่อเลือกออบเจ็กต์ที่มีคุณสมบัติบางอย่างหรือเป็นไปตามเกณฑ์ชุดใดชุดหนึ่ง

ไวยากรณ์

ไวยากรณ์พื้นฐานของ Where-Object cmdlet นั้นตรงไปตรงมา ใช้บล็อก FilterScript ซึ่งเป็นบล็อกสคริปต์ที่ประเมินแต่ละออบเจ็กต์ในไปป์ไลน์และส่งกลับ True หากควรรวมออบเจ็กต์ไว้ในเอาต์พุต ไวยากรณ์สามารถแสดงเป็น:

Where-Object {<FilterScript>}

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

Get-Service | Where-Object {$_.Status -eq 'Running'}

ในกรณีนี้ $_ แสดงถึงแต่ละออบเจ็กต์ที่ส่งไปยัง Where-Object จากไปป์ไลน์ และ -eq เป็นตัวดำเนินการเพื่อความเท่าเทียมกัน

บล็อกฟิลเตอร์สคริปต์

บล็อก FilterScript คือชุดของเงื่อนไขที่กำหนดไว้ในบล็อกสคริปต์ {} ที่กรองออบเจ็กต์ บล็อกสคริปต์ได้รับแต่ละอ็อบเจ็กต์จากไปป์ไลน์และใช้ตัวดำเนินการเปรียบเทียบเพื่อประเมิน ทำให้เกิดผลลัพธ์บูลีน ($True หรือ $False)

ไวยากรณ์:

{ $_.<PropertyName> -<Operator> <Value> }

ตัวดำเนินการได้แก่:

  • -eq: เท่ากับ
  • -ne: ไม่เท่ากับ
  • -gt: มากกว่า
  • -lt: น้อยกว่า
  • -ge: มากกว่าหรือเท่ากับ
  • -le: น้อยกว่าหรือเท่ากับ

ตัวอย่าง:

หากต้องการเลือกไฟล์ที่มีขนาดใหญ่กว่า 1MB คุณสามารถใช้ FilterScript ต่อไปนี้:

Get-ChildItem | Where-Object {$_.Length -gt 1MB}

คุณสมบัติ Length เก็บขนาดของไฟล์ และใช้ตัวดำเนินการ -gt เพื่อเปรียบเทียบกับ 1MB หากเงื่อนไขส่งคืน True แสดงว่าวัตถุนั้นรวมอยู่ในเอาต์พุต

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

PowerShell Where-Object cmdlet ใช้ประโยชน์จากตัวดำเนินการเปรียบเทียบเพื่อประเมินเงื่อนไขและกรองออบเจ็กต์

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

ตัวดำเนินการเปรียบเทียบมาตรฐานใน PowerShell จะทำการเปรียบเทียบในลักษณะที่ไม่คำนึงถึงตัวพิมพ์เล็กและใหญ่ตามค่าเริ่มต้น ซึ่งหมายความว่าเมื่อเปรียบเทียบสองค่า จะไม่พิจารณาตัวพิมพ์ของอักขระด้วย ตัวดำเนินการทั่วไปได้แก่:

  • -eq: เท่ากับ
  • -ne: ไม่เท่ากับ
  • -gt: มากกว่า
  • -lt: น้อยกว่า
  • -ge: มากกว่าหรือเท่ากับ
  • -le: น้อยกว่าหรือเท่ากับ

นี่คือไวยากรณ์มาตรฐานสำหรับคำสั่งเปรียบเทียบ:

\$Object | Where-Object { $_.Property -Operator Value }

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

Get-Process | Where-Object { $_.PriorityClass -eq "Normal" }

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

ตัวดำเนินการเปรียบเทียบแบบคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่

เมื่อคำนึงถึงตัวพิมพ์เล็กและใหญ่ PowerShell จะจัดเตรียมตัวดำเนินการเปรียบเทียบที่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ โอเปอเรเตอร์เหล่านี้ขึ้นต้นด้วย 'c' เพื่อแสดงถึงลักษณะที่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ รายการประกอบด้วย:

  • -ceq: คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่
  • -cne: คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ไม่เท่ากัน
  • -cgt: คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่มากกว่า
  • -clt: คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่น้อยกว่า
  • -cge: คำนึงถึงขนาดตัวพิมพ์มากกว่าหรือเท่ากับ
  • -cle: คำนึงถึงขนาดตัวพิมพ์น้อยกว่าหรือเท่ากับ

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

Get-Service | Where-Object { $_.Status -ceq "Running" }

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

การใช้สัญลักษณ์ตัวแทนและนิพจน์ทั่วไป

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

ตัวดำเนินการ -Like และ -NotLike

ตัวดำเนินการ -Like และ -NotLike ใน PowerShell ช่วยให้ผู้ใช้สามารถเปรียบเทียบสตริงกับรูปแบบโดยใช้ไวด์การ์ด ไวด์การ์ดที่พบบ่อยที่สุดคือเครื่องหมายดอกจัน * ซึ่งแสดงถึงอักขระจำนวนเท่าใดก็ได้ เครื่องหมายคำถาม ? แทนอักขระตัวเดียว

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

Get-Process | Where-Object { $_.Name -Like 's*' }

คำสั่งนี้จะกรองกระบวนการที่มีชื่อขึ้นต้นด้วยตัวอักษร 's'

ในทางตรงกันข้าม -NotLike จะยกเว้นรายการที่ตรงกับรูปแบบ:

Get-Service | Where-Object { $_.DisplayName -NotLike '*Network*' }

คำสั่งนี้แสดงรายการบริการทั้งหมดที่ไม่มีคำว่า "เครือข่าย" ในชื่อที่แสดง

ตัวดำเนินการ -Match และ -NotMatch

ตัวดำเนินการ -Match และ -NotMatch ใน PowerShell ใช้นิพจน์ทั่วไปสำหรับการจับคู่รูปแบบที่ซับซ้อนมากขึ้น นิพจน์ทั่วไปหรือ regex คือลำดับของอักขระที่สร้างรูปแบบการค้นหา สามารถใช้เพื่อตรวจสอบว่าสตริงมีลำดับอักขระเฉพาะหรือไม่

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

Get-Process | Where-Object { $_.Name -Match '^s.*' }

คำสั่งนี้เลือกกระบวนการที่ชื่อขึ้นต้นด้วย 's' (^ หมายถึงจุดเริ่มต้นของสตริงใน regex)

หรือ -NotMatch จะกรองสตริงที่ตรงตามเกณฑ์ regex ออก:

Get-Process | Where-Object { $_.Name -NotMatch 'svc$' }

สิ่งนี้รวบรวมกระบวนการที่ชื่อไม่ได้ลงท้ายด้วย 'svc' ($ หมายถึงจุดสิ้นสุดของสตริงใน regex)

ตัวกรองขั้นสูงโดยใช้ PowerShell Where-Object

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

การใช้ Script Blocks สำหรับตัวกรองที่ซับซ้อน

บล็อกสคริปต์เป็นส่วนสำคัญในการเขียนสคริปต์ PowerShell ขั้นสูง ช่วยให้ผู้ใช้สามารถระบุเงื่อนไขที่ซับซ้อนมากขึ้นเมื่อกรองออบเจ็กต์ บล็อกสคริปต์จะแสดงด้วยเครื่องหมายปีกกา {} และสามารถมีลำดับของคำสั่ง PowerShell ได้ เมื่อใช้กับ Where-Object บล็อกสคริปต์จะทำให้สามารถประเมินนิพจน์ที่ซับซ้อนได้ ซึ่งช่วยให้กลไกการกรองมีประสิทธิภาพสะดวกขึ้น

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

Get-Process | Where-Object { $_.CPU -gt 100 -and $_.ProcessName -eq "notepad" }

ในคำสั่งนี้ บล็อกสคริปต์จะกรองกระบวนการที่มีการใช้งาน CPU มากกว่า 100 และชื่อกระบวนการเป็น "notepad"

การผูกมัดหลายเงื่อนไข

เงื่อนไขการเชื่อมโยงเป็นวิธีการใช้ชุดตัวกรองโดยใช้ตัวดำเนินการเชิงตรรกะ เช่น -และ, -หรือ และ -not ซึ่งช่วยให้มีแนวทางที่เหมาะสมยิ่งขึ้นในการกรองออบเจ็กต์ โดยสามารถรวมเกณฑ์หลายเกณฑ์ไว้ในแบบสอบถามเดียวได้ การใช้ตัวดำเนินการเหล่านี้อย่างมีประสิทธิผลสามารถนำไปสู่ผลลัพธ์ที่เลือกสรรและแม่นยำยิ่งขึ้น

ตัวอย่างที่มีเงื่อนไขหลายลูกโซ่:

Get-Service | Where-Object { $_.Status -eq "Running" -and ($_.StartType -eq "Automatic" -or $_.StartType -eq "Manual") }

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

การใช้ไปป์ไลน์และออบเจ็กต์

ใน PowerShell ไปป์ไลน์อนุญาตให้ส่งผ่านออบเจ็กต์จาก cmdlet หนึ่งไปยังอีกอันหนึ่งได้ ช่วยให้การจัดการข้อมูลมีความคล่องตัวยิ่งขึ้น Where-Object cmdlet เป็นส่วนสำคัญสำหรับการกรองวัตถุภายในเวิร์กโฟลว์นี้

การกรองวัตถุด้วย Get-Command

Get-Command cmdlet ของ PowerShell ดึงรายการคำสั่งทั้งหมดที่มีอยู่ในเซสชัน เมื่อใช้งานภายในไปป์ไลน์ Where-Object สามารถกรองคำสั่งเหล่านี้ตามเกณฑ์เฉพาะได้ ตัวอย่างเช่น:

Get-Command | Where-Object { $_.CommandType -eq 'Cmdlet' }

คำสั่งนี้แสดงรายการ cmdlets ทั้งหมดที่ผู้ใช้สามารถใช้ได้ Where-Object ใช้บล็อกสคริปต์ { } ซึ่งมีเงื่อนไขที่กรองเอาต์พุตของ Get-Command ตาม CommandType รหัส> คุณสมบัติ

การรวม Where-Object กับ ForEach-Object

สำหรับการจัดการอ็อบเจ็กต์ที่ถูกกรองเพิ่มเติม เราสามารถรวม Where-Object กับ ForEach-Object ได้ ซึ่งช่วยให้สามารถดำเนินการบล็อกสคริปต์กับแต่ละรายการในไปป์ไลน์ได้

Get-Command | Where-Object { $_.CommandType -eq 'Function' } | ForEach-Object { $_.Name }

ลำดับนี้จะดึงฟังก์ชัน PowerShell ทั้งหมด จากนั้นไปป์ไปที่ ForEach-Object ซึ่งจะแยกชื่อของแต่ละฟังก์ชัน ด้วยการผูกมัด cmdlets เหล่านี้ เราสามารถกรองและดำเนินการกับข้อมูลได้อย่างมีประสิทธิภาพ

การใช้ Select-Object ร่วมกับ cmdlet เหล่านี้สามารถช่วยในการเลือกคุณสมบัติของวัตถุเฉพาะ ซึ่งจะช่วยปรับแต่งผลลัพธ์เพิ่มเติมได้ นอกจากนี้ การใช้ นามแฝง จะทำให้คำสั่งสั้นลง ทำให้กระชับ ตัวอย่างเช่น foreach เป็นนามแฝงสำหรับ ForEach-Object และ ? เป็นนามแฝงสำหรับ Where-Object สิ่งสำคัญที่ควรทราบคือแม้ว่านามแฝงจะช่วยเพิ่มความเร็วในการพิมพ์คำสั่ง แต่การใช้นามแฝงในสคริปต์สามารถลดความสามารถในการอ่านและการบำรุงรักษาได้

การทำงานกับประเภทวัตถุเฉพาะใน Where-Object

Where-Object cmdlet ของ PowerShell ทำหน้าที่เป็นเครื่องมืออเนกประสงค์สำหรับการกรองออบเจ็กต์ประเภทเฉพาะ เช่น ไฟล์ ไดเรกทอรี กระบวนการ และบริการ ด้วยการใช้ความสามารถ ทำให้สามารถสืบค้นและจัดการทรัพยากรระบบได้อย่างมีประสิทธิภาพ

การกรองไฟล์และไดเร็กทอรี

ใน PowerShell นั้น Get-ChildItem มักจะจับคู่กับ Where-Object เพื่อกรองไฟล์และไดเรกทอรีตามคุณสมบัติ เช่น ชื่อ วันที่ และ LastWriteTime ตัวอย่างเช่น หากต้องการดึงไฟล์ที่แก้ไขภายในสัปดาห์ที่ผ่านมา อาจใช้:

Get-ChildItem -Path C:\ -Recurse | Where-Object { $_.LastWriteTime -gt (Get-Date).AddDays(-7) }

การแสดงรายการไฟล์ที่ถูกกรองตามนามสกุลสามารถทำได้ดังนี้:

Get-ChildItem -Path C:\*.txt -Recurse

แสดงรายการไฟล์ข้อความทั้งหมดในไดรฟ์ C:

`…

โดยที่วัตถุ { $_.Name -like 'รายงาน' }`

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

Get-ChildItem -Path C:\ -Recurse | Where-Object { $_.PSIsContainer -and $_.GetFiles().Count -eq 0 }

การทำงานกับกระบวนการและบริการ

เมื่อกรองกระบวนการ Get-Process ควบคู่กับ Where-Object อนุญาตให้แสดงรายการกระบวนการตามสถานะหรือชื่อ ตัวอย่างเช่น หากต้องการค้นหากระบวนการที่ใช้งานอยู่ด้วยชื่อเฉพาะ:

Get-Process | Where-Object { $_.Name -eq 'notepad' }

บริการได้รับการจัดการโดยใช้ Get-Service สามารถกรองสิ่งเหล่านี้ตาม Status หรือ StartType:

Get-Service | Where-Object { $_.Status -eq 'Running' }

หากต้องการแสดงบริการที่ตั้งค่าให้เริ่มโดยอัตโนมัติแต่หยุดทำงานอยู่ในปัจจุบัน:

Status

เท่ากับ 'หยุด'

StartType

เท่ากับ 'อัตโนมัติ'

ผลลัพธ์การกรองจะขึ้นอยู่กับการทำความเข้าใจคุณสมบัติของออบเจ็กต์ที่เป็นปัญหาและการสร้างนิพจน์การเปรียบเทียบที่แม่นยำ

แนวทางปฏิบัติที่ดีที่สุดสำหรับการใช้ PowerShell Where-Object

เมื่อใช้ Where-Object ใน PowerShell ผู้ใช้ควรปฏิบัติตามชุดแนวทางปฏิบัติที่ดีที่สุดที่สอดคล้องกันเพื่อให้มั่นใจถึงประสิทธิภาพสูงสุดและความสามารถในการอ่าน

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

ในการสืบค้น ผู้ใช้จะต้องระบุพารามิเตอร์อย่างเจาะจงเพื่อหลีกเลี่ยงความสับสน พารามิเตอร์ที่มีชื่อจะให้ความชัดเจน โดยเฉพาะอย่างยิ่งเมื่อฟังก์ชันยอมรับพารามิเตอร์หลายตัว พวกเขาสนับสนุนการเขียนโค้ดด้วยตนเอง ทำให้ผู้อื่นเข้าใจได้ง่ายขึ้น

การใช้พารามิเตอร์ทั่วไปอย่างสม่ำเสมอสามารถปรับปรุงสคริปต์ได้ พารามิเตอร์ทั่วไป เช่น -Verbose และ -ErrorAction ให้ข้อมูลเพิ่มเติมที่มีคุณค่าอย่างยิ่งสำหรับการแก้ไขจุดบกพร่องและการบันทึก

ตารางสำหรับเน้นพารามิเตอร์หลัก:

-EQ

แสดงถึงความเท่าเทียมกัน

-LT, -GT

แสดงว่าน้อยกว่าและมากกว่าตามลำดับ

-Contains

ตรวจสอบว่าคอลเลกชันมีองค์ประกอบเฉพาะหรือไม่

-Like

อนุญาตการจับคู่ไวด์การ์ด

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

สุดท้ายนี้ ควรส่งวัตถุผ่านไปป์ไลน์ด้วยความระมัดระวังเสมอ การเชื่อมโยง Where-Object อาจเป็นวิธีที่มีประโยชน์ในการกรองผลลัพธ์ แต่การมีคำสั่งที่เชื่อมโยงมากเกินไปอาจส่งผลต่อความสามารถในการอ่านและประสิทธิภาพ พวกเขาต้องมุ่งมั่นเพื่อความสมดุลระหว่างการเขียนสคริปต์เชิงฟังก์ชันและโค้ดที่ชัดเจนและบำรุงรักษาได้

PowerShell Where-Object ตัวอย่าง

เมื่อทำงานกับ Windows PowerShell 3.0 Where-Object จะทำหน้าที่เป็นตัวกรองที่ขาดไม่ได้สำหรับสตรีมข้อมูล PowerShell ใช้เงื่อนไขกับออบเจ็กต์ที่ส่งผ่านไปป์ไลน์ ทำให้ผู้ใช้สามารถแยกรายการที่สนใจได้ ด้านล่างนี้คือการใช้งานจริงของ Where-Object พร้อมด้วยตัวดำเนินการเปรียบเทียบต่างๆ:

    • หากต้องการแสดงรายการบริการทั้งหมดที่หยุดอยู่ในปัจจุบัน อาจใช้: Get-Service | โดยที่วัตถุ { $_.สถานะ -eq 'หยุด' }
    • เราสามารถระบุไฟล์ที่ถูกแก้ไขมานานกว่า 30 วันที่ผ่านมาด้วยวิธี AddDays ควบคู่ไปกับ -lt (น้อยกว่า): Get- รายการย่อย | โดยที่วัตถุ { $_.LastWriteTime -lt (รับวันที่) AddDays (-30)
    • การค้นหากระบวนการที่ใช้หน่วยความจำมากกว่า 100 MB จะใช้ -gt (มากกว่า): Get-Process | โดยที่วัตถุ { $_.WS -gt 100MB }
    • เงื่อนไขการประนอมอาจเกี่ยวข้องกับการแสดงรายการผู้ใช้ที่สร้างขึ้นในปีที่แล้วแต่ไม่ได้แก้ไขล่าสุด: Get-ADUser | โดยที่วัตถุ { $_.whenCreated -gt (รับวันที่).AddDays(-365) -และ $_.whenChanged -eq $_.whenCreated
    • หากต้องการลบรายการออกจากคอลเลกชันที่ไม่ตรงกับเงื่อนไข: $collection | โดยที่วัตถุ { $_ -ne "unwantedValue" }

คำถามที่พบบ่อย

ฉันจะใช้หลายเงื่อนไขกับ Where-Object cmdlet ใน PowerShell ได้อย่างไร

เงื่อนไขหลายข้อถูกรวมไว้ใน Where-Object cmdlet เดียวโดยใช้ตัวดำเนินการทางตรรกะ -และ, -หรือ และ -not อนุญาตให้ใช้การรวมกันของนิพจน์ต่างๆ เพื่อปรับแต่งการกรอง

คุณสามารถยกตัวอย่างการใช้ Where-Object ในคำสั่ง PowerShell ได้หรือไม่

แน่นอน. หากต้องการกรองกระบวนการที่มีการใช้หน่วยความจำมากกว่า 100 MB อาจใช้: Get-Process | โดยที่วัตถุ {$_.WS -gt 100MB}

วิธีที่ดีที่สุดในการกรองสตริงที่มีสตริงย่อยเฉพาะโดยใช้ Where-Object คืออะไร

ในการกรองสตริงที่มีสตริงย่อยเฉพาะ โดยทั่วไปตัวดำเนินการ -like จะถูกนำมาใช้พร้อมกับอักขระตัวแทน: | โดยที่วัตถุ {$_ -like "*substring*"}

ฉันจะเลือกวัตถุที่ขึ้นต้นด้วยสตริงบางอย่างใน PowerShell โดยใช้ Where-Object ได้อย่างไร

หนึ่งเลือกวัตถุที่เริ่มต้นด้วยสตริงที่ระบุโดยใช้ตัวดำเนินการ -like ที่มีรูปแบบที่เหมาะสม: | โดยที่วัตถุ {$_ - เช่น "string*"}

วิธีการตรวจสอบการมีอยู่ของรายการในอาร์เรย์โดยใช้ Where-Object คืออะไร

หากต้องการตรวจสอบการมีอยู่ของรายการในอาร์เรย์ ให้ใช้ตัวดำเนินการ -contains หรือ -in: $array -contains 'item' หรือ 'รายการ' -ใน $array.

ฟังก์ชัน 'เริ่มต้นด้วย' และ 'ในรายการ' ทำงานอย่างไรกับ Where-Object ใน PowerShell

ฟังก์ชัน 'เริ่มต้นด้วย' ใช้ -like จับคู่กับส่วนต่อท้ายไวด์การ์ด และ 'in list' ใช้ประโยชน์จากตัวดำเนินการ -contains เพื่อประเมินว่าอาร์เรย์มีองค์ประกอบที่ระบุหรือไม่

บทสรุป

Where-Object cmdlet ช่วยให้ผู้ใช้สามารถกรองวัตถุตามเกณฑ์ที่ระบุ

  • โดยยอมรับอินพุตโดยตรงจากไปป์ไลน์หรือผ่านพารามิเตอร์ -InputObject
  • ใช้สคริปต์บล็อก {} เพื่อกำหนดเงื่อนไข

ประเด็นสำคัญ:

  • ความหลากหลาย: Where-Object สามารถรองรับตัวดำเนินการเปรียบเทียบต่างๆ (-eq, -gt, -lt ฯลฯ)
  • ประสิทธิภาพ: สำหรับชุดข้อมูลขนาดใหญ่ การใช้เมธอด .where() ในคอลเลกชันสามารถให้ประโยชน์ด้านประสิทธิภาพได้
  • บล็อกสคริปต์: สามารถใช้เงื่อนไขที่ซับซ้อนได้โดยใช้บล็อกสคริปต์ ซึ่งเป็นวิธีการกรองเอาต์พุตที่มีประสิทธิภาพ

การใช้งานที่มีประสิทธิภาพ:

  • รักษาเงื่อนไขให้เรียบง่ายที่สุด
  • เพื่อประสิทธิภาพสูงสุด ให้กรองโดยเร็วที่สุดในไปป์ไลน์
  • อย่าลืมรวมเงื่อนไขเข้ากับตัวดำเนินการเชิงตรรกะ (-และ, -หรือ) เพื่อการควบคุมที่ได้รับการปรับปรุง

ตัวอย่างการใช้งาน:

Get-Process | Where-Object {$_.CPU -gt 100}

ในบรรทัดโค้ดนี้ Where-Object จะกรองกระบวนการที่ใช้ CPU มากกว่า 100 หน่วย

ฉันหวังว่าจากบทช่วยสอนนี้ คุณจะมีแนวคิดที่สมบูรณ์เกี่ยวกับวิธีใช้ PowerShell Where-Object

บทความที่เกี่ยวข้อง