എന്താണ് Windows PowerShell, അത് എന്തിനുവേണ്ടിയാണ് ഉപയോഗിക്കുന്നത്? ഭാഗം 4: ഒബ്‌ജക്‌റ്റുകൾ, സ്വന്തം ക്ലാസുകൾ എന്നിവയ്‌ക്കൊപ്പം പ്രവർത്തിക്കുന്നു

പവർഷെൽ ഇന്റർപ്രെറ്റർ വിൻഡോയിലെ കമാൻഡുകളുടെ ടെക്സ്റ്റ് ഔട്ട്പുട്ട് മനുഷ്യ ധാരണയ്ക്ക് അനുയോജ്യമായ രൂപത്തിൽ വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഒരു മാർഗം മാത്രമാണ്. യഥാർത്ഥത്തിൽ ബുധനാഴ്ച ഓറിയന്റഡ് ഒബ്‌ജക്‌റ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കാൻ: cmdlets ഉം ഫംഗ്‌ഷനുകളും അവ ഇൻപുട്ടായി സ്വീകരിക്കുന്നു ഒപ്പം പുറത്തുകടക്കുമ്പോൾ മടങ്ങി, കൂടാതെ സംവേദനാത്മകമായും സ്ക്രിപ്റ്റുകളിലും ലഭ്യമായ വേരിയബിൾ തരങ്ങൾ .NET ക്ലാസുകളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. പരമ്പരയുടെ നാലാമത്തെ ലേഖനത്തിൽ, വസ്തുക്കളുമായി കൂടുതൽ വിശദമായി പ്രവർത്തിക്കുന്നത് ഞങ്ങൾ പഠിക്കും.

ഉള്ളടക്ക പട്ടിക:

PowerShell-ലെ വസ്തുക്കൾ
വസ്തുക്കളുടെ ഘടന കാണുക
വസ്തുക്കൾ ഫിൽട്ടർ ചെയ്യുന്നു
വസ്തുക്കൾ അടുക്കുന്നു
വസ്തുക്കളും അവയുടെ ഭാഗങ്ങളും തിരഞ്ഞെടുക്കുന്നു
ഓരോ ഒബ്ജക്റ്റിനും, ഗ്രൂപ്പ് ഒബ്ജക്റ്റിനും, മെഷർ ഒബ്ജക്റ്റിനും
.NET, COM ഒബ്‌ജക്‌റ്റുകൾ സൃഷ്‌ടിക്കുന്നു (പുതിയ-ഒബ്‌ജക്‌റ്റ്)
സ്റ്റാറ്റിക് രീതികൾ വിളിക്കുന്നു
PSCustomObject എന്ന് ടൈപ്പ് ചെയ്യുക
നിങ്ങളുടെ സ്വന്തം ക്ലാസുകൾ സൃഷ്ടിക്കുന്നു

PowerShell-ലെ വസ്തുക്കൾ

ഒരു ഒബ്ജക്റ്റ് എന്നത് ഡാറ്റാ ഫീൽഡുകളുടെയും (പ്രോപ്പർട്ടികൾ, ഇവന്റുകൾ മുതലായവ) അവ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള രീതികളുടെയും (രീതികൾ) ഒരു ശേഖരമാണെന്ന് നമുക്ക് ഓർക്കാം. അതിന്റെ ഘടന ഒരു തരം വ്യക്തമാക്കുന്നു, ഇത് സാധാരണയായി ഏകീകൃത .NET കോർ പ്ലാറ്റ്‌ഫോമിൽ ഉപയോഗിക്കുന്ന ക്ലാസുകളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. COM, CIM (WMI), ADSI ഒബ്‌ജക്‌റ്റുകൾ എന്നിവയ്‌ക്കൊപ്പം പ്രവർത്തിക്കാനും കഴിയും. ഡാറ്റയിൽ വിവിധ പ്രവർത്തനങ്ങൾ നടത്താൻ പ്രോപ്പർട്ടികളും രീതികളും ആവശ്യമാണ്; കൂടാതെ, PowerShell-ൽ, ഒബ്ജക്റ്റുകൾ ഫംഗ്ഷനുകളിലേക്കും 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

വസ്തുക്കൾ അടുക്കുന്നു

ഒബ്ജക്റ്റുകളുടെ പൈപ്പ്ലൈൻ പ്രോസസ്സ് ചെയ്യുമ്പോൾ, അവയെ അടുക്കാൻ പലപ്പോഴും ആവശ്യമുണ്ട്. സോർട്ട്-ഒബ്ജക്റ്റ് 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-Member ഉപയോഗിച്ച് നമുക്ക് ഇത് പരിശോധിക്കാം:

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

