การเรียนรู้ศิลปะแห่งการสร้างสคริปต์ PowerShell 2: นำระบบอัตโนมัติของบรรทัดคำสั่งไปสู่อีกระดับหนึ่ง

หัวข้อ: เทคนิค 5 อันดับแรกสำหรับการสร้างสคริปต์ PowerShell 2.0 อันทรงพลัง

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

1. การสร้างฟังก์ชันขั้นสูง

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

function Get-FileInfo {
[CmdletBinding()]
param(
[Parameter(Mandatory = $true)]
[string] $FilePath
)
 if (Test-Path $FilePath) {
$fileInfo = Get-ItemProperty -Path $FilePath
return $fileInfo
} else {
Write-Error “File not found.”
return $null
}
}

ในตัวอย่างนี้ เราใช้แอตทริบิวต์ CmdletBinding ซึ่งเปิดใช้ฟีเจอร์ฟังก์ชันขั้นสูง เช่น ไปป์ไลน์อินพุตและพารามิเตอร์ทั่วไป เช่น -Verbose ฟังก์ชันของเรายังใช้พารามิเตอร์บังคับ การจัดการข้อผิดพลาด และค่าส่งคืน

2. การใช้เทคนิคการจัดการข้อผิดพลาด

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

function Set-ConfigValue {
[CmdletBinding()]
param(
[Parameter(Mandatory = $true)]
[string] $ConfigFile,
[Parameter(Mandatory = $true)]
[string] $Key,
[Parameter(Mandatory = $true)]
[string] $Value
)
 try {
$configJson = Get-Content -Path $ConfigFile -ErrorAction Stop | ConvertFrom-Json
$configJson.$Key = $Value
$configJson | ConvertTo-Json | Set-Content -Path $ConfigFile -ErrorAction Stop
} catch {
Write-Error “Failed to update configuration file: $_”
}
}

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

3. การใช้ประโยชน์จากการป้อนข้อมูลไปป์ไลน์

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

function Remove-OldFiles {
[CmdletBinding()]
param(
[Parameter(ValueFromPipeline = $true, Mandatory = $true)]
[System.IO.FileSystemInfo] $File,
[Parameter()]
[int] $Days = 30
)
 process {
if ((Get-Date) – $File.LastWriteTime -gt (New-TimeSpan -Days $Days)) {
Remove-Item -Path $File.FullName
}
}
}
Get-ChildItem -Path “C:Logs” | Remove-OldFiles -Days 60

ในตัวอย่างนี้ ฟังก์ชัน Remove-OldFiles ยอมรับอินพุตไปป์ไลน์สำหรับพารามิเตอร์ $File ทำให้สามารถทำงานได้อย่างราบรื่นกับ cmdlets อื่นๆ ที่ส่งคืนอ็อบเจ็กต์ไฟล์ เช่น รับ ChildItem

4. การใช้การดำเนินการแบบขนาน

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

$result = Get-Content -Path .Computers.txt | ForEach-Object -Parallel {
$computerName = $_
if (Test-Connection -ComputerName $computerName -Quiet -Count 1) {
$osInfo = Get-WmiObject -Class Win32_OperatingSystem -ComputerName $computerName
[PSCustomObject] @{
ComputerName = $computerName
OSVersion = $osInfo.Version
}
}
} -ThrottleLimit 10

ในตัวอย่างนี้ เราใช้ ForEach-Object -Parallel เพื่อสืบค้นเวอร์ชันระบบปฏิบัติการของรายการคอมพิวเตอร์พร้อมกัน ซึ่งช่วยลดเวลาดำเนินการทั้งหมด

5. การเขียนโค้ดที่บำรุงรักษาและอ่านได้

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

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

