Windows PowerShell คืออะไรและใช้ทำอะไร? ส่วนที่ 4: การทำงานกับวัตถุ คลาสของตัวเอง

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

คำศัพท์:

วัตถุใน PowerShell
การดูโครงสร้างของวัตถุ
การกรองวัตถุ
การเรียงลำดับวัตถุ
การเลือกวัตถุและชิ้นส่วน
สำหรับแต่ละวัตถุ กลุ่มวัตถุ และการวัดวัตถุ
การสร้างวัตถุ .NET และ COM (วัตถุใหม่)
การเรียกวิธีการแบบคงที่
พิมพ์ PSCustomObject
การสร้างชั้นเรียนของคุณเอง

วัตถุใน PowerShell

ขอให้เราจำไว้ว่าออบเจ็กต์คือชุดของเขตข้อมูล (คุณสมบัติ เหตุการณ์ ฯลฯ) และวิธีการประมวลผลข้อมูลเหล่านั้น (วิธีการ) โครงสร้างจะถูกระบุตามประเภท ซึ่งโดยทั่วไปจะขึ้นอยู่กับคลาสที่ใช้ในแพลตฟอร์ม .NET Core แบบครบวงจร นอกจากนี้ยังสามารถทำงานกับวัตถุ COM, CIM (WMI) และ ADSI ได้อีกด้วย จำเป็นต้องใช้คุณสมบัติและวิธีการในการดำเนินการต่างๆ กับข้อมูล นอกจากนี้ใน PowerShell วัตถุสามารถส่งผ่านเป็นอาร์กิวเมนต์ไปยังฟังก์ชันและ cmdlets กำหนดค่าให้กับตัวแปรและยังมี กลไกการจัดองค์ประกอบคำสั่ง (สายพานลำเลียงหรือท่อ) แต่ละคำสั่งในไปป์ไลน์จะส่งผ่านเอาต์พุตไปยังคำสั่งถัดไปตามลำดับ ทีละวัตถุ สำหรับการประมวลผล คุณสามารถใช้ cmdlets ที่คอมไพล์แล้วหรือสร้างขึ้นเองได้ คุณสมบัติขั้นสูงเพื่อดำเนินการจัดการต่างๆ กับวัตถุในไปป์ไลน์: การกรอง การเรียงลำดับ การจัดกลุ่ม และแม้แต่การเปลี่ยนโครงสร้าง การส่งข้อมูลในรูปแบบนี้มีข้อได้เปรียบอย่างมาก: ทีมที่รับไม่จำเป็นต้องแยกวิเคราะห์ไบต์สตรีม (ข้อความ) ข้อมูลที่จำเป็นทั้งหมดสามารถเรียกค้นได้อย่างง่ายดายโดยการเรียกคุณสมบัติและวิธีการที่เหมาะสม

การดูโครงสร้างของวัตถุ

ตัวอย่างเช่น เรียกใช้ Get-Process cmdlet ซึ่งช่วยให้คุณได้รับข้อมูลเกี่ยวกับกระบวนการที่ทำงานอยู่ในระบบ:

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

Get-Process | Get-Member

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

Get-Process | Get-Member -MemberType Property

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

การกรองวัตถุ

PowerShell อนุญาตให้วัตถุที่ตรงตามเงื่อนไขบางอย่างสามารถส่งผ่านไปป์ไลน์ได้:

Where-Object { блок сценария }

ผลลัพธ์ของการดำเนินการบล็อกสคริปต์ภายในวงเล็บต้องเป็นค่าบูลีน หากเป็นจริง ($true) วัตถุที่ป้อนเข้าใน Where-Object cmdlet จะถูกส่งไปตามไปป์ไลน์ มิฉะนั้น ($false) จะถูกลบ ตัวอย่างเช่น ลองแสดงรายการบริการ Windows Server ที่หยุดทำงาน เช่น ผู้ที่มีคุณสมบัติสถานะตั้งค่าเป็น "หยุด":

Get-Service | Where-Object {$_.Status -eq "Stopped"}

