விண்டோஸ் பவர்ஷெல் என்றால் என்ன, அது எதற்காகப் பயன்படுத்தப்படுகிறது? பகுதி 4: பொருள்கள், சொந்த வகுப்புகளுடன் வேலை செய்தல்

பவர்ஷெல் மொழிபெயர்ப்பாளரின் சாளரத்தில் உள்ள கட்டளைகளின் உரை வெளியீடு மனித கருத்துக்கு ஏற்ற வடிவத்தில் தகவலைக் காண்பிப்பதற்கான ஒரு வழியாகும். உண்மையில் புதன் சார்ந்த பொருள்களுடன் வேலை செய்ய: cmdlets மற்றும் செயல்பாடுகள் அவற்றை உள்ளீடாகப் பெறுகின்றன மற்றும் வெளியேறும் இடத்தில் திரும்பினார், மற்றும் ஊடாடும் மற்றும் ஸ்கிரிப்ட்களில் கிடைக்கும் மாறி வகைகள் .NET வகுப்புகளை அடிப்படையாகக் கொண்டவை. தொடரின் நான்காவது கட்டுரையில், பொருள்களுடன் வேலை செய்வதை இன்னும் விரிவாகப் படிப்போம்.

உள்ளடக்க அட்டவணை:

பவர்ஷெல்லில் உள்ள பொருள்கள்
பொருட்களின் கட்டமைப்பைப் பார்க்கவும்
பொருட்களை வடிகட்டுதல்
பொருட்களை வரிசைப்படுத்துதல்
பொருள்கள் மற்றும் அவற்றின் பாகங்களைத் தேர்ந்தெடுப்பது
ஒவ்வொரு பொருளுக்கும், குழு-பொருளுக்கும் மற்றும் அளவிடும் பொருளுக்கும்
.NET மற்றும் COM பொருள்களை உருவாக்குதல் (புதிய பொருள்)
நிலையான முறைகள் அழைப்பு
PSCustomObject என டைப் செய்யவும்
உங்கள் சொந்த வகுப்புகளை உருவாக்குதல்

பவர்ஷெல்லில் உள்ள பொருள்கள்

ஒரு பொருள் என்பது தரவுப் புலங்கள் (பண்புகள், நிகழ்வுகள், முதலியன) மற்றும் அவற்றைச் செயலாக்குவதற்கான முறைகள் (முறைகள்) ஆகியவற்றின் தொகுப்பாகும் என்பதை நினைவில் கொள்வோம். அதன் அமைப்பு ஒரு வகையால் குறிப்பிடப்படுகிறது, இது பொதுவாக ஒருங்கிணைந்த .NET கோர் பிளாட்ஃபார்மில் பயன்படுத்தப்படும் வகுப்புகளை அடிப்படையாகக் கொண்டது. COM, CIM (WMI) மற்றும் ADSI பொருட்களுடன் வேலை செய்வதும் சாத்தியமாகும். தரவுகளில் பல்வேறு செயல்களைச் செய்ய பண்புகள் மற்றும் முறைகள் தேவை; கூடுதலாக, பவர்ஷெல்லில், பொருள்களை செயல்பாடுகள் மற்றும் cmdlet களுக்கு வாதங்களாக அனுப்பலாம், அவற்றின் மதிப்புகளை மாறிகளுக்கு ஒதுக்கலாம், மேலும் உள்ளது. கட்டளை கலவை பொறிமுறை (கன்வேயர் அல்லது பைப்லைன்). பைப்லைனில் உள்ள ஒவ்வொரு கட்டளையும் அதன் வெளியீட்டை அடுத்தவருக்கு, பொருளின் அடிப்படையில் அனுப்புகிறது. செயலாக்கத்திற்கு, நீங்கள் தொகுக்கப்பட்ட cmdlets ஐப் பயன்படுத்தலாம் அல்லது உங்களுடையதை உருவாக்கலாம் மேம்படுத்தப்பட்ட அம்சங்கள்பைப்லைனில் உள்ள பொருள்களுடன் பல்வேறு கையாளுதல்களைச் செய்ய: வடிகட்டுதல், வரிசைப்படுத்துதல், தொகுத்தல் மற்றும் அவற்றின் கட்டமைப்பை மாற்றுதல். இந்த வடிவத்தில் தரவை அனுப்புவது ஒரு தீவிர நன்மையைக் கொண்டுள்ளது: பெறும் குழுவானது பைட் ஸ்ட்ரீமை (உரை) பாகுபடுத்த வேண்டிய அவசியமில்லை, பொருத்தமான பண்புகள் மற்றும் முறைகளை அழைப்பதன் மூலம் தேவையான அனைத்து தகவல்களும் எளிதாக மீட்டெடுக்கப்படுகின்றன.

