విండోస్ పవర్‌షెల్ అంటే ఏమిటి మరియు ఇది దేనికి ఉపయోగించబడుతుంది? పార్ట్ 4: వస్తువులు, స్వంత తరగతులతో పని చేయడం

పవర్‌షెల్ ఇంటర్‌ప్రెటర్ విండోలోని కమాండ్‌ల టెక్స్ట్ అవుట్‌పుట్ అనేది మానవ అవగాహనకు తగిన రూపంలో సమాచారాన్ని ప్రదర్శించడానికి ఒక మార్గం. నిజానికి బుధవారం ఓరియెంటెడ్ వస్తువులతో పని చేయడానికి: cmdlets మరియు ఫంక్షన్‌లు వాటిని ఇన్‌పుట్‌గా స్వీకరిస్తాయి మరియు నిష్క్రమణ వద్ద తిరిగి వచ్చారు, మరియు ఇంటరాక్టివ్‌గా మరియు స్క్రిప్ట్‌లలో అందుబాటులో ఉండే వేరియబుల్ రకాలు .NET తరగతులపై ఆధారపడి ఉంటాయి. సిరీస్ యొక్క నాల్గవ కథనంలో, వస్తువులతో పని చేయడం గురించి మరింత వివరంగా అధ్యయనం చేస్తాము.

ఆటలు:

పవర్‌షెల్‌లోని వస్తువులు
వస్తువుల నిర్మాణాన్ని వీక్షించడం
వడపోత వస్తువులు
వస్తువులను క్రమబద్ధీకరించడం
వస్తువులు మరియు వాటి భాగాలను ఎంచుకోవడం
ప్రతి వస్తువు, సమూహం-వస్తువు మరియు కొలత-వస్తువు కోసం
.NET మరియు COM ఆబ్జెక్ట్‌లను సృష్టించడం (కొత్త-ఆబ్జెక్ట్)
కాలింగ్ స్టాటిక్ మెథడ్స్
PSCustomObject అని టైప్ చేయండి
మీ స్వంత తరగతులను సృష్టించడం

పవర్‌షెల్‌లోని వస్తువులు

ఆబ్జెక్ట్ అనేది డేటా ఫీల్డ్‌ల (గుణాలు, ఈవెంట్‌లు మొదలైనవి) మరియు వాటిని ప్రాసెస్ చేసే పద్ధతులు (పద్ధతులు) యొక్క సేకరణ అని గుర్తుచేసుకుందాం. దీని నిర్మాణం ఒక రకం ద్వారా పేర్కొనబడింది, ఇది సాధారణంగా ఏకీకృత .NET కోర్ ప్లాట్‌ఫారమ్‌లో ఉపయోగించే తరగతులపై ఆధారపడి ఉంటుంది. COM, CIM (WMI) మరియు ADSI వస్తువులతో పని చేయడం కూడా సాధ్యమే. డేటాపై వివిధ చర్యలను నిర్వహించడానికి లక్షణాలు మరియు పద్ధతులు అవసరం; అదనంగా, పవర్‌షెల్‌లో, ఆబ్జెక్ట్‌లను ఫంక్షన్‌లు మరియు cmdlet లకు ఆర్గ్యుమెంట్‌లుగా పంపవచ్చు, వాటి విలువలను వేరియబుల్స్‌కు కేటాయించవచ్చు మరియు కూడా ఉంది కమాండ్ కంపోజిషన్ మెకానిజం (కన్వేయర్ లేదా పైప్లైన్). పైప్‌లైన్‌లోని ప్రతి ఆదేశం దాని అవుట్‌పుట్‌ను ఆబ్జెక్ట్ వారీగా తదుపరి దానికి పంపుతుంది. ప్రాసెసింగ్ కోసం, మీరు కంపైల్ చేయబడిన cmdletలను ఉపయోగించవచ్చు లేదా మీ స్వంతంగా సృష్టించవచ్చు ఆధునిక లక్షణాలనుపైప్‌లైన్‌లోని వస్తువులతో వివిధ అవకతవకలను నిర్వహించడానికి: వడపోత, క్రమబద్ధీకరించడం, సమూహపరచడం మరియు వాటి నిర్మాణాన్ని కూడా మార్చడం. ఈ రూపంలో డేటాను బదిలీ చేయడం వల్ల తీవ్రమైన ప్రయోజనం ఉంది: స్వీకరించే బృందం బైట్‌ల స్ట్రీమ్‌ను (టెక్స్ట్) అన్వయించాల్సిన అవసరం లేదు, తగిన లక్షణాలు మరియు పద్ధతులను కాల్ చేయడం ద్వారా అవసరమైన అన్ని సమాచారం సులభంగా తిరిగి పొందబడుతుంది.

