რა არის Windows PowerShell და რისთვის გამოიყენება? ნაწილი 4: ობიექტებთან მუშაობა, საკუთარი კლასები

PowerShell-ის ინტერპრეტაციის ფანჯარაში ბრძანებების ტექსტის გამომავალი მხოლოდ საშუალებაა ინფორმაციის ჩვენება ადამიანის აღქმისთვის შესაფერისი ფორმით. ფაქტიურად ოთხშაბათს ორიენტირებული ობიექტებთან მუშაობისთვის: cmdlets და ფუნქციები იღებენ მათ შეყვანის სახით და გასასვლელში დაბრუნდადა ცვლადის ტიპები, რომლებიც ხელმისაწვდომია ინტერაქტიულად და სკრიპტებში, დაფუძნებულია .NET კლასებზე. სერიის მეოთხე სტატიაში უფრო დეტალურად შევისწავლით ობიექტებთან მუშაობას.

დამყარება:

ობიექტები PowerShell-ში
ობიექტების სტრუქტურის დათვალიერება
ობიექტების გაფილტვრა
ობიექტების დახარისხება
ობიექტების და მათი ნაწილების შერჩევა
ForEach-Object, Group-Object და Measure-Object
.NET და COM ობიექტების შექმნა (New-Object)
სტატიკური მეთოდების გამოძახება
აკრიფეთ PSCustomObject
საკუთარი კლასების შექმნა

ობიექტები PowerShell-ში

შეგახსენებთ, რომ ობიექტი არის მონაცემთა ველების (თვისებები, მოვლენები და ა.შ.) და მათი დამუშავების მეთოდების (მეთოდები) ერთობლიობა. მისი სტრუქტურა მითითებულია ტიპით, რომელიც ჩვეულებრივ ეფუძნება კლასებს, რომლებიც გამოიყენება ერთიან .NET Core პლატფორმაში. ასევე შესაძლებელია COM, CIM (WMI) და ADSI ობიექტებთან მუშაობა. მონაცემების შესახებ სხვადასხვა მოქმედებების შესასრულებლად საჭიროა თვისებები და მეთოდები; გარდა ამისა, PowerShell-ში ობიექტები შეიძლება გადაეცეს არგუმენტებად ფუნქციებს და cmdlet-ებს, მათი მნიშვნელობები მიენიჭოს ცვლადებს და ასევე არსებობს ბრძანების შემადგენლობის მექანიზმი (კონვეიერი ან მილსადენი). მილსადენის თითოეული ბრძანება თავის გამომავალს გადასცემს მეორეს თავის მხრივ, ობიექტის მიხედვით. დამუშავებისთვის შეგიძლიათ გამოიყენოთ კომპილირებული cmdlets ან შექმნათ თქვენი საკუთარი მოწინავე ფუნქციებიმილსადენის ობიექტებთან სხვადასხვა მანიპულაციების შესრულება: გაფილტვრა, დახარისხება, დაჯგუფება და მათი სტრუქტურის შეცვლაც კი. ამ ფორმით მონაცემების გადაცემას სერიოზული უპირატესობა აქვს: მიმღებ ჯგუფს არ სჭირდება ბაიტის ნაკადის (ტექსტის) გარჩევა, ყველა საჭირო ინფორმაცია ადვილად მოიპოვება შესაბამისი თვისებებისა და მეთოდების გამოძახებით.

ობიექტების სტრუქტურის დათვალიერება

მაგალითად, გავუშვათ Get-Process cmdlet, რომელიც საშუალებას გაძლევთ მიიღოთ ინფორმაცია სისტემაში მიმდინარე პროცესების შესახებ:

ის აჩვენებს რამდენიმე ფორმატირებულ ტექსტურ მონაცემს, რომელიც არ იძლევა რაიმე წარმოდგენას დაბრუნებული ობიექტების თვისებებზე და მათ მეთოდებზე. გამოსავლის სრულყოფილად დასარეგულირებლად, ჩვენ უნდა ვისწავლოთ ობიექტების სტრუქტურის შემოწმება და ამაში დაგვეხმარება Get-Member cmdlet:

Get-Process | Get-Member

აქ ჩვენ უკვე ვხედავთ ტიპს და სტრუქტურას და დამატებითი პარამეტრების დახმარებით შეგვიძლია, მაგალითად, აჩვენოთ მხოლოდ შეყვანის ობიექტის თვისებები:

Get-Process | Get-Member -MemberType Property

