ਵਿੰਡੋਜ਼ ਪਾਵਰਸ਼ੇਲ ਕੀ ਹੈ ਅਤੇ ਇਸਦੀ ਵਰਤੋਂ ਕਿਸ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ? ਭਾਗ 4: ਵਸਤੂਆਂ, ਆਪਣੀਆਂ ਕਲਾਸਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ

PowerShell ਇੰਟਰਪ੍ਰੇਟਰ ਵਿੰਡੋ ਵਿੱਚ ਕਮਾਂਡਾਂ ਦਾ ਟੈਕਸਟ ਆਉਟਪੁੱਟ ਮਨੁੱਖੀ ਧਾਰਨਾ ਲਈ ਢੁਕਵੇਂ ਰੂਪ ਵਿੱਚ ਜਾਣਕਾਰੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ। ਦਰਅਸਲ ਬੁੱਧਵਾਰ ਮੁਖੀ ਵਸਤੂਆਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ: cmdlets ਅਤੇ ਫੰਕਸ਼ਨ ਉਹਨਾਂ ਨੂੰ ਇਨਪੁਟ ਦੇ ਤੌਰ ਤੇ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ ਅਤੇ ਨਿਕਾਸ 'ਤੇ ਵਾਪਸ ਪਰਤਿਆ, ਅਤੇ ਪਰਸਪਰ ਅਤੇ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਉਪਲਬਧ ਵੇਰੀਏਬਲ ਕਿਸਮਾਂ .NET ਕਲਾਸਾਂ 'ਤੇ ਅਧਾਰਤ ਹਨ। ਲੜੀ ਦੇ ਚੌਥੇ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਵਸਤੂਆਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦਾ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਅਧਿਐਨ ਕਰਾਂਗੇ।

ਵਿਸ਼ਾ - ਸੂਚੀ:

PowerShell ਵਿੱਚ ਵਸਤੂਆਂ
ਵਸਤੂਆਂ ਦੀ ਬਣਤਰ ਨੂੰ ਵੇਖਣਾ
ਵਸਤੂਆਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ
ਵਸਤੂਆਂ ਨੂੰ ਛਾਂਟਣਾ
ਵਸਤੂਆਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਹਿੱਸੇ ਚੁਣਨਾ
ਹਰੇਕ-ਆਬਜੈਕਟ, ਸਮੂਹ-ਆਬਜੈਕਟ ਅਤੇ ਮਾਪ-ਆਬਜੈਕਟ ਲਈ
.NET ਅਤੇ COM ਆਬਜੈਕਟ ਬਣਾਉਣਾ (ਨਵਾਂ-ਆਬਜੈਕਟ)
ਕਾਲਿੰਗ ਸਥਿਰ ਢੰਗ
PSCustomObject ਟਾਈਪ ਕਰੋ
ਆਪਣੀਆਂ ਖੁਦ ਦੀਆਂ ਕਲਾਸਾਂ ਬਣਾਉਣਾ

PowerShell ਵਿੱਚ ਵਸਤੂਆਂ