ที่นี่เราเห็นการแสดงข้อความอีกครั้ง แต่ถ้าคุณต้องการเข้าใจประเภทและโครงสร้างภายในของวัตถุที่ผ่านไปป์ไลน์ก็ไม่ยาก:

Get-Service | Where-Object {$_.Status -eq "Stopped"} | Get-Member

การเรียงลำดับวัตถุ

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

Get-Process | Sort-Object –Property cpu

สามารถละเว้นพารามิเตอร์ -Property ได้เมื่อเรียกใช้ Sort-Object cmdlet โดยจะใช้เป็นค่าเริ่มต้น สำหรับการเรียงลำดับแบบย้อนกลับ ให้ใช้พารามิเตอร์ -Descending:

Get-Process | Sort-Object cpu -Descending

การเลือกวัตถุและชิ้นส่วน

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

คำสั่งต่อไปนี้แสดงข้อมูลเกี่ยวกับกระบวนการ 10 กระบวนการที่ใช้ RAM สูงสุด (คุณสมบัติ WS):

Get-Process | Sort-Object WS -Descending | Select-Object -First 10

คุณสามารถเลือกเฉพาะคุณสมบัติบางอย่างของออบเจ็กต์ที่ส่งผ่านไปป์ไลน์และสร้างคุณสมบัติใหม่ตามคุณสมบัติเหล่านั้น:

Get-Process | Select-Object ProcessName, Id -First 1

จากการดำเนินการของไปป์ไลน์ เราจะได้รับออบเจ็กต์ใหม่ โครงสร้างที่จะแตกต่างจากโครงสร้างที่ส่งคืนโดย Get-Process cmdlet มาตรวจสอบสิ่งนี้โดยใช้ Get-Member:

Get-Process | Select-Object ProcessName, Id -First 1 | Get-Member

โปรดทราบว่า Select-Object ส่งคืนออบเจ็กต์เดียว (-First 1) ที่มีเพียงสองฟิลด์ที่เราระบุ: ค่าของพวกเขาถูกคัดลอกจากออบเจ็กต์แรกที่ส่งผ่านไปยังไปป์ไลน์โดย Get-Process cmdlet วิธีหนึ่งในการสร้างวัตถุในสคริปต์ PowerShell ขึ้นอยู่กับการใช้ Select-Object:

$obj = Get-Process | Select-Object ProcessName, Id -First 1
$obj.GetType()

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

Get-Process | Select-Object -Property ProcessName, @{Name="StartTime"; Expression = {$_.StartTime.Minute}}

ลองดูโครงสร้างของวัตถุที่ผ่านสายพานลำเลียง:

Get-Process | Select-Object -Property ProcessName, @{Name="StartTime"; Expression = {$_.StartTime.Minute}} | Get-Member

สำหรับแต่ละวัตถุ กลุ่มวัตถุ และการวัดวัตถุ

มี cmdlets อื่น ๆ สำหรับการทำงานกับวัตถุ ตัวอย่างเช่น เรามาพูดถึงสามสิ่งที่มีประโยชน์มากที่สุด:

สำหรับแต่ละวัตถุ อนุญาตให้คุณเรียกใช้โค้ด PowerShell สำหรับแต่ละอ็อบเจ็กต์ในไปป์ไลน์:

ForEach-Object { блок сценария }

กลุ่มวัตถุ จัดกลุ่มวัตถุตามมูลค่าทรัพย์สิน:

Group-Object PropertyName

หากคุณรันด้วยพารามิเตอร์ -NoElement คุณสามารถดูจำนวนองค์ประกอบในกลุ่มได้

วัด-วัตถุ รวมพารามิเตอร์สรุปต่างๆตามค่าฟิลด์วัตถุในไปป์ไลน์ (คำนวณผลรวมและค้นหาค่าต่ำสุดสูงสุดหรือค่าเฉลี่ย):

Measure-Object -Property PropertyName -Minimum -Maximum -Average -Sum

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

การสร้างวัตถุ .NET และ COM (วัตถุใหม่)