వస్తువుల నిర్మాణాన్ని వీక్షించడం

ఉదాహరణకు, సిస్టమ్‌లో నడుస్తున్న ప్రక్రియల గురించి సమాచారాన్ని పొందేందుకు మిమ్మల్ని అనుమతించే Get-Process cmdletని అమలు చేద్దాం:

ఇది తిరిగి వచ్చిన ఆబ్జెక్ట్‌ల లక్షణాలు మరియు వాటి పద్ధతుల గురించి ఎలాంటి ఆలోచన ఇవ్వని కొన్ని ఫార్మాట్ చేసిన టెక్స్ట్ డేటాను ప్రదర్శిస్తుంది. అవుట్‌పుట్‌ను చక్కగా ట్యూన్ చేయడానికి, వస్తువుల నిర్మాణాన్ని ఎలా పరిశీలించాలో మనం నేర్చుకోవాలి మరియు గెట్-మెంబర్ cmdlet దీనితో మాకు సహాయం చేస్తుంది:

Get-Process | Get-Member

ఇక్కడ మేము ఇప్పటికే రకం మరియు నిర్మాణాన్ని చూస్తాము మరియు అదనపు పారామితుల సహాయంతో, ఉదాహరణకు, ఇన్‌పుట్‌లో చేర్చబడిన వస్తువు యొక్క లక్షణాలను మాత్రమే ప్రదర్శిస్తాము:

Get-Process | Get-Member -MemberType Property

అడ్మినిస్ట్రేషన్ సమస్యలను ఇంటరాక్టివ్‌గా పరిష్కరించడానికి లేదా మీ స్వంత స్క్రిప్ట్‌లను వ్రాయడానికి ఈ జ్ఞానం అవసరం: ఉదాహరణకు, రెస్పాండింగ్ ప్రాపర్టీని ఉపయోగించి హంగ్ ప్రాసెస్‌ల గురించి సమాచారాన్ని పొందడం.

వడపోత వస్తువులు

పవర్‌షెల్ ఒక నిర్దిష్ట షరతుకు అనుగుణంగా ఉన్న వస్తువులను పైప్‌లైన్ ద్వారా పంపడానికి అనుమతిస్తుంది:

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

కుండలీకరణాల్లో స్క్రిప్ట్ బ్లాక్‌ని అమలు చేయడం వల్ల వచ్చే ఫలితం తప్పనిసరిగా బూలియన్ విలువ అయి ఉండాలి. ఇది నిజమైతే ($true), వేర్-ఆబ్జెక్ట్ cmdletకి ఇన్‌పుట్ చేయబడిన ఆబ్జెక్ట్ పైప్‌లైన్ వెంట పంపబడుతుంది, లేకుంటే ($false) అది తొలగించబడుతుంది. ఉదాహరణకు, ఆగిపోయిన Windows సర్వర్ సేవల జాబితాను ప్రదర్శిస్తాము, అనగా. స్టేటస్ ప్రాపర్టీ "ఆపివేయబడింది"కి సెట్ చేయబడిన వారు:

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

సెలెక్ట్-ఆబ్జెక్ట్ మేము పేర్కొన్న రెండు ఫీల్డ్‌లను మాత్రమే కలిగి ఉన్న ఒకే వస్తువు (-మొదటి 1)ని తిరిగి ఇస్తుందని గమనించండి: వాటి విలువలు గెట్-ప్రాసెస్ 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

యాక్సెస్ హక్కులు ఉంటే క్లియర్() పద్ధతి ద్వారా ఇది క్లియర్ చేయబడిందని చెప్పండి:

$AppLog.Clear()

కొత్త-ఆబ్జెక్ట్ cmdlet కూడా COM భాగాలతో పని చేయడానికి ఉపయోగించబడుతుంది. వాటిలో చాలా చాలా ఉన్నాయి - Windows స్క్రిప్ట్ సర్వర్‌తో సరఫరా చేయబడిన లైబ్రరీల నుండి Internet Explorer వంటి ActiveX అప్లికేషన్‌ల వరకు. COM ఆబ్జెక్ట్‌ని సృష్టించడానికి, మీరు కోరుకున్న తరగతి యొక్క ప్రోగ్రామాటిక్ ProgIdతో -ComObject పరామితిని సెట్ చేయాలి:

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