ਆਓ ਯਾਦ ਕਰੀਏ ਕਿ ਇੱਕ ਵਸਤੂ ਡੇਟਾ ਫੀਲਡਾਂ (ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ, ਘਟਨਾਵਾਂ, ਆਦਿ) ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਲਈ ਵਿਧੀਆਂ (ਤਰੀਕਿਆਂ) ਦਾ ਸੰਗ੍ਰਹਿ ਹੈ। ਇਸਦਾ ਢਾਂਚਾ ਇੱਕ ਕਿਸਮ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਆਮ ਤੌਰ 'ਤੇ ਯੂਨੀਫਾਈਡ .NET ਕੋਰ ਪਲੇਟਫਾਰਮ ਵਿੱਚ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਕਲਾਸਾਂ 'ਤੇ ਅਧਾਰਤ ਹੈ। COM, CIM (WMI) ਅਤੇ ADSI ਵਸਤੂਆਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਵੀ ਸੰਭਵ ਹੈ। ਡੇਟਾ 'ਤੇ ਵੱਖ-ਵੱਖ ਕਿਰਿਆਵਾਂ ਕਰਨ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਵਿਧੀਆਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ; ਇਸ ਤੋਂ ਇਲਾਵਾ, PowerShell ਵਿੱਚ, ਆਬਜੈਕਟਾਂ ਨੂੰ ਫੰਕਸ਼ਨਾਂ ਅਤੇ cmdlets ਨੂੰ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ 'ਤੇ ਪਾਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਉਹਨਾਂ ਦੇ ਮੁੱਲ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਅਤੇ ਇਹ ਵੀ ਹੈ ਕਮਾਂਡ ਰਚਨਾ ਵਿਧੀ (ਕਨਵੇਅਰ ਜਾਂ ਪਾਈਪਲਾਈਨ) ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਹਰੇਕ ਕਮਾਂਡ ਆਪਣੀ ਆਉਟਪੁੱਟ ਨੂੰ ਬਦਲੇ ਵਿੱਚ, ਇਕ ਆਬਜੈਕਟ ਦੁਆਰਾ ਅਗਲੇ ਨੂੰ ਭੇਜਦੀ ਹੈ। ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ, ਤੁਸੀਂ ਕੰਪਾਇਲ ਕੀਤੇ cmdlets ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜਾਂ ਆਪਣੇ ਖੁਦ ਦੇ ਬਣਾ ਸਕਦੇ ਹੋ ਉੱਨਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂਪਾਈਪਲਾਈਨ ਵਿੱਚ ਵਸਤੂਆਂ ਨਾਲ ਵੱਖ-ਵੱਖ ਹੇਰਾਫੇਰੀ ਕਰਨ ਲਈ: ਫਿਲਟਰਿੰਗ, ਛਾਂਟੀ, ਸਮੂਹੀਕਰਨ, ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਉਹਨਾਂ ਦੀ ਬਣਤਰ ਨੂੰ ਬਦਲਣਾ। ਇਸ ਫਾਰਮ ਵਿੱਚ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਦਾ ਇੱਕ ਗੰਭੀਰ ਫਾਇਦਾ ਹੈ: ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੀ ਟੀਮ ਨੂੰ ਬਾਈਟਸ (ਟੈਕਸਟ) ਦੀ ਸਟ੍ਰੀਮ ਨੂੰ ਪਾਰਸ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਸਾਰੀਆਂ ਲੋੜੀਂਦੀਆਂ ਜਾਣਕਾਰੀ ਨੂੰ ਢੁਕਵੇਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਕੇ ਆਸਾਨੀ ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਵਸਤੂਆਂ ਦੀ ਬਣਤਰ ਨੂੰ ਵੇਖਣਾ

ਉਦਾਹਰਨ ਲਈ, ਆਓ Get-Process cmdlet ਨੂੰ ਚਲਾਈਏ, ਜੋ ਤੁਹਾਨੂੰ ਸਿਸਟਮ ਵਿੱਚ ਚੱਲ ਰਹੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ:

ਇਹ ਕੁਝ ਫਾਰਮੈਟ ਕੀਤੇ ਟੈਕਸਟ ਡੇਟਾ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗਾ ਜੋ ਵਾਪਸ ਕੀਤੀਆਂ ਵਸਤੂਆਂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਤਰੀਕਿਆਂ ਬਾਰੇ ਕੋਈ ਵਿਚਾਰ ਨਹੀਂ ਦਿੰਦਾ ਹੈ। ਆਉਟਪੁੱਟ ਨੂੰ ਵਧੀਆ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਵਸਤੂਆਂ ਦੀ ਬਣਤਰ ਦੀ ਜਾਂਚ ਕਿਵੇਂ ਕਰਨੀ ਹੈ ਇਹ ਸਿੱਖਣ ਦੀ ਲੋੜ ਹੈ, ਅਤੇ Get-Member cmdlet ਇਸ ਵਿੱਚ ਸਾਡੀ ਮਦਦ ਕਰੇਗਾ:

Get-Process | Get-Member

ਇੱਥੇ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕਿਸਮ ਅਤੇ ਬਣਤਰ ਵੇਖਦੇ ਹਾਂ, ਅਤੇ ਵਾਧੂ ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਮਦਦ ਨਾਲ ਅਸੀਂ, ਉਦਾਹਰਨ ਲਈ, ਸਿਰਫ ਇਨਪੁਟ ਵਿੱਚ ਸ਼ਾਮਲ ਵਸਤੂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹਾਂ:

Get-Process | Get-Member -MemberType Property

ਪ੍ਰਸ਼ਾਸਨ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਇੰਟਰਐਕਟਿਵ ਤਰੀਕੇ ਨਾਲ ਹੱਲ ਕਰਨ ਲਈ ਜਾਂ ਤੁਹਾਡੀਆਂ ਖੁਦ ਦੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਲਿਖਣ ਲਈ ਇਸ ਗਿਆਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ: ਉਦਾਹਰਨ ਲਈ, ਰਿਸਪੌਂਡਿੰਗ ਪ੍ਰਾਪਰਟੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੰਗ ਪ੍ਰਕਿਰਿਆਵਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ।

ਵਸਤੂਆਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ

PowerShell ਉਹਨਾਂ ਵਸਤੂਆਂ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਜੋ ਇੱਕ ਖਾਸ ਸਥਿਤੀ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਨ ਇੱਕ ਪਾਈਪਲਾਈਨ ਰਾਹੀਂ ਲੰਘਣ ਲਈ:

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

ਬਰੈਕਟਾਂ ਦੇ ਅੰਦਰ ਸਕ੍ਰਿਪਟ ਬਲਾਕ ਨੂੰ ਚਲਾਉਣ ਦਾ ਨਤੀਜਾ ਇੱਕ ਬੂਲੀਅਨ ਮੁੱਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇਕਰ ਇਹ ਸਹੀ ਹੈ ($true), ਤਾਂ ਆਬਜੈਕਟ ਜੋ ਕਿੱਥੇ-ਆਬਜੈਕਟ 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

ਵਸਤੂਆਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਹਿੱਸੇ ਚੁਣਨਾ

ਸਿਲੈਕਟ-ਆਬਜੈਕਟ 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) ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਸਿਰਫ਼ ਦੋ ਖੇਤਰ ਹਨ ਜੋ ਅਸੀਂ ਨਿਰਧਾਰਿਤ ਕੀਤੇ ਹਨ: ਉਹਨਾਂ ਦੇ ਮੁੱਲ Get-Process 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 ਹਨ। ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ ਤੇ, ਆਓ ਤਿੰਨ ਸਭ ਤੋਂ ਲਾਭਦਾਇਕ ਬਾਰੇ ਗੱਲ ਕਰੀਏ:

ਹਰ ਇਕ ਵਸਤੂ ਲਈ ਤੁਹਾਨੂੰ ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਹਰੇਕ ਵਸਤੂ ਲਈ PowerShell ਕੋਡ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ:

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

ਮੰਨ ਲਓ ਕਿ ਇਹ Clear() ਵਿਧੀ ਦੁਆਰਾ ਸਾਫ਼ ਕੀਤਾ ਗਿਆ ਹੈ ਜੇਕਰ ਪਹੁੰਚ ਅਧਿਕਾਰ ਹਨ:

$AppLog.Clear()

ਨਿਊ-ਆਬਜੈਕਟ cmdlet ਨੂੰ COM ਕੰਪੋਨੈਂਟਸ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਵੀ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਉਹਨਾਂ ਵਿੱਚੋਂ ਬਹੁਤ ਸਾਰੇ ਹਨ - ਵਿੰਡੋਜ਼ ਸਕ੍ਰਿਪਟ ਸਰਵਰ ਨਾਲ ਸਪਲਾਈ ਕੀਤੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਤੋਂ ਲੈ ਕੇ ActiveX ਐਪਲੀਕੇਸ਼ਨਾਂ, ਜਿਵੇਂ ਕਿ ਇੰਟਰਨੈੱਟ ਐਕਸਪਲੋਰਰ। ਇੱਕ COM ਆਬਜੈਕਟ ਬਣਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ -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 ਵਸਤੂਆਂ ਦੀ ਵੀ ਪੜਚੋਲ ਕਰਾਂਗੇ।

ਕਾਲਿੰਗ ਸਥਿਰ ਢੰਗ

ਕੁਝ .NET ਕੋਰ ਕਲਾਸਾਂ ਨੂੰ ਸ਼ੁਰੂ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ, ਜਿਸ ਵਿੱਚ System.Environment ਅਤੇ System.Math ਸ਼ਾਮਲ ਹਨ। ਉਹ ਸਥਿਰ ਅਤੇ ਸਿਰਫ਼ ਸਥਿਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਵਿਧੀਆਂ ਸ਼ਾਮਲ ਹਨ। ਇਹ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਹਵਾਲਾ ਲਾਇਬ੍ਰੇਰੀਆਂ ਹਨ ਜੋ ਵਸਤੂਆਂ ਨੂੰ ਬਣਾਏ ਬਿਨਾਂ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਤੁਸੀਂ ਟਾਈਪ ਨਾਮ ਨੂੰ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਕੇ ਇੱਕ ਸ਼ਾਬਦਿਕ ਦੁਆਰਾ ਇੱਕ ਸਥਿਰ ਕਲਾਸ ਦਾ ਹਵਾਲਾ ਦੇ ਸਕਦੇ ਹੋ। ਹਾਲਾਂਕਿ, ਜੇਕਰ ਅਸੀਂ Get-Member ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਬਜੈਕਟ ਦੀ ਬਣਤਰ ਨੂੰ ਦੇਖਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ System.Environment ਦੀ ਬਜਾਏ System.RuntimeType ਦੀ ਕਿਸਮ ਦੇਖਾਂਗੇ:

[System.Environment] | Get-Member

ਸਿਰਫ਼ ਸਥਿਰ ਮੈਂਬਰਾਂ ਨੂੰ ਦੇਖਣ ਲਈ, -ਸਟੈਟਿਕ ਪੈਰਾਮੀਟਰ ਨਾਲ 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()

ਇਸ ਕਿਸਮ ਦੀਆਂ ਵਸਤੂਆਂ ਦਾ ਇੱਕ ਨੁਕਸਾਨ ਇਹ ਹੈ ਕਿ ਉਹਨਾਂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਕ੍ਰਮ ਬਦਲ ਸਕਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਚਣ ਲਈ, ਤੁਹਾਨੂੰ [ordered] ਗੁਣ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ:

$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)

ਢੰਗਾਂ ਨੂੰ ਓਵਰਲੋਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ; ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇੱਕ ਕਲਾਸ ਹੈ ਸਥਿਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਢੰਗ, ਅਤੇ ਨਾਲ ਹੀ ਕੰਸਟਰਕਟਰ ਜਿਨ੍ਹਾਂ ਦੇ ਨਾਮ ਕਲਾਸ ਦੇ ਨਾਮ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ। ਇੱਕ ਸਕ੍ਰਿਪਟ ਜਾਂ PowerShell ਮੋਡੀਊਲ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਇੱਕ ਕਲਾਸ ਦੂਜੇ ਲਈ ਇੱਕ ਅਧਾਰ ਵਜੋਂ ਕੰਮ ਕਰ ਸਕਦੀ ਹੈ - ਇਸ ਤਰ੍ਹਾਂ ਵਿਰਾਸਤ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਇਸ ਨੂੰ ਮੌਜੂਦਾ .NET ਕਲਾਸਾਂ ਨੂੰ ਅਧਾਰ ਦੇ ਤੌਰ 'ਤੇ ਵਰਤਣ ਦੀ ਆਗਿਆ ਹੈ:

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

PowerShell ਵਿੱਚ ਵਸਤੂਆਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਦਾ ਸਾਡਾ ਵਰਣਨ ਸ਼ਾਇਦ ਹੀ ਸੰਪੂਰਨ ਹੈ। ਨਿਮਨਲਿਖਤ ਪ੍ਰਕਾਸ਼ਨਾਂ ਵਿੱਚ, ਅਸੀਂ ਇਸ ਨੂੰ ਵਿਹਾਰਕ ਉਦਾਹਰਣਾਂ ਦੇ ਨਾਲ ਡੂੰਘਾ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗੇ: ਲੜੀ ਦਾ ਪੰਜਵਾਂ ਲੇਖ ਤੀਜੀ-ਧਿਰ ਦੇ ਸੌਫਟਵੇਅਰ ਭਾਗਾਂ ਦੇ ਨਾਲ PowerShell ਨੂੰ ਏਕੀਕ੍ਰਿਤ ਕਰਨ ਦੇ ਮੁੱਦਿਆਂ ਨੂੰ ਸਮਰਪਿਤ ਹੋਵੇਗਾ। ਪਿਛਲੇ ਹਿੱਸੇ ਹੇਠਾਂ ਦਿੱਤੇ ਲਿੰਕਾਂ 'ਤੇ ਲੱਭੇ ਜਾ ਸਕਦੇ ਹਨ।

ਭਾਗ 1: ਬੁਨਿਆਦੀ Windows PowerShell ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ
ਭਾਗ 2: ਵਿੰਡੋਜ਼ ਪਾਵਰਸ਼ੇਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਨਾਲ ਜਾਣ-ਪਛਾਣ
ਭਾਗ 3: ਸਕ੍ਰਿਪਟਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਪੈਰਾਮੀਟਰ ਪਾਸ ਕਰਨਾ, cmdlets ਬਣਾਉਣਾ

ਸਰੋਤ: www.habr.com