Ինչ է Windows PowerShell-ը և ինչի համար է այն օգտագործվում: Մաս 4. Աշխատանք առարկաների հետ, սեփական դասեր

PowerShell-ի թարգմանիչի պատուհանում հրամանների տեքստային ելքը պարզապես տեղեկատվության ցուցադրման միջոց է մարդու ընկալման համար հարմար ձևով: Իրականում չորեքշաբթի կողմնորոշված Օբյեկտների հետ աշխատելու համար. cmdlet-ները և ֆունկցիաները դրանք ստանում են որպես մուտքային և վերադարձել է ելքի մոտ, իսկ փոփոխականների տեսակները, որոնք հասանելի են ինտերակտիվ և սկրիպտներով, հիմնված են .NET դասերի վրա: Շարքի չորրորդ հոդվածում մենք ավելի մանրամասն կուսումնասիրենք առարկաների հետ աշխատանքը։

Բովանդակություն:

Օբյեկտներ PowerShell-ում
Օբյեկտների կառուցվածքի դիտում
Օբյեկտների զտում
Տեսակավորել առարկաները
Օբյեկտների և դրանց մասերի ընտրություն
ForEach-Object, Group-Object և Measure-Object
.NET և COM օբյեկտների ստեղծում (New-Object)
Զանգահարելով ստատիկ մեթոդներ
Մուտքագրեք PSCustomObject
Ստեղծելով ձեր սեփական դասերը

Օբյեկտներ PowerShell-ում

Հիշեցնենք, որ օբյեկտը տվյալների դաշտերի (հատկություններ, իրադարձություններ և այլն) և դրանց մշակման մեթոդների (մեթոդների) հավաքածու է։ Դրա կառուցվածքը նշվում է մի տեսակով, որը սովորաբար հիմնված է միասնական .NET Core հարթակում օգտագործվող դասերի վրա։ Հնարավոր է նաև աշխատել COM, CIM (WMI) և ADSI օբյեկտների հետ։ Տվյալների վրա տարբեր գործողություններ կատարելու համար անհրաժեշտ են հատկություններ և մեթոդներ, բացի այդ, PowerShell-ում օբյեկտները կարող են փոխանցվել որպես արգումենտներ ֆունկցիաներին և cmdlet-ներին, դրանց արժեքները վերագրել փոփոխականներին, և կա նաև հրամանի կազմի մեխանիզմ (փոխակրիչ կամ խողովակաշար): Խողովակաշարի յուրաքանչյուր հրաման հերթով փոխանցում է իր ելքը հաջորդին` օբյեկտ առ օբյեկտ: Մշակման համար կարող եք օգտագործել կոմպիլացված cmdlet-ներ կամ ստեղծել ձեր սեփականը առաջադեմ առանձնահատկություններխողովակաշարում գտնվող առարկաների հետ տարբեր մանիպուլյացիաներ իրականացնել՝ զտել, տեսակավորել, խմբավորել և նույնիսկ փոխել դրանց կառուցվածքը: Այս ձևով տվյալներ փոխանցելը լուրջ առավելություն ունի. ստացող թիմը կարիք չունի վերլուծելու բայթային հոսքը (տեքստը), բոլոր անհրաժեշտ տեղեկությունները հեշտությամբ առբերվում են՝ զանգահարելով համապատասխան հատկություններ և մեթոդներ:

Օբյեկտների կառուցվածքի դիտում

Օրինակ՝ գործարկենք 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 հատկություն).

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

Սովորաբար, քննարկվող cmdlet-ները օգտագործվում են ինտերակտիվ կերպով և հաճախ ստեղծվում են սցենարներով: գործառույթները Սկիզբ, Գործընթաց և Վերջ բլոկներով:

.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 script server-ով մատակարարվող գրադարաններից մինչև 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-ը թույլ է տալիս ավելացնել ոչ միայն հատկություններ, այլ նաև մեթոդներ նախկինում ստեղծված $օբյեկտին՝ օգտագործելով «-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

Source: www.habr.com