ეს ცოდნა დაგჭირდებათ ადმინისტრაციის პრობლემების ინტერაქტიულად გადასაჭრელად ან საკუთარი სკრიპტების დასაწერად: მაგალითად, Responding თვისების გამოყენებით დაკიდებული პროცესების შესახებ ინფორმაციის მისაღებად.

ობიექტების გაფილტვრა

PowerShell საშუალებას აძლევს ობიექტებს, რომლებიც აკმაყოფილებენ გარკვეულ პირობას, გაიარონ მილსადენი:

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

სკრიპტის ბლოკის შესრულების შედეგი ფრჩხილებში უნდა იყოს ლოგიკური მნიშვნელობა. თუ ეს არის true ($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

ForEach-Object, Group-Object და Measure-Object

არის სხვა cmdlet ობიექტებთან მუშაობისთვის. მაგალითად, მოდით ვისაუბროთ სამ ყველაზე სასარგებლოზე:

თითოეული ობიექტისთვის საშუალებას გაძლევთ გაუშვათ PowerShell კოდი მილსადენის თითოეული ობიექტისთვის:

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

ჯგუფი-ობიექტი აჯგუფებს ობიექტებს ქონების ღირებულების მიხედვით:

Group-Object PropertyName

თუ მას გაუშვით -NoElement პარამეტრით, შეგიძლიათ გაიგოთ ელემენტების რაოდენობა ჯგუფებში.

ღონისძიება-ობიექტი აგროვებს სხვადასხვა შემაჯამებელ პარამეტრებს მილსადენში ობიექტის ველის მნიშვნელობების მიხედვით (ითვლის ჯამს და ასევე პოულობს მინიმალურ, მაქსიმალურ ან საშუალო მნიშვნელობას):

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

როგორც წესი, განხილული cmdlets გამოიყენება ინტერაქტიულად და ხშირად იქმნება სკრიპტებში. ფუნქციები დასაწყისი, პროცესი და დასასრული ბლოკებით.

.NET და COM ობიექტების შექმნა (New-Object)

არსებობს მრავალი პროგრამული კომპონენტი .NET Core და COM ინტერფეისებით, რომლებიც სასარგებლოა სისტემის ადმინისტრატორებისთვის. System.Diagnostics.EventLog კლასის გამოყენებით, თქვენ შეგიძლიათ მართოთ სისტემის ჟურნალები პირდაპირ Windows PowerShell-იდან. მოდით შევხედოთ ამ კლასის მაგალითის შექმნის მაგალითს New-Object cmdlet-ის გამოყენებით -TypeName პარამეტრით:

New-Object -TypeName System.Diagnostics.EventLog

ვინაიდან ჩვენ არ დავაკონკრეტეთ კონკრეტული მოვლენის ჟურნალი, კლასის შედეგად მიღებული მაგალითი არ შეიცავს მონაცემებს. ამის შესაცვლელად, თქვენ უნდა გამოიძახოთ სპეციალური კონსტრუქტორის მეთოდი მისი შექმნისას -ArgumentList პარამეტრის გამოყენებით. თუ გვინდა აპლიკაციის ჟურნალში წვდომა, კონსტრუქტორს არგუმენტად უნდა გადავცეთ სტრიქონი "Application":

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

გთხოვთ გაითვალისწინოთ, რომ ჩვენ შევინახეთ ბრძანების გამომავალი $AppLog ცვლადში. მიუხედავად იმისა, რომ მილსადენები ჩვეულებრივ გამოიყენება ინტერაქტიულ რეჟიმში, სკრიპტების დაწერა ხშირად მოითხოვს ობიექტზე მითითების შენარჩუნებას. გარდა ამისა, ძირითადი .NET Core კლასები შეიცავს System namespace-ში: PowerShell ნაგულისხმევად ეძებს მასში მითითებულ ტიპებს, ამიტომ System.Diagnostics.EventLog-ის ნაცვლად 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.Environment-ის ნაცვლად დავინახავთ ტიპს System.RuntimeType:

[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

აქ მოცემულია არსებული ჰეშტებლის ობიექტად გადაქცევის მაგალითი:

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

ამ ტიპის ობიექტების ერთ-ერთი მინუსი არის ის, რომ მათი თვისებების თანმიმდევრობა შეიძლება შეიცვალოს. ამის თავიდან ასაცილებლად, თქვენ უნდა გამოიყენოთ [შეკვეთილი] ატრიბუტი:

$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 ახალი ობიექტი, ან სიტყვასიტყვით ტიპი [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: პარამეტრების გადაცემა სკრიპტებზე და ფუნქციებზე, cmdlet-ების შექმნა

წყარო: www.habr.com