Vēsturiski komandrindas utilītas Unix sistēmās ir labāk izstrādātas nekā Windows, taču līdz ar jauna risinājuma parādīšanos situācija ir mainījusies.
PowerShell ļauj rakstīt skriptus interpretētā, vairāku paradigmu valodā, kas satur klasiskas procesuālās, objektorientētās un pat funkcionālās programmēšanas elementus: nosacījuma zaru, cilpas, mainīgos, masīvus, jaucēj tabulas, klases, kļūdu apstrādi, kā arī funkcijas, cmdlet un cauruļvadi . bija veltīta pamatiem darbam vidē, un tagad saviem lasītājiem piedāvājam nelielu uzziņu grāmatu programmētājiem.
Satura rādītājs:
Varat rakstīt kodu jebkurā teksta redaktorā vai izmantojot integrētu izstrādes vidi — vienkāršākais veids ir izmantot Windows PowerShell ISE, kas tiek piegādāta kopā ar Microsoft serveru operētājsistēmām. Tas ir nepieciešams tikai diezgan sarežģītiem skriptiem: īsas komandu kopas ir vieglāk izpildīt interaktīvi.
Komentāri
Komentāru izmantošana tiek uzskatīta par daļu no laba programmēšanas stila, kā arī pareiza atkāpe un atstarpes:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Mainīgie lielumi un to veidi
PowerShell mainīgie ir nosaukti objekti. Viņu nosaukumos var būt iekļauta pasvītra rakstzīme, kā arī burti un cipari. Pirms nosaukuma vienmēr ir simbols $, un, lai deklarētu mainīgo, jums vienkārši jānorāda tulkam derīgs nosaukums:
Lai inicializētu mainīgo (piešķirtu tam vērtību), izmantojiet piešķiršanas operatoru (simbols =):
$test = 100Varat deklarēt mainīgo, norādot tā veidu kvadrātiekavās (tipa cast operatoru) pirms nosaukuma vai vērtības:
[int]$test = 100
$test = [int]100Ir svarīgi saprast, ka PowerShell mainīgie ir pilnvērtīgi objekti (klases) ar īpašībām un metodēm, kuru veidi ir balstīti uz tiem, kas atrodami .NET Core. Uzskaitīsim galvenos:
Tips (.NET klase)
Apraksts
Koda piemērs
[string] System.StringUnikoda virkne
$test = "pārbaude"
$test = 'pārbaude'
Unikoda rakstzīme (16 bitu)
[char]$test = 'c' [būls] System.BooleanBūla veids (būla vērtība True vai False)
[bool]$test = $true [int]Sistēma.Int32trīsdesmit divu bitu vesels skaitlis (32 biti)
[int]$test = 123456789 [garš] System.Int64sešdesmit četru bitu vesels skaitlis (64 biti)
[garš]$test = 12345678910 [single]Sistēma.Singlepeldošā komata skaitlis 32 biti garš
[single]$test = 12345.6789 [double]Sistēma.Doublepeldošā komata skaitlis, 64 biti garš (8 baiti)
[double]$test = 123456789.101112 [decimal] System.Decimalpeldošā komata skaitlis 128 biti garš (beigās jāiekļauj d)
[decimal]$test = 12345.6789d [DateTime] System.DateTimedatums un laiks
$test = Get-Date
[masīvs]Sistēma.Objekts[]masīvs, kura elementu indekss sākas ar 0
$test_array = 1, 2, "tests", 3, 4
[hashtable] System.Collections.Hashtablehash tabulas ir asociatīvi masīvi ar nosauktām atslēgām, kas veidotas pēc principa: @{key = “value”}
$test_hashtable = @{one="viens"; divi = "divi"; trīs = "trīs"}
PowerShell atbalsta netiešo tipa konvertēšanu, un mainīgā veidu var mainīt lidojuma laikā (piemēram, izmantojot piešķiršanas operatoru), ja vien tas nav piespiedu kārtā, un tādā gadījumā tulks radīs kļūdu. Varat noteikt mainīgā veidu no iepriekšējā piemēra, izsaucot GetType() metodi:
$test.GetType().FullName
Mainīgo pārvaldīšanai ir vairākas cmdlet. To saraksts ērtā formā tiek parādīts, izmantojot komandu:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap
Lai skatītu deklarētos mainīgos un to vērtības, varat izmantot īpašu cmdlet:
Get-Variable | moreŠī metode šķiet pārāk apgrūtinoša; ir daudz ērtāk strādāt ar mainīgajiem, izmantojot operatorus vai tieši piekļūstot to īpašībām un metodēm. Tomēr cmdlet ir sava vieta, jo tās ļauj iestatīt dažus papildu parametrus. Ir svarīgi saprast, ka lietotāja mainīgie tiek definēti tikai pašreizējā sesijā. Kad konsole ir aizvērta vai skripts ir pabeigts, tie tiek dzēsti.
Sistēmas mainīgie
Papildus tiem, ko deklarējis lietotājs, ir iebūvēti (sistēmas) mainīgie, kas netiek dzēsti pēc pašreizējās sesijas beigām. Tie ir sadalīti divos veidos, un PowerShell stāvokļa dati tiek glabāti automātiskajos mainīgajos, kuriem nevar piešķirt patvaļīgas vērtības. Tie ietver, piemēram, $PWD:
$PWD.Path
Lai saglabātu lietotāja preferences, ir nepieciešami preferenču mainīgie, kuru vērtības var mainīt. Piemēram, izmantojot $ErrorActionPreference, varat iestatīt komandu tulka reakciju uz nekritiskām kļūdām.
Papildus operatoriem un cmdlet, lai piekļūtu deklarētajiem mainīgajiem, ir mainīgais: pseidoakumulators. Ar to var strādāt pēc analoģijas ar citiem diskdziņiem, un mainīgie šajā gadījumā atgādina failu sistēmas objektus:
Get-ChildItem Variable: | morevai
ls Variable: | more
Darbības joma
PowerShell mainīgajiem ir jēdziens, ko sauc par darbības jomu. Globālais tvērums attiecas uz visu pašreizējo sesiju - tas ietver, piemēram, sistēmas mainīgos. Vietējie mainīgie ir pieejami tikai tajā tvērumā, kurā tie tika definēti: piemēram, funkcijā. Pastāv arī skripta darbības jomas (Script) jēdziens, bet skripta komandām tas būtībā ir lokāls. Pēc noklusējuma, deklarējot mainīgos, tiem tiek piešķirts lokāls tvērums, un, lai to mainītu, ir nepieciešama īpaša konstrukcija, piemēram: $Global: mainīgais = vērtība.
Piemēram, šādi:
$Global:test = 100
Vides mainīgie
No PowerShell ir pieejams vēl viens pseido disks, Env:, ko varat izmantot, lai piekļūtu vides mainīgajiem. Kad čaula tiek startēta, tās tiek kopētas no vecākprocesa (tas ir, no programmas, kas uzsāka pašreizējo sesiju), un parasti to sākotnējās vērtības sakrīt ar vērtībām vadības panelī. Lai skatītu vides mainīgos, izmantojiet cmdlet Get-ChildItem vai tā aizstājvārdus: ls un dir.
dir Env:
Šie mainīgie ir baitu (vai rakstzīmju, ja vēlaties) secības, kuru interpretācija ir atkarīga tikai no programmas, kas tos izmanto. *-Mainīgo cmdlet ar vides mainīgajiem nedarbojas. Lai uz tiem atsauktos, jums būs jāizmanto diska prefikss:
$env:TEST = "Hello, World!"
Aritmētikas un salīdzināšanas operatori
PowerShell ir šādi aritmētiskie operatori: + (saskaitīšana), - (atņemšana), * (reizināšana), / (dalīšana) un % (dalīšanas modulis vai atlikums). Aritmētiskās izteiksmes rezultāts tiek novērtēts no kreisās puses uz labo saskaņā ar vispārpieņemto darbību secību, un izteiksmes daļu grupēšanai tiek izmantotas iekavas. Atstarpes starp operatoriem tiek ignorētas un tiek izmantotas tikai tādēļ, lai lietas būtu vieglāk lasāmas. Arī operators + savienojas, un operators * atkārto virknes. Ja mēģināsit virknei pievienot skaitli, tā tiks pārveidota par virkni. Turklāt PowerShell ir daudz salīdzināšanas operatoru, kas salīdzina divas vērtības un atgriež Būla vērtību True vai False:
Operators
Apraksts
Koda piemērs
-ekv
Vienāds / vienāds (analogs = vai == citās valodās)
$tests = 100
$test -eq 123
-nē
Nav vienāds / Nav vienāds (analogs <> vai !=)
$tests = 100
$test -ne 123
-gt
Lielāks par / Vairāk (analogs >)
$tests = 100
$test -gt 123
-vecums
Lielāks vai vienāds / Lielāks vai vienāds (analogs >=)
$tests = 100
$test -ge 123
-lt
Mazāk nekā / Mazāk (analogs <)
$tests = 100
$test -lt 123
-viņi
Mazāks par vai vienāds / Mazāks par vai vienāds (analogs <=)
$tests = 100
$test -le 123
Ir arī citi līdzīgi operatori, kas ļauj, piemēram, salīdzināt virknes, izmantojot aizstājējzīmes, vai izmantot regulāras izteiksmes, lai saskaņotu modeli. Mēs tos sīkāk aplūkosim turpmākajos rakstos. Simboli <, > un = netiek izmantoti salīdzināšanai, jo tie tiek izmantoti citiem mērķiem.
Piešķiršanas operatori
Papildus visizplatītākajam operatoram = ir arī citi piešķiršanas operatori: +=, -=, *=, /= un %=. Viņi maina vērtību pirms piešķiršanas. Unārie operatori ++ un -, kas palielina vai samazina mainīgā lielumu, uzvedas līdzīgi - tie arī pieder pie piešķiršanas operatoriem.
Loģiskie operatori
Ar salīdzinājumu vien nepietiek, lai aprakstītu sarežģītus apstākļus. Jūs varat rakstīt jebkuras loģiskās izteiksmes, izmantojot operatorus: -and, -or, -xor, -not and!.. Tie darbojas tāpat kā citās programmēšanas valodās, bet jūs varat izmantot iekavas, lai norādītu aprēķina secību:
("Тест" -eq "Тест") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Nosacīts lēciens
Atzarošanas operatori programmā PowerShell ir standarta: IF(IF...ELSE, IF...ELSEIF...ELSE) un SWITCH. Apskatīsim to izmantošanu ar piemēriem:
[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 или значение не определено"}
}
Cikli
PowerShell ir vairāku veidu cilpas: WHILE, DO WHILE, DO UNTIL, FOR un FOREACH.
Cikla ar priekšnosacījumu tiek izpildīta, ja/kamēr tā ir patiesa:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Cilpas ar pēcnosacījumu darbosies vismaz vienu reizi, jo nosacījums tiek pārbaudīts pēc iterācijas pabeigšanas. Šajā gadījumā DO WHILE darbojas, kamēr nosacījums ir patiess, un DO UNTIL darbojas, kamēr tas ir nepatiess:
[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 cilpas iterāciju skaits ir zināms iepriekš:
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
FOREACH cilpā atkārtojas masīva vai kolekcijas elementi (jaucēja tabula):
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Masīvi
PowerShell mainīgie saglabā ne tikai atsevišķus objektus (numuru, virkni utt.), bet arī vairākus. Vienkāršākais šādu mainīgo veids ir masīvi. Masīvs var sastāvēt no vairākiem elementiem, viena elementa vai būt tukšs, t.i. nesatur elementus. Lai to deklarētu, mēs izmantojam @() operatoru, kas mums būs nepieciešams nākamajā rakstā - tas ir ļoti svarīgi, lai masīvam pievienotu citus masīvus (izveidotu daudzdimensiju masīvus), nodotu masīvus funkcijām kā argumentu un līdzīgiem uzdevumiem:
$test_array = @() #создаем пустой массивInicializējot masīvu, tā vērtības tiek uzskaitītas atdalot ar komatiem (īpašs operators ,):
$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов Vairumā gadījumu @() operatoru var izlaist:
$test_array = 1, 2, 3, 4Šajā gadījumā viena elementa masīvs tiek inicializēts šādi
$test_array = , 1Lai piekļūtu masīva elementiem, izmantojiet nulles veselu skaitļu indeksu un indeksa operatoru (kvadrātiekavas):
$test_array[0] = 1Varat norādīt vairākus indeksus, atdalot tos ar komatiem, t.sk. atkārtojot:
$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]
Operators .. (divi punkti — diapazona operators) atgriež veselu skaitļu masīvu noteiktā augšējā un apakšējā robežā. Piemēram, izteiksme 1..4 izvada četru elementu masīvu @(1, 2, 3, 4), un izteiksme 8..5 izvada masīvu @(8, 7, 6, 5).
Izmantojot diapazona operatoru, varat inicializēt masīvu ($test_array = 1..4) vai iegūt šķēli, t.i. viena masīva elementu secība ar indeksiem no cita. Šajā gadījumā negatīvais skaitlis -1 apzīmē masīva pēdējo elementu, -2 - priekšpēdējo utt.
$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Ņemiet vērā, ka veselu skaitļu masīva vērtības var būt lielākas par datu masīva maksimālo indeksa vērtību. Šajā gadījumā tiek atgrieztas visas vērtības līdz pēdējai:
$test_array[0..100]Ja mēģināt piekļūt vienam neeksistējošam masīva elementam, tiek atgriezta vērtība $null.
Programmā PowerShell masīvi var saturēt dažāda veida elementus vai būt stingri drukāti:
$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
Kur $test_array.count rekvizīts ir masīva elementu skaits.
Stingri drukāta masīva izveides piemērs:
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Hash tabulas
Vēl viens PowerShell mainīgā pamatveids ir jaucēj tabulas, ko sauc arī par asociatīvajiem masīviem. Hashtables ir līdzīgas JSON objektiem un ir veidotas, pamatojoties uz atslēgas vērtību. Atšķirībā no parastajiem masīviem, to elementiem var piekļūt, izmantojot nosauktos taustiņus, kas ir objekta īpašības (var izmantot arī indeksa operatoru - kvadrātiekavas).
Tukša hash tabula tiek deklarēta, izmantojot simbolu @ un operatora iekavas:
$test_hashtable = @{}Deklarējot, jūs varat nekavējoties izveidot atslēgas un piešķirt tām vērtības:
$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}Lai pievienotu elementu jaukšanas tabulai, tam jāpiešķir atslēga, kas vēl neeksistē, vai jāizmanto metode Add(). Ja piešķiršana tiek veikta esošai atslēgai, tās vērtība mainīsies. Lai noņemtu elementu no hash tabulas, izmantojiet metodi Remove().
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")
Šāda veida mainīgos var nodot kā argumentus funkcijām un cmdlet - nākamajā rakstā mēs pētīsim, kā tas tiek darīts, kā arī apskatīsim citu līdzīgu veidu - PSCustomObject.
Funkcijas
PowerShell ir viss, kas nepieciešams procesuālajai programmēšanai, tostarp funkcijas. Lai tos aprakstītu, tiek izmantots servisa vārds Funkcija, pēc kura jānorāda funkcijas nosaukums un korpuss, kas ievietots operatora iekavās. Ja funkcijai ir jānodod argumenti, tos var norādīt uzreiz aiz nosaukuma iekavās.
function имя-функции (аргумент1, ..., аргументN)
{
тело-функции
}
Funkcija vienmēr atgriež rezultātu - tas ir visu tās paziņojumu rezultātu masīvs, ja ir vairāk nekā viens. Ja ir tikai viens priekšraksts, tiek atgriezta viena attiecīgā veida vērtība. Atgrieztā $vērtības konstrukcija pievieno rezultātu masīvam elementu ar vērtību $value un pārtrauc priekšrakstu saraksta izpildi, savukārt tukša funkcija atgriež $null.
Piemēram, izveidosim funkciju skaitļa kvadrātā:
function sqr ($number)
{
return $number * $number
}
Ņemiet vērā, ka funkcijas pamattekstā varat izmantot jebkurus mainīgos, kas deklarēti pirms tās izsaukšanas, un funkciju izsaukšana programmā PowerShell var šķist neparasta: argumenti (ja tādi ir) nav ievietoti iekavās un ir atdalīti ar atstarpēm.
sqr 2vai šādi:
sqr -number 2Argumentu nodošanas veida dēļ pati funkcija dažreiz ir jāiekļauj iekavās:
function test_func ($n) {}
test_func -eq $null # функция не вызывалась
(test_func) -eq $null # результат выражения — $true
Aprakstot funkciju, argumentiem varat piešķirt noklusējuma vērtības:
function func ($arg = value) {
#тело функции
}
Funkciju argumentu aprakstīšanai ir arī cita sintakse, un parametrus var nolasīt arī no konveijera – tas viss noderēs nākamajā rakstā, kad apskatīsim moduļu eksportēšanu un savu cmdlet izveidi.
Kļūda apstrādē
PowerShell ir Try...Catch...Finally mehānisms, kas ļauj rīkoties izņēmuma situācijās. Blokā Try ir kods, kurā var rasties kļūda, un blokā Catch ir tā apdarinātājs. Ja kļūdas nav, tas netiek izpildīts. Bloks Beidzot tiek izpildīts pēc bloka Try neatkarīgi no tā, vai ir radusies kļūda, un dažāda veida izņēmumiem var būt vairāki Catch bloki. Pats izņēmums ir ierakstīts nedeklarētā noklusējuma mainīgajā ($_), un to var viegli izgūt. Tālāk esošajā piemērā tiek ieviesta aizsardzība pret nepareizas vērtības ievadīšanu:
try {
[int]$test = Read-Host "Введите число"
100 / $test
} catch {
Write-Warning "Некорректное число"
Write-Host $_
}
Šeit mums jābeidz mūsu PowerShell programmēšanas pamatu apskats. Nākamajos rakstos mēs sīkāk aplūkosim darbu ar dažāda veida mainīgajiem, kolekcijām, regulārām izteiksmēm, funkciju, moduļu un savu cmdlet izveidi, kā arī objektu orientētu programmēšanu.
Avots: www.habr.com