มีส่วนประกอบซอฟต์แวร์มากมายที่มีอินเทอร์เฟซ .NET Core และ COM ที่เป็นประโยชน์สำหรับผู้ดูแลระบบ เมื่อใช้คลาส System.Diagnostics.EventLog คุณสามารถจัดการบันทึกของระบบได้โดยตรงจาก Windows PowerShell ลองดูตัวอย่างการสร้างอินสแตนซ์ของคลาสนี้โดยใช้ New-Object cmdlet พร้อมด้วยพารามิเตอร์ -TypeName:

New-Object -TypeName System.Diagnostics.EventLog

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

$AppLog = New-Object -TypeName System.Diagnostics.EventLog -ArgumentList Application
$AppLog

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

หากต้องการทำงานกับบันทึก คุณสามารถใช้วิธีการที่เหมาะสม:

$AppLog | Get-Member -MemberType Method

สมมติว่ามันถูกล้างโดยเมธอด Clear() หากมีสิทธิ์การเข้าถึง:

$AppLog.Clear()

New-Object cmdlet ยังใช้เพื่อทำงานกับคอมโพเนนต์ COM มีค่อนข้างมาก - ตั้งแต่ไลบรารีที่มาพร้อมกับเซิร์ฟเวอร์สคริปต์ Windows ไปจนถึงแอปพลิเคชัน ActiveX เช่น Internet Explorer ในการสร้างวัตถุ COM คุณต้องตั้งค่าพารามิเตอร์ -ComObject ด้วย ProgId ทางโปรแกรมของคลาสที่ต้องการ:

New-Object -ComObject WScript.Shell
New-Object -ComObject WScript.Network
New-Object -ComObject Scripting.Dictionary
New-Object -ComObject Scripting.FileSystemObject

หากต้องการสร้างออบเจ็กต์ของคุณเองด้วยโครงสร้างที่กำหนดเอง การใช้ New-Object ดูเหมือนจะล้าสมัยและยุ่งยากเกินไป cmdlet นี้ใช้เพื่อทำงานกับส่วนประกอบซอฟต์แวร์ภายนอก PowerShell ในบทความต่อๆ ไป ประเด็นนี้จะได้รับการพิจารณาอย่างละเอียดยิ่งขึ้น นอกจากออบเจ็กต์ .NET และ COM แล้ว เราจะสำรวจออบเจ็กต์ CIM (WMI) และ ADSI ด้วย

การเรียกวิธีการแบบคงที่

คลาส .NET Core บางคลาสไม่สามารถสร้างอินสแตนซ์ได้ รวมถึง System.Environment และ System.Math พวกเขาคือ คงที่ และมีเพียงคุณสมบัติและวิธีการคงที่เท่านั้น เหล่านี้คือไลบรารีอ้างอิงหลักที่ใช้โดยไม่ต้องสร้างอ็อบเจ็กต์ คุณสามารถอ้างถึงคลาสแบบคงที่ผ่านตัวอักษรโดยใส่ชื่อประเภทในวงเล็บเหลี่ยม อย่างไรก็ตาม หากเราดูโครงสร้างของอ็อบเจ็กต์โดยใช้ Get-Member เราจะเห็นประเภท System.RuntimeType แทน System.Environment:

[System.Environment] | Get-Member

หากต้องการดูเฉพาะสมาชิกแบบคงที่ ให้เรียก Get-Member ด้วยพารามิเตอร์ -Static (สังเกตประเภทวัตถุ):

[System.Environment] | Get-Member -Static

ในการเข้าถึงคุณสมบัติและวิธีการแบบคงที่ ให้ใช้เครื่องหมายโคลอนสองตัวติดต่อกันแทนจุดหลังตัวอักษร:

[System.Environment]::OSVersion

หรือ

$test=[System.Math]::Sqrt(25) 
$test
$test.GetType()

พิมพ์ PSCustomObject

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

$object = New-Object  –TypeName PSCustomObject -Property @{Name = 'Ivan Danko'; 
                                          City = 'Moscow';
                                          Country = 'Russia'}

ลองดูที่โครงสร้างของวัตถุ:

$object | Get-Member

ตั้งแต่ PowerShell 3.0 เป็นต้นไป จะมีไวยากรณ์อื่นให้เลือกใช้:

$object = [PSCustomObject]@{Name = 'Ivan Danko'; 
                                          City = 'Moscow';
                                          Country = 'Russia'
}

คุณสามารถเข้าถึงข้อมูลด้วยวิธีใดวิธีหนึ่งที่เทียบเท่า:

$object.Name

$object.'Name'

$value = 'Name'
$object.$value

นี่คือตัวอย่างการแปลง hashtable ที่มีอยู่ให้เป็นอ็อบเจ็กต์:

$hash = @{'Name'='Ivan Danko'; 'City'='Moscow'; 'Country'='Russia'}
$hash.GetType()
$object = [pscustomobject]$hash
$object.GetType()

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

$object = [PSCustomObject][ordered]@{Name = 'Ivan Danko'; 
                                          City = 'Moscow';
                                          Country = 'Russia'
}

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

$object | Add-Member –MemberType NoteProperty –Name Age  –Value 33
$object | Get-Member

Add-Member cmdlet ช่วยให้คุณสามารถเพิ่มไม่เพียงแต่คุณสมบัติ แต่ยังรวมถึงวิธีการให้กับ $object ที่สร้างขึ้นก่อนหน้านี้โดยใช้โครงสร้าง "-MemberType ScriptMethod":

$ScriptBlock = {
    # код 
}
$object | Add-Member -Name "MyMethod" -MemberType ScriptMethod -Value $ScriptBlock
$object | Get-Member

โปรดทราบว่าเราใช้ตัวแปร $ScriptBlock ประเภท ScriptBlock เพื่อจัดเก็บโค้ดสำหรับวิธีการใหม่

หากต้องการลบคุณสมบัติ ให้ใช้วิธีการที่เกี่ยวข้อง:

$object.psobject.properties.remove('Name')

การสร้างชั้นเรียนของคุณเอง

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

class MyClass
{
    # тело класса
}

นี่เป็นประเภท .NET Core ที่แท้จริง โดยมีเนื้อความที่อธิบายคุณสมบัติ วิธีการ และองค์ประกอบอื่นๆ ลองดูตัวอย่างการกำหนดคลาสที่ง่ายที่สุด:

class MyClass 
{
     [string]$Name
     [string]$City
     [string]$Country
}

หากต้องการสร้างวัตถุ (อินสแตนซ์ของคลาส) ให้ใช้ cmdlet ใหม่-Objectหรือตัวอักษรประเภท [MyClass] และ วิธีการหลอก ใหม่ (ตัวสร้างเริ่มต้น):

$object = New-Object -TypeName MyClass

หรือ

$object = [MyClass]::new()

มาวิเคราะห์โครงสร้างของวัตถุกัน:

$object | Get-Member

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

หลังจากสร้างวัตถุแล้ว ให้กรอกคุณสมบัติ:

$object.Name = 'Ivan Danko'
$object.City = 'Moscow'
$object.Country = 'Russia'
$object

โปรดทราบว่าคำอธิบายคลาสไม่เพียงระบุประเภทคุณสมบัติเท่านั้น แต่ยังระบุค่าเริ่มต้นด้วย:

class Example
{
     [string]$Name = 'John Doe'
}

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

class MyClass 
{
     [string]$Name
     [string]$City
     [string]$Country
     
     #описание метода
     Smile([bool]$param1)
     {
         If($param1) {
            Write-Host ':)'
         }
     }
}

ตอนนี้ตัวแทนชั้นเรียนของเรายิ้มได้แล้ว:

$object = [MyClass]::new()
$object.Smile($true)

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

class MyClass2 : MyClass
{
      #тело нового класса, базовым для которого является MyClass
}
[MyClass2]::new().Smile($true)

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

ส่วนที่ 1: คุณสมบัติพื้นฐานของ Windows PowerShell
ส่วนที่ 2: ความรู้เบื้องต้นเกี่ยวกับภาษาการเขียนโปรแกรม Windows PowerShell
ส่วนที่ 3: การส่งพารามิเตอร์ไปยังสคริปต์และฟังก์ชัน การสร้าง cmdlets

ที่มา: will.com