സാധാരണയായി, ചർച്ച ചെയ്യപ്പെടുന്ന cmdlets ഇന്ററാക്ടീവ് ആയി ഉപയോഗിക്കുന്നു, അവ പലപ്പോഴും സ്ക്രിപ്റ്റുകളിൽ സൃഷ്ടിക്കപ്പെടുന്നു. പ്രവർത്തനങ്ങൾ ബിഗിൻ, പ്രോസസ്, എൻഡ് ബ്ലോക്കുകൾക്കൊപ്പം.

.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 കോർ ക്ലാസുകൾ സിസ്റ്റം നെയിംസ്പേസിൽ അടങ്ങിയിരിക്കുന്നു: PowerShell ഡിഫോൾട്ടായി അതിൽ നിർദ്ദിഷ്ട തരങ്ങൾക്കായി തിരയുന്നു, അതിനാൽ System.Diagnostics.EventLog എന്നതിന് പകരം Diagnostics.EventLog എഴുതുന്നത് വളരെ ശരിയാണ്.

ലോഗ് ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ, നിങ്ങൾക്ക് ഉചിതമായ രീതികൾ ഉപയോഗിക്കാം:

$AppLog | Get-Member -MemberType Method

ആക്സസ് അവകാശങ്ങൾ ഉണ്ടെങ്കിൽ, ക്ലിയർ () രീതി ഉപയോഗിച്ച് ഇത് മായ്‌ച്ചുവെന്ന് പറയാം:

$AppLog.Clear()

COM ഘടകങ്ങളുമായി പ്രവർത്തിക്കാൻ New-Object cmdlet ഉപയോഗിക്കുന്നു. അവയിൽ ധാരാളം ഉണ്ട് - വിൻഡോസ് സ്ക്രിപ്റ്റ് സെർവർ നൽകുന്ന ലൈബ്രറികൾ മുതൽ 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

അനിയന്ത്രിതമായ ഘടനയോടെ നിങ്ങളുടെ സ്വന്തം ഒബ്‌ജക്റ്റുകൾ സൃഷ്‌ടിക്കുന്നതിന്, ന്യൂ-ഒബ്‌ജക്റ്റ് ഉപയോഗിക്കുന്നത് വളരെ പുരാതനവും ബുദ്ധിമുട്ടുള്ളതുമാണെന്ന് തോന്നുന്നു; 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 എന്ന് ടൈപ്പ് ചെയ്യുക

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

"-MemberType ScriptMethod" കൺസ്ട്രക്‌റ്റ് ഉപയോഗിച്ച് മുമ്പ് സൃഷ്‌ടിച്ച $object-ലേക്ക് പ്രോപ്പർട്ടികൾ മാത്രമല്ല, രീതികളും ചേർക്കാൻ ആഡ്-മെമ്പർ cmdlet നിങ്ങളെ അനുവദിക്കുന്നു:

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

പുതിയ രീതിക്കായി കോഡ് സംഭരിക്കുന്നതിന് സ്‌ക്രിപ്റ്റ്ബ്ലോക്ക് ടൈപ്പിന്റെ $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-ലെ ഒബ്‌ജക്‌റ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനെക്കുറിച്ചുള്ള ഞങ്ങളുടെ വിവരണം പൂർണ്ണമല്ല. ഇനിപ്പറയുന്ന പ്രസിദ്ധീകരണങ്ങളിൽ, പ്രായോഗിക ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് ഞങ്ങൾ ഇത് ആഴത്തിലാക്കാൻ ശ്രമിക്കും: പരമ്പരയിലെ അഞ്ചാമത്തെ ലേഖനം മൂന്നാം കക്ഷി സോഫ്റ്റ്വെയർ ഘടകങ്ങളുമായി പവർഷെൽ സംയോജിപ്പിക്കുന്ന പ്രശ്നങ്ങൾക്കായി നീക്കിവയ്ക്കും. പഴയ ഭാഗങ്ങൾ താഴെയുള്ള ലിങ്കുകളിൽ കാണാം.

ഭാഗം 1: അടിസ്ഥാന വിൻഡോസ് പവർഷെൽ സവിശേഷതകൾ
ഭാഗം 2: വിൻഡോസ് പവർഷെൽ പ്രോഗ്രാമിംഗ് ഭാഷയിലേക്കുള്ള ആമുഖം
ഭാഗം 3: സ്ക്രിപ്റ്റുകളിലേക്കും ഫംഗ്ഷനുകളിലേക്കും പാരാമീറ്ററുകൾ കൈമാറുന്നു, cmdlets സൃഷ്ടിക്കുന്നു

അവലംബം: www.habr.com