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

ประวัติโดยย่อของยูทิลิตี้บรรทัดคำสั่งของ 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

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

cmdlets ใน PowerShell

รากฐานของคำสั่ง PowerShell คือ cmdlet Microsoft ใช้กลยุทธ์การออกแบบหลายประการเมื่อสร้าง cmdlets ใน PowerShell

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

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

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

โมดูลใน PowerShell

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

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

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

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

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

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

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

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

ใน PowerShell 4.0 Get-ChildItem ได้เพิ่มความสามารถในการจำกัดผลลัพธ์ให้เป็นไฟล์หรือไดเร็กทอรีโดยใช้สวิตช์–Fileหรือ–Directory PowerShell เวอร์ชันก่อนหน้าจะต้องส่งผลลัพธ์ไปยัง Where-Object โดยกรองคุณสมบัติ PSIsContainer เพื่อทำการกำหนดนี้ ตัวอย่างของทั้งสองเทคนิคที่ใช้ในการส่งคืนโฟลเดอร์ที่มีอยู่ใน 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ตามลำดับ ฟังก์ชันการทำงานที่คล้ายกันสามารถทำได้ในเวอร์ชันก่อนหน้าโดยการกรองคุณสมบัติโหมดโดยใช้ Where-Object:

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

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

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

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

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

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

ย้ายรายการ:ย้ายไฟล์หรือโฟลเดอร์

เมื่อมีการคัดลอกหรือย้ายโครงสร้างไดเร็กทอรี ควรใช้ -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 ยังคงทำงานเหมือนยูทิลิตี้เชลล์ดั้งเดิม สามารถพิมพ์คำสั่ง สคริปต์ และไฟล์ปฏิบัติการได้ และรันได้จากบรรทัดคำสั่ง และผลลัพธ์จะแสดงในรูปแบบข้อความ ไฟล์ .CMD และ .BAT ของ Windows, VBScripts, JScripts และไฟล์ปฏิบัติการที่ทำงานภายใน CMD.EXE ทั้งหมดยังคงทำงานใน PowerShell อย่างไรก็ตาม เนื่องจากไม่ใช่แบบมุ่งเน้นวัตถุ ดังนั้นจึงไม่สามารถเข้าถึงวัตถุที่ถูกสร้างและใช้ใน PowerShell ได้อย่างสมบูรณ์ สคริปต์และการดำเนินการล้าสมัยเหล่านี้จะยังคงปฏิบัติต่อทุกอย่างเป็นข้อความ แต่คุณสามารถรวม PowerShell เข้ากับเทคโนโลยีอื่นๆ ได้จำนวนหนึ่ง นี่เป็นประเด็นสำคัญมากหากคุณต้องการเริ่มใช้ PowerShell ด้วยคอลเลกชันสคริปต์ที่มีอยู่ซึ่งไม่สามารถแปลงทั้งหมดในครั้งเดียวได้

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

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

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

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

Get-Process -Name Slack

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

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

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

Get-Help Get-Process

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

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

สมมติว่าคุณกำลังสร้างสคริปต์เพื่อจัดเรียงและแสดงไฟล์ 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 ให้ไว้: ขนาดทั้งหมดของไฟล์ในไดเร็กทอรี จำนวนไฟล์ทั้งหมด และจำนวนไดเร็กทอรีย่อยทั้งหมด

รูปที่ 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: รายการไฟล์/โฟลเดอร์

ตอนนี้คุณพร้อมที่จะแสดงเนื้อหาและคุณสมบัติของโฟลเดอร์นี้แล้ว สิ่งแรกที่ต้องทำคือเรียกคำสั่ง PowerShell Get-ChildItem เพื่อรับชุดไฟล์และส่งต่อไปยังสคริปต์เป็นพารามิเตอร์ คำสั่ง 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!"

หากต้องการบันทึกไฟล์ ให้คลิกไฟล์ > บันทึกเป็นและป้อนOrganizeDownloadsFolder.ps1เป็นชื่อไฟล์ จากนั้นคลิกบันทึกเป็นประเภทและเลือกไฟล์ทั้งหมด ดับเบิลคลิก ไฟล์ 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 แต่สคริปต์ที่สร้างในตัวอย่างนั้นค่อนข้างเรียบง่าย เชื่อว่าสามารถสร้างและพัฒนาได้ครอบคลุมยิ่งขึ้นเพื่อรองรับการใช้งานที่ซับซ้อนมากยิ่งขึ้น