🥇Ano ang Windows PowerShell at saan ito kinakain? Bahagi 2: Panimula sa programming language

Sa kasaysayan, ang mga command-line utilities sa Unix system ay mas mahusay na binuo kaysa sa Windows, ngunit sa pagdating ng isang bagong solusyon, ang sitwasyon ay nagbago.

Maaaring i-script ang PowerShell sa isang binibigyang kahulugan, multi-paradigm na wika na may mga elemento ng klasikong procedural, object-oriented, at maging functional programming: conditional branching, loops, variables, arrays, hash tables, classes, error handling, pati na rin ang mga function, cmdlet, at pipelines . Nakaraang artikulo ay nakatuon sa mga pangunahing kaalaman sa pagtatrabaho sa kapaligiran, at ngayon ay nag-aalok kami sa aming mga mambabasa ng isang maliit na reference na libro para sa mga programmer.

Talaan ng nilalaman:

Comments
Mga variable at kanilang mga uri
Mga variable ng system
Saklaw
Mga variable ng kapaligiran (environment)
Mga operator ng aritmetika at paghahambing
Mga operator ng assignment
Mga lohikal na operator
Kondisyonal na Paglukso
Mga cycle
Mga Arrays
Hash table
Pag-andar
Error sa pagproseso

Maaari kang magsulat ng code sa anumang text editor o gamit ang pinagsama-samang development environment - ang pinakamadaling paraan ay kunin ang Windows PowerShell ISE na kasama ng mga operating system ng Microsoft server. Ito ay kinakailangan lamang para sa medyo kumplikadong mga script: ang maikling hanay ng mga utos ay mas madaling isagawa nang interactive.

Comments

Ang paggamit ng mga komento ay itinuturing na bahagi ng magandang istilo ng programming kasama ng wastong indentation at whitespace:

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

<# 

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

#>

Mga variable at kanilang mga uri

Ang mga variable sa PowerShell ay pinangalanang object. Maaaring kabilang sa kanilang mga pangalan ang underscore na character, pati na rin ang mga titik at numero. Ang simbolo ng $ ay palaging ginagamit bago ang pangalan, at upang magdeklara ng isang variable, sapat na upang bigyan ang interpreter ng isang wastong pangalan:

Upang simulan ang isang variable (magtalaga ng isang halaga dito), ang assignment operator (simbolo =) ay ginagamit:

$test = 100

Maaari kang magdeklara ng variable sa pamamagitan ng pagtukoy ng uri nito sa mga square bracket (type casting operator) bago ang pangalan o halaga:

[int]$test = 100

$test = [int]100

Mahalagang maunawaan na ang mga variable sa PowerShell ay mga ganap na bagay (mga klase) na may mga katangian at pamamaraan na ang mga uri ay batay sa mga nasa .NET Core. Inilista namin ang mga pangunahing:

Uri (.NET class)

Описание

Halimbawa ng code

[string] System.String

Unicode string

$test = "test"
$test = 'test'

[char]System.Char

Unicode character (16 bits)

[char]$test = 'c'

[bool] System.Boolean

uri ng boolean (boolean True o False)

[bool]$test = $true

[int] System.Int32

tatlumpu't dalawang bit integer (32 bits)

[int]$test = 123456789

[mahaba] System.Int64

animnapu't apat na bit integer (64 bits)

[long]$test = 12345678910

[single] System.Single

floating point number na 32 bits ang haba

[solong]$test = 12345.6789

[double]System.Doble

floating point bilang ng haba 64 bits (8 bytes)

[double]$test = 123456789.101112

[decimal]System.Decimal

128-bit na numero ng floating point (kinakailangang magtapos sa d)

[decimal]$test = 12345.6789d

[DateTime]System.DateTime

petsa at oras

$test = GetDate

[array] System.Object[]

isang array na ang index ng elemento ay nagsisimula sa 0

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

[hashtable] System.Collections.Hashtable

Ang mga hash table ay mga associative array na may mga pinangalanang key, na binuo ayon sa prinsipyo: @{key = "value"}

$test_hashtable = @{one="one"; dalawa="dalawa"; tatlo="tatlo"}

Sinusuportahan ng PowerShell ang implicit type na conversion, bilang karagdagan, ang uri ng variable ay maaaring mabago sa mabilisang (halimbawa, gamit ang isang assignment operator), kung hindi ito puwersahang tinukoy - sa kasong ito, ang interpreter ay magbibigay ng error. Maaari mong matukoy ang uri ng variable mula sa nakaraang halimbawa sa pamamagitan ng pagtawag sa GetType() method:

$test.GetType().FullName

Mayroong ilang mga cmdlet para sa pagmamanipula ng mga variable. Ang kanilang listahan sa isang maginhawang form ay ipinapakita gamit ang command:

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

Upang tingnan ang mga ipinahayag na variable at ang kanilang mga halaga, maaari kang gumamit ng isang espesyal na cmdlet:

Get-Variable | more

Ang pamamaraang ito ay tila napakahirap, ito ay mas maginhawa upang gumana sa mga variable sa pamamagitan ng mga operator o sa pamamagitan ng direktang pag-access sa kanilang mga katangian at pamamaraan. Gayunpaman, may karapatang umiral ang mga cmdlet dahil pinapayagan ka nitong magtakda ng ilang karagdagang parameter. Mahalagang maunawaan na ang mga variable ng user ay tinukoy lamang sa loob ng kasalukuyang session. Kapag ang console ay sarado o ang script ay natapos, ang mga ito ay tatanggalin.

Mga variable ng system

Bilang karagdagan sa mga idineklara ng user, may mga built-in (system) na variable na hindi nabubura pagkatapos ng kasalukuyang session. Ang mga ito ay nahahati sa dalawang uri, habang ang data ng estado ng PowerShell ay naka-imbak sa mga awtomatikong variable na hindi maaaring magtalaga ng mga arbitrary na halaga nang mag-isa. Kabilang dito, halimbawa, ang $PWD:

$PWD.Path

Ang mga variable ng kagustuhan ay kinakailangan upang mag-imbak ng mga kagustuhan ng gumagamit, ang mga halaga nito ay maaaring baguhin. Halimbawa, gamit ang $ErrorActionPreference , itinakda ang reaksyon ng command interpreter sa paglitaw ng mga hindi nakamamatay na error.

Bilang karagdagan sa mga operator at cmdlet para sa pag-access sa mga ipinahayag na variable, mayroong isang Variable: pseudo-accumulator. Maaari mong gawin ito sa pamamagitan ng pagkakatulad sa iba pang mga drive, at ang mga variable sa kasong ito ay kahawig ng mga object ng file system:

Get-ChildItem Variable: | more

ls Variable: | more

Saklaw

Para sa mga variable sa PowerShell, mayroong konsepto ng saklaw (Scope). Ang pagkilos ng pandaigdigang saklaw (Global) ay nalalapat sa buong kasalukuyang session - kabilang dito, halimbawa, ang mga variable ng system. Available lang ang mga lokal (Lokal) na variable sa saklaw kung saan tinukoy ang mga ito: sabihin sa loob ng isang function. Mayroon ding konsepto ng saklaw ng script (Script), ngunit para sa mga script command, ito ay mahalagang lokal. Bilang default, kapag nagdedeklara ng mga variable, binibigyan sila ng lokal na saklaw, at para baguhin ito, kailangan mo ng espesyal na construct tulad ng: $Global: variable = value.

Halimbawa, tulad nito:

$Global:test = 100

Mga variable ng kapaligiran (environment)

Ang isa pang pseudo-drive, Env:, ay makukuha mula sa PowerShell at maaaring magamit upang ma-access ang mga variable ng kapaligiran. Kapag nagsimula ang shell, kinopya sila mula sa proseso ng magulang (iyon ay, mula sa programa na nagpasimula ng kasalukuyang session) at kadalasan ang kanilang mga paunang halaga ay kapareho ng mga halaga sa control panel. Upang tingnan ang mga variable ng kapaligiran, gamitin ang Get-ChildItem cmdlet o ang mga alias nito (mga alias): ls at dir.

dir Env:

Ang mga variable na ito ay mga pagkakasunud-sunod ng mga byte (o mga character, kung gusto mo), ang interpretasyon nito ay nakasalalay lamang sa program na gumagamit ng mga ito. Ang *-Variable cmdlet ay hindi gumagana sa mga variable ng kapaligiran. Upang ma-access ang mga ito, kailangan mong gamitin ang drive prefix:

$env:TEST = "Hello, World!"

Mga operator ng aritmetika at paghahambing

Nagbibigay ang PowerShell ng mga sumusunod na operator ng arithmetic: + (dagdag), - (pagbabawas), * (multiply), / (division), at % (modulo o modulo). Ang resulta ng isang arithmetic expression ay sinusuri mula kaliwa hanggang kanan alinsunod sa karaniwang tinatanggap na pagkakasunud-sunod ng mga operasyon, at ang mga panaklong ay ginagamit upang pangkatin ang mga bahagi ng expression. Ang mga puwang sa pagitan ng mga operator ay hindi pinapansin, ginagamit lamang ang mga ito upang gawing mas madaling basahin. Ang + operator ay magkakadugtong din, at ang * operator ay inuulit ang mga string. Kung susubukan mong magdagdag ng isang numero sa isang string, ito ay mako-convert sa isang string. Bilang karagdagan, ang wika ng PowerShell ay may maraming mga operator ng paghahambing na tumitingin para sa isang tugma sa pagitan ng dalawang mga halaga at ibinabalik ang boolean na True o False:

Opereytor

Описание

Halimbawa ng code

-eq

Equal / Equals (katulad ng = o == sa ibang mga wika)

$test = 100
$test -eq 123

- ay

Hindi katumbas / Hindi katumbas (katulad ng <> o !=)

$test = 100
$test -ne 123

-gt

Higit sa / Higit pa (analogue >)

$test = 100
$test -gt 123

-ge

Higit sa o katumbas / Higit sa o katumbas (katulad ng >=)

$test = 100
$test -ge 123

-lt

Mas mababa sa / Mas kaunti (katulad ng <)

$test = 100
$test -lt 123

-ang

Mas mababa sa o katumbas / Mas mababa sa o katumbas (katulad ng <=)

$test = 100
$test -le 123

Mayroong iba pang mga katulad na operator na nagbibigay-daan sa iyong, halimbawa, paghambingin ang mga string batay sa isang wildcard o gumamit ng mga regular na expression upang tumugma sa isang pattern. Tatalakayin namin ang mga ito nang detalyado sa mga artikulo sa hinaharap. Ang mga simbolo na <, > at = ay hindi ginagamit para sa paghahambing dahil ginagamit ang mga ito para sa iba pang layunin.

Mga operator ng assignment

Bilang karagdagan sa pinakakaraniwang = operator, mayroong iba pang mga operator ng pagtatalaga: +=, -=, *=, /= at %=. Binabago nila ang halaga bago ang pagtatalaga. Ang unary operator ++ at -, na nagpapataas o nagpapababa sa halaga ng isang variable, ay kumikilos nang katulad - nalalapat din ang mga ito sa mga operator ng pagtatalaga.

Mga lohikal na operator

Ang paghahambing lamang ay hindi sapat upang ilarawan ang mga kumplikadong kondisyon. Maaari kang sumulat ng anumang mga lohikal na expression gamit ang mga operator: -at, -o, -xor, -hindi at!

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

-not (123 -gt 321) 

!(123 -gt 321)

Kondisyonal na Paglukso

Ang mga operator ng sangay sa PowerShell ay karaniwan: IF(IF...ELSE, IF...ELSEIF...ELSE) at SWITCH. Tingnan natin ang kanilang paggamit sa mga halimbawa:

[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 или значение не определено"}
}

Mga cycle

Ang PowerShell ay may ilang uri ng mga loop: WHILE, DO WHILE, DO UNTIL, FOR, at FOREACH.

Gumagana ang loop na may precondition kung/habang ito ay totoo:

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

Ang mga loop na may postcondition ay tatakbo nang hindi bababa sa isang beses, dahil ang kundisyon ay sinusuri pagkatapos ng pag-ulit. Kasabay nito, ang DO WHILE ay gumagana habang ang kundisyon ay totoo, at ang DO UNTIL ay gumagana habang ito ay mali:

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

Ang bilang ng mga pag-ulit ng FOR loop ay alam nang maaga:

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

Sa FOREACH loop, umuulit sa mga elemento ng isang array o koleksyon (hash table):

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

Mga Arrays

Ang mga variable ng PowerShell ay nag-iimbak hindi lamang ng mga solong bagay (numero, string, atbp.), kundi pati na rin ng marami. Ang pinakasimpleng uri ng naturang mga variable ay mga array. Ang isang array ay maaaring binubuo ng ilang elemento, isang elemento, o walang laman, i.e. walang mga elemento. Ito ay idineklara gamit ang @() operator, na kakailanganin natin sa susunod na artikulo - ito ay napakahalaga para sa pagdaragdag ng iba pang mga arrays sa isang array (paglikha ng multidimensional arrays), pagpasa ng mga arrays sa mga function bilang argumento, at mga katulad na gawain:

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

Kapag ang isang array ay sinimulan, ang mga halaga nito ay nakalista na pinaghihiwalay ng mga kuwit (espesyal na operator ,):

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

Sa karamihan ng mga kaso, ang operator na @() ay maaaring tanggalin:

$test_array = 1, 2, 3, 4

Sa kasong ito, ang isang array ng isang elemento ay sinisimulan bilang mga sumusunod

$test_array = , 1

Ang mga elemento ng array ay ina-access gamit ang zero-based na integer index at ang index operator (square bracket):

$test_array[0] = 1

Maaari mong tukuyin ang ilang mga index na pinaghihiwalay ng mga kuwit, kasama. umuulit:

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

Opereytor .. (dalawang tuldok - range operator) ay nagbabalik ng hanay ng mga integer sa loob ng tinukoy na upper at lower bounds. Halimbawa, ang expression 1..4 ay naglalabas ng array ng apat na elemento @(1, 2, 3, 4), at ang expression 8..5 ay naglalabas ng array @(8, 7, 6, 5).

Gamit ang range operator, maaari kang magpasimula ng array ($test_array = 1..4) o kumuha ng slice (slice), i.e. isang pagkakasunud-sunod ng mga elemento mula sa isang array na may mga indeks mula sa isa pa. Sa kasong ito, ang isang negatibong numero -1 ay nagpapahiwatig ng huling elemento ng array, -2 - ang penultimate isa, at iba pa.

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

Tandaan na ang mga halaga ng integer array ay maaaring mas malaki kaysa sa maximum na halaga ng index ng array ng data. Sa kasong ito, ang lahat ng mga halaga ay ibinalik hanggang sa huling isa:

$test_array[0..100]

Kung susubukan mong i-access ang isang hindi umiiral na elemento ng array, ibabalik ang $null.

Sa PowerShell, ang mga array ay maaaring maglaman ng mga elemento ng iba't ibang uri o malakas na na-type:

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

Kung saan ang $test_array.count property ay ang bilang ng mga elemento ng array.

Isang halimbawa ng paglikha ng isang malakas na na-type na array:

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

Hash table

Ang isa pang pangunahing uri ng mga variable sa wikang PowerShell ay mga hash table, na kilala rin bilang mga associative array. Ang mga Hashtable ay katulad ng mga bagay na JSON at binuo sa batayan ng key-value. Hindi tulad ng mga ordinaryong array, ang kanilang mga elemento ay na-access sa pamamagitan ng pinangalanang mga susi, na mga katangian ng bagay (maaari mo ring gamitin ang index operator - mga square bracket).

Ang isang walang laman na hash table ay idineklara gamit ang @ symbol at operator bracket:

$test_hashtable = @{}

Kapag nagdedeklara, maaari kang agad na lumikha ng mga susi at magtalaga ng mga halaga sa kanila:

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

Upang magdagdag ng elemento sa isang hash table, dapat kang magtalaga ng key na hindi pa umiiral dito, o gamitin ang Add () na paraan. Kung ang isang pagtatalaga ay ginawa sa isang umiiral na key, ang halaga nito ay magbabago. Ang paraan ng Remove() ay ginagamit upang alisin ang isang elemento mula sa isang hash table.

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

Ang mga variable ng ganitong uri ay maaaring ipasa bilang mga argumento sa mga function at cmdlet - sa susunod na artikulo ay pag-aaralan natin kung paano ito ginagawa, at isaalang-alang din ang isa pang katulad na uri - PSCustomObject.

Pag-andar

Nasa PowerShell ang lahat ng kailangan mo para sa procedural programming, kasama ang mga function. Upang ilarawan ang mga ito, ginagamit ang salitang function na Function, pagkatapos nito kailangan mong tukuyin ang pangalan ng function at ang katawan na nakapaloob sa mga bracket ng operator. Kung kailangan mong ipasa ang mga argumento sa function, maaari mong tukuyin ang mga ito kaagad pagkatapos ng pangalan sa mga panaklong.

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

Ang function ay palaging nagbabalik ng isang resulta - ito ay isang hanay ng mga resulta ng lahat ng mga pahayag nito, kung mayroong higit sa isa. Kung mayroon lamang isang pahayag, ang tanging halaga ng kaukulang uri ay ibinalik. Ang return $value construct ay nagdaragdag ng isang elemento na may value na $value sa result array at abort ang execution ng statement list, at ang walang laman na function ay nagbabalik ng $null.

Halimbawa, gumawa tayo ng isang function para sa pag-squaring ng isang numero:

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

Tandaan na sa katawan ng isang function, maaari mong gamitin ang anumang mga variable na idineklara bago ito tawagan, at ang pagtawag sa mga function sa PowerShell ay maaaring mukhang hindi karaniwan: ang mga argumento (kung mayroon man) ay hindi nakapaloob sa mga panaklong at pinaghihiwalay ng mga puwang.

sqr 2

o ganito:

sqr -number 2

Dahil sa paraan ng pagpasa ng mga argumento, ang mismong function kung minsan ay kailangang nakapaloob sa mga panaklong:

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

Kapag naglalarawan ng isang function, maaari kang magtalaga ng mga default na halaga sa mga argumento:

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

Mayroong isa pang syntax para sa paglalarawan ng mga argumento ng pag-andar, bilang karagdagan, ang mga parameter ay maaaring basahin mula sa pipeline - lahat ng ito ay magiging kapaki-pakinabang sa susunod na artikulo, kapag tiningnan namin ang mga na-export na module at lumikha ng aming sariling mga cmdlet.

Error sa pagproseso

Ang PowerShell ay may Try...Catch...Finally na mekanismo para mahawakan ang mga exception. Ang Try block ay naglalaman ng code kung saan maaaring magkaroon ng error, at ang Catch block ay naglalaman ng handler nito. Kung walang error, hindi ito maisasakatuparan. Ang Panghuli block ay isinasagawa pagkatapos ng Try block, anuman ang paglitaw ng isang error, at maaaring mayroong ilang Catch block para sa iba't ibang uri ng mga exception. Ang pagbubukod mismo ay isinulat sa isang hindi ipinahayag na default na variable ($_) at madaling makuha. Sa halimbawa sa ibaba, nagpapatupad kami ng proteksyon laban sa pagpasok ng di-wastong halaga:

try {

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

} catch {

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

}

Tinatapos nito ang pagsusuri ng mga pangunahing kaalaman sa programming sa wikang PowerShell. Sa mga sumusunod na artikulo, pag-aaralan namin nang mas detalyado ang pagtatrabaho sa mga variable ng iba't ibang uri, koleksyon, regular na expression, paglikha ng mga function, module at custom cmdlet, pati na rin ang object-oriented na programming.

Pinagmulan: www.habr.com

Ano ang Windows PowerShell at saan ito kinakain? Bahagi 2: Panimula sa programming language