ఒక ఏకపక్ష నిర్మాణంతో మీ స్వంత వస్తువులను సృష్టించడానికి, New-Objectని ఉపయోగించడం చాలా ప్రాచీనమైనది మరియు గజిబిజిగా అనిపిస్తుంది; PowerShellకి వెలుపలి సాఫ్ట్‌వేర్ భాగాలతో పని చేయడానికి ఈ cmdlet ఉపయోగించబడుతుంది. భవిష్యత్ కథనాలలో ఈ సమస్య మరింత వివరంగా చర్చించబడుతుంది. .NET మరియు COM ఆబ్జెక్ట్‌లతో పాటు, మేము CIM (WMI) మరియు ADSI ఆబ్జెక్ట్‌లను కూడా అన్వేషిస్తాము.

కాలింగ్ స్టాటిక్ మెథడ్స్

System.Environment మరియు System.Mathతో సహా కొన్ని .NET కోర్ తరగతులను ఇన్‌స్టంషియేట్ చేయడం సాధ్యం కాదు. వారు స్థిరమైన మరియు స్థిర లక్షణాలు మరియు పద్ధతులను మాత్రమే కలిగి ఉంటాయి. ఇవి తప్పనిసరిగా వస్తువులను సృష్టించకుండా ఉపయోగించే సూచన లైబ్రరీలు. స్క్వేర్ బ్రాకెట్‌లలో టైప్ పేరును జతచేయడం ద్వారా మీరు లిటరల్ ద్వారా స్టాటిక్ క్లాస్‌ని సూచించవచ్చు. అయితే, మనం Get-Memberని ఉపయోగించి ఆబ్జెక్ట్ యొక్క నిర్మాణాన్ని చూస్తే, System.Environmentకి బదులుగా System.RuntimeType టైప్ చూస్తాము:

[System.Environment] | Get-Member

స్టాటిక్ మెంబర్‌లను మాత్రమే వీక్షించడానికి, -స్టాటిక్ పారామీటర్‌తో గెట్-మెంబర్‌కి కాల్ చేయండి (ఆబ్జెక్ట్ రకాన్ని గమనించండి):

[System.Environment] | Get-Member -Static

స్టాటిక్ లక్షణాలు మరియు పద్ధతులను యాక్సెస్ చేయడానికి, లిటరల్ తర్వాత వ్యవధికి బదులుగా రెండు వరుస కోలన్‌లను ఉపయోగించండి:

[System.Environment]::OSVersion

లేదా

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

PSCustomObject అని టైప్ చేయండి

పవర్‌షెల్‌లో అందుబాటులో ఉన్న అనేక డేటా రకాల్లో, ఏకపక్ష నిర్మాణంతో వస్తువులను నిల్వ చేయడానికి రూపొందించిన 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ని ఉపయోగించడాన్ని చూశాము Select-కర్మ. మూలకాలను జోడించడం మరియు తీసివేయడం గుర్తించడం మాత్రమే మిగిలి ఉంది. మునుపటి ఉదాహరణ నుండి వస్తువు కోసం దీన్ని చేయడం చాలా సులభం:

$object | Add-Member –MemberType NoteProperty –Name Age  –Value 33
$object | Get-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)

పవర్‌షెల్‌లోని వస్తువులతో పని చేయడం గురించి మా వివరణ సమగ్రంగా లేదు. కింది ప్రచురణలలో, మేము దానిని ఆచరణాత్మక ఉదాహరణలతో మరింత లోతుగా చేయడానికి ప్రయత్నిస్తాము: సిరీస్‌లోని ఐదవ కథనం పవర్‌షెల్‌ను మూడవ పక్ష సాఫ్ట్‌వేర్ భాగాలతో అనుసంధానించే సమస్యలకు అంకితం చేయబడుతుంది. గత భాగాలను క్రింది లింక్‌లలో చూడవచ్చు.

పార్ట్ 1: ప్రాథమిక Windows PowerShell ఫీచర్లు
పార్ట్ 2: విండోస్ పవర్‌షెల్ ప్రోగ్రామింగ్ లాంగ్వేజ్ పరిచయం
పార్ట్ 3: స్క్రిప్ట్‌లు మరియు ఫంక్షన్‌లకు పారామితులను పంపడం, cmdletలను సృష్టించడం

మూలం: www.habr.com