Windows PowerShell શું છે અને તેનો ઉપયોગ શેના માટે થાય છે? ભાગ 4: વસ્તુઓ, પોતાના વર્ગો સાથે કામ કરવું

પાવરશેલ ઈન્ટરપ્રીટર વિન્ડોમાં આદેશોનું ટેક્સ્ટ આઉટપુટ એ માનવીય ધારણા માટે યોગ્ય સ્વરૂપમાં માહિતી પ્રદર્શિત કરવાની એક રીત છે. ખરેખર બુધવાર લક્ષી ઑબ્જેક્ટ્સ સાથે કામ કરવા માટે: cmdlets અને ફંક્શન્સ તેમને ઇનપુટ તરીકે પ્રાપ્ત કરે છે અને બહાર નીકળતા પાછા ફર્યા, અને અરસપરસ અને સ્ક્રિપ્ટમાં ઉપલબ્ધ ચલ પ્રકારો .NET વર્ગો પર આધારિત છે. શ્રેણીના ચોથા લેખમાં, આપણે વધુ વિગતવાર વસ્તુઓ સાથે કામ કરવાનો અભ્યાસ કરીશું.

ઑગ્લેવલેનિએ:

PowerShell માં ઓબ્જેક્ટો
ઑબ્જેક્ટનું માળખું જોવું
ફિલ્ટરિંગ પદાર્થો
ઑબ્જેક્ટ્સનું વર્ગીકરણ
વસ્તુઓ અને તેમના ભાગો પસંદ કરી રહ્યા છીએ
દરેક-ઑબ્જેક્ટ, ગ્રુપ-ઑબ્જેક્ટ અને મેઝર-ઑબ્જેક્ટ માટે
.NET અને COM ઑબ્જેક્ટ બનાવવું (નવું-ઑબ્જેક્ટ)
કૉલિંગ સ્ટેટિક પદ્ધતિઓ
PSCustomObject લખો
તમારા પોતાના વર્ગો બનાવવા

PowerShell માં ઓબ્જેક્ટો

ચાલો યાદ કરીએ કે ઑબ્જેક્ટ એ ડેટા ફીલ્ડ (ગુણધર્મો, ઘટનાઓ, વગેરે) અને તેના પર પ્રક્રિયા કરવાની પદ્ધતિઓ (પદ્ધતિઓ) નો સંગ્રહ છે. તેનું માળખું એક પ્રકાર દ્વારા નિર્દિષ્ટ કરવામાં આવ્યું છે, જે સામાન્ય રીતે એકીકૃત .NET કોર પ્લેટફોર્મમાં વપરાતા વર્ગો પર આધારિત છે. COM, CIM (WMI) અને ADSI ઑબ્જેક્ટ્સ સાથે કામ કરવું પણ શક્ય છે. ડેટા પર વિવિધ ક્રિયાઓ કરવા માટે ગુણધર્મો અને પદ્ધતિઓ જરૂરી છે; વધુમાં, પાવરશેલમાં, ઑબ્જેક્ટ્સને ફંક્શન્સ અને cmdlets માટે દલીલો તરીકે પસાર કરી શકાય છે, તેમના મૂલ્યોને ચલોને સોંપી શકાય છે અને ત્યાં પણ કમાન્ડ કમ્પોઝિશન મિકેનિઝમ (કન્વેયર અથવા પાઇપલાઇન). પાઈપલાઈનમાં દરેક કમાન્ડ તેના આઉટપુટને બદલામાં, ઑબ્જેક્ટ બાય ઑબ્જેક્ટ પસાર કરે છે. પ્રક્રિયા કરવા માટે, તમે સંકલિત cmdlets નો ઉપયોગ કરી શકો છો અથવા તમારા પોતાના બનાવી શકો છો અદ્યતન સુવિધાઓપાઈપલાઈનમાં ઓબ્જેક્ટો સાથે વિવિધ મેનીપ્યુલેશન કરવા માટે: ફિલ્ટરિંગ, સૉર્ટિંગ, ગ્રૂપિંગ અને તેમની રચનામાં ફેરફાર પણ. આ ફોર્મમાં ડેટા ટ્રાન્સમિટ કરવાનો ગંભીર ફાયદો છે: પ્રાપ્ત કરનાર ટીમને બાઈટ સ્ટ્રીમ (ટેક્સ્ટ)ને પાર્સ કરવાની જરૂર નથી, યોગ્ય ગુણધર્મો અને પદ્ધતિઓ પર કૉલ કરીને તમામ જરૂરી માહિતી સરળતાથી મેળવી શકાય છે.

ઑબ્જેક્ટનું માળખું જોવું

ઉદાહરણ તરીકે, ચાલો ગેટ-પ્રોસેસ cmdlet ચલાવીએ, જે તમને સિસ્ટમમાં ચાલતી પ્રક્રિયાઓ વિશે માહિતી મેળવવાની મંજૂરી આપે છે:

તે કેટલાક ફોર્મેટ કરેલ ટેક્સ્ટ ડેટા પ્રદર્શિત કરશે જે પરત કરાયેલી વસ્તુઓના ગુણધર્મો અને તેમની પદ્ધતિઓ વિશે કોઈ ખ્યાલ આપતું નથી. આઉટપુટને ફાઇન-ટ્યુન કરવા માટે, આપણે ઑબ્જેક્ટના બંધારણની તપાસ કેવી રીતે કરવી તે શીખવાની જરૂર છે, અને Get-Member cmdlet અમને આમાં મદદ કરશે:

Get-Process | Get-Member

અહીં આપણે પહેલાથી જ પ્રકાર અને માળખું જોઈ શકીએ છીએ, અને વધારાના પરિમાણોની મદદથી આપણે, ઉદાહરણ તરીકે, ઇનપુટમાં સમાવિષ્ટ ઑબ્જેક્ટના ગુણધર્મોને જ પ્રદર્શિત કરી શકીએ છીએ:

Get-Process | Get-Member -MemberType Property

આ જ્ઞાનની જરૂર પડશે વહીવટી સમસ્યાઓને ક્રિયાપ્રતિક્રિયાથી ઉકેલવા માટે અથવા તમારી પોતાની સ્ક્રિપ્ટો લખવા માટે: ઉદાહરણ તરીકે, રિસ્પોન્ડિંગ પ્રોપર્ટીનો ઉપયોગ કરીને હંગ પ્રક્રિયાઓ વિશે માહિતી મેળવવા માટે.

ફિલ્ટરિંગ પદાર્થો

પાવરશેલ ચોક્કસ શરતને પૂર્ણ કરતી વસ્તુઓને પાઇપલાઇનમાંથી પસાર થવા દે છે:

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

કૌંસની અંદર સ્ક્રિપ્ટ બ્લોક ચલાવવાનું પરિણામ બુલિયન મૂલ્ય હોવું આવશ્યક છે. જો તે સાચું ($true) હોય, તો જ્યાં-ઑબ્જેક્ટ 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

સૉર્ટ-ઑબ્જેક્ટ cmdlet કૉલ કરતી વખતે -પ્રોપર્ટી પરિમાણ અવગણવામાં આવી શકે છે; તે મૂળભૂત રીતે ઉપયોગમાં લેવાય છે. રિવર્સ સોર્ટિંગ માટે, -Descending પેરામીટરનો ઉપયોગ કરો:

Get-Process | Sort-Object cpu -Descending

વસ્તુઓ અને તેમના ભાગો પસંદ કરી રહ્યા છીએ

સિલેક્ટ-ઓબ્જેક્ટ 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

પાઇપલાઇનની કામગીરીના પરિણામે, અમને એક નવો ઑબ્જેક્ટ પ્રાપ્ત થશે, જેનું માળખું ગેટ-પ્રોસેસ cmdlet દ્વારા પરત કરવામાં આવેલા માળખાથી અલગ હશે. ચાલો ગેટ-મેમ્બરનો ઉપયોગ કરીને આની ચકાસણી કરીએ:

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

નોંધ કરો કે સિલેક્ટ-ઓબ્જેક્ટ એક જ ઑબ્જેક્ટ (-પ્રથમ 1) પરત કરે છે જેમાં અમે ઉલ્લેખિત ફીલ્ડમાંથી માત્ર બે જ હોય ​​છે: તેમના મૂલ્યો ગેટ-પ્રોસેસ cmdlet દ્વારા પાઇપલાઇનમાં પસાર કરાયેલ પ્રથમ ઑબ્જેક્ટમાંથી કૉપિ કરવામાં આવ્યા હતા. PowerShell સ્ક્રિપ્ટ્સમાં ઑબ્જેક્ટ બનાવવાની એક રીત સિલેક્ટ-ઑબ્જેક્ટના ઉપયોગ પર આધારિત છે:

$obj = Get-Process | Select-Object ProcessName, Id -First 1
$obj.GetType()

સિલેક્ટ-ઑબ્જેક્ટનો ઉપયોગ કરીને, તમે ઑબ્જેક્ટ્સમાં ગણતરી કરેલ ગુણધર્મો ઉમેરી શકો છો જેને રજૂ કરવાની જરૂર છે હેશ કોષ્ટકો. આ કિસ્સામાં, તેની પ્રથમ કીનું મૂલ્ય મિલકતના નામને અનુરૂપ છે, અને બીજી કીનું મૂલ્ય વર્તમાન પાઇપલાઇન તત્વ માટે મિલકત મૂલ્યને અનુરૂપ છે:

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 કોર વર્ગો સિસ્ટમ નેમસ્પેસમાં સમાયેલ છે: પાવરશેલ મૂળભૂત રીતે તેમાં ઉલ્લેખિત પ્રકારો માટે જુએ છે, તેથી System.Diagnostics.EventLog ને બદલે Diagnostics.EventLog લખવું એકદમ સાચું છે.

