តើ Windows PowerShell ជាអ្វី ហើយតើវាស៊ីជាមួយអ្វី? ផ្នែកទី 2: ការណែនាំអំពីភាសាសរសេរកម្មវិធី

ជាប្រវត្តិសាស្ត្រ ឧបករណ៍ប្រើប្រាស់បន្ទាត់ពាក្យបញ្ជានៅក្នុងប្រព័ន្ធយូនីកត្រូវបានអភិវឌ្ឍប្រសើរជាងនៅក្នុងវីនដូ ប៉ុន្តែជាមួយនឹងការមកដល់នៃដំណោះស្រាយថ្មីស្ថានភាពបានផ្លាស់ប្តូរ។

PowerShell អនុញ្ញាតឱ្យអ្នកសរសេរស្គ្រីបនៅក្នុងភាសាពហុគំរូដែលបានបកប្រែដែលមានធាតុផ្សំនៃនីតិវិធីបុរាណ ការតម្រង់ទិសវត្ថុ និងសូម្បីតែការសរសេរកម្មវិធីមុខងារ៖ សាខាតាមលក្ខខណ្ឌ រង្វិលជុំ អថេរ អារេ តារាងសញ្ញា ថ្នាក់ ការគ្រប់គ្រងកំហុស ក៏ដូចជា មុខងារ cmdlets និងបំពង់។ អត្ថបទមុន ត្រូវបានឧទ្ទិសដល់មូលដ្ឋានគ្រឹះនៃការងារនៅក្នុងបរិស្ថាន ហើយឥឡូវនេះយើងផ្តល់ជូនអ្នកអានរបស់យើងនូវសៀវភៅយោងតូចមួយសម្រាប់អ្នកសរសេរកម្មវិធី។

តារាង​មាតិកា:

យោបល់
អថេរ និងប្រភេទរបស់វា។
អថេរប្រព័ន្ធ
វិសាលភាព
អថេរបរិស្ថាន (បរិស្ថាន)
នព្វន្ធ និងប្រតិបត្តិករប្រៀបធៀប
ប្រតិបត្តិករចាត់តាំង
ប្រតិបត្តិករឡូជីខល
លោតតាមលក្ខខណ្ឌ
វដ្ត
អារេ
តារាងហាស
អនុគមន៍
ដំណើរការខុស

អ្នកអាចសរសេរកូដនៅក្នុងកម្មវិធីនិពន្ធអត្ថបទណាមួយ ឬប្រើបរិយាកាសអភិវឌ្ឍន៍រួមបញ្ចូលគ្នា - វិធីងាយស្រួលបំផុតគឺយក Windows PowerShell ISE ដែលភ្ជាប់មកជាមួយប្រព័ន្ធប្រតិបត្តិការម៉ាស៊ីនមេ Microsoft ។ នេះគឺចាំបាច់សម្រាប់តែស្គ្រីបស្មុគ្រស្មាញប៉ុណ្ណោះ៖ សំណុំពាក្យបញ្ជាខ្លីៗគឺងាយស្រួលក្នុងការប្រតិបត្តិអន្តរកម្ម។

យោបល់

ការ​ប្រើ​មតិ​ត្រូវ​បាន​ចាត់​ទុក​ជា​ផ្នែក​នៃ​រចនាប័ទ្ម​កម្មវិធី​ល្អ រួម​ជាមួយ​នឹង​ការ​ចូល​បន្ទាត់​ត្រឹមត្រូវ និង​ដកឃ្លា៖

# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.

<# 

       Так обозначаются начало и конец блочного комментария. 
       Заключенный между ними текст интерпретатор игнорирует.

#>

អថេរ និងប្រភេទរបស់វា។

អថេរនៅក្នុង PowerShell គឺជាវត្ថុដែលមានឈ្មោះ។ ឈ្មោះ​របស់​ពួកគេ​អាច​រួម​បញ្ចូល​តួអក្សរ​គូស​ក្រោម ព្រម​ទាំង​អក្សរ និង​លេខ។ និមិត្តសញ្ញា $ តែងតែប្រើនៅពីមុខឈ្មោះ ហើយដើម្បីប្រកាសអថេរ វាគ្រប់គ្រាន់ក្នុងការផ្តល់ឱ្យអ្នកបកប្រែនូវឈ្មោះត្រឹមត្រូវ៖

ដើម្បីចាប់ផ្តើមអថេរ (កំណត់តម្លៃទៅវា) ប្រើ assignment operator (the = symbol):