“`พาวเวอร์เชลล์

-

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

การดำเนินการของเซิร์ฟเวอร์ Next.js… 5 สิ่งที่ยอดเยี่ยมที่คุณสามารถทำได้

คำสั่ง PowerShell 10 อันดับแรกสำหรับผู้เริ่มต้น | ตัวอย่างที่สมจริงพร้อมคำอธิบาย!

ฉันจะสร้างสคริปต์ PowerShell ได้อย่างไร

หากต้องการสร้างสคริปต์ PowerShell ให้ทำตามขั้นตอนเหล่านี้:

1. เปิดโปรแกรมแก้ไขข้อความ: เริ่มต้นด้วยการเปิดโปรแกรมแก้ไขข้อความที่รองรับไฟล์ข้อความธรรมดา เช่น Notepad หรือ Visual Studio Code

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

$FolderPath = “C:Example”
$Files = Get-ChildItem -Path $FolderPath -Recurse -File
foreach ($File in $Files) {
$FileSize = $File.Length / 1KB
if ($FileSize -gt 10) {
Write-Host “File $($File.Name) is greater than 10KB with size: $($FileSize)KB”
}
}

สคริปต์นี้จะตรวจสอบไฟล์ทั้งหมดภายในโฟลเดอร์ C:Example และแสดงชื่อไฟล์ที่มีขนาดมากกว่า 10KB

3. บันทึกสคริปต์: บันทึกสคริปต์ของคุณด้วยนามสกุลไฟล์ .ps1 ซึ่งหมายถึงไฟล์สคริปต์ PowerShell ตัวอย่างเช่น คุณสามารถบันทึกเป็น example_script.ps1 ได้

4. เรียกใช้สคริปต์: หากต้องการเรียกใช้สคริปต์ PowerShell ให้เปิดหน้าต่างบรรทัดคำสั่ง PowerShell นำทางไปยังตำแหน่งที่คุณบันทึกสคริปต์ และพิมพ์คำสั่งต่อไปนี้:

.example_script.ps1

ตรวจสอบให้แน่ใจว่าได้แทนที่ example_script.ps1 ด้วยชื่อไฟล์สคริปต์ของคุณ

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

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

ขอให้มีความสุขในการเขียนสคริปต์!

ฉันจะเริ่มต้น PowerShell เวอร์ชัน 2 ได้อย่างไร

หากต้องการเริ่มต้น PowerShell เวอร์ชัน 2 ในบรรทัดคำสั่ง PowerShell คุณสามารถใช้คำสั่งต่อไปนี้:

powershell.exe -version 2.0

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

PowerShell V2 แสดงถึงอะไร

PowerShell V2 แสดงถึง เวอร์ชันที่สอง ของอินเทอร์เฟซบรรทัดคำสั่ง Windows PowerShell และภาษาสคริปต์ เปิดตัวในปี 2009 ด้วยการเปิดตัว Windows 7 และ Windows Server 2008 R2 เวอร์ชันนี้นำการปรับปรุงและคุณลักษณะใหม่หลายประการมาสู่ PowerShell ดั้งเดิม รวมถึง งานพื้นหลัง, โมดูล, การแก้ไขข้อบกพร่องสคริปต์ และ ฟังก์ชันขั้นสูง< /แข็งแกร่ง>. การปรับปรุงเหล่านี้ทำให้ PowerShell V2 มีประสิทธิภาพและยืดหยุ่นมากขึ้น ทำให้ผู้ใช้สามารถทำงานต่างๆ โดยอัตโนมัติและจัดการระบบได้อย่างมีประสิทธิภาพมากขึ้น

PowerShell 2.0 ถือว่าล้าสมัยหรือไม่

ใช่ PowerShell 2.0 ถือว่า ล้าสมัย ในบริบทของบรรทัดคำสั่ง PowerShell เปิดตัวในปี 2552 โดยเป็นส่วนหนึ่งของ Windows 7 และ Windows Server 2008 R2 ตั้งแต่นั้นเป็นต้นมา มีการอัปเดตที่สำคัญหลายประการใน PowerShell รวมถึง PowerShell 5.1 (เวอร์ชันล่าสุดสำหรับ Windows) และ PowerShell 7.x (เวอร์ชันข้ามแพลตฟอร์มล่าสุด) .

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

ฉันจะสร้างสคริปต์ PowerShell ที่มีประสิทธิภาพและมีโครงสร้างที่ดีเพื่อทำให้งานอัตโนมัติในอินเทอร์เฟซบรรทัดคำสั่งได้อย่างไร

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

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

2. เลือกโปรแกรมแก้ไขสคริปต์: ใช้โปรแกรมแก้ไขสคริปต์ที่เหมาะสม เช่น PowerShell ISE หรือ Visual Studio Code ที่มีส่วนขยาย PowerShell สำหรับการเขียนและแก้ไขสคริปต์ของคุณ

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

-

-

4. ใช้ชื่อตัวแปรที่ชัดเจนและสื่อความหมาย: ตรวจสอบให้แน่ใจว่าชื่อตัวแปรของคุณแสดงถึงวัตถุประสงค์อย่างชัดเจนและเข้าใจง่าย

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

6. ใช้การจัดการข้อผิดพลาดที่เหมาะสม: ใช้บล็อก Try-Catch เพื่อจัดการข้อผิดพลาดที่อาจเกิดขึ้นและออกจากสคริปต์อย่างสง่างามเมื่อจำเป็น

try {
# Your code here
}
catch {
Write-Error “An error occurred: $_”
exit 1
}

7. เขียนข้อความแบบละเอียด: รวมคำสั่ง Write-Verbose เพื่อให้ข้อมูลโดยละเอียดเกี่ยวกับความคืบหน้าของสคริปต์เมื่อรันด้วยสวิตช์ -Verbose

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

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

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

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

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

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

1. ใช้การบล็อก Try-Catch-Finally: ใช้การบล็อก Try-Catch-Finally เสมอเพื่อจัดการกับข้อผิดพลาดในการสิ้นสุดในสคริปต์ของคุณ ใส่รหัสหลักที่อาจสร้างข้อผิดพลาดภายในบล็อก Try จัดการข้อผิดพลาดในบล็อก Catch และดำเนินการล้างข้อมูลในบล็อกสุดท้าย

Try {
# Code that might throw an error
}
Catch {
# Handle the error
}
Finally {
# Cleanup actions
}

2. พารามิเตอร์ ErrorAction: ใช้พารามิเตอร์ ErrorAction เพื่อควบคุมวิธีจัดการข้อผิดพลาดที่ไม่ยุติ คุณสามารถตั้งค่าเป็น 'ดำเนินการต่ออย่างเงียบ ๆ', 'ดำเนินการต่อ', 'สอบถาม', 'หยุด' หรือ 'เพิกเฉย'

Get-ChildItem -Path “C:InvalidPath” -ErrorAction SilentlyContinue

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

if ($Error.Count -gt 0) {
Write-Host “The following errors occurred:”
$Error | Format-Table -AutoSize
}

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

if (-not (Test-Path $FilePath)) {
Write-Error “File not found: $FilePath”
}

5. การบันทึกข้อผิดพลาด: บันทึกข้อผิดพลาดโดยใช้ Start-Transcript และ Stop-Transcript cmdlets หรือโดยการเปลี่ยนเส้นทางเอาต์พุตข้อผิดพลาดไปยังไฟล์ ซึ่งจะช่วยในการวินิจฉัยและแก้ไขปัญหาในสคริปต์ของคุณ

Start-Transcript -Path “C:LogsScriptLog.txt”
# Your script code here
Stop-Transcript

6. ใช้โหมดเข้มงวด: เปิดใช้งานโหมดเข้มงวดโดยใช้ Set-StrictMode เพื่อตรวจจับข้อผิดพลาดเกี่ยวกับสคริปต์ทั่วไป เช่น การใช้ตัวแปรที่ไม่ได้เตรียมใช้งาน ณ รันไทม์

Set-StrictMode -Version Latest

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

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

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

1. สำหรับการวนซ้ำ:

For loop สามารถใช้เพื่อวนซ้ำช่วงของตัวเลขหรือองค์ประกอบในอาร์เรย์

for ($i = 0; $i -lt 10; $i++) {
Write-Host “Iteration: $i”
}

2. วง foreach:

Foreach loop สามารถใช้เพื่อวนซ้ำรายการในคอลเลกชัน เช่น อาร์เรย์หรือรายการ

$array = @(1, 2, 3, 4, 5)
foreach ($number in $array) {
Write-Host “Current number: $number”
}

3. ขณะวนซ้ำ:

While loop สามารถใช้เพื่อดำเนินการบล็อกโค้ดซ้ำๆ ตราบใดที่เงื่อนไขที่ระบุยังคงเป็นจริง

$counter = 0
while ($counter -lt 5) {
Write-Host “Counter: $counter”
$counter++
}

4. คำสั่งเงื่อนไข If-else:

คำสั่ง If-else สามารถใช้เพื่อดำเนินการบล็อกโค้ดต่างๆ โดยขึ้นอยู่กับว่าเงื่อนไขเป็นจริงหรือเท็จ

$age = 25
if ($age -ge 18) {
Write-Host “You are an adult.”
} else {
Write-Host “You are not an adult.”
}

5. สลับคำสั่ง:

คำสั่ง Switch สามารถใช้เพื่อดำเนินการต่างๆ โดยขึ้นอยู่กับค่าของตัวแปรหรือนิพจน์

$userRole = “Admin”
switch ($userRole) {
“Admin” {
Write-Host “Welcome, administrator!”
}
“Moderator” {
Write-Host “Hello, moderator!”
}
“User” {
Write-Host “Hi, user!”
}
default {
Write-Host “Invalid role.”
}
}

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