🥇 Windows PowerShell ແມ່ນຫຍັງ ແລະມັນກິນກັບຫຍັງ? ພາກທີ 2: ການແນະນໍາພາສາການຂຽນໂປລແກລມ

ໃນປະຫວັດສາດ, ເຄື່ອງໃຊ້ຄໍາສັ່ງໃນລະບົບ Unix ແມ່ນພັດທະນາດີກວ່າໃນ Windows, ແຕ່ກັບການມາເຖິງຂອງການແກ້ໄຂໃຫມ່, ສະຖານະການໄດ້ປ່ຽນແປງ.

PowerShell ສາມາດຖືກຕີຄວາມໝາຍໃນພາສາທີ່ແປໄດ້ຫຼາຍຮູບຫຼາຍແບບທີ່ມີອົງປະກອບຂອງຂັ້ນຕອນແບບຄລາສສິກ, ຮັດກຸມວັດຖຸ, ແລະແມ້ກະທັ້ງການຂຽນໂປຼແກຼມທີ່ເຮັດວຽກໄດ້: ການແບ່ງຕາມເງື່ອນໄຂ, loops, variables, arrays, hash tables, classes, error handle, as well as functions, cmdlets, ແລະທໍ່. ບົດຄວາມທີ່ຜ່ານມາ ໄດ້ຖືກອຸທິດໃຫ້ແກ່ພື້ນຖານຂອງການເຮັດວຽກໃນສະພາບແວດລ້ອມ, ແລະໃນປັດຈຸບັນພວກເຮົາສະເຫນີໃຫ້ຜູ້ອ່ານຂອງພວກເຮົາເປັນປື້ມອ້າງອີງຂະຫນາດນ້ອຍສໍາລັບນັກຂຽນໂປລແກລມ.

ພາສາ:

Комментарии
ຕົວແປແລະປະເພດຂອງພວກເຂົາ
ຕົວແປຂອງລະບົບ
ຂອບເຂດ
ຕົວແປສະພາບແວດລ້ອມ (ສະພາບແວດລ້ອມ)
ຕົວປະຕິບັດການເລກຄະນິດສາດແລະການປຽບທຽບ
ຜູ້ປະຕິບັດການມອບຫມາຍ
ຕົວ ດຳ ເນີນເຫດຜົນ
ໂດດຕາມເງື່ອນໄຂ
ຮອບວຽນ
Arrays
ຕາຕະລາງ Hash
ຟັງຊັນ
ການປະມວນຜົນຜິດພາດ

ທ່ານສາມາດຂຽນລະຫັດໃນບັນນາທິການຂໍ້ຄວາມໃດຫນຶ່ງຫຼືການນໍາໃຊ້ສະພາບແວດລ້ອມການພັດທະນາປະສົມປະສານ - ວິທີທີ່ງ່າຍທີ່ສຸດແມ່ນການໃຊ້ Windows PowerShell ISE ທີ່ມາພ້ອມກັບລະບົບປະຕິບັດການເຊີບເວີ Microsoft. ນີ້ແມ່ນມີຄວາມຈໍາເປັນພຽງແຕ່ສໍາລັບສະຄິບທີ່ສັບສົນພໍສົມຄວນ: ຊຸດຄໍາສັ່ງສັ້ນແມ່ນງ່າຍຕໍ່ການປະຕິບັດການໂຕ້ຕອບ.

ການນໍາໃຊ້ຄໍາຄິດຄໍາເຫັນແມ່ນຖືວ່າເປັນສ່ວນຫນຶ່ງຂອງຮູບແບບການຂຽນໂປຼແກຼມທີ່ດີພ້ອມກັບການຫຍໍ້ຫນ້າທີ່ເຫມາະສົມແລະຊ່ອງຫວ່າງ:

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

<# 

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

#>

ຕົວແປແລະປະເພດຂອງພວກເຂົາ

ຕົວແປໃນ PowerShell ແມ່ນຊື່ວັດຖຸ. ຊື່ຂອງພວກມັນສາມາດປະກອບມີຕົວອັກສອນຂີດກ້ອງ, ເຊັ່ນດຽວກັນກັບຕົວອັກສອນ ແລະຕົວເລກ. ສັນຍາລັກ $ ຖືກໃຊ້ກ່ອນຊື່, ແລະເພື່ອປະກາດຕົວແປ, ມັນພຽງພໍທີ່ຈະໃຫ້ນາຍແປພາສາຊື່ທີ່ຖືກຕ້ອງ:

ເພື່ອເລີ່ມຕົ້ນຕົວແປ (ມອບຄ່າໃຫ້ມັນ), ຕົວປະຕິບັດການມອບຫມາຍ (ສັນຍາລັກ =) ຖືກນໍາໃຊ້:

$test = 100

ທ່ານສາມາດປະກາດຕົວປ່ຽນໂດຍການລະບຸປະເພດຂອງຕົນໃນວົງເລັບສີ່ຫຼ່ຽມ (ຕົວປະຕິບັດການການພິມ) ກ່ອນຊື່ຫຼືຄ່າ:

[int]$test = 100

$test = [int]100

ມັນເປັນສິ່ງ ສຳ ຄັນທີ່ຈະເຂົ້າໃຈວ່າຕົວແປໃນ PowerShell ແມ່ນວັດຖຸເຕັມຮູບແບບ (ຊັ້ນຮຽນ) ທີ່ມີຄຸນສົມບັດແລະວິທີການທີ່ປະເພດແມ່ນອີງໃສ່ສິ່ງທີ່ຢູ່ໃນ .NET Core. ພວກເຮົາບອກລາຍຊື່ຕົ້ນຕໍ:

ປະເພດ (.NET class)

ລາຍລະອຽດ

ຕົວຢ່າງລະຫັດ

[string] System.String

ສະຕຣິງ Unicode

$test = "ທົດສອບ"
$test = 'ທົດສອບ'

[char] System.Char

ຕົວອັກສອນ Unicode (16 bits)

[char]$test = 'ຄ'

[bool] System.Boolean

ປະເພດ boolean (boolean ຖືກ ຫຼືຜິດ)

[bool]$test = $true

[int] System.Int32

ຈຳນວນເຕັມສາມສິບສອງບິດ (32 ບິດ)

[int]$test = 123456789

[long] System.Int64

ຈໍານວນຫົກສິບສີ່ບິດ (64 ບິດ)

[long]$test = 12345678910

[single] System.Single

ຕົວເລກຈຸດລອຍຕົວຍາວ 32 ບິດ

[ດຽວ]$test = 12345.6789

[double] System.Double

ຈໍານວນຈຸດລອຍຂອງຄວາມຍາວ 64 ບິດ (8 bytes)

[double]$test = 123456789.101112

[decimal] System.Decimal

ຕົວເລກຈຸດລອຍ 128-ບິດ (ຕ້ອງການລົງທ້າຍດ້ວຍ d)

[decimal]$test = 12345.6789d

[DateTime] System.DateTime

ວັນທີແລະເວລາ

$test = GetDate

[array] System.Object[]

array ທີ່ດັດຊະນີອົງປະກອບເລີ່ມຕົ້ນທີ່ 0

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

[hashtable] System.Collections.Hashtable

ຕາຕະລາງ hash ແມ່ນ array ສະມາຄົມທີ່ມີລະຫັດທີ່ມີຊື່, ສ້າງຂຶ້ນຕາມຫຼັກການ: @{key = "value"}

$test_hashtable = @{one="one"; two="ສອງ"; ສາມ="ສາມ"}

PowerShell ສະຫນັບສະຫນູນການແປງປະເພດ implicit, ນອກຈາກນັ້ນ, ປະເພດຂອງຕົວແປສາມາດປ່ຽນແປງໄດ້ທັນທີ (ຕົວຢ່າງເຊັ່ນ, ການນໍາໃຊ້ຕົວປະຕິບັດການມອບຫມາຍ), ຖ້າມັນບໍ່ຖືກກໍານົດໂດຍບັງຄັບ - ໃນກໍລະນີນີ້, ນາຍພາສາຈະໃຫ້ຄວາມຜິດພາດ. ທ່ານສາມາດກໍານົດປະເພດຂອງຕົວແປຈາກຕົວຢ່າງທີ່ຜ່ານມາໂດຍການໂທຫາວິທີການ GetType():

$test.GetType().FullName

ມີຈໍານວນ cmdlets ສໍາລັບການຈັດການຕົວແປ. ບັນຊີລາຍຊື່ຂອງພວກເຂົາໃນຮູບແບບທີ່ສະດວກແມ່ນສະແດງໂດຍໃຊ້ຄໍາສັ່ງ:

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

ເພື່ອເບິ່ງຕົວແປທີ່ປະກາດແລະຄ່າຂອງພວກມັນ, ທ່ານສາມາດນໍາໃຊ້ cmdlet ພິເສດ:

Get-Variable | more

ວິທີການນີ້ເບິ່ງຄືວ່າຫຍຸ້ງຍາກເກີນໄປ, ມັນສະດວກກວ່າທີ່ຈະເຮັດວຽກກັບຕົວແປໂດຍຜ່ານຜູ້ປະກອບການຫຼືໂດຍການເຂົ້າເຖິງຄຸນສົມບັດແລະວິທີການຂອງພວກເຂົາໂດຍກົງ. ຢ່າງໃດກໍຕາມ, cmdlets ມີສິດທີ່ຈະມີຢູ່ເພາະວ່າພວກເຂົາອະນຸຍາດໃຫ້ທ່ານຕັ້ງບາງຕົວກໍານົດການເພີ່ມເຕີມ. ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະເຂົ້າໃຈວ່າຕົວແປຂອງຜູ້ໃຊ້ຖືກກໍານົດພຽງແຕ່ພາຍໃນກອງປະຊຸມປະຈຸບັນ. ເມື່ອ console ປິດຫຼືສະຄິບສິ້ນສຸດລົງ, ພວກມັນຈະຖືກລຶບຖິ້ມ.

ຕົວແປຂອງລະບົບ

ນອກເຫນືອຈາກຜູ້ທີ່ປະກາດໂດຍຜູ້ໃຊ້, ມີຕົວແປທີ່ສ້າງຂຶ້ນໃນ (ລະບົບ) ທີ່ບໍ່ໄດ້ຖືກລຶບລ້າງຫຼັງຈາກກອງປະຊຸມປະຈຸບັນສິ້ນສຸດລົງ. ພວກມັນແບ່ງອອກເປັນສອງປະເພດ, ໃນຂະນະທີ່ຂໍ້ມູນລັດ PowerShell ຖືກເກັບໄວ້ໃນຕົວແປອັດຕະໂນມັດທີ່ບໍ່ສາມາດກໍານົດຄ່າທີ່ຕົນເອງມັກໄດ້. ເຫຼົ່ານີ້ລວມມີ, ສໍາລັບການຍົກຕົວຢ່າງ, $PWD:

$PWD.Path

ຕົວແປຄວາມມັກແມ່ນຈໍາເປັນເພື່ອເກັບຮັກສາຄວາມມັກຂອງຜູ້ໃຊ້, ມູນຄ່າທີ່ສາມາດປ່ຽນແປງໄດ້. ຕົວຢ່າງເຊັ່ນ, ການນໍາໃຊ້ $ErrorActionPreference , ປະຕິກິລິຍາຂອງນາຍພາສາຄໍາສັ່ງຕໍ່ກັບການປະກົດຕົວຂອງຄວາມຜິດພາດທີ່ບໍ່ເປັນອັນຕະລາຍແມ່ນຖືກກໍານົດ.

ນອກເຫນືອຈາກຕົວປະຕິບັດການແລະ cmdlets ສໍາລັບການເຂົ້າເຖິງຕົວແປທີ່ປະກາດ, ມີຕົວແປ: pseudo-accumulator. ທ່ານສາມາດເຮັດວຽກກັບມັນໄດ້ໂດຍການປຽບທຽບກັບໄດອື່ນໆ, ແລະຕົວແປໃນກໍລະນີນີ້ຄ້າຍຄືກັບວັດຖຸລະບົບໄຟລ໌:

Get-ChildItem Variable: | more

ຫຼື

ls Variable: | more

ຂອບເຂດ

ສໍາລັບຕົວແປໃນ PowerShell, ມີແນວຄວາມຄິດຂອງຂອບເຂດ (Scope). ການປະຕິບັດຂອງຂອບເຂດທົ່ວໂລກ (Global) ນໍາໃຊ້ກັບກອງປະຊຸມປະຈຸບັນທັງຫມົດ - ມັນປະກອບມີ, ຕົວຢ່າງ, ຕົວແປຂອງລະບົບ. ຕົວແປທ້ອງຖິ່ນ (Local) ແມ່ນມີຢູ່ໃນຂອບເຂດທີ່ພວກມັນຖືກກໍານົດເທົ່ານັ້ນ: ເວົ້າພາຍໃນຟັງຊັນ. ຍັງມີແນວຄວາມຄິດຂອງຂອບເຂດຂອງ script (Script), ແຕ່ສໍາລັບຄໍາສັ່ງ script, ມັນເປັນສິ່ງຈໍາເປັນໃນທ້ອງຖິ່ນ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ເມື່ອປະກາດຕົວແປ, ພວກມັນໄດ້ຮັບຂອບເຂດທ້ອງຖິ່ນ, ແລະເພື່ອປ່ຽນແປງມັນ, ທ່ານຕ້ອງການໂຄງສ້າງພິເສດເຊັ່ນ: $Global: variable = value.

ຕົວຢ່າງເຊັ່ນນີ້:

$Global:test = 100

ຕົວແປສະພາບແວດລ້ອມ (ສະພາບແວດລ້ອມ)

pseudo-drive ອື່ນ, Env:, ມີໃຫ້ຈາກ PowerShell ແລະສາມາດໃຊ້ເພື່ອເຂົ້າເຖິງຕົວແປສະພາບແວດລ້ອມ. ເມື່ອແກະເລີ່ມຕົ້ນ, ພວກມັນຖືກຄັດລອກຈາກຂະບວນການແມ່ (ນັ້ນແມ່ນ, ຈາກໂຄງການທີ່ເລີ່ມຕົ້ນກອງປະຊຸມໃນປະຈຸບັນ) ແລະປົກກະຕິແລ້ວຄ່າເບື້ອງຕົ້ນຂອງພວກເຂົາແມ່ນຄືກັນກັບຄ່າໃນແຜງຄວບຄຸມ. ເພື່ອເບິ່ງຕົວແປສະພາບແວດລ້ອມ, ໃຊ້ Get-ChildItem cmdlet ຫຼືນາມແຝງຂອງມັນ (ນາມແຝງ): ls ແລະ dir.

dir Env:

ຕົວແປເຫຼົ່ານີ້ແມ່ນລໍາດັບຂອງ bytes (ຫຼືຕົວອັກສອນ, ຖ້າທ່ານຕ້ອງການ), ການຕີຄວາມຫມາຍທີ່ຂຶ້ນກັບໂຄງການທີ່ໃຊ້ພວກມັນເທົ່ານັ້ນ. *-variable cmdlets ບໍ່ເຮັດວຽກກັບຕົວແປສະພາບແວດລ້ອມ. ເພື່ອເຂົ້າເຖິງພວກມັນ, ທ່ານຕ້ອງໃຊ້ຄໍານໍາຫນ້າຂອງ drive:

$env:TEST = "Hello, World!"

ຕົວປະຕິບັດການເລກຄະນິດສາດແລະການປຽບທຽບ

PowerShell ໃຫ້ຕົວປະຕິບັດເລກຄະນິດດັ່ງຕໍ່ໄປນີ້: + (ການເພີ່ມ), - (ການລົບ), * (ຄູນ), / (ການຫານ), ແລະ % (ໂມດູໂລ ຫຼື ໂມດູໂລ). ຜົນໄດ້ຮັບຂອງການສະແດງອອກທາງເລກຄະນິດໄດ້ຖືກປະເມີນຈາກຊ້າຍໄປຂວາຕາມລໍາດັບການດໍາເນີນງານທີ່ຍອມຮັບໂດຍທົ່ວໄປ, ແລະວົງເລັບຖືກໃຊ້ເພື່ອຈັດກຸ່ມສ່ວນຂອງການສະແດງຜົນ. ຊ່ອງຫວ່າງລະຫວ່າງຕົວປະຕິບັດການຖືກລະເວັ້ນ, ພວກມັນຖືກນໍາໃຊ້ເພື່ອຄວາມສະດວກໃນຄວາມເຂົ້າໃຈເທົ່ານັ້ນ. ຕົວປະຕິບັດການ + ຍັງ concatenates, ແລະຕົວປະຕິບັດການ * repeats strings. ຖ້າທ່ານພະຍາຍາມເພີ່ມຕົວເລກໃສ່ສະຕຣິງ, ມັນຈະປ່ຽນເປັນສະຕຣິງ. ນອກຈາກນັ້ນ, ມີຫຼາຍຕົວປະຕິບັດການປຽບທຽບໃນ PowerShell ທີ່ທົດສອບການຈັບຄູ່ລະຫວ່າງສອງຄ່າ ແລະສົ່ງຄ່າ boolean True ຫຼື False:

ຜູ້ປະຕິບັດງານ

ລາຍລະອຽດ

ຕົວຢ່າງລະຫັດ

-eq

ເທົ່າກັນ / ເທົ່າກັນ (ຄ້າຍກັບ = ຫຼື == ໃນພາສາອື່ນ)

$test = 100
$test -eq 123

- ບໍ່

ບໍ່ເທົ່າກັນ / ບໍ່ເທົ່າກັນ (ຄ້າຍກັບ <> ຫຼື !=)

$test = 100
$test -ne 123

-gt

ຫຼາຍກວ່າ / ຫຼາຍ (ອະນາລັອກ >)

$test = 100
$test -gt 123

-ຈີ

ໃຫຍ່ກວ່າ ຫຼື ເທົ່າກັນ / ໃຫຍ່ກວ່າ ຫຼື ເທົ່າກັນ (ຄ້າຍກັບ >=)

$test = 100
$test -ge 123

-lt

ຫນ້ອຍກວ່າ / ຫນ້ອຍ (ຄ້າຍກັບ <)

$test = 100
$test -lt 123

-ການ

ໜ້ອຍກວ່າ ຫຼື ເທົ່າກັນ / ໜ້ອຍກວ່າ ຫຼື ເທົ່າກັນ (ຄ້າຍກັບ <=)

$test = 100
$test -le 123

ມີຕົວປະຕິບັດການທີ່ຄ້າຍຄືກັນອື່ນໆທີ່ອະນຸຍາດໃຫ້ທ່ານ, ຕົວຢ່າງ, ປຽບທຽບສະຕຣິງໂດຍອີງໃສ່ wildcard ຫຼືໃຊ້ການສະແດງອອກປົກກະຕິເພື່ອຈັບຄູ່ຮູບແບບ. ພວກເຮົາຈະກວມເອົາພວກເຂົາຢ່າງລະອຽດໃນບົດຄວາມໃນອະນາຄົດ. ສັນຍາລັກ <, > ແລະ = ບໍ່ໄດ້ໃຊ້ສໍາລັບການປຽບທຽບ ເພາະວ່າພວກມັນຖືກໃຊ້ເພື່ອຈຸດປະສົງອື່ນ.

ຜູ້ປະຕິບັດການມອບຫມາຍ

ນອກເຫນືອໄປຈາກຕົວປະຕິບັດການ = ທົ່ວໄປທີ່ສຸດ, ຍັງມີຕົວປະຕິບັດການມອບຫມາຍອື່ນໆ: +=, -=, *=, /= ແລະ %=. ພວກເຂົາປ່ຽນມູນຄ່າກ່ອນການມອບຫມາຍ. ຕົວປະຕິບັດການ unary ++ ແລະ -, ເຊິ່ງເພີ່ມຫຼືຫຼຸດລົງມູນຄ່າຂອງຕົວແປ, ປະຕິບັດຕົວຄ້າຍຄືກັນ - ພວກເຂົາຍັງໃຊ້ກັບຜູ້ປະຕິບັດການມອບຫມາຍ.

ຕົວ ດຳ ເນີນເຫດຜົນ

ການປຽບທຽບຢ່າງດຽວແມ່ນບໍ່ພຽງພໍທີ່ຈະອະທິບາຍເງື່ອນໄຂທີ່ສັບສົນ. ທ່ານສາມາດຂຽນການສະແດງອອກຢ່າງມີເຫດຜົນໂດຍໃຊ້ຕົວປະຕິບັດການ: -and, -or, -xor, -not and!.. ພວກມັນເຮັດວຽກຄືກັບພາສາການຂຽນໂປລແກລມອື່ນ, ໃນຂະນະທີ່ທ່ານສາມາດນໍາໃຊ້ວົງເລັບເພື່ອກໍານົດຄໍາສັ່ງຂອງການປະເມີນຜົນ:

("Тест" -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 ມີຫຼາຍຊະນິດຂອງ loops: WHILE, DO WHILE, DO UNTIL, FOR, ແລະ FOREACH.

loop ທີ່ມີ precondition ເຮັດວຽກຖ້າ / ຕາບໃດທີ່ມັນເປັນຄວາມຈິງ:

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

Loops ກັບ postcondition ຈະດໍາເນີນການຢ່າງຫນ້ອຍຫນຶ່ງຄັ້ງ, ເນື່ອງຈາກວ່າເງື່ອນໄຂໄດ້ຖືກກວດສອບຫຼັງຈາກ iteration. ໃນເວລາດຽວກັນ, 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 loop ແມ່ນຮູ້ລ່ວງຫນ້າ:

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

ໃນວົງ FOREACH, ຊ້ຳກັບອົງປະກອບຂອງ array ຫຼື collection (hash table):

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

Arrays

ຕົວແປ PowerShell ບໍ່ພຽງແຕ່ເກັບຮັກສາວັດຖຸດຽວ (ຈໍານວນ, ສະຕຣິງ, ແລະອື່ນໆ), ແຕ່ຍັງຫຼາຍອັນ. ປະເພດທີ່ງ່າຍດາຍທີ່ສຸດຂອງຕົວແປດັ່ງກ່າວແມ່ນ arrays. array ສາມາດປະກອບດ້ວຍຫຼາຍອົງປະກອບ, ອົງປະກອບຫນຶ່ງ, ຫຼືຫວ່າງເປົ່າ, i.e. ບໍ່ມີອົງປະກອບ. ມັນໄດ້ຖືກປະກາດໂດຍໃຊ້ຕົວປະຕິບັດການ @() ທີ່ພວກເຮົາຈະຕ້ອງການໃນບົດຄວາມຕໍ່ໄປ - ມັນເປັນສິ່ງສໍາຄັນຫຼາຍສໍາລັບການເພີ່ມ array ອື່ນໃສ່ array (ການສ້າງ array multidimensional), ການຖ່າຍທອດ arrays ເພື່ອປະຕິບັດຫນ້າທີ່ເປັນ argument, ແລະວຽກງານທີ່ຄ້າຍຄືກັນ:

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

ເມື່ອ array ຖືກເລີ່ມຕົ້ນ, ຄ່າຂອງມັນຖືກຈັດໃສ່ໂດຍເຄື່ອງໝາຍຈຸດ (ຕົວປະຕິບັດການພິເສດ ,):

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

ໃນກໍລະນີຫຼາຍທີ່ສຸດ, ຕົວປະຕິບັດການ @() ສາມາດຖືກລະເວັ້ນ:

$test_array = 1, 2, 3, 4

ໃນກໍລະນີນີ້, array ຂອງອົງປະກອບຫນຶ່ງແມ່ນເລີ່ມຕົ້ນດັ່ງຕໍ່ໄປນີ້

$test_array = , 1

ອົງປະກອບອາເຣຖືກເຂົ້າເຖິງໂດຍໃຊ້ດັດຊະນີຈຳນວນເຕັມທີ່ອີງໃສ່ສູນ ແລະຕົວປະຕິບັດການດັດສະນີ (ວົງເລັບສີ່ຫຼ່ຽມ):

$test_array[0] = 1

ທ່ານສາມາດລະບຸດັດຊະນີຈໍານວນຫນຶ່ງແຍກອອກໂດຍເຄື່ອງຫມາຍຈຸດ, ລວມ. ເກີດຂຶ້ນຊ້ຳ:

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

ຜູ້ປະຕິບັດງານ .. (ສອງຈຸດ - range operator) ສົ່ງຄືນ array ຂອງຈຳນວນເຕັມພາຍໃນຂອບເຂດທີ່ລະບຸໄວ້ເທິງ ແລະລຸ່ມ. ຕົວຢ່າງ, expression 1..4 outputs an array of four elements @(1, 2, 3, 4), and expression 8..5 outputs an array @(8, 7, 6, 5).

ການນໍາໃຊ້ range operator, ທ່ານສາມາດເລີ່ມຕົ້ນ array ($test_array = 1..4) ຫຼືໄດ້ຮັບ slice (slice), i.e. ລໍາດັບຂອງອົງປະກອບຈາກ array ຫນຶ່ງທີ່ມີດັດຊະນີຈາກອື່ນ. ໃນກໍລະນີນີ້, ຕົວເລກລົບ -1 ສະແດງເຖິງອົງປະກອບສຸດທ້າຍຂອງອາເຣ, -2 - ອັນສຸດທ້າຍ, ແລະອື່ນໆ.

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

ໃຫ້ສັງເກດວ່າຄ່າ integer array ສາມາດໃຫຍ່ກວ່າຄ່າດັດຊະນີສູງສຸດຂອງ array ຂໍ້ມູນ. ໃນກໍລະນີນີ້, ຄ່າທັງຫມົດຈະຖືກສົ່ງຄືນເຖິງອັນສຸດທ້າຍ:

$test_array[0..100]

ຖ້າທ່ານພະຍາຍາມເຂົ້າເຖິງອົງປະກອບ array ທີ່ບໍ່ມີຢູ່ອັນດຽວ, $null ຈະຖືກສົ່ງຄືນ.

ໃນ PowerShell, arrays ສາມາດປະກອບມີອົງປະກອບຂອງປະເພດຕ່າງໆຫຼືຖືກພິມຢ່າງແຂງແຮງ:

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

ບ່ອນທີ່ຄຸນສົມບັດ $test_array.count ແມ່ນຈຳນວນຂອງອົງປະກອບອາເຣ.

ຕົວຢ່າງຂອງການສ້າງ array ທີ່ພິມຢ່າງແຂງແຮງ:

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

ຕາຕະລາງ Hash

ປະເພດພື້ນຖານອື່ນຂອງຕົວແປໃນພາສາ PowerShell ແມ່ນຕາຕະລາງ hash, ເຊິ່ງເອີ້ນກັນວ່າ associative arrays. Hashtables ແມ່ນຄ້າຍຄືກັນກັບວັດຖຸ JSON ແລະຖືກສ້າງຂຶ້ນບົນພື້ນຖານທີ່ສໍາຄັນມູນຄ່າ. ບໍ່ເຫມືອນກັບ arrays ທໍາມະດາ, ອົງປະກອບຂອງພວກມັນຖືກເຂົ້າເຖິງໂດຍປຸ່ມທີ່ມີຊື່, ເຊິ່ງເປັນຄຸນສົມບັດຂອງວັດຖຸ (ທ່ານຍັງສາມາດໃຊ້ຕົວປະຕິບັດການດັດສະນີ - ວົງເລັບສີ່ຫຼ່ຽມ).

ຕາຕະລາງ 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 ຖືກນໍາໃຊ້, ຫຼັງຈາກນັ້ນທ່ານຈໍາເປັນຕ້ອງລະບຸຊື່ຂອງຫນ້າທີ່ແລະຮ່າງກາຍທີ່ຕິດກັບວົງເລັບປະຕິບັດການ. ຖ້າທ່ານຕ້ອງການສົ່ງ arguments ໄປຫາຟັງຊັນ, ທ່ານສາມາດກໍານົດພວກມັນທັນທີຫຼັງຈາກຊື່ໃນວົງເລັບ.

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

ຟັງຊັນຈະສົ່ງຜົນໄດ້ຮັບສະເຫມີ - ມັນເປັນ array ຂອງຜົນໄດ້ຮັບຂອງຄໍາຖະແຫຼງການທັງຫມົດຂອງມັນ, ຖ້າມີຫຼາຍກວ່າຫນຶ່ງ. ຖ້າມີພຽງແຕ່ຄໍາຖະແຫຼງທີ່, ຄ່າດຽວຂອງປະເພດທີ່ສອດຄ້ອງກັນຈະຖືກສົ່ງຄືນ. ຜົນຕອບແທນ $value construct ເພີ່ມອົງປະກອບທີ່ມີຄ່າ $value ໃຫ້ກັບ array ຜົນໄດ້ຮັບ ແລະຍົກເລີກການປະຕິບັດລາຍການຄໍາຖະແຫຼງການ, ແລະຟັງຊັນຫວ່າງເປົ່າຈະສົ່ງຄືນ $null.

ຕົວຢ່າງ, ໃຫ້ພວກເຮົາສ້າງຟັງຊັນສໍາລັບການ squaring ຕົວເລກ:

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

ເມື່ອອະທິບາຍຟັງຊັນໃດໜຶ່ງ, ທ່ານສາມາດກຳນົດຄ່າເລີ່ມຕົ້ນໃຫ້ກັບ arguments:

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

ມີ syntax ອື່ນສໍາລັບການອະທິບາຍການໂຕ້ຖຽງຂອງຫນ້າທີ່, ນອກຈາກນັ້ນ, ພາລາມິເຕີສາມາດອ່ານໄດ້ຈາກທໍ່ - ທັງຫມົດນີ້ຈະເປັນປະໂຫຍດໃນບົດຄວາມຕໍ່ໄປ, ເມື່ອພວກເຮົາເບິ່ງໂມດູນທີ່ສົ່ງອອກແລະສ້າງ cmdlets ຂອງພວກເຮົາເອງ.

ການປະມວນຜົນຜິດພາດ

PowerShell ມີ Try...Catch...ສຸດທ້າຍແມ່ນກົນໄກເພື່ອຈັດການກັບຂໍ້ຍົກເວັ້ນ. ບລັອກລອງມີລະຫັດທີ່ອາດເກີດຄວາມຜິດພາດຂຶ້ນ, ແລະບລັອກ Catch ມີຕົວຈັດການຂອງມັນ. ຖ້າບໍ່ມີຂໍ້ຜິດພາດ, ມັນຈະບໍ່ຖືກປະຕິບັດ. ບລັອກສຸດທ້າຍຖືກປະຕິບັດຫຼັງຈາກລອງບລັອກ, ໂດຍບໍ່ຄໍານຶງເຖິງການເກີດຂື້ນຂອງຄວາມຜິດພາດ, ແລະສາມາດມີຫຼາຍຕັນ Catch ສໍາລັບປະເພດທີ່ແຕກຕ່າງກັນຂອງຂໍ້ຍົກເວັ້ນ. ຂໍ້ຍົກເວັ້ນຕົວມັນເອງຖືກຂຽນໃສ່ຕົວແປເລີ່ມຕົ້ນທີ່ບໍ່ໄດ້ປະກາດ ($_) ແລະສາມາດດຶງຂໍ້ມູນໄດ້ງ່າຍ. ໃນຕົວຢ່າງຂ້າງລຸ່ມນີ້, ພວກເຮົາປະຕິບັດການປ້ອງກັນການໃສ່ຄ່າທີ່ບໍ່ຖືກຕ້ອງ:

try {

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

} catch {

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

}

ນີ້ສະຫຼຸບການທົບທວນພື້ນຖານຂອງການຂຽນໂປລແກລມໃນພາສາ PowerShell. ໃນບົດຄວາມຕໍ່ໄປນີ້, ພວກເຮົາຈະສຶກສາລາຍລະອຽດເພີ່ມເຕີມທີ່ເຮັດວຽກກັບຕົວແປຂອງປະເພດຕ່າງໆ, ການລວບລວມ, ການສະແດງອອກປົກກະຕິ, ການສ້າງຫນ້າທີ່, ໂມດູນແລະ cmdlets ທີ່ກໍາຫນົດເອງ, ເຊັ່ນດຽວກັນກັບການຂຽນໂປລແກລມແບບວັດຖຸ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com

Windows PowerShell ແມ່ນຫຍັງ ແລະມັນກິນກັບຫຍັງ? ພາກທີ 2: ການແນະນໍາພາສາການຂຽນໂປລແກລມ