લોગ સાથે કામ કરવા માટે, તમે યોગ્ય પદ્ધતિઓનો ઉપયોગ કરી શકો છો:

$AppLog | Get-Member -MemberType Method

ચાલો કહીએ કે જો ઍક્સેસ અધિકારો હોય તો તે Clear() પદ્ધતિ દ્વારા સાફ કરવામાં આવે છે:

$AppLog.Clear()

New-Object cmdlet નો ઉપયોગ COM ઘટકો સાથે કામ કરવા માટે પણ થાય છે. તેમાંના ઘણા બધા છે - વિન્ડોઝ સ્ક્રિપ્ટ સર્વર સાથે પૂરી પાડવામાં આવેલ લાઇબ્રેરીઓથી લઈને એક્ટિવએક્સ એપ્લિકેશન્સ, જેમ કે ઇન્ટરનેટ એક્સપ્લોરર. COM ઑબ્જેક્ટ બનાવવા માટે, તમારે ઇચ્છિત વર્ગના પ્રોગ્રામેટિક ProgId સાથે -ComObject પેરામીટર સેટ કરવાની જરૂર છે:

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

મનસ્વી સ્ટ્રક્ચર સાથે તમારા પોતાના ઑબ્જેક્ટ બનાવવા માટે, ન્યૂ-ઑબ્જેક્ટનો ઉપયોગ કરવો ખૂબ જ અર્વાચીન અને બોજારૂપ લાગે છે; આ cmdlet નો ઉપયોગ પાવરશેલની બહારના સોફ્ટવેર ઘટકો સાથે કામ કરવા માટે થાય છે. ભવિષ્યના લેખોમાં આ મુદ્દાની વધુ વિગતવાર ચર્ચા કરવામાં આવશે. .NET અને COM ઑબ્જેક્ટ્સ ઉપરાંત, અમે CIM (WMI) અને ADSI ઑબ્જેક્ટ્સનું પણ અન્વેષણ કરીશું.

કૉલિંગ સ્ટેટિક પદ્ધતિઓ

કેટલાક .NET કોર વર્ગો શરૂ કરી શકાતા નથી, જેમાં System.Environment અને System.Mathનો સમાવેશ થાય છે. તેઓ છે સ્થિર અને માત્ર સ્થિર ગુણધર્મો અને પદ્ધતિઓ સમાવે છે. આ અનિવાર્યપણે સંદર્ભ પુસ્તકાલયો છે જેનો ઉપયોગ ઑબ્જેક્ટ બનાવ્યા વિના થાય છે. તમે ચોરસ કૌંસમાં પ્રકારનું નામ બંધ કરીને શાબ્દિક દ્વારા સ્થિર વર્ગનો સંદર્ભ લઈ શકો છો. જો કે, જો આપણે 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 નો ઉલ્લેખ કરવો યોગ્ય છે, જે મનસ્વી બંધારણ સાથે વસ્તુઓને સંગ્રહિત કરવા માટે રચાયેલ છે. ન્યૂ-ઑબ્જેક્ટ cmdlet નો ઉપયોગ કરીને આવા ઑબ્જેક્ટ બનાવવાને ક્લાસિક ગણવામાં આવે છે, પરંતુ બોજારૂપ અને જૂની રીત:

$object = New-Object  –TypeName PSCustomObject -Property @{Name = 'Ivan Danko'; 
                                          City = 'Moscow';
                                          Country = 'Russia'}

ચાલો ઑબ્જેક્ટની રચના જોઈએ:

$object | Get-Member

પાવરશેલ 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

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 માં ઑબ્જેક્ટ્સ સાથે કામ કરવાનું અમારું વર્ણન ભાગ્યે જ સંપૂર્ણ છે. નીચેના પ્રકાશનોમાં, અમે વ્યવહારિક ઉદાહરણો સાથે તેને વધુ ઊંડું કરવાનો પ્રયાસ કરીશું: શ્રેણીનો પાંચમો લેખ તૃતીય-પક્ષ સોફ્ટવેર ઘટકો સાથે પાવરશેલને એકીકૃત કરવાના મુદ્દાઓને સમર્પિત કરવામાં આવશે. ભૂતકાળના ભાગો નીચેની લિંક્સ પર મળી શકે છે.

ભાગ 1: મૂળભૂત Windows PowerShell સુવિધાઓ
ભાગ 2: Windows PowerShell પ્રોગ્રામિંગ ભાષાનો પરિચય
ભાગ 3: સ્ક્રિપ્ટ્સ અને ફંક્શન્સમાં પેરામીટર્સ પસાર કરવા, cmdlets બનાવવી

સોર્સ: www.habr.com