PowerShell และทุกสิ่งที่คุณจำเป็นต้องรู้เกี่ยวกับยูทิลิตี้นี้

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

สารบัญ

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

PowerShell คืออะไร?

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

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

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

หากคุณมีงานบำรุงรักษารูทีนที่ใช้เวลาตั้งค่าเพียงไม่กี่นาที คุณสามารถเขียนสคริปต์ฟังก์ชันเดียวกันนี้ลงในคำสั่งเดียวที่ชื่อว่า PowerShell ได้ จากนั้นในครั้งต่อไปที่คุณเปิดสคริปต์นั้น สคริปต์จะทำงานอยู่เบื้องหลัง การฝึกฝนตรรกะการเขียนสคริปต์ของ PowerShell การเข้าใจวิธีการทำงานของออบเจ็กต์ var (ตัวแปร) และการปรับใช้อย่างชาญฉลาดทั่วทั้งเครือข่าย จะทำให้คุณสงสัยว่าทำไมคุณถึงไม่ใช้ PowerShell เร็วกว่านี้

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

ประวัติโดยย่อของยูทิลิตี้บรรทัดคำสั่งของ Windows

หลังจาก Windows NT ออกสู่ตลาด CMD.EXE ได้กลายเป็นยูทิลิตี้บรรทัดคำสั่งสำหรับ Windows แม้ว่า CMD.EXE จะสืบทอดองค์ประกอบบางอย่างมาจาก DOS รุ่นก่อน (COMMAN.COM) แต่ก็ยังคงใช้ภาษาสคริปต์ที่ค่อนข้าง "พื้นฐาน" นั่นคือการใช้ไฟล์คำสั่งของ Windows (.CMD และ .BAT) การเพิ่ม Windows Scripting Host และภาษา VBScript และ JScript ช่วยเพิ่มประสิทธิภาพการเขียนสคริปต์ของยูทิลิตี้นี้อย่างมาก

เทคโนโลยีเหล่านี้เป็นการผสมผสานระหว่างยูทิลิตี้บรรทัดคำสั่งขั้นสูงและสภาพแวดล้อมการเขียนสคริปต์ที่ค่อนข้างสมดุล ความกังวลที่แท้จริงไม่ได้อยู่ที่ว่าสามารถจัดการไฟล์ CMD.EXE, .CMD และ Windows Scripting Host ได้มากน้อยแค่ไหน แต่สิ่งที่น่ากังวลหลักคือการทำงานที่ดูเหมือนง่ายๆ ให้สำเร็จ

การใช้ "เฟรมเวิร์ก" ของเครื่องมือบรรทัดคำสั่งและสคริปต์ สคริปต์ที่มีความครอบคลุมระดับปานกลางใดๆ จำเป็นต้องใช้ชุดคำสั่งแบบแบตช์, Windows Scripting Host และไฟล์ปฏิบัติการแบบสแตนด์อโลน สคริปต์แต่ละตัวใช้รูปแบบการทำงานและคำขอที่แตกต่างกัน การแยกวิเคราะห์ และการส่งคืนข้อมูล

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

แนะนำเครื่องมือ คำสั่ง และโมดูล PowerShell

แนวคิดสามประการที่แนะนำในส่วนนี้เป็นเพียงพื้นฐานเบื้องต้นในการทำความเข้าใจแนวคิดสำคัญที่เป็นรากฐานของ PowerShell คุณจะต้องใช้เวลาเรียนรู้และฝึกฝนแนวคิดขั้นสูงเพิ่มเติมเมื่อใช้งานคำสั่ง PowerShell

เครื่องมือ PowerShell

PowerShell ได้รับการติดตั้งตามค่าเริ่มต้นใน Windows 10, Windows 7, Windows Server 2008 R2 และ Windows เวอร์ชันใหม่ๆ PowerShell เวอร์ชันใหม่ๆ จะมีการเพิ่มฟีเจอร์และ "cmdlets" (คำศัพท์ที่ Microsoft ใช้เรียกคำสั่ง PowerShell - ออกเสียงว่า "command-lets") และติดตั้งพร้อมกับ Windows Management Framework (WMF) เวอร์ชันที่เกี่ยวข้อง

ปัจจุบัน WMF 5.1 เป็นเวอร์ชันล่าสุดที่แนะนำ ในบางกรณี ฟีเจอร์ใหม่บางอย่างจะขึ้นอยู่กับระบบปฏิบัติการ นอกเหนือจากเวอร์ชันของ WMF ตัวอย่างเช่น Windows 8 และ Windows Server 2012 รองรับ cmdlet Test-NetConnection ซึ่งช่วยให้คุณทดสอบการเชื่อมต่อกับ พอร์ต TCP/IP เฉพาะ แต่ cmdlet นี้ไม่สามารถใช้งานได้ใน Windows 7 แม้ว่าจะใช้งาน WMF เวอร์ชันล่าสุดอยู่ก็ตาม

ในระบบ Windows ส่วนใหญ่ ผู้ใช้จะมีสภาพแวดล้อม PowerShell สองแบบให้เลือกใช้ ได้แก่ คอนโซล PowerShell และ PowerShell ISE (Integrated Scripting Environment) คอนโซล PowerShell มีลักษณะเหมือนบรรทัดคำสั่งทั่วไป แต่มาพร้อมฟังก์ชันการทำงานเต็มรูปแบบของ PowerShell คอนโซล PowerShell มีทั้งชื่อตัวแปร ลูป การเติมคำสั่งอัตโนมัติ และการเรียกใช้คำสั่งแบบ pip

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

cmdlets ใน PowerShell

พื้นฐานของคำสั่ง PowerShell คือ cmdlet Microsoft ได้ใช้กลยุทธ์การออกแบบหลายอย่างในการสร้าง cmdlet ใน PowerShell

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

cmdlets ใช้รูปแบบ Verb-Noun เช่น Get-Service, Stop-Service หรือ Import-Csv ส่วนกริยาในชื่อ cmdlet ระบุถึงการดำเนินการกับคำนาม โดยทั่วไป cmdlets ที่ใช้เรียกข้อมูลจะมีกริยาGetอยู่ในชื่อ เช่นGet-ProcessหรือGet-Content คำ สั่งที่ใช้แก้ไขข้อมูลมักจะเริ่มต้นด้วยกริยาSetและคำสั่งที่ใช้เพิ่มเอนทิตีใหม่ให้กับข้อมูลมักจะเริ่มต้นด้วยAddหรือNew

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

โมดูลใน PowerShell

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

ใน PowerShell นามแฝงต่างๆ เช่น DIR, CD, DEL และ CLS สอดคล้องกับ cmdlet Get-ChildItem, Set-Location, Remove-Item และ Clear-Host ตามลำดับ นามแฝงพารามิเตอร์สามารถทำงานได้สองวิธี คือ ใช้นามแฝงที่กำหนดไว้ล่วงหน้าใน cmdlet หรือสร้างนามแฝงโดยการป้อนอักขระให้เพียงพอเพื่อสร้างการจับคู่ที่ไม่ซ้ำระหว่างพารามิเตอร์ที่รองรับใน cmdlet

การจัดการไฟล์และโฟลเดอร์

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

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

PowerShell มีคำสั่งที่คล้ายกันในรูปแบบของ Cmdlet Get-ChildItem Get-ChildItem ช่วยให้คุณสร้างรายการไฟล์ในไดเรกทอรีได้อย่างรวดเร็ว เพื่อให้สามารถจัดการไฟล์ผ่านคำสั่งแบบไปป์ หรือกำหนดผลลัพธ์ให้กับตัวแปรได้

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

พารามิเตอร์-Filterเป็นวิธีหนึ่งในการค้นหาไฟล์ โดยค่าเริ่มต้น Get-ChildItem จะส่งคืนเฉพาะไฟล์ย่อยโดยตรงของไดเรกทอรีเป้าหมายเท่านั้น ฟังก์ชันนี้สามารถขยายได้โดยใช้ พารามิเตอร์ -Recurseซึ่งจะค้นหาไดเรกทอรีที่อยู่ในไดเรกทอรีปัจจุบันแบบเรียกซ้ำ

ใน PowerShell 4.0 Get-ChildItem ได้เพิ่มความสามารถในการจำกัดผลลัพธ์ให้อยู่ในไฟล์หรือไดเรกทอรีโดยใช้ สวิตช์ –Fileหรือ–Directory PowerShell เวอร์ชันก่อนหน้าต้องส่งผลลัพธ์ไปยัง Where-Object โดยใช้ตัวกรองคุณสมบัติ PIsContainer เพื่อกำหนดผลลัพธ์นี้ ตัวอย่างเทคนิคทั้งสองที่ใช้ในการส่งคืนไดเรกทอรีที่อยู่ใน C:Users แสดงไว้ที่นี่:

Get-ChildItem C:Users -Directory Get-ChildItem C:Users | Where-Object {$_.PSIsContainer –eq $true}

ในการตรวจจับไฟล์ที่ซ่อนอยู่หรือไฟล์ระบบ ต้องใช้  -Force Get-ChildItem ใน PowerShell 4.0 และเวอร์ชันใหม่กว่าสามารถใช้เพื่อส่งคืนเฉพาะไฟล์ที่ซ่อนอยู่ ไฟล์แบบอ่านอย่างเดียว หรือไฟล์ระบบ โดยใช้-Hidden, -ReadOnlyและ–Systemตามลำดับ ฟังก์ชันการทำงานที่คล้ายกันนี้สามารถทำได้ในเวอร์ชันก่อนหน้าโดยการกรองคุณสมบัติ Mode โดยใช้ Where-Object:

Get-ChildItem C:Users | Where-Object {$_.Mode -like '*R*'}

ตรวจสอบว่าไฟล์มีอยู่หรือไม่

โดยปกติแล้ว เมื่อทำงานกับไฟล์ สิ่งที่เราจำเป็นต้องรู้คือไฟล์นั้นมีอยู่จริงหรือไม่ หรือเส้นทางไดเรกทอรีนั้นถูกต้องหรือไม่ PowerShell มี cmdlet สำหรับดำเนินการนี้ในรูปแบบของ Test-Path ซึ่งส่งคืนค่า true หรือ false

Test-Path ใช้เป็นขั้นตอนป้องกันก่อนที่จะพยายามคัดลอกหรือลบไฟล์ที่ระบุ

คัดลอก ย้าย และลบไฟล์

Copy-Item:คัดลอกไฟล์หรือไดเร็กทอรีหนึ่งรายการหรือมากกว่าจากตำแหน่งที่ระบุโดยพารามิเตอร์ -Path ไปยังตำแหน่งที่ระบุโดยตัวเลือก -Destination

Move-Item:ย้ายไฟล์หรือโฟลเดอร์

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

Remove-Item:ลบไฟล์, โฟลเดอร์

ควรใช้ Switch -Forceเมื่อพบไฟล์แบบอ่านอย่างเดียว และ ควรใช้ -Recurseเมื่อลบไดเร็กทอรีและเนื้อหาของมัน

การใช้ PowerShell -WhatIf และ -Confirm

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

สำหรับสคริปต์ที่คุณต้องการรันด้วยตนเอง หรือที่แย่กว่านั้นคือมีคำสั่งที่ต้องรันด้วยตนเอง โปรดพิจารณาใช้-Confirmวิธีนี้ช่วยให้คุณสามารถกำหนดให้ผู้ใช้โต้ตอบก่อนการดำเนินการจริงได้

สคริปต์ PowerShell = ไฟล์แบตช์บนสเตียรอยด์

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

การปฏิบัติต่อทุกสิ่งเสมือนเป็นอ็อบเจ็กต์และความสามารถในการรับอ็อบเจ็กต์ระหว่างคำสั่งต่างๆ ถือเป็นการเปลี่ยนแปลงครั้งใหญ่ในทฤษฎีของยูทิลิตี้บรรทัดคำสั่ง อย่างไรก็ตาม PowerShell ยังคงทำงานเหมือนเชลล์แบบดั้งเดิม คำสั่ง สคริปต์ และไฟล์ปฏิบัติการสามารถพิมพ์และรันได้จากบรรทัดคำสั่ง และผลลัพธ์จะแสดงเป็นข้อความ ไฟล์ Windows .CMD และ .BAT, VBScript, JScript และไฟล์ปฏิบัติการที่ทำงานภายใน CMD.EXE ทั้งหมดยังคงทำงานใน PowerShell อย่างไรก็ตาม เนื่องจากไฟล์เหล่านี้ไม่ใช่แบบเชิงวัตถุ จึงไม่สามารถเข้าถึงอ็อบเจ็กต์ที่สร้างและใช้งานใน PowerShell ได้อย่างสมบูรณ์ สคริปต์และไฟล์ปฏิบัติการแบบดั้งเดิมเหล่านี้จะยังคงปฏิบัติต่อทุกสิ่งเป็นข้อความ แต่คุณสามารถรวม PowerShell เข้ากับเทคโนโลยีอื่นๆ ได้อีกมากมาย สิ่งนี้สำคัญอย่างยิ่งหากคุณต้องการเริ่มใช้ PowerShell กับสคริปต์ที่มีอยู่มากมายซึ่งคุณไม่สามารถแปลงทั้งหมดในคราวเดียวได้

อธิบายพารามิเตอร์ของ PowerShell

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

ตัวอย่างเช่น Get-Process จะดึงข้อมูลและแสดงรายการกระบวนการทั้งหมดที่กำลังทำงานอยู่ในระบบปฏิบัติการของคุณ:

แต่ถ้าคุณต้องการรับเฉพาะกระบวนการใดกระบวนการหนึ่งล่ะ? คุณสามารถทำได้โดยใช้พารามิเตอร์ ตัวอย่างเช่น หากต้องการรับกระบวนการทั้งหมดของ Slack คุณสามารถใช้พารามิเตอร์ Name ร่วมกับคำสั่ง Get-Process Cmdlet ได้:

Get-Process -Name Slack

จากนั้นคุณจะเห็นเฉพาะกระบวนการที่มีชื่อว่า "slack" เท่านั้น:

เคล็ดลับ : พารามิเตอร์บางตัวเป็นแบบ "ระบุตำแหน่ง" ซึ่งหมายความว่าชื่อของพารามิเตอร์เหล่านั้นเป็นตัวเลือก ในกรณีนี้Get-Process -Name SlackและGet-Process Slackจะทำงานเหมือนกัน

แต่ละ Cmdlet จะยอมรับพารามิเตอร์ประเภทต่างๆ กัน ใช้คำสั่ง Get-Help เพื่อดูพารามิเตอร์ที่ Cmdlet ยอมรับในส่วน SYNTAX

Get-Help Get-Process

คุณจะเห็นรายการวิธีที่เป็นไปได้ทั้งหมดในการรัน Cmdlet ที่กำหนด:

ในกรณีนี้ คำสั่ง Get-Process จะยอมรับพารามิเตอร์ต่างๆ เช่นName, Id, ComputerName, Module, FileVersionInfoและพารามิเตอร์ทั่วไปอื่นๆ สัญลักษณ์ในที่นี้หมายถึง:

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

Get-Process [[-Name] ]

... หมายความว่า พารามิเตอร์ Nameยอมรับค่าสตริงหนึ่งค่าขึ้นไป ในขณะที่คำสั่งนี้:

Get-Process -Id 

... หมายความว่า พารามิเตอร์ Idยอมรับค่าจำนวนเต็มหนึ่งค่าขึ้นไป

ตัวอย่าง Get-Process ก่อนหน้านี้ใช้พารามิเตอร์ Name เพื่อจำกัดผลลัพธ์ให้แคบลง อย่างไรก็ตาม หากคุณต้องการจำกัดผลลัพธ์ให้เฉพาะเจาะจงมากขึ้น คุณสามารถใช้ พารามิเตอร์ IDซึ่งต้องใช้จำนวนเต็มตามที่ระบุไว้ในไวยากรณ์

Get-Process -Id 3016

จากนั้นคุณจะเห็นเพียงกระบวนการเดียวในรายการ:

สร้างไปป์ไลน์

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

สมมติว่าคุณกำลังสร้างสคริปต์เพื่อจัดเรียงและแสดงไฟล์ 5 ไฟล์ที่ใช้พื้นที่มากที่สุดในไดเรกทอรี มีวิธีการเขียนสคริปต์จัดเรียงไฟล์ที่มีประสิทธิภาพมากกว่า แต่สคริปต์ง่ายๆ นี้เข้าใจง่าย:

หากต้องการดำเนินการนี้ใน PowerShell ให้ใช้ไปป์ไลน์ที่มีลักษณะดังนี้:

Get-ChildItem -Path "C:\Directory" -File | Sort-Object Length -Descending `
 | Select-Object -First 5 | Format-Table Name, Length -AutoSize

บันทึกไปป์ไลน์เป็นสคริปต์ PS1

ตอนนี้เรามีไพพ์ไลน์การทำงานแล้ว คุณสามารถบันทึกเป็นไฟล์สคริปต์ PS1 ได้ ดังนั้นคุณจึงไม่จำเป็นต้องนำเข้าทุกครั้งที่ใช้งาน

วิธีที่ง่ายที่สุดในการสร้างไฟล์ PS1 คือวางสคริปต์ของคุณลงใน Notepad และบันทึกไฟล์ด้วยนามสกุล .ps1

เมื่อคุณสร้างไฟล์ PS1 แล้ว คุณสามารถใช้ไฟล์นั้นใน PowerShell ได้โดยการรัน./ScriptName.ps1 :

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

ขอแสดงความยินดี! ตอนนี้คุณสามารถสร้างสคริปต์ PowerShell PS1 ได้แล้ว

ตัวอย่างสคริปต์ PowerShell

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

DIR เป็นหนึ่งในคำสั่งที่ใช้บ่อยที่สุดใน CMD.EXEคำสั่งนี้จะแสดงไฟล์และไดเรกทอรีย่อยทั้งหมดที่อยู่ในไดเรกทอรีหลัก (ดังแสดงในรูปที่ 1) นอกจากชื่อของแต่ละอ็อบเจ็กต์แล้ว ข้อมูลที่ให้ไว้ยังรวมถึงวันที่และเวลาอัปเดตล่าสุด และขนาดของไฟล์แต่ละไฟล์อีกด้วย นอกจากนี้ DIR ยังแสดงขนาดรวมของไฟล์ทั้งหมดในไดเรกทอรี รวมถึงจำนวนไฟล์และไดเรกทอรีย่อยทั้งหมดอีกด้วย

รูปที่ 1

การเรียกใช้ DIR ใน PowerShell จะสร้างรายการไดเรกทอรีดังรูปที่ 2 แต่แตกต่างกันเล็กน้อย PowerShell ไม่มีคำสั่ง DIR แต่มี Get-ChildItem ซึ่งทำหน้าที่เดียวกัน ใน PowerShell DIR เป็นนามแฝงของ Get-ChildItem ผมไม่ได้ตั้งใจจะลงรายละเอียดเกี่ยวกับนามแฝงในบทความนี้ คุณสามารถมองว่า DIR ใน PowerShell เป็นตัวย่อของ Get-ChildItem ได้

DIR ใน PowerShell ให้ข้อมูลส่วนใหญ่เหมือนกับที่กล่าวไว้ข้างต้น ได้แก่ รายการไฟล์และโฟลเดอร์ วันที่และเวลาที่มีการแก้ไขล่าสุด และขนาดของแต่ละไฟล์ อย่างไรก็ตาม DIR ใน CMD.EXE ไม่มีข้อมูลสรุปที่ DIR มี ได้แก่ ขนาดรวมของไฟล์ทั้งหมดในโฟลเดอร์ จำนวนไฟล์ทั้งหมด และจำนวนโฟลเดอร์ย่อยทั้งหมด

รูปที่ 2

สำหรับสถานการณ์ตัวอย่างนี้ คุณจะต้องสร้างสคริปต์ PowerShell ที่จำลองคำสั่ง CMD.EXE DIR ต่อไปนี้ ผมจะอธิบายส่วนที่สำคัญที่สุดของสคริปต์

DIR.PS1: ส่วนหัว

สคริปต์ PowerShell ประกอบด้วยคำสั่ง PowerShellในไฟล์ข้อความธรรมดาที่มีนามสกุล .PS1 แทนที่จะใช้ DIR คุณจะใช้ไฟล์ข้อความชื่อ DIR.PS1

หากต้องการเรียกใช้สคริปต์ ให้พิมพ์คำสั่งต่อไปนี้ในหน้าจอ PowerShell:

.DIR.PS1 X:Folder

โดยที่ X คือตัวอักษรพาร์ติชันไดรฟ์ (เช่น C, D, E) และ Folder คือชื่อโฟลเดอร์

หากคุณต้องการทราบข้อมูลเกี่ยวกับพาร์ติชันของไดรฟ์ คุณจะต้องใช้ Windows Management Instrumentation (WMI) รายละเอียดของ WMI อยู่นอกเหนือขอบเขตของบทความนี้ ดังนั้นเราจะไม่ลงรายละเอียดในที่นี้ แต่โค้ด PowerShell ด้านล่างนี้สามารถเข้าใจได้ง่ายโดยไม่ต้องใช้ WMI คุณสามารถสร้างตัวแปร “$filter” เพื่อใช้กับคำสั่ง Get-WmiObject ได้ ตัวกรองนี้จะแจ้งคำสั่ง Get-WmiObject ว่าคุณต้องการข้อมูลเกี่ยวกับไดรฟ์ที่ระบุเท่านั้น ผลลัพธ์ของคำสั่ง Get-WmiObject จะถูกเก็บไว้ในตัวแปรชื่อ $volInfo โปรดจำไว้ว่าใน PowerShell ทุกอย่างเป็นอ็อบเจ็กต์ และตอนนี้ $volInfo กลายเป็นอ็อบเจ็กต์ที่ส่งคืนโดย Get-WmiObject

$filter = "DeviceID = '" + $drive + ":'"
$volInfo = Get-WmiObject -Class Win32_LogicalDisk -Filter $filter

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

$serial = $volInfo.VolumeSerialNumber.SubString(0, 4) + "-" + `
$volInfo.VolumeSerialNumber.SubString(4, 4)

ตอนนี้คุณมีออบเจ็กต์ $volInfo แล้ว คุณสามารถเขียนข้อมูลส่วนหัวของ DIR ลงบนหน้าจอได้ หากไดรฟ์ไม่มีชื่อ ข้อความที่เขียนลงบนหน้าจอจะแตกต่างจากกรณีที่ไดรฟ์มีชื่อเล็กน้อย คำสั่ง If-Else แบบง่าย ๆ ใช้เพื่อตรวจสอบว่าคุณสมบัติ VolumeName เป็นสตริงว่างหรือไม่ คำสั่ง Write-Host ใช้เพื่อเขียนข้อความแต่ละบรรทัดลงบนหน้าจอ

If ($volInfo.VolumeName -eq "") { Write-Host (" Volume in drive " + $drive + " has no label") } Else { Write-Host (" Volume in drive " + $drive + " is " + $volInfo.VolumeName) } Write-Host (" Volume Serial Number is " + $serial) Write-Host ("`n Directory of " + $args[0] + "`n")

อักขระ “`n” ที่ขึ้นต้นและลงท้ายคำสั่ง Write-Host ใช้เพื่อขึ้นบรรทัดใหม่ก่อนและหลังข้อความ คำสั่ง Write-Host จะเพิ่มบรรทัดใหม่ที่ท้ายแต่ละบรรทัด ดังนั้นผลของ “`n” คือการสร้างบรรทัดว่างก่อนและหลังข้อความ

คุณสังเกตเห็น “-eq” ในคำสั่ง If ไหม? มันเป็นตัวดำเนินการเปรียบเทียบความเท่าเทียม ตารางด้านล่างแสดงตัวดำเนินการเปรียบเทียบทั้งหมด:

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

รูปที่ 3: ข้อมูลเอาต์พุตของสคริปต์ที่คุณมีอยู่ในปัจจุบัน

DIR.PS1: รายการไฟล์/โฟลเดอร์

ตอนนี้คุณพร้อมที่จะแสดงเนื้อหาและคุณสมบัติของโฟลเดอร์นี้แล้ว สิ่งแรกที่ต้องทำคือเรียกใช้คำสั่ง Get-ChildItem ของ PowerShell เพื่อดึงข้อมูลชุดของไฟล์และส่งผ่านไปยังสคริปต์เป็นพารามิเตอร์ คำสั่ง Get-ChildItem จะดึงข้อมูลชุดของออบเจ็กต์ไฟล์และโฟลเดอร์ ไม่ใช่แค่ชื่อเท่านั้น แต่จะส่งต่อออบเจ็กต์เหล่านี้ไปยังคำสั่ง Sort-Object โดยตรงเพื่อเรียงลำดับ โดยค่าเริ่มต้น คำสั่ง Sort-Object จะเรียงลำดับออบเจ็กต์ตามคุณสมบัติ Name ดังนั้นคุณไม่จำเป็นต้องระบุพารามิเตอร์อื่นๆ คอลเล็กชันของออบเจ็กต์ที่เรียงลำดับแล้วจะถูกเก็บไว้ในตัวแปรชื่อ $items

$items = Get-ChildItem $args[0] | Sort-Object

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

คำสั่ง If คือส่วนที่คุณใช้กำหนดว่าออบเจ็กต์นั้นเป็นไดเร็กทอรีหรือไม่ หากอักขระตัวแรกของแอตทริบิวต์ Mode คือ "d" แสดงว่าออบเจ็กต์นั้นเป็นไดเร็กทอรี คุณจำเป็นต้องตรวจสอบอีกครั้ง เนื่องจากโค้ดสำหรับไดเร็กทอรีมักจะแตกต่างจากโค้ดสำหรับไฟล์

สังเกตบรรทัด $totalDirs++ ภายในคำสั่ง If ซึ่งเป็นตัวนับที่ทำหน้าที่ติดตามจำนวนไดเรกทอรี ในทำนองเดียวกัน ยังมีตัวแปร $totalFiles ที่ใช้ติดตามขนาดรวมของไฟล์ทั้งหมด ค่าเหล่านี้จะถูกคำนวณระหว่างการดำเนินการเสมอ แต่จะแสดงเฉพาะเมื่อกระบวนการแสดงรายการไฟล์เสร็จสิ้นเท่านั้น

ForEach ($i In $items)
{
$date = "{0, -20:MM/dd/yyyy hh:mm tt}" -f $i.LastWriteTime
$file = $i.Name
If ($i.Mode.SubString(0, 1) -eq "d")
{
$totalDirs++
$list = $date + " {0, -15}" -f "
" + " " + $file
}
Else
{
$totalFiles++
$size = "{0, 18:N0}" -f $i.Length
$list = $date + $size + " " + $file
}
$totalSize += $i.Length
Write-Host $list
}

รูปที่ 4: แสดงข้อมูลเอาต์พุตของสคริปต์ที่อัปเดต

DIR.PS1: ส่วนท้าย

สิ่งเดียวที่เหลือให้ทำคือเขียนจำนวนไฟล์ทั้งหมด ไดเรกทอรี ขนาดไฟล์ทั้งหมด และพื้นที่ว่างบนพาร์ติชันไดรฟ์นี้ลงบนหน้าจอ ในการทำเช่นนี้ คุณจะต้องใช้ตัวแปรตัวนับ ($totalFiles, $totalDirs, $totalSize) ที่สร้างไว้ในหัวข้อก่อนหน้า คุณสามารถดูปริมาณพื้นที่ว่างได้จากตัวแปร $volInfo ที่สร้างขึ้นในตอนต้นของสคริปต์

Write-Host ("{0, 16:N0}" -f $totalFiles + " File(s)" + `
"{0, 15:N0}" -f $totalSize + " bytes")
Write-Host ("{0, 16:N0}" -f $totalDirs + " Dir(s)" + `
"{0, 16:N0}" -f $volInfo.FreeSpace + " bytes free`n")

รูปที่ 5: แสดงข้อมูลเอาท์พุตของสคริปต์ทั้งหมด

การพยากรณ์และการปรับปรุงสามารถทำได้

แม้ว่าสคริปต์ที่คุณสร้างจะสร้างผลลัพธ์ที่เกือบจะเหมือนกับคำสั่ง CMD.EXE DIR แต่ก็มีข้อควรระวังบางประการที่คุณควรทราบ และสามารถทำการปรับปรุงบางอย่างได้

• สคริปต์นี้ไม่ได้ดำเนินการตรวจสอบข้อผิดพลาดใด ๆ
• หากไม่ส่งเส้นทางที่ถูกต้องไปยังสคริปต์ สคริปต์จะล้มเหลวโดยมีข้อความแสดงข้อผิดพลาดของ PowerShell
• จำนวนไดเร็กทอรีทั้งหมดที่กำหนดไว้ในสคริปต์น้อยกว่าผลลัพธ์จากคำสั่ง CMD.EXE DIR 2 เนื่องจากคำสั่ง Get-ChildItem ไม่นับไดเร็กทอรีทั้งสอง “.” และ “..” เหมือนใน CMD.EXE
• สคริปต์ของคุณจะเรียงลำดับตามชื่อไฟล์ ชื่อโฟลเดอร์เท่านั้น และไม่มีการเรียงลำดับตามแอตทริบิวต์อื่น ๆ
• สคริปต์ของคุณไม่สามารถแสดงเนื้อหาของโฟลเดอร์และโฟลเดอร์ย่อยทั้งหมดได้

PowerShell ช่วยให้คุณทำสิ่งต่างๆ บนพีซีของคุณโดยอัตโนมัติได้อย่างไร

เขียนสคริปต์ PowerShell ง่ายๆ

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

หมายเหตุ : หากคุณพบข้อผิดพลาดขณะดำเนินการสคริปต์เกี่ยวกับนโยบายการดำเนินการ คุณอาจต้องอนุญาตให้สคริปต์ดำเนินการชั่วคราวโดยเรียกใช้ "Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass"

เปลี่ยนชื่อไฟล์เป็นชุดในโฟลเดอร์

คุณสามารถใช้ PowerShell เพื่อคัดลอก ย้าย และลบไฟล์บนพีซีของคุณได้ คุณยังสามารถเปลี่ยนชื่อไฟล์ประเภทใดประเภทหนึ่งได้พร้อมกันหลายไฟล์ ตัวอย่างเช่น คุณสามารถเปลี่ยนชื่อไฟล์ข้อความหลายไฟล์ได้โดยการแทนที่คำนำหน้า "oldco" ด้วย "newco" ในชื่อไฟล์:

Get-ChildItem -Path "C:\CompanyFiles" -Filter "*.txt" | Rename-Item -NewName {$_.Name -replace "oldco","newco"}

ในสคริปต์ด้านบน ".txt" คือตัวกรองนามสกุลไฟล์ คุณสามารถแก้ไขและตั้งค่าเป็น .jpg, .docx ฯลฯ เพื่อค้นหาไฟล์ประเภทต่างๆ ได้

การเปิดใช้งานแอปพลิเคชันอัตโนมัติ

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

#Open multiple apps with a single click
Start-Process "notepad.exe"
Start-Process "calc.exe"
Start-Process "Chrome.exe"
Start-Process "slack.exe"

วางสคริปต์ลงในไฟล์ Notepad แล้วบันทึกเป็นไฟล์LaunchFavoriteApps.ps1จากนั้นดับเบิลคลิกไฟล์เพื่อเปิดแอปทั้งหมดที่อยู่ในสคริปต์

คัดลอกไฟล์สำคัญไปยังตำแหน่งสำรองข้อมูล

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

#Copy MyFiles folder contents to MyFilesBackup in D:\
Copy-Item -Path "C:\Documents\MyFiles" -Destination "D:\MyFilesBackup" -Recurse

เขียนสคริปต์ PowerShell เพื่อจัดระเบียบไฟล์โดยอัตโนมัติทุกวัน

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

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

# Change the source folder path below
$sourcePath = "E:\Downloads"
# Add file mapping folder names; the Others folder includes all the files that do not match file types in the other categories
$fileTypes = @{
"Documents" = @("*.docx", "*.pdf", "*.txt")
"Images" = @("*.jpg", "*.png", "*.gif")
"Media" = @("*.mp4", "*.mp3", "*.mov")
"Zip" = @("*.zip", "*.rar")
"ISO" = @("*.iso")
"Others" = @("*")
}
# Iterate through each folder type and prepare a destination folder for organizing files
foreach ($folder in $fileTypes.Keys) {
# Create the destination folder path
$destPath = Join-Path -Path $sourcePath -ChildPath $folder
# Check if the destination folder exists, and create it if it doesn't
if (!(Test-Path -Path $destPath)) {
New-Item -ItemType Directory -Path $destPath | Out-Null
}
# Move matching files from the source folder to the destination folder based on file type patterns
foreach ($pattern in $fileTypes[$folder]) {
Get-ChildItem -Path $sourcePath -Filter $pattern -File -ErrorAction SilentlyContinue | ForEach-Object {
try {
Move-Item -Path $_.FullName -Destination $destPath -Force -ErrorAction Stop
Write-Output "Moved: $($_.FullName) to $destPath"
} catch {
Write-Warning "Failed to move file: $($_.FullName). Error: $_"
}
}
}
}
Write-Output "Files organized successfully!"

หากต้องการบันทึกไฟล์ ให้คลิกFile > Save As (ไฟล์ > บันทึกเป็น)แล้วพิมพ์OrganizeDownloadsFolder.ps1เป็นชื่อไฟล์ จากนั้นคลิกSave as Type (บันทึกเป็นประเภท)แล้วเลือกAll Files (ไฟล์ทั้งหมด ) ดับเบิลคลิกที่ ไฟล์ OrganizeDownloadsFolder.ps1เพื่อเรียกใช้สคริปต์

กำหนดเวลาและดำเนินการงาน

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

เปิด PowerShell จากนั้นคัดลอกและวางสคริปต์ต่อไปนี้ แล้วกดEnterอย่าลืมแทนที่'J:\OrganizeDownloadsFolder.ps1'ด้วยเส้นทางไฟล์แบบเต็มไปยัง สคริปต์ OrganizeDownloadsFolder.ps1ของคุณ

$action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File 'J:\OrganizeDownloadsFolder.ps1'"
$trigger = New-ScheduledTaskTrigger -Daily -At "5:00 PM"
Register-ScheduledTask -Action $action -Trigger $trigger -TaskName "OrganizeDownloadsFolderDaily"

เมื่อเสร็จแล้ว ให้กดEnterสคริปต์จะสร้างงานที่กำหนดเวลาไว้ในตัวกำหนดเวลางาน (Task Scheduler) เพื่อรันสคริปต์จัดระเบียบไฟล์ทุกวันเวลา 17.00 น. หากต้องการเวลาอื่น คุณสามารถแก้ไขในสคริปต์ด้านบนได้

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

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