பொருட்களின் கட்டமைப்பைப் பார்க்கவும்

எடுத்துக்காட்டாக, Get-Process cmdlet ஐ இயக்குவோம், இது கணினியில் இயங்கும் செயல்முறைகள் பற்றிய தகவலைப் பெற உங்களை அனுமதிக்கிறது:

திரும்பிய பொருட்களின் பண்புகள் மற்றும் அவற்றின் முறைகள் பற்றி எந்த யோசனையும் கொடுக்காத சில வடிவமைக்கப்பட்ட உரைத் தரவை இது காண்பிக்கும். வெளியீட்டை நன்றாக மாற்ற, பொருட்களின் கட்டமைப்பை எவ்வாறு ஆய்வு செய்வது என்பதை நாம் கற்றுக் கொள்ள வேண்டும், மேலும் Get-Member cmdlet இதற்கு உதவும்:

Get-Process | Get-Member

இங்கே நாம் ஏற்கனவே வகை மற்றும் கட்டமைப்பைக் காண்கிறோம், மேலும் கூடுதல் அளவுருக்களின் உதவியுடன், எடுத்துக்காட்டாக, உள்ளீட்டில் சேர்க்கப்பட்டுள்ள பொருளின் பண்புகளை மட்டுமே காண்பிக்க முடியும்:

Get-Process | Get-Member -MemberType Property

நிர்வாகச் சிக்கல்களை ஊடாடும் வகையில் தீர்க்க அல்லது உங்கள் சொந்த ஸ்கிரிப்ட்களை எழுத இந்த அறிவு தேவைப்படும்: எடுத்துக்காட்டாக, பதிலளிக்கும் சொத்தைப் பயன்படுத்தி தொங்கும் செயல்முறைகள் பற்றிய தகவலைப் பெற.

பொருட்களை வடிகட்டுதல்

பவர்ஷெல் ஒரு குறிப்பிட்ட நிபந்தனையை பூர்த்தி செய்யும் பொருட்களை குழாய் வழியாக அனுப்ப அனுமதிக்கிறது:

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

அடைப்புக்குறிக்குள் ஸ்கிரிப்ட் பிளாக்கை இயக்குவதன் முடிவு பூலியன் மதிப்பாக இருக்க வேண்டும். அது உண்மையாக இருந்தால் ($true), Where-Object cmdlet க்கு உள்ளீடு செய்யப்பட்ட பொருள் குழாய் வழியாக அனுப்பப்படும், இல்லையெனில் ($false) அது நீக்கப்படும். எடுத்துக்காட்டாக, நிறுத்தப்பட்ட விண்டோஸ் சர்வர் சேவைகளின் பட்டியலைக் காண்பிப்போம், அதாவது. அந்தஸ்து சொத்து "நிறுத்தப்பட்டது" என அமைக்கப்பட்டவர்கள்:

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

Sort-Object cmdlet ஐ அழைக்கும் போது -Property அளவுரு தவிர்க்கப்படலாம்; இது முன்னிருப்பாகப் பயன்படுத்தப்படும். தலைகீழ் வரிசைப்படுத்த, -Descending அளவுருவைப் பயன்படுத்தவும்:

Get-Process | Sort-Object cpu -Descending

பொருள்கள் மற்றும் அவற்றின் பாகங்களைத் தேர்ந்தெடுப்பது

Select-Object cmdlet ஆனது -First அல்லது -Last அளவுருக்களைப் பயன்படுத்தி பைப்லைனின் தொடக்கத்தில் அல்லது முடிவில் குறிப்பிட்ட எண்ணிக்கையிலான பொருட்களைத் தேர்ந்தெடுக்க உங்களை அனுமதிக்கிறது. அதன் உதவியுடன், நீங்கள் ஒற்றை பொருள்கள் அல்லது சில பண்புகளைத் தேர்ந்தெடுக்கலாம், மேலும் அவற்றின் அடிப்படையில் புதிய பொருட்களை உருவாக்கலாம். எளிய எடுத்துக்காட்டுகளைப் பயன்படுத்தி cmdlet எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்.

பின்வரும் கட்டளையானது அதிகபட்ச அளவு RAM (WS சொத்து) உட்கொள்ளும் 10 செயல்முறைகள் பற்றிய தகவலைக் காட்டுகிறது:

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

பைப்லைன் வழியாக செல்லும் பொருள்களின் சில பண்புகளை மட்டுமே நீங்கள் தேர்ந்தெடுத்து அவற்றின் அடிப்படையில் புதியவற்றை உருவாக்கலாம்:

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

பைப்லைனின் செயல்பாட்டின் விளைவாக, நாம் ஒரு புதிய பொருளைப் பெறுவோம், அதன் அமைப்பு Get-Process cmdlet மூலம் திரும்பிய கட்டமைப்பிலிருந்து வேறுபடும். கெட்-மெம்பரைப் பயன்படுத்தி இதைச் சரிபார்க்கலாம்:

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

Select-Object ஆனது நாம் குறிப்பிட்ட இரண்டு புலங்களை மட்டுமே கொண்ட ஒரு பொருளை (-முதல் 1) வழங்கும் என்பதை நினைவில் கொள்ளவும்: அவற்றின் மதிப்புகள் Get-Process cmdlet மூலம் குழாய் வழியாக அனுப்பப்பட்ட முதல் பொருளிலிருந்து நகலெடுக்கப்பட்டது. பவர்ஷெல் ஸ்கிரிப்ட்களில் பொருள்களை உருவாக்குவதற்கான வழிகளில் ஒன்று, தேர்ந்தெடுக்கப்பட்ட பொருளைப் பயன்படுத்துவதை அடிப்படையாகக் கொண்டது:

$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 உள்ளன. உதாரணமாக, மிகவும் பயனுள்ள மூன்றைப் பற்றி பேசலாம்:

ஒவ்வொரு பொருளுக்கும் பைப்லைனில் உள்ள ஒவ்வொரு பொருளுக்கும் பவர்ஷெல் குறியீட்டை இயக்க உங்களை அனுமதிக்கிறது:

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

குழு-பொருள் சொத்து மதிப்பின் அடிப்படையில் பொருட்களைக் குழுவாக்குகிறது:

Group-Object PropertyName

நீங்கள் அதை -NoElement அளவுருவுடன் இயக்கினால், குழுக்களில் உள்ள உறுப்புகளின் எண்ணிக்கையை நீங்கள் கண்டுபிடிக்கலாம்.

அளத்தல்-பொருள் பைப்லைனில் உள்ள பொருள் புல மதிப்புகள் மூலம் பல்வேறு சுருக்க அளவுருக்களை ஒருங்கிணைக்கிறது (தொகையைக் கணக்கிடுகிறது, மேலும் குறைந்தபட்ச, அதிகபட்ச அல்லது சராசரி மதிப்பையும் கண்டறியும்):

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

பொதுவாக, விவாதிக்கப்படும் cmdletகள் ஊடாடும் வகையில் பயன்படுத்தப்படுகின்றன, மேலும் அவை பெரும்பாலும் ஸ்கிரிப்ட்களில் உருவாக்கப்படுகின்றன. செயல்பாடுகளை ஆரம்பம், செயலாக்கம் மற்றும் முடிவு தொகுதிகளுடன்.

.NET மற்றும் COM பொருள்களை உருவாக்குதல் (புதிய பொருள்)

கணினி நிர்வாகிகளுக்குப் பயனுள்ள .NET கோர் மற்றும் COM இடைமுகங்களுடன் கூடிய பல மென்பொருள் கூறுகள் உள்ளன. System.Diagnostics.EventLog வகுப்பைப் பயன்படுத்தி, நீங்கள் Windows PowerShell இலிருந்து நேரடியாக கணினி பதிவுகளை நிர்வகிக்கலாம். -TypeName அளவுருவுடன் New-Object cmdlet ஐப் பயன்படுத்தி இந்த வகுப்பின் உதாரணத்தை உருவாக்குவதற்கான உதாரணத்தைப் பார்ப்போம்:

New-Object -TypeName System.Diagnostics.EventLog

குறிப்பிட்ட நிகழ்வுப் பதிவை நாங்கள் குறிப்பிடாததால், வகுப்பின் விளைவான நிகழ்வில் தரவு இல்லை. இதை மாற்ற, நீங்கள் -ArgumentList அளவுருவைப் பயன்படுத்தி அதன் உருவாக்கத்தின் போது ஒரு சிறப்பு கட்டமைப்பாளர் முறையை அழைக்க வேண்டும். நாம் பயன்பாட்டு பதிவை அணுக விரும்பினால், "பயன்பாடு" என்ற சரத்தை ஒரு வாதமாக கட்டமைப்பாளருக்கு அனுப்ப வேண்டும்:

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

கட்டளையின் வெளியீட்டை $AppLog மாறியில் சேமித்துள்ளோம் என்பதை நினைவில் கொள்ளவும். பைப்லைன்கள் பொதுவாக ஊடாடும் பயன்முறையில் பயன்படுத்தப்பட்டாலும், ஸ்கிரிப்ட்களை எழுதுவதற்கு பெரும்பாலும் ஒரு பொருளின் குறிப்பை பராமரிக்க வேண்டும். கூடுதலாக, கோர் .NET கோர் வகுப்புகள் சிஸ்டம் நேம்ஸ்பேஸில் உள்ளன: பவர்ஷெல் முன்னிருப்பாக அதில் குறிப்பிட்ட வகைகளைத் தேடுகிறது, எனவே System.Diagnostics.EventLog என்பதற்குப் பதிலாக Diagnostics.EventLog எழுதுவது மிகவும் சரியானது.

பதிவோடு வேலை செய்ய, நீங்கள் பொருத்தமான முறைகளைப் பயன்படுத்தலாம்:

$AppLog | Get-Member -MemberType Method

அணுகல் உரிமைகள் இருந்தால், அது Clear() முறையில் அழிக்கப்பட்டது என்று வைத்துக்கொள்வோம்:

$AppLog.Clear()

New-Object cmdlet ஆனது COM கூறுகளுடன் வேலை செய்யப் பயன்படுகிறது. அவற்றில் நிறைய உள்ளன - விண்டோஸ் ஸ்கிரிப்ட் சேவையகத்துடன் வழங்கப்பட்ட நூலகங்கள் முதல் இன்டர்நெட் எக்ஸ்ப்ளோரர் போன்ற ActiveX பயன்பாடுகள் வரை. COM பொருளை உருவாக்க, நீங்கள் விரும்பிய வகுப்பின் நிரல் ProgId உடன் -ComObject அளவுருவை அமைக்க வேண்டும்:

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

ஒரு தன்னிச்சையான கட்டமைப்புடன் உங்கள் சொந்த பொருட்களை உருவாக்க, புதிய பொருளைப் பயன்படுத்துவது மிகவும் பழமையானதாகவும் சிக்கலானதாகவும் தோன்றுகிறது; இந்த cmdlet PowerShell க்கு வெளியே உள்ள மென்பொருள் கூறுகளுடன் வேலை செய்யப் பயன்படுகிறது. எதிர்கால கட்டுரைகளில் இந்த பிரச்சினை இன்னும் விரிவாக விவாதிக்கப்படும். .NET மற்றும் COM ஆப்ஜெக்ட்டுகளுக்கு கூடுதலாக, CIM (WMI) மற்றும் ADSI பொருட்களையும் ஆராய்வோம்.

நிலையான முறைகள் அழைப்பு

System.Environment மற்றும் System.Math உட்பட சில .NET கோர் வகுப்புகளை உடனடியாக உருவாக்க முடியாது. அவர்கள் நிலையான மற்றும் நிலையான பண்புகள் மற்றும் முறைகளை மட்டுமே கொண்டுள்ளது. இவை அடிப்படையில் பொருள்களை உருவாக்காமல் பயன்படுத்தப்படும் குறிப்பு நூலகங்கள். வகைப் பெயரை சதுர அடைப்புக்குறிக்குள் இணைப்பதன் மூலம் நீங்கள் ஒரு நிலையான வகுப்பைக் குறிப்பிடலாம். இருப்பினும், Get-Member ஐப் பயன்படுத்தி பொருளின் கட்டமைப்பைப் பார்த்தால், System.Environment என்பதற்குப் பதிலாக System.RuntimeType என்ற வகையைக் காண்போம்:

[System.Environment] | 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" கட்டமைப்பைப் பயன்படுத்தி, முன்பு உருவாக்கப்பட்ட $objectக்கு பண்புகளை மட்டும் சேர்க்காமல், முறைகளையும் சேர்க்க அனுமதிக்கிறது:

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

புதிய முறைக்கான குறியீட்டைச் சேமிக்க, ScriptBlock வகையின் $ScriptBlock மாறியைப் பயன்படுத்தினோம் என்பதை நினைவில் கொள்ளவும்.

பண்புகளை அகற்ற, தொடர்புடைய முறையைப் பயன்படுத்தவும்:

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

உங்கள் சொந்த வகுப்புகளை உருவாக்குதல்

பவர்ஷெல் 5.0 வரையறுக்கும் திறனை அறிமுகப்படுத்தியது வகுப்புகள் பொருள் சார்ந்த நிரலாக்க மொழிகளின் தொடரியல் பண்புகளைப் பயன்படுத்துதல். கிளாஸ் என்ற சேவை வார்த்தை இதற்காக வடிவமைக்கப்பட்டுள்ளது, அதன் பிறகு நீங்கள் வகுப்பின் பெயரைக் குறிப்பிட்டு அதன் உடலை ஆபரேட்டர் அடைப்புக்குறிக்குள் விவரிக்க வேண்டும்:

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

இது ஒரு உண்மையான .NET கோர் வகை, அதன் பண்புகள், முறைகள் மற்றும் பிற கூறுகளை விவரிக்கும் உடல். எளிமையான வகுப்பை வரையறுப்பதற்கான உதாரணத்தைப் பார்ப்போம்:

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)

முறைகள் ஓவர்லோட் செய்யப்படலாம்; கூடுதலாக, ஒரு வகுப்பில் உள்ளது நிலையான பண்புகள் மற்றும் முறைகள், அத்துடன் வகுப்பின் பெயருடன் ஒத்துப்போகும் பெயர்களைக் கொண்ட கட்டமைப்பாளர்கள். ஒரு ஸ்கிரிப்ட் அல்லது பவர்ஷெல் தொகுதியில் வரையறுக்கப்பட்ட ஒரு வர்க்கம் மற்றொன்றுக்கு ஒரு தளமாக செயல்படும் - பரம்பரை இவ்வாறு செயல்படுத்தப்படுகிறது. இந்த வழக்கில், ஏற்கனவே உள்ள .NET வகுப்புகளை அடிப்படை வகுப்புகளாகப் பயன்படுத்த அனுமதிக்கப்படுகிறது:

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

PowerShell இல் உள்ள பொருள்களுடன் பணிபுரிவது பற்றிய எங்கள் விளக்கம் முழுமையானதாக இல்லை. பின்வரும் வெளியீடுகளில், நடைமுறை எடுத்துக்காட்டுகளுடன் அதை ஆழப்படுத்த முயற்சிப்போம்: தொடரின் ஐந்தாவது கட்டுரை மூன்றாம் தரப்பு மென்பொருள் கூறுகளுடன் PowerShell ஐ ஒருங்கிணைப்பதில் உள்ள சிக்கல்களுக்கு அர்ப்பணிக்கப்படும். கடந்த பகுதிகளை கீழே உள்ள இணைப்புகளில் காணலாம்.

பகுதி 1: அடிப்படை விண்டோஸ் பவர்ஷெல் அம்சங்கள்
பகுதி 2: விண்டோஸ் பவர்ஷெல் புரோகிராமிங் மொழிக்கான அறிமுகம்
பகுதி 3: ஸ்கிரிப்டுகள் மற்றும் செயல்பாடுகளுக்கு அளவுருக்களை அனுப்புதல், cmdlets உருவாக்குதல்

ஆதாரம்: www.habr.com