การปลดล็อกประสิทธิภาพสูงสุด: วิธีเร่งความเร็วประสิทธิภาพของ PowerShell สำหรับการดำเนินการบรรทัดคำสั่งที่มีความคล่องตัว

หัวข้อ: 7 เทคนิคที่ได้รับการพิสูจน์แล้วเพื่อเร่งความเร็วประสิทธิภาพของ PowerShell

บทนำ: กรณีที่อยากรู้อยากเห็นของสคริปต์ PowerShell ที่ช้า

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

คุณจะเร่งความเร็วประสิทธิภาพ PowerShell ได้อย่างไร

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

1. ใช้แนวทางกรองด้านซ้ายเพื่อเพิ่มประสิทธิภาพไปป์ไลน์สูงสุด

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

ตัวอย่างเช่น พิจารณาสคริปต์ PowerShell ที่ดึงข้อมูลจาก Active Directory (AD) ประมวลผล และส่งออกข้อมูลที่เกี่ยวข้องไปยังไฟล์ CSV:

Get-ADUser -Filter * | Where-Object { $_.Surname -eq ‘Smith’ } | Export-CSV -Path .ADOutput.csv -NoTypeInformation

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

Get-ADUser -Filter { Surname -eq ‘Smith’ } | Export-CSV -Path .ADOutput.csv -NoTypeInformation

สคริปต์ที่แก้ไขนี้จะกรองข้อมูลที่ต้นทางก่อนที่จะส่งต่อไปยังไปป์ไลน์ ส่งผลให้ประสิทธิภาพเพิ่มขึ้นอย่างมาก

2. ควบคุมพลังของการประมวลผลแบบขนาน

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

พิจารณาสคริปต์ที่ทำงานที่เน้น CPU บนเซิร์ฟเวอร์หลายเครื่อง:

$servers = Get-Content .servers.txt
$result = $servers | ForEach-Object {
Perform-CPUIntensiveTask -Server $_
}

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

$servers = Get-Content .servers.txt
$result = $servers | ForEach-Object -Parallel {
Perform-CPUIntensiveTask -Server $_
} -ThrottleLimit 10

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

3. เพิ่มประสิทธิภาพลูปของคุณ

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

- แทนที่ cmdlets ForEach-Object ที่ช้าด้วยคำสั่ง foreach ที่เร็วขึ้น
- หลีกเลี่ยงการใช้ตัวดำเนินการ += ที่ช้าในอาร์เรย์ ให้ใช้อ็อบเจ็กต์ List (จาก System.Collections.Generic) และเมธอด .Add() แทนเพื่อประสิทธิภาพที่ดีขึ้น
- ใช้คำสั่ง switch แทนการใช้คำสั่ง if หลายคำสั่ง เพื่อปรับปรุงความสามารถในการอ่านโค้ดและความเร็วในการดำเนินการ

4. ใช้ฟังก์ชันขั้นสูงด้วยแอตทริบิวต์ [CmdletBinding()]

ฟังก์ชันขั้นสูงมอบคุณประโยชน์มากมาย รวมถึงประสิทธิภาพที่ได้รับการปรับปรุงด้วย ด้วยการเพิ่มแอตทริบิวต์ [CmdletBinding()] ให้กับฟังก์ชันของคุณ คุณจะเปิดใช้งานพารามิเตอร์ทั่วไป เช่น -Verbose, -Debug และ -ErrorAction ซึ่งสามารถช่วยแก้ไขปัญหาและเพิ่มประสิทธิภาพสคริปต์ของคุณได้อย่างมาก

5. ลดการใช้ Cmdlets ที่มีราคาแพงให้เหลือน้อยที่สุด

cmdlet บางตัว เช่น Sort-Object อาจใช้ทรัพยากรมากและทำให้สคริปต์ของคุณช้าลง การลดการใช้งานให้เหลือน้อยที่สุดหรือการค้นหาทางเลือกอื่นสามารถเร่งประสิทธิภาพของ PowerShell ได้ ตัวอย่างเช่น หากคุณต้องการแยกองค์ประกอบที่ไม่ซ้ำออกจากอาร์เรย์ ให้พิจารณาใช้คลาส HashSet (จาก System.Collections.Generic) แทน Select-Object -Unique cmdlet เพื่อเพิ่มประสิทธิภาพ

6. เพิ่มประสิทธิภาพการแสดงออกปกติของคุณ

เมื่อทำงานกับนิพจน์ทั่วไปใน PowerShell การเพิ่มประสิทธิภาพให้เหมาะสมเป็นสิ่งสำคัญ ปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดเหล่านี้:

- ใช้ตัวระบุปริมาณที่ไม่โลภโดยเติม ? ต่อท้ายตัวปริมาณโลภใดๆ (*, + หรือ {n,m}).
- ใช้ประโยชน์จากกลุ่มอะตอมมิก (?>…) เพื่อป้องกันการย้อนรอยโดยไม่จำเป็น

7. เลือกใช้วิธี Native .NET บน Cmdlets ในกรณีที่เป็นไปได้

PowerShell สร้างขึ้นบน .NET Framework; ดังนั้นวิธีการดั้งเดิมของ .NET หลายวิธีจึงสามารถใช้ได้โดยตรงในสคริปต์ของคุณ วิธีการดั้งเดิมเหล่านี้มักจะมีประสิทธิภาพเหนือกว่า cmdlets ที่เทียบเท่า ส่งผลให้ประสิทธิภาพ PowerShell โดยรวมดีขึ้น

สรุป: เพิ่มประสิทธิภาพ PowerShell ของคุณวันนี้

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

วิธีรับความเร็วอินเทอร์เน็ตที่เร็วขึ้นเมื่อคุณเปลี่ยนการตั้งค่าง่ายๆ

เร่งความเร็วพีซี Windows 10 เพื่อประสิทธิภาพสูงสุด (ความลับที่ซ่อนอยู่) - 2021

การใช้ Write-Host ทำให้ประสิทธิภาพการทำงานของ PowerShell ช้าลงหรือไม่

การใช้ Write-Host ใน PowerShell อาจทำให้ประสิทธิภาพการทำงานช้าลง โดยเฉพาะอย่างยิ่งเมื่อต้องจัดการกับข้อมูลจำนวนมากหรือเอาต์พุตบ่อยครั้ง เนื่องจาก Write-Host เขียนไปยังคอนโซลโดยตรง ทำให้สคริปต์ต้องรอให้คอนโซลประมวลผลเอาต์พุตก่อนดำเนินการต่อ

ในทางตรงกันข้าม การใช้วิธีต่างๆ เช่น Write-Output หรือ Write-Verbose สามารถช่วยปรับปรุงประสิทธิภาพได้ เนื่องจากวิธีการเหล่านี้ไม่ได้เขียนลงในคอนโซลโดยตรง และอนุญาตให้สคริปต์ดำเนินการประมวลผลต่อไปโดยไม่ต้องรอ สำหรับเอาต์พุตคอนโซล

เพื่อเพิ่มประสิทธิภาพ PowerShell ขอแนะนำให้หลีกเลี่ยงการใช้ Write-Host หากเป็นไปได้ และเลือกใช้วิธีการอื่น เช่น Write-Output, Write-Verbose หรือแม้แต่ส่งออกเป็นไฟล์แทน

เครื่องมือใดที่ทำให้การเรียกใช้สคริปต์ใน PowerShell ง่ายขึ้น

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

ISE นำเสนอคุณลักษณะต่างๆ เช่น การเน้นไวยากรณ์ การเติมข้อความอัตโนมัติ และการแก้ไขข้อบกพร่องของสคริปต์ ซึ่งช่วยให้เขียนสคริปต์ได้อย่างมีประสิทธิภาพมากขึ้นและใช้งานง่าย นอกจากนี้ยังรองรับการใช้ โมดูล PowerShell เพื่อขยายฟังก์ชันการทำงานและปรับปรุงงานต่างๆ

เหตุใด Windows PowerShell จึงปรากฏอย่างต่อเนื่องทุกๆ 10 นาที

อาจมีสาเหตุหลายประการที่ทำให้ Windows PowerShell ปรากฏอย่างต่อเนื่องทุกๆ 10 นาที ต่อไปนี้คือสาเหตุที่เป็นไปได้บางประการ:

1. งานที่กำหนดเวลาไว้: อาจมีงานที่กำหนดเวลาไว้ซึ่งตั้งค่าให้เรียกใช้สคริปต์ PowerShell หรือคำสั่งทุกๆ 10 นาที คุณสามารถตรวจสอบ Task Scheduler ใน Windows เพื่อดูว่ามีงานดังกล่าวหรือไม่ และปิดใช้งานหรือแก้ไขหากจำเป็น

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

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

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

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

อะไรคือปัจจัยที่ส่งผลต่อประสิทธิภาพของ PowerShell?

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

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

2. Cmdlets: Cmdlet เป็นส่วนสำคัญของคำสั่ง PowerShell เป็นคำสั่งแบบฟังก์ชันเดียวน้ำหนักเบาที่ให้ผู้ใช้สามารถทำงานเฉพาะได้ เช่น การจัดการบริการหรือการทำงานกับไฟล์ มีคอลเลกชัน cmdlets ในตัวจำนวนมาก และผู้ใช้สามารถสร้าง cmdlets แบบกำหนดเองได้ตามต้องการ

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

4. ความสามารถในการเขียนสคริปต์: ภาษาสคริปต์ของ PowerShell นั้นทั้งทรงพลังและง่ายต่อการเรียนรู้ ทำให้ผู้ใช้สามารถทำงานอัตโนมัติ สร้างฟังก์ชันที่กำหนดเอง และพัฒนาแอปพลิเคชันเต็มรูปแบบ ภาษารองรับตัวแปร ลูป คำสั่งแบบมีเงื่อนไข การจัดการข้อผิดพลาด และอื่นๆ อีกมากมาย

5. บูรณาการกับ .NET Framework: PowerShell สร้างขึ้นบน .NET Framework ซึ่งช่วยให้สามารถทำงานร่วมกับแอปพลิเคชันและไลบรารี .NET อื่นๆ ได้อย่างราบรื่น สิ่งนี้ทำให้ PowerShell สามารถใช้ประโยชน์จากทรัพยากรมากมายที่มีอยู่ในระบบนิเวศ .NET และขยายขีดความสามารถเพิ่มเติมอีก

6. การจัดการระยะไกล: PowerShell รองรับการจัดการระยะไกล ช่วยให้ผู้ใช้สามารถดำเนินการคำสั่งและจัดการระบบผ่านเครือข่ายและสภาพแวดล้อมที่แตกต่างกัน ช่วยให้ผู้ดูแลระบบจัดการระบบจำนวนมากจากที่เดียวได้ง่ายขึ้น

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

8. การพัฒนาและการสนับสนุนที่ใช้งานอยู่: PowerShell ได้รับการพัฒนาและสนับสนุนอย่างแข็งขันโดย Microsoft เพื่อให้มั่นใจว่าจะมีการอัปเดตอยู่เสมอและได้รับการอัปเดตและปรับปรุงเป็นประจำ นอกจากนี้ยังมีชุมชนผู้ใช้และผู้เชี่ยวชาญมากมายที่มีส่วนร่วมในการพัฒนาอย่างต่อเนื่องและจัดหาทรัพยากรอันมีค่า เช่น ฟอรัม บล็อก และบทช่วยสอน

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

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

1. ใช้ไปป์ไลน์: ไปป์ไลน์ของ PowerShell ช่วยให้คุณสามารถส่งข้อมูลจาก cmdlet (คำสั่ง) หนึ่งไปยังอีกที่หนึ่ง ช่วยลดความจำเป็นในการใช้ตัวแปรชั่วคราว และทำให้โค้ดของคุณมีประสิทธิภาพมากขึ้น

2. หลีกเลี่ยงการใช้นามแฝง: นามแฝงอาจช่วยคุณประหยัดเวลาในการกดแป้นพิมพ์ แต่อาจทำให้การทำงานของสคริปต์ช้าลง ใช้ชื่อคำสั่งเต็มเพื่อปรับปรุงประสิทธิภาพ

3. กรองตั้งแต่เนิ่นๆ: เมื่อประมวลผลข้อมูล พยายามกรองโดยเร็วที่สุดเพื่อลดปริมาณข้อมูลที่ส่งผ่านไปป์ไลน์ ซึ่งจะส่งผลให้การดำเนินการเร็วขึ้น

4. ใช้ PowerShell cmdlets ดั้งเดิม: หากเป็นไปได้ ให้ใช้ PowerShell cmdlets ดั้งเดิมแทนโปรแกรมหรือคำสั่งภายนอก เนื่องจากได้รับการปรับให้เหมาะสมสำหรับการใช้งานภายในสภาพแวดล้อม PowerShell

5. ลดการใช้ลูป: ลูปอาจทำให้การทำงานของสคริปต์ช้าลง โดยเฉพาะอย่างยิ่งหากซ้อนกัน ลองค้นหาทางเลือกอื่น เช่น การใช้สวิตช์ -ForEach, -Filter หรือ -Include ด้วย cmdlets

6. เพิ่มประสิทธิภาพนิพจน์ทั่วไป: หากคุณใช้นิพจน์ทั่วไปสำหรับการจับคู่รูปแบบ ตรวจสอบให้แน่ใจว่านิพจน์เหล่านั้นได้รับการปรับให้เหมาะสมเพื่อลดการย้อนรอยและเพิ่มประสิทธิภาพ

7. ลดการเชื่อมต่อระยะไกล: หากสคริปต์ของคุณต้องการการเชื่อมต่อระยะไกลหลายรายการ ให้พิจารณาใช้เซสชันระยะไกลเดียวเพื่อดำเนินงานหลายงาน หรือใช้งานพื้นหลังเพื่อรันงานแบบขนาน

8. เพิ่มประสิทธิภาพการจัดการสตริง: เมื่อทำงานกับสตริง ให้ใช้เทคนิคการจัดการสตริงดั้งเดิมของ PowerShell และหลีกเลี่ยงการใช้วิธี .NET เว้นแต่จำเป็น เนื่องจากอาจทำให้ดำเนินการได้ช้ากว่า

9. สร้างโปรไฟล์สคริปต์ของคุณ: ใช้ Measure-Command cmdlet เพื่อพิจารณาว่าส่วนใดของสคริปต์ของคุณที่ใช้เวลานานที่สุด และมุ่งเน้นไปที่การเพิ่มประสิทธิภาพส่วนเหล่านั้น

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

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

ฉันจะใช้การประมวลผลแบบขนานหรือเทคนิคมัลติเธรดในบรรทัดคำสั่ง PowerShell เพื่อปรับปรุงประสิทธิภาพได้อย่างไร

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

1. การใช้ ForEach-Object กับพารามิเตอร์ -Parallel:

คุณลักษณะ ForEach-Object -Parallel มีอยู่ใน PowerShell 7 และใหม่กว่า ช่วยให้คุณสามารถประมวลผลรายการในคอลเลกชันพร้อมกันแทนที่จะดำเนินการตามลำดับ นี่คือตัวอย่าง:

$Items = 1..10
$ScriptBlock = { param($item) Write-Output (“Item: $item Processed by: $($PSThreadId)”) }
$Items | ForEach-Object -ThrottleLimit 5 -Parallel $ScriptBlock

ในตัวอย่างนี้ -ThrottleLimit ระบุจำนวนเธรดสูงสุดที่อนุญาตให้ทำงานพร้อมกัน ขีดจำกัดเริ่มต้นคือ 5

<แข็งแกร่ง>2. การใช้งาน PowerShell:

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

$JobList = @()
for ($i = 1; $i -le 10; $i++) {
$Job = Start-Job -ScriptBlock { param($item) Write-Output (“Item: $item Processed by: $($PSThreadId)”) } -ArgumentList $i
$JobList += $Job
}
$JobList | Wait-Job | Receive-Job

ในตัวอย่างนี้ เราสร้างอาร์เรย์ชื่อ $JobList เพื่อเก็บงาน จากนั้นเราใช้ลูปเพื่อสร้างงาน 10 งานด้วย Start-Job cmdlet โดยส่งอาร์กิวเมนต์ $i ไปยังบล็อกสคริปต์ในแต่ละครั้ง หลังจากงานทั้งหมดเริ่มต้นแล้ว งานเหล่านั้นจะถูกรวบรวมไว้ในอาร์เรย์ และใช้ Wait-Job เพื่อรอให้งานทั้งหมดเสร็จสิ้น สุดท้าย Receive-Job จะดึงข้อมูลเอาต์พุตจากงาน

เทคนิคทั้งสองช่วยปรับปรุงประสิทธิภาพโดยใช้การประมวลผลแบบขนานในสคริปต์บรรทัดคำสั่ง PowerShell ของคุณ

มี cmdlets เฉพาะหรือแนวปฏิบัติที่ดีที่สุดที่ต้องปฏิบัติตามเมื่อปรับประสิทธิภาพบรรทัดคำสั่ง PowerShell ให้เหมาะสมหรือไม่

การเพิ่มประสิทธิภาพบรรทัดคำสั่ง PowerShell ถือเป็นสิ่งสำคัญสำหรับการเรียกใช้สคริปต์ที่มีประสิทธิภาพและมีประสิทธิภาพสูง ด้านล่างนี้คือ cmdlets เฉพาะและแนวทางปฏิบัติที่ดีที่สุดที่คุณควรพิจารณาเมื่อต้องการปรับการใช้งานบรรทัดคำสั่ง PowerShell ให้เหมาะสม:

1. Measure-Command: ใช้ Measure-Command cmdlet เพื่อวัดเวลาที่ใช้ในการเรียกใช้บล็อกสคริปต์หรือ cmdlets ซึ่งจะช่วยให้คุณตรวจพบปัญหาคอขวดของประสิทธิภาพและเปรียบเทียบเวลาดำเนินการของคำสั่งต่างๆ

2. กรองตั้งแต่เนิ่นๆ: เมื่อทำงานกับชุดข้อมูลขนาดใหญ่ พยายามกรองข้อมูลให้เร็วที่สุดเท่าที่จะเป็นไปได้ในไปป์ไลน์ ซึ่งจะช่วยลดปริมาณข้อมูลที่ส่งผ่านไปป์ไลน์ ซึ่งจะช่วยปรับปรุงประสิทธิภาพ

3. ใช้คำสั่งดั้งเดิมเมื่อเป็นไปได้: ในบางกรณี การใช้คำสั่งดั้งเดิมใน PowerShell จะให้ประสิทธิภาพที่เร็วกว่าเมื่อเทียบกับ cmdlets ที่เทียบเท่า ตัวอย่างเช่น แทนที่จะใช้ Get-Content ให้ลองใช้วิธี System.IO.File ในการอ่านและเขียนไฟล์

4. หลีกเลี่ยงการวนซ้ำที่ไม่จำเป็น: ลดการใช้การวนซ้ำเช่น ForEach-Object หรือ For ในสคริปต์ของคุณ โดยเฉพาะอย่างยิ่งเมื่อต้องจัดการกับชุดข้อมูลขนาดใหญ่ เนื่องจากสามารถนำไปสู่เวลาดำเนินการที่เพิ่มขึ้นได้

5. ดำเนินการแบบขนาน: ใช้ประโยชน์จากพารามิเตอร์ ForEach-Object -Parallel หรือ Start-Job cmdlet เพื่อรันงานพร้อมกัน ซึ่งจะช่วยลดเวลาดำเนินการโดยรวมของสคริปต์ของคุณเมื่อทำงานหลายอย่างพร้อมกัน

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

7. เพิ่มประสิทธิภาพการกรองโดยใช้ Where-Object: แทนที่จะใช้ ForEach-Object และคำสั่ง if เพื่อกรองข้อมูล ให้ใช้ประโยชน์จาก < รหัส > Where-Object cmdlet

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

ด้วยการใช้แนวทางปฏิบัติที่ดีที่สุดเหล่านี้และคำนึงถึงการใช้งาน cmdlet คุณสามารถเพิ่มประสิทธิภาพการทำงานของสคริปต์บรรทัดคำสั่ง PowerShell ของคุณและรับรองการใช้ทรัพยากรอย่างมีประสิทธิภาพ