$test = 100

អ្នក​អាច​ប្រកាស​អថេរ​មួយ​ដោយ​បញ្ជាក់​ប្រភេទ​របស់​វា​ក្នុង​តង្កៀប​ការ៉េ (ប្រភេទ​ការ​ដេញ​ប្រតិបត្តិករ) មុន​ឈ្មោះ ឬ​តម្លៃ៖

[int]$test = 100

$test = [int]100

វាជាការសំខាន់ណាស់ដែលត្រូវយល់ថាអថេរនៅក្នុង PowerShell គឺជាវត្ថុពេញលេញ (ថ្នាក់) ដែលមានលក្ខណៈសម្បត្តិ និងវិធីសាស្ត្រដែលប្រភេទរបស់វាផ្អែកលើ .NET Core ។ យើងរាយបញ្ជីសំខាន់ៗ៖

ប្រភេទ (.NET class)

បរិយាយ

ឧទាហរណ៍កូដ

[string] ប្រព័ន្ធ.ខ្សែអក្សរ

ខ្សែអក្សរយូនីកូដ 

$test = "តេស្ត"
$test = 'សាកល្បង'

[char]System.Char

តួអក្សរយូនីកូដ (១៦ ប៊ីត)

[char]$test = 'c'

[ប៊ូល] ប្រព័ន្ធ.ប៊ូលីន

ប្រភេទប៊ូលីន (ប៊ូលីនពិត ឬមិនពិត)

[bool] $test = $true

[int] ប្រព័ន្ធ.Int32

ចំនួនគត់សាមសិបពីរប៊ីត (៣២ ប៊ីត)

[int]$test = 123456789

[វែង] ប្រព័ន្ធ.Int64

ចំនួនគត់ហុកសិបបួនប៊ីត (64 ប៊ីត)

[ឡុង] $test = 12345678910

[ទោល] System.Single

លេខចំណុចអណ្តែត 32 ប៊ីត

[ទោល]$test = 12345.6789

[ទ្វេ] ប្រព័ន្ធ។ ទ្វេ

ចំនួនចំណុចអណ្តែតនៃប្រវែង 64 ប៊ីត (8 បៃ)

[ពីរដង]$test = 123456789.101112

[ទសភាគ]ប្រព័ន្ធ.ទសភាគ

លេខចំណុចអណ្តែត 128 ប៊ីត (តម្រូវឱ្យបញ្ចប់ដោយ d)

[ទសភាគ]$test = 12345.6789d

[កាលបរិច្ឆេទ] System.DateTime

កាលបរិច្ឆេទ​និង​ពេលវេលា 

$test = GetDate

[អារេ]System.Object[]

អារេដែលសន្ទស្សន៍ធាតុចាប់ផ្តើមនៅ 0

$test_array = 1, 2, "test", 3, 4

[hashtable] System.Collections.Hashtable

តារាង hash គឺ​ជា​អារេ​សហការ​ជាមួយ​នឹង​គ្រាប់ចុច​ដែល​បាន​ដាក់​ឈ្មោះ​តាម​គោលការណ៍៖ @{key = "value"}

$test_hashtable = @{one="one"; ពីរ = "ពីរ"; three="បី"}

PowerShell គាំទ្រការបំប្លែងប្រភេទអថេរ លើសពីនេះ ប្រភេទអថេរអាចត្រូវបានផ្លាស់ប្តូរភ្លាមៗ (ឧទាហរណ៍ ដោយប្រើប្រតិបត្តិករកិច្ចការ) ប្រសិនបើវាមិនបានបញ្ជាក់ដោយបង្ខំ - ក្នុងករណីនេះ អ្នកបកប្រែនឹងផ្តល់កំហុស។ អ្នកអាចកំណត់ប្រភេទនៃអថេរពីឧទាហរណ៍មុនដោយហៅវិធីសាស្ត្រ GetType()៖

$test.GetType().FullName

មាន cmdlets មួយចំនួនសម្រាប់រៀបចំអថេរ។ បញ្ជីរបស់ពួកគេក្នុងទម្រង់ងាយស្រួលត្រូវបានបង្ហាញដោយប្រើពាក្យបញ្ជា៖

Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap

ដើម្បីមើលអថេរដែលបានប្រកាស និងតម្លៃរបស់វា អ្នកអាចប្រើ cmdlet ពិសេស៖

Get-Variable | more

