ಏನು Windows ಪವರ್‌ಶೆಲ್ ಮತ್ತು ಅದರೊಂದಿಗೆ ಏನು ತಿನ್ನಬೇಕು? ಭಾಗ 4: ವಸ್ತುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು, ಕಸ್ಟಮ್ ತರಗತಿಗಳು

ಪವರ್‌ಶೆಲ್ ಇಂಟರ್ಪ್ರಿಟರ್ ವಿಂಡೋದಲ್ಲಿನ ಆಜ್ಞೆಗಳ ಪಠ್ಯ ಔಟ್‌ಪುಟ್ ಮಾನವ ಗ್ರಹಿಕೆಗೆ ಸೂಕ್ತವಾದ ರೂಪದಲ್ಲಿ ಮಾಹಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ. ವಾಸ್ತವವಾಗಿ ಬುಧವಾರ ಆಧಾರಿತ ವಸ್ತುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು: cmdlets ಮತ್ತು ಕಾರ್ಯಗಳು ಅವುಗಳನ್ನು ಇನ್ಪುಟ್ ಆಗಿ ಸ್ವೀಕರಿಸುತ್ತವೆ ಮತ್ತು ನಿರ್ಗಮನದಲ್ಲಿ ಮರಳಿದರು, ಮತ್ತು ಸಂವಾದಾತ್ಮಕವಾಗಿ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಲಭ್ಯವಿರುವ ವೇರಿಯಬಲ್ ಪ್ರಕಾರಗಳು .NET ತರಗತಿಗಳನ್ನು ಆಧರಿಸಿವೆ. ಸರಣಿಯ ನಾಲ್ಕನೇ ಲೇಖನದಲ್ಲಿ, ನಾವು ವಸ್ತುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ಅಧ್ಯಯನ ಮಾಡುತ್ತೇವೆ.

ಪರಿವಿಡಿ:

PowerShell ನಲ್ಲಿನ ವಸ್ತುಗಳು
ವಸ್ತುಗಳ ರಚನೆಯನ್ನು ನೋಡುವುದು
ಫಿಲ್ಟರಿಂಗ್ ವಸ್ತುಗಳು
ವಸ್ತುಗಳನ್ನು ವಿಂಗಡಿಸುವುದು
ವಸ್ತುಗಳು ಮತ್ತು ಅವುಗಳ ಭಾಗಗಳ ಆಯ್ಕೆ
ಪ್ರತಿ-ವಸ್ತು, ಗುಂಪು-ವಸ್ತು ಮತ್ತು ಅಳತೆ-ವಸ್ತು
.NET ಮತ್ತು COM ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು (ಹೊಸ-ಆಬ್ಜೆಕ್ಟ್)
ಸ್ಥಾಯೀ ವಿಧಾನಗಳನ್ನು ಕರೆಯಲಾಗುತ್ತಿದೆ
PSCustomObject ಎಂದು ಟೈಪ್ ಮಾಡಿ
ನಿಮ್ಮ ಸ್ವಂತ ತರಗತಿಗಳನ್ನು ರಚಿಸುವುದು

PowerShell ನಲ್ಲಿನ ವಸ್ತುಗಳು

ವಸ್ತುವು ಡೇಟಾ ಕ್ಷೇತ್ರಗಳ (ಪ್ರಾಪರ್ಟೀಸ್, ಈವೆಂಟ್‌ಗಳು, ಇತ್ಯಾದಿ) ಮತ್ತು ಅವುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ವಿಧಾನಗಳ (ವಿಧಾನಗಳು) ಸಂಗ್ರಹವಾಗಿದೆ ಎಂದು ನಾವು ನೆನಪಿಸಿಕೊಳ್ಳೋಣ. ಇದರ ರಚನೆಯನ್ನು ಒಂದು ಪ್ರಕಾರದಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಏಕೀಕೃತ .NET ಕೋರ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ಬಳಸುವ ವರ್ಗಗಳನ್ನು ಆಧರಿಸಿದೆ. COM, CIM (WMI) ಮತ್ತು ADSI ವಸ್ತುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಸಹ ಸಾಧ್ಯವಿದೆ. ಡೇಟಾದ ಮೇಲೆ ವಿವಿಧ ಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳು ಅಗತ್ಯವಿದೆ; ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪವರ್‌ಶೆಲ್‌ನಲ್ಲಿ, ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಫಂಕ್ಷನ್‌ಗಳು ಮತ್ತು ಸಿಎಮ್‌ಡಿಲೆಟ್‌ಗಳಿಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ರವಾನಿಸಬಹುದು, ಅವುಗಳ ಮೌಲ್ಯಗಳನ್ನು ವೇರಿಯೇಬಲ್‌ಗಳಿಗೆ ನಿಯೋಜಿಸಬಹುದು ಮತ್ತು ಸಹ ಇದೆ ಆಜ್ಞೆಯ ಸಂಯೋಜನೆಯ ಕಾರ್ಯವಿಧಾನ (ಕನ್ವೇಯರ್ ಅಥವಾ ಪೈಪ್ಲೈನ್). ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಆಜ್ಞೆಯು ಅದರ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮುಂದಿನದಕ್ಕೆ, ವಸ್ತುವಿನ ಮೂಲಕ ವಸ್ತುವಿಗೆ ರವಾನಿಸುತ್ತದೆ. ಪ್ರಕ್ರಿಯೆಗಾಗಿ, ನೀವು ಕಂಪೈಲ್ ಮಾಡಿದ cmdlets ಅನ್ನು ಬಳಸಬಹುದು ಅಥವಾ ನಿಮ್ಮದೇ ಆದದನ್ನು ರಚಿಸಬಹುದು ಮುಂದುವರಿದ ವೈಶಿಷ್ಟ್ಯಗಳುಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿರುವ ವಸ್ತುಗಳೊಂದಿಗೆ ವಿವಿಧ ಕುಶಲತೆಯನ್ನು ನಿರ್ವಹಿಸಲು: ಫಿಲ್ಟರಿಂಗ್, ವಿಂಗಡಣೆ, ಗುಂಪು ಮಾಡುವುದು ಮತ್ತು ಅವುಗಳ ರಚನೆಯನ್ನು ಬದಲಾಯಿಸುವುದು. ಈ ರೂಪದಲ್ಲಿ ಡೇಟಾವನ್ನು ರವಾನಿಸುವುದು ಗಂಭೀರ ಪ್ರಯೋಜನವನ್ನು ಹೊಂದಿದೆ: ಸ್ವೀಕರಿಸುವ ತಂಡವು ಬೈಟ್ ಸ್ಟ್ರೀಮ್ (ಪಠ್ಯ) ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ, ಸೂಕ್ತವಾದ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಕರೆಯುವ ಮೂಲಕ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಮಾಹಿತಿಯನ್ನು ಸುಲಭವಾಗಿ ಹಿಂಪಡೆಯಲಾಗುತ್ತದೆ.

ವಸ್ತುಗಳ ರಚನೆಯನ್ನು ನೋಡುವುದು

ಉದಾಹರಣೆಗೆ, ಗೆಟ್-ಪ್ರೊಸೆಸ್ cmdlet ಅನ್ನು ರನ್ ಮಾಡೋಣ, ಇದು ಸಿಸ್ಟಮ್ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ:

ಹಿಂತಿರುಗಿದ ವಸ್ತುಗಳ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ಅವುಗಳ ವಿಧಾನಗಳ ಬಗ್ಗೆ ಯಾವುದೇ ಕಲ್ಪನೆಯನ್ನು ನೀಡದ ಕೆಲವು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲಾದ ಪಠ್ಯ ಡೇಟಾವನ್ನು ಇದು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಔಟ್‌ಪುಟ್ ಅನ್ನು ಉತ್ತಮಗೊಳಿಸಲು, ವಸ್ತುಗಳ ರಚನೆಯನ್ನು ಹೇಗೆ ಪರಿಶೀಲಿಸಬೇಕು ಎಂಬುದನ್ನು ನಾವು ಕಲಿಯಬೇಕಾಗಿದೆ, ಮತ್ತು ಗೆಟ್-ಮೆಂಬರ್ cmdlet ಇದನ್ನು ನಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ:

Get-Process | Get-Member

ಇಲ್ಲಿ ನಾವು ಈಗಾಗಲೇ ಪ್ರಕಾರ ಮತ್ತು ರಚನೆಯನ್ನು ನೋಡುತ್ತೇವೆ ಮತ್ತು ಹೆಚ್ಚುವರಿ ನಿಯತಾಂಕಗಳ ಸಹಾಯದಿಂದ ನಾವು, ಉದಾಹರಣೆಗೆ, ಇನ್ಪುಟ್ನಲ್ಲಿ ಸೇರಿಸಲಾದ ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮಾತ್ರ ಪ್ರದರ್ಶಿಸಬಹುದು:

Get-Process | Get-Member -MemberType Property

ಆಡಳಿತದ ಸಮಸ್ಯೆಗಳನ್ನು ಸಂವಾದಾತ್ಮಕವಾಗಿ ಪರಿಹರಿಸಲು ಅಥವಾ ನಿಮ್ಮ ಸ್ವಂತ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬರೆಯಲು ಈ ಜ್ಞಾನದ ಅಗತ್ಯವಿದೆ: ಉದಾಹರಣೆಗೆ, ಪ್ರತಿಕ್ರಿಯಿಸುವ ಆಸ್ತಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಹ್ಯಾಂಗ್ ಪ್ರಕ್ರಿಯೆಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು.

ಫಿಲ್ಟರಿಂಗ್ ವಸ್ತುಗಳು

ಪವರ್‌ಶೆಲ್ ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಯನ್ನು ಪೂರೈಸುವ ವಸ್ತುಗಳನ್ನು ಪೈಪ್‌ಲೈನ್ ಮೂಲಕ ರವಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ:

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

ಆಪರೇಟರ್ ಬ್ರಾಕೆಟ್‌ಗಳ ಒಳಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಫಲಿತಾಂಶವು ಬೂಲಿಯನ್ ಮೌಲ್ಯವಾಗಿರಬೇಕು. ಅದು ನಿಜವಾಗಿದ್ದರೆ ($true), Where-Object cmdlet ಗೆ ರವಾನಿಸಲಾದ ವಸ್ತುವನ್ನು ಪೈಪ್‌ಲೈನ್ ಮೂಲಕ ರವಾನಿಸಲಾಗುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ ($false ಮೌಲ್ಯ), ಅದನ್ನು ಅಳಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಿಲ್ಲಿಸಿದ ಸೇವೆಗಳ ಪಟ್ಟಿಯನ್ನು ಪ್ರದರ್ಶಿಸೋಣ. Windows Server, ಅಂದರೆ "ನಿಲ್ಲಿಸಲಾಗಿದೆ" ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ಸ್ಥಿತಿ ಆಸ್ತಿ ಹೊಂದಿರುವವರು:

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 ಗೆ ಕರೆ ಮಾಡುವಾಗ -ಪ್ರಾಪರ್ಟಿ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು; ಇದನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಹಿಮ್ಮುಖ ವಿಂಗಡಣೆಗಾಗಿ, -ಅವರೋಹಣ ನಿಯತಾಂಕವನ್ನು ಬಳಸಿ:

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

ಪೈಪ್ಲೈನ್ನ ಕಾರ್ಯಾಚರಣೆಯ ಪರಿಣಾಮವಾಗಿ, ನಾವು ಹೊಸ ವಸ್ತುವನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ, ಅದರ ರಚನೆಯು ಗೆಟ್-ಪ್ರೊಸೆಸ್ cmdlet ನಿಂದ ಹಿಂದಿರುಗಿದ ರಚನೆಯಿಂದ ಭಿನ್ನವಾಗಿರುತ್ತದೆ. ಗೆಟ್-ಮೆಂಬರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಪರಿಶೀಲಿಸೋಣ:

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

ಸೆಲೆಕ್ಟ್-ಆಬ್ಜೆಕ್ಟ್ ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಎರಡು ಕ್ಷೇತ್ರಗಳನ್ನು ಹೊಂದಿರುವ ಒಂದೇ ವಸ್ತುವನ್ನು (-ಮೊದಲ 1) ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ: ಅವುಗಳ ಮೌಲ್ಯಗಳನ್ನು ಗೆಟ್-ಪ್ರೊಸೆಸ್ cmdlet ಮೂಲಕ ಪೈಪ್‌ಲೈನ್‌ಗೆ ರವಾನಿಸಿದ ಮೊದಲ ವಸ್ತುವಿನಿಂದ ನಕಲಿಸಲಾಗಿದೆ. ಪವರ್‌ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವ ವಿಧಾನವೆಂದರೆ ಸೆಲೆಕ್ಟ್-ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸುವುದನ್ನು ಆಧರಿಸಿದೆ:

$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 ಪವರ್‌ಶೆಲ್. -ಟೈಪ್‌ನೇಮ್ ನಿಯತಾಂಕದೊಂದಿಗೆ ಹೊಸ-ವಸ್ತು 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 ಇಂಟರ್ನೆಟ್ ಎಕ್ಸ್‌ಪ್ಲೋರರ್‌ನಂತಹ ಆಕ್ಟಿವ್‌ಎಕ್ಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಲೈಬ್ರರಿಗಳನ್ನು ರಚಿಸಿ. 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

ಸ್ಥಿರ ಸದಸ್ಯರನ್ನು ಮಾತ್ರ ವೀಕ್ಷಿಸಲು, ಗೆಟ್-ಮೆಂಬರ್ ಅನ್ನು -ಸ್ಟಾಟಿಕ್ ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ ಕರೆ ಮಾಡಿ (ವಸ್ತು ಪ್ರಕಾರವನ್ನು ಗಮನಿಸಿ):

[System.Environment] | Get-Member -Static

ಸ್ಥಿರ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಪ್ರವೇಶಿಸಲು, ಅಕ್ಷರಶಃ ನಂತರದ ಅವಧಿಯ ಬದಲಿಗೆ ಎರಡು ಸತತ ಕಾಲನ್‌ಗಳನ್ನು ಬಳಸಿ:

[System.Environment]::OSVersion

ಅಥವಾ

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

PSCustomObject ಎಂದು ಟೈಪ್ ಮಾಡಿ

ಪವರ್‌ಶೆಲ್‌ನಲ್ಲಿ ಲಭ್ಯವಿರುವ ಹಲವಾರು ಡೇಟಾ ಪ್ರಕಾರಗಳಲ್ಲಿ, ಅನಿಯಂತ್ರಿತ ರಚನೆಯೊಂದಿಗೆ ವಸ್ತುಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ PSCustomObject ಅನ್ನು ಉಲ್ಲೇಖಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ. ಹೊಸ-ಆಬ್ಜೆಕ್ಟ್ 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

ಆಡ್-ಸದಸ್ಯ cmdlet ನಿಮಗೆ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮಾತ್ರ ಸೇರಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ "-MemberType ScriptMethod" ರಚನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಹಿಂದೆ ರಚಿಸಲಾದ $ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ವಿಧಾನಗಳನ್ನು ಸಹ ಸೇರಿಸುತ್ತದೆ:

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

ಹೊಸ ವಿಧಾನಕ್ಕಾಗಿ ಕೋಡ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಲು ScriptBlock ಪ್ರಕಾರದ $ScriptBlock ವೇರಿಯೇಬಲ್ ಅನ್ನು ನಾವು ಬಳಸಿದ್ದೇವೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ.

ಗುಣಲಕ್ಷಣಗಳನ್ನು ತೆಗೆದುಹಾಕಲು, ಅನುಗುಣವಾದ ವಿಧಾನವನ್ನು ಬಳಸಿ:

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

ನಿಮ್ಮ ಸ್ವಂತ ತರಗತಿಗಳನ್ನು ರಚಿಸುವುದು

PowerShell 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 ಪವರ್ಶೆಲ್
ಭಾಗ 2: ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯ ಪರಿಚಯ Windows ಪವರ್ಶೆಲ್
ಭಾಗ 3: ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಮತ್ತು ಕಾರ್ಯಗಳಿಗೆ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ರವಾನಿಸುವುದು, cmdlets ಅನ್ನು ರಚಿಸುವುದು

ಮೂಲ: www.habr.com