វិធីសាស្រ្តនេះហាក់បីដូចជាពិបាកខ្លាំងពេក វាងាយស្រួលជាងក្នុងការធ្វើការជាមួយអថេរតាមរយៈប្រតិបត្តិករ ឬដោយការចូលប្រើលក្ខណៈសម្បត្តិ និងវិធីសាស្ត្ររបស់ពួកគេដោយផ្ទាល់។ ទោះយ៉ាងណាក៏ដោយ cmdlets មានកន្លែងរបស់ពួកគេព្រោះវាអនុញ្ញាតឱ្យអ្នកកំណត់ប៉ារ៉ាម៉ែត្របន្ថែមមួយចំនួន។ វាជាការសំខាន់ណាស់ដែលត្រូវយល់ថាអថេរអ្នកប្រើប្រាស់ត្រូវបានកំណត់តែនៅក្នុងវគ្គបច្ចុប្បន្នប៉ុណ្ណោះ។ នៅពេលដែលកុងសូលត្រូវបានបិទ ឬស្គ្រីបបញ្ចប់ ពួកគេត្រូវបានលុប។

អថេរប្រព័ន្ធ

បន្ថែមពីលើអ្វីដែលបានប្រកាសដោយអ្នកប្រើប្រាស់ មានអថេរដែលភ្ជាប់មកជាមួយ (ប្រព័ន្ធ) ដែលមិនត្រូវបានលុបបន្ទាប់ពីវគ្គបច្ចុប្បន្នបញ្ចប់។ ពួកវាត្រូវបានបែងចែកជាពីរប្រភេទ ខណៈពេលដែលទិន្នន័យរដ្ឋ PowerShell ត្រូវបានរក្សាទុកក្នុងអថេរស្វ័យប្រវត្តិដែលមិនអាចកំណត់តម្លៃតាមអំពើចិត្តដោយខ្លួនឯងបានទេ។ ទាំងនេះរួមបញ្ចូលឧទាហរណ៍ $PWD៖

$PWD.Path

អថេរចំណូលចិត្តគឺត្រូវការដើម្បីរក្សាទុកចំណូលចិត្តរបស់អ្នកប្រើ តម្លៃដែលអាចផ្លាស់ប្តូរបាន។ ឧទាហរណ៍ ដោយប្រើ $ErrorActionPreference ប្រតិកម្មរបស់អ្នកបកប្រែពាក្យបញ្ជាចំពោះការកើតឡើងនៃកំហុសដែលមិនធ្ងន់ធ្ងរត្រូវបានកំណត់។

បន្ថែមពីលើប្រតិបត្តិករ និង cmdlets សម្រាប់ចូលប្រើអថេរដែលបានប្រកាស មាន Variable: pseudo-accumulator ។ អ្នកអាចធ្វើការជាមួយវាដោយការប្ៀបប្ដូចជាមួយដ្រាយផ្សេងទៀត ហើយអថេរក្នុងករណីនេះស្រដៀងនឹងវត្ថុប្រព័ន្ធឯកសារ៖

Get-ChildItem Variable: | more

ឬ

ls Variable: | more

វិសាលភាព

សម្រាប់អថេរនៅក្នុង PowerShell មានគោលគំនិតនៃវិសាលភាព (Scope)។ វិសាលភាពសកលអនុវត្តចំពោះវគ្គបច្ចុប្បន្នទាំងមូល - វារួមបញ្ចូលឧទាហរណ៍ អថេរប្រព័ន្ធ។ អថេរក្នុងស្រុកអាចប្រើបានតែក្នុងវិសាលភាពដែលពួកវាត្រូវបានកំណត់៖ និយាយ នៅខាងក្នុងអនុគមន៍។ វាក៏មានគោលគំនិតនៃវិសាលភាពស្គ្រីប (ស្គ្រីប) ប៉ុន្តែសម្រាប់ពាក្យបញ្ជាស្គ្រីប វាជាមូលដ្ឋានសំខាន់។ តាមលំនាំដើម នៅពេលប្រកាសអថេរ ពួកគេត្រូវបានផ្តល់វិសាលភាពមូលដ្ឋាន ហើយដើម្បីផ្លាស់ប្តូរវា អ្នកត្រូវការសំណង់ពិសេសដូចជា៖ $Global: variable = តម្លៃ។

ឧទាហរណ៍ដូចនេះ៖

$Global:test = 100

អថេរបរិស្ថាន (បរិស្ថាន)

pseudo-drive មួយផ្សេងទៀត Env: អាចរកបានពី PowerShell ហើយអាចត្រូវបានប្រើដើម្បីចូលប្រើអថេរបរិស្ថាន។ នៅពេលដែលសែលចាប់ផ្តើម ពួកគេត្រូវបានចម្លងពីដំណើរការមេ (នោះគឺពីកម្មវិធីដែលចាប់ផ្តើមវគ្គបច្ចុប្បន្ន) ហើយជាធម្មតាតម្លៃដំបូងរបស់ពួកគេគឺដូចគ្នាទៅនឹងតម្លៃនៅក្នុងផ្ទាំងបញ្ជា។ ដើម្បីមើលអថេរបរិស្ថាន សូមប្រើ Get-ChildItem cmdlet ឬឈ្មោះក្លែងក្លាយរបស់វា (ឈ្មោះក្លែងក្លាយ): ls និង dir ។

dir Env:

អថេរទាំងនេះគឺជាលំដាប់នៃបៃ (ឬតួអក្សរប្រសិនបើអ្នកចូលចិត្ត) ការបកស្រាយដែលអាស្រ័យលើកម្មវិធីដែលប្រើពួកវាប៉ុណ្ណោះ។ *-អថេរ cmdlets មិនដំណើរការជាមួយអថេរបរិស្ថានទេ។ ដើម្បីចូលប្រើពួកវា អ្នកត្រូវប្រើបុព្វបទ drive៖

$env:TEST = "Hello, World!"

នព្វន្ធ និងប្រតិបត្តិករប្រៀបធៀប

PowerShell មានប្រមាណវិធីនព្វន្ធដូចខាងក្រោម៖ + (បន្ថែម), - (ដក), * (គុណ), / (ចែក) និង % (ម៉ូឌុល ឬនៅសល់នៃការបែងចែក)។ លទ្ធផលនៃកន្សោមនព្វន្ធត្រូវបានវាយតម្លៃពីឆ្វេងទៅស្តាំយោងទៅតាមលំដាប់នៃប្រតិបត្តិការដែលទទួលយកជាទូទៅ ហើយវង់ក្រចកត្រូវបានប្រើដើម្បីដាក់ជាក្រុមផ្នែកនៃកន្សោម។ ចន្លោះរវាងប្រតិបត្តិករមិនត្រូវបានអើពើ ហើយត្រូវបានប្រើដើម្បីធ្វើឱ្យអ្វីៗកាន់តែងាយស្រួលអាន។ ប្រតិបត្តិករ + ក៏ភ្ជាប់គ្នាដែរ ហើយប្រតិបត្តិករ * ធ្វើខ្សែឡើងវិញ។ ប្រសិនបើអ្នកព្យាយាមបន្ថែមលេខទៅខ្សែអក្សរ វានឹងត្រូវបានបំប្លែងទៅជាខ្សែអក្សរ។ លើសពីនេះ PowerShell មានប្រតិបត្តិករប្រៀបធៀបជាច្រើនដែលប្រៀបធៀបតម្លៃពីរ ហើយត្រឡប់ Boolean True ឬ False៖

ប្រតិបត្តិករ

បរិយាយ

ឧទាហរណ៍កូដ

-eq

ស្មើ / ស្មើ (ស្រដៀងនឹង = ឬ == ជាភាសាផ្សេង)

$test = 100
$test -eq 123 

- នេ

មិនស្មើគ្នា / មិនស្មើគ្នា (ប្រៀបធៀបទៅនឹង <> ឬ !=)

$test = 100
$test -ne ១២៣   

-gt

ធំជាង / ច្រើនទៀត (អាណាឡូក>)

$test = 100
$test -gt ១២៣

-ហ្គេ

ធំជាង ឬស្មើ / ធំជាង ឬស្មើ (ស្រដៀងនឹង >=)

$test = 100
$test -ge 123

-lt

តិចជាង / តិច (ស្រដៀងនឹង <)

$test = 100
$test -lt ១២៣  

-លី

តិចជាង ឬស្មើ / តិចជាង ឬស្មើ (អាណាឡូក <=)

$test = 100
$test -le 123

មានសញ្ញាប្រមាណវិធីស្រដៀងគ្នាផ្សេងទៀតដែលអនុញ្ញាតឱ្យអ្នកឧទាហរណ៍ ប្រៀបធៀបខ្សែអក្សរដែលមានមូលដ្ឋានលើតួអក្សរជំនួស ឬប្រើកន្សោមធម្មតាដើម្បីផ្គូផ្គងលំនាំមួយ។ យើងនឹងរៀបរាប់លម្អិតនៅក្នុងអត្ថបទនាពេលខាងមុខ។ និមិត្តសញ្ញា <,> និង = មិនត្រូវបានប្រើសម្រាប់ការប្រៀបធៀបទេ ព្រោះវាត្រូវបានប្រើសម្រាប់គោលបំណងផ្សេងទៀត។

ប្រតិបត្តិករចាត់តាំង

បន្ថែមពីលើប្រតិបត្តិករ = ទូទៅបំផុត មានប្រតិបត្តិករចាត់តាំងផ្សេងទៀត៖ +=, -=, *=, /= និង %= ។ ពួកគេផ្លាស់ប្តូរតម្លៃមុនពេលធ្វើការ។ ប្រតិបត្តិករ unary ++ និង - ដែលបង្កើន ឬបន្ថយតម្លៃនៃអថេរ មានឥរិយាបថស្រដៀងគ្នា - ពួកគេក៏អនុវត្តចំពោះប្រតិបត្តិករចាត់តាំងផងដែរ។

ប្រតិបត្តិករឡូជីខល

ការប្រៀបធៀបតែមួយមុខមិនគ្រប់គ្រាន់ដើម្បីពិពណ៌នាអំពីលក្ខខណ្ឌស្មុគស្មាញនោះទេ។ អ្នកអាចសរសេរកន្សោមឡូជីខលដោយប្រើសញ្ញាប្រមាណវិធី៖ -and, -or, -xor, -not និង!.. ពួកវាដំណើរការដូចនៅក្នុងភាសាសរសេរកម្មវិធីផ្សេងទៀត ប៉ុន្តែអ្នកអាចប្រើវង់ក្រចកដើម្បីបញ្ជាក់លំដាប់នៃការគណនា៖

("Тест" -eq "Тест") -and (100 -eq 100)

-not (123 -gt 321) 

!(123 -gt 321)

លោតតាមលក្ខខណ្ឌ

ប្រតិបត្តិករសាខានៅក្នុង PowerShell គឺជាស្តង់ដារ៖ IF (IF...ELSE, IF...ELSEIF...ELSE) និង SWITCH ។ តោះមើលការប្រើប្រាស់របស់ពួកគេជាមួយឧទាហរណ៍៖

[int]$test = 100
if ($test -eq 100) {
      Write-Host "test = 100"
}



[int]$test = 50
if ($test -eq 100) {
       Write-Host "test = 100"
}
else {
      Write-Host "test <> 100"
}



[int]$test = 10
if ($test -eq 100) {
      Write-Host "test = 100"
}
elseif ($test -gt 100) {
      Write-Host "test > 100"
}
else {
       Write-Host "test < 100"
}



[int]$test = 5
switch ($test) {
     0 {Write-Host "test = 0"}
     1 {Write-Host "test = 1"}
     2 {Write-Host "test = 2"}
     3 {Write-Host "test = 3"}
     4 {Write-Host "test = 4"}
     5 {Write-Host "test = 5"}
     default {Write-Host "test > 5 или значение не определено"}
}

វដ្ត

PowerShell មានរង្វិលជុំជាច្រើនប្រភេទ៖ ខណៈពេល ធ្វើខណៈពេល ធ្វើរហូត ដល់ និង FOREACH ។

រង្វិលជុំដែលមានលក្ខខណ្ឌជាមុនដំណើរការប្រសិនបើ/ដរាបណាវាពិត៖

[int]$test = 0
while ($test -lt 10) {
      Write-Host $test
      $test = $test + 1
}

រង្វិលជុំដែលមានលក្ខខណ្ឌក្រោយនឹងដំណើរការយ៉ាងហោចណាស់ម្តង ពីព្រោះលក្ខខណ្ឌត្រូវបានពិនិត្យបន្ទាប់ពីការធ្វើម្តងទៀត។ ក្នុងពេលជាមួយគ្នានេះ DO WHILE ដំណើរការខណៈពេលដែលលក្ខខណ្ឌគឺពិត ហើយ DO រហូតដល់ដំណើរការខណៈពេលដែលវាមិនពិត៖

[int]$test = 0
do {
      Write-Host $test
      $test = $test + 1 
}
while ($test -lt 10)



[int]$test = 0
do {
      Write-Host $test
      $test = $test + 1 
}
until ($test -gt 9)

ចំនួននៃការធ្វើម្តងទៀតនៃរង្វិលជុំ FOR ត្រូវបានគេដឹងជាមុន:

for ([int]$test = 0; $test -lt 10; $test++) {
       Write-Host $test
}

នៅក្នុងរង្វិលជុំ FOREACH ធ្វើម្តងទៀតលើធាតុនៃអារេ ឬបណ្តុំ (តារាងហាស)៖

$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
        Write-Host $item
}

អារេ

អថេរ PowerShell រក្សាទុកមិនត្រឹមតែវត្ថុតែមួយ (លេខ ខ្សែអក្សរ។ល។) ប៉ុន្តែក៏មានវត្ថុជាច្រើនផងដែរ។ ប្រភេទដ៏សាមញ្ញបំផុតនៃអថេរបែបនេះគឺអារេ។ អារេអាចមានធាតុជាច្រើន ធាតុមួយ ឬទទេ ពោលគឺឧ។ មិនមានធាតុ។ វាត្រូវបានប្រកាសដោយប្រើប្រតិបត្តិករ @() ដែលយើងនឹងត្រូវការនៅក្នុងអត្ថបទបន្ទាប់ - វាមានសារៈសំខាន់ខ្លាំងណាស់សម្រាប់ការបន្ថែមអារេផ្សេងទៀតទៅអារេមួយ (បង្កើតអារេពហុវិមាត្រ) ការបញ្ជូនអារេទៅមុខងារជាអាគុយម៉ង់ និងកិច្ចការស្រដៀងគ្នា៖

$test_array = @() #создаем пустой массив

នៅពេលចាប់ផ្តើមអារេ តម្លៃរបស់វាត្រូវបានរាយដោយបំបែកដោយសញ្ញាក្បៀស (ប្រតិបត្តិករពិសេស ,):

$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов 

ក្នុងករណីភាគច្រើន ប្រតិបត្តិករ @() អាចត្រូវបានលុបចោល៖

$test_array = 1, 2, 3, 4

ក្នុងករណីនេះ អារេនៃធាតុមួយត្រូវបានចាប់ផ្តើមដូចខាងក្រោម

$test_array = , 1

ដើម្បីចូលប្រើធាតុអារេ សូមប្រើលិបិក្រមចំនួនគត់ដែលមានមូលដ្ឋានសូន្យ និងសញ្ញាប្រតិបត្តិការសន្ទស្សន៍ (តង្កៀបការ៉េ)៖

$test_array[0] = 1

អ្នកអាចបញ្ជាក់លិបិក្រមជាច្រើនដែលបំបែកដោយសញ្ញាក្បៀស រួមទាំង។ កើតឡើងវិញ៖

$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]

ប្រតិបត្តិករ .. (សញ្ញាចុចពីរ - ជួរប្រតិបត្តិករ) ត្រឡប់អារេនៃចំនួនគត់ក្នុងដែនកំណត់ខាងលើ និងខាងក្រោមដែលបានបញ្ជាក់។ ឧទាហរណ៍ កន្សោម 1..4 បញ្ចេញអារេនៃធាតុបួន @(1, 2, 3, 4) ហើយកន្សោម 8..5 បញ្ចេញអារេ @(8, 7, 6, 5)។

ដោយប្រើសញ្ញាប្រមាណវិធី អ្នកអាចចាប់ផ្តើមអារេមួយ ($test_array = 1..4) ឬទទួលបានចំណិត (ចំណិត) ឧ។ លំដាប់នៃធាតុពីអារេមួយជាមួយសន្ទស្សន៍ពីមួយទៀត។ ក្នុងករណីនេះលេខអវិជ្ជមាន -1 តំណាងឱ្យធាតុចុងក្រោយនៃអារេ -2 - លេខចុងក្រោយ។ល។

$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]

ចំណាំថាតម្លៃអារេចំនួនគត់អាចធំជាងតម្លៃសន្ទស្សន៍អតិបរមានៃអារេទិន្នន័យ។ ក្នុងករណីនេះ តម្លៃទាំងអស់ត្រូវបានត្រឡប់រហូតដល់តម្លៃចុងក្រោយ៖

$test_array[0..100]

ប្រសិនបើអ្នកព្យាយាមចូលប្រើធាតុអារេដែលមិនមានតែមួយ $null ត្រូវបានបញ្ជូនមកវិញ។

នៅក្នុង PowerShell អារេអាចមានធាតុនៃប្រភេទផ្សេងៗគ្នា ឬត្រូវបានវាយបញ្ចូលយ៉ាងខ្លាំង៖

$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
          Write-Host $test_array[$i]
}

ដែលទ្រព្យសម្បត្តិ $test_array.count គឺជាចំនួនធាតុអារេ។

ឧទាហរណ៍នៃការបង្កើតអារេវាយខ្លាំង៖

[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

តារាងហាស

ប្រភេទអថេរមូលដ្ឋានមួយទៀតនៅក្នុងភាសា PowerShell គឺជាតារាងសញ្ញា ដែលត្រូវបានគេស្គាល់ថាជាអារេពាក់ព័ន្ធ។ Hashtables គឺស្រដៀងទៅនឹងវត្ថុ JSON ហើយត្រូវបានបង្កើតឡើងនៅលើមូលដ្ឋានតម្លៃគន្លឹះ។ មិនដូចអារេធម្មតាទេ ធាតុរបស់ពួកវាត្រូវបានចូលប្រើដោយគ្រាប់ចុចដែលមានឈ្មោះ ដែលជាលក្ខណៈសម្បត្តិរបស់វត្ថុ (អ្នកក៏អាចប្រើលិបិក្រមប្រតិបត្តិករផងដែរ - តង្កៀបការ៉េ)។

តារាង hash ទទេត្រូវបានប្រកាសដោយប្រើសញ្ញា @ និងតង្កៀបប្រតិបត្តិករ៖

$test_hashtable = @{}

ពេល​ប្រកាស អ្នក​អាច​បង្កើត​គ្រាប់ចុច​ភ្លាមៗ ហើយ​កំណត់​តម្លៃ​ឱ្យ​ពួកគេ៖

$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}

ដើម្បីបន្ថែមធាតុមួយទៅក្នុងតារាង hash អ្នកត្រូវកំណត់វានូវសោដែលមិនទាន់មាន ឬប្រើវិធីសាស្ត្រ Add()។ ប្រសិនបើកិច្ចការមួយត្រូវបានធ្វើឡើងចំពោះសោដែលមានស្រាប់ តម្លៃរបស់វានឹងផ្លាស់ប្តូរ។ វិធីសាស្ត្រ Remove() ត្រូវបានប្រើដើម្បីលុបធាតុចេញពីតារាង hash ។

$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")

អថេរនៃប្រភេទនេះអាចត្រូវបានបញ្ជូនជាអាគុយម៉ង់ទៅមុខងារនិង cmdlets - នៅក្នុងអត្ថបទបន្ទាប់យើងនឹងសិក្សាពីរបៀបដែលវាត្រូវបានធ្វើហើយក៏មើលប្រភេទស្រដៀងគ្នាផ្សេងទៀតផងដែរ - PSCustomObject ។

អនុគមន៍

PowerShell មានអ្វីគ្រប់យ៉ាងដែលអ្នកត្រូវការសម្រាប់ការសរសេរកម្មវិធីតាមនីតិវិធី រួមទាំងមុខងារផងដែរ។ ដើម្បីពិពណ៌នាអំពីពួកវា ពាក្យសេវាកម្ម មុខងារត្រូវបានប្រើប្រាស់ បន្ទាប់ពីនោះអ្នកត្រូវបង្ហាញឈ្មោះមុខងារ និងតួដែលរុំព័ទ្ធក្នុងតង្កៀបប្រតិបត្តិករ។ ប្រសិនបើអ្នកត្រូវការបញ្ជូនអាគុយម៉ង់ទៅអនុគមន៍ ពួកវាអាចត្រូវបានបញ្ជាក់ភ្លាមៗបន្ទាប់ពីឈ្មោះក្នុងវង់ក្រចក។

function имя-функции (аргумент1, ..., аргументN) 
{ 
        тело-функции 
} 

មុខងារតែងតែត្រឡប់លទ្ធផល - វាគឺជាអារេនៃលទ្ធផលនៃសេចក្តីថ្លែងការណ៍របស់វាទាំងអស់ ប្រសិនបើមានច្រើនជាងមួយ។ ប្រសិនបើមានសេចក្តីថ្លែងការណ៍តែមួយ តម្លៃតែមួយគត់នៃប្រភេទដែលត្រូវគ្នាត្រូវបានត្រឡប់។ ត្រឡប់ $value construct បន្ថែមធាតុមួយដែលមានតម្លៃ $value ទៅអារេលទ្ធផល ហើយបោះបង់ការប្រតិបត្តិនៃបញ្ជីសេចក្តីថ្លែងការណ៍ ហើយមុខងារទទេនឹងត្រឡប់ $null ។

ឧទាហរណ៍ ចូរយើងបង្កើតអនុគមន៍មួយសម្រាប់បំបែកលេខ៖

function sqr ($number)
{
      return $number * $number
}

ចំណាំថានៅក្នុងតួនៃអនុគមន៍ អ្នកអាចប្រើអថេរណាមួយដែលបានប្រកាសមុនពេលហៅវា ហើយមុខងារហៅនៅក្នុង PowerShell ហាក់ដូចជាមិនធម្មតា៖ អាគុយម៉ង់ (ប្រសិនបើមាន) មិនត្រូវបានរុំព័ទ្ធក្នុងវង់ក្រចក ហើយត្រូវបានបំបែកដោយដកឃ្លា។

sqr 2

ឬដូច្នេះ:

sqr -number 2

ដោយសារ​វិធី​ដែល​អាគុយម៉ង់​ត្រូវ​បាន​ឆ្លង​កាត់ មុខងារ​ខ្លួន​វា​ជួនកាល​ត្រូវ​បាន​បញ្ចូល​ក្នុង​វង់ក្រចក៖

function test_func ($n) {}
test_func -eq $null     # функция не вызывалась
(test_func) -eq $null   # результат выражения — $true

នៅពេលពិពណ៌នាមុខងារ អ្នកអាចកំណត់តម្លៃលំនាំដើមទៅអាគុយម៉ង់៖

function func ($arg = value) {
         #тело функции
}

មានវាក្យសម្ព័ន្ធមួយផ្សេងទៀតសម្រាប់ការពិពណ៌នាអំពីអាគុយម៉ង់មុខងារ លើសពីនេះទៀតប៉ារ៉ាម៉ែត្រអាចត្រូវបានអានពីបំពង់ - ទាំងអស់នេះនឹងមានប្រយោជន៍នៅក្នុងអត្ថបទបន្ទាប់នៅពេលយើងមើលម៉ូឌុលដែលបាននាំចេញនិងបង្កើត cmdlets ផ្ទាល់ខ្លួនរបស់យើង។

ដំណើរការខុស

PowerShell មានយន្តការសាកល្បង...Catch...ចុងក្រោយដែលអនុញ្ញាតឱ្យអ្នកដោះស្រាយស្ថានភាពករណីលើកលែង។ ប្លុកសាកល្បងមានលេខកូដដែលកំហុសអាចកើតឡើង ហើយប្លុក Catch មានឧបករណ៍ដោះស្រាយរបស់វា។ ប្រសិនបើគ្មានកំហុសទេ វាមិនដំណើរការទេ។ ប្លុកចុងក្រោយត្រូវបានប្រតិបត្តិបន្ទាប់ពីប្លុកសាកល្បង ដោយមិនគិតពីថាតើមានកំហុសកើតឡើងទេ ហើយវាអាចមានប្លុក Catch ជាច្រើនសម្រាប់ប្រភេទផ្សេងគ្នានៃករណីលើកលែង។ ករណីលើកលែងខ្លួនវាត្រូវបានសរសេរទៅអថេរលំនាំដើមដែលមិនបានប្រកាស ($_) ហើយអាចទាញយកបានយ៉ាងងាយស្រួល។ ក្នុងឧទាហរណ៍ខាងក្រោម យើងអនុវត្តការការពារប្រឆាំងនឹងការបញ្ចូលតម្លៃមិនត្រឹមត្រូវ៖

try {

        [int]$test = Read-Host "Введите число"
        100 / $test

} catch {

         Write-Warning "Некорректное число"
         Write-Host $_

}

នេះបញ្ចប់ការពិនិត្យឡើងវិញនៃមូលដ្ឋាននៃការសរសេរកម្មវិធីនៅក្នុងភាសា PowerShell ។ នៅក្នុងអត្ថបទនាពេលអនាគត យើងនឹងពិនិត្យមើលកាន់តែដិតដល់ក្នុងការធ្វើការជាមួយអថេរនៃប្រភេទផ្សេងៗគ្នា ការប្រមូល កន្សោមធម្មតា ការបង្កើតមុខងារ ម៉ូឌុល និង cmdlets ផ្ទាល់ខ្លួនរបស់អ្នក ក៏ដូចជាការសរសេរកម្មវិធីតម្រង់ទិសវត្ថុផងដែរ។

ប្រភព: www.habr.com