Historiallisesti Unix-järjestelmien komentorivin apuohjelmat ovat kehittyneet paremmin kuin Windowsissa, mutta uuden ratkaisun myötä tilanne on muuttunut.
PowerShell voidaan skriptaa tulkitulla, moniparadigmakielellä, jossa on klassisen proseduaalisen, oliokeskeisen ja jopa toiminnallisen ohjelmoinnin elementtejä: ehdollinen haaroitus, silmukat, muuttujat, taulukot, hash-taulukot, luokat, virheiden käsittely sekä funktiot, cmdletit ja liukuhihnat . oli omistettu ympäristötyön perusteisiin, ja nyt tarjoamme lukijoille pienen ohjelmoijien oppaan.
Vastaaja:
Voit kirjoittaa koodia millä tahansa tekstieditorilla tai käyttämällä integroitua kehitysympäristöä – helpoin tapa on käyttää Microsoftin palvelinkäyttöjärjestelmien mukana tulevaa Windows PowerShell ISE:tä. Tämä on tarpeen vain melko monimutkaisille skripteille: lyhyet komentosarjat on helpompi suorittaa interaktiivisesti.
Kommentit
Kommenttien käyttöä pidetään osana hyvää ohjelmointityyliä oikean sisennyksen ja välilyöntien ohella:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Muuttujat ja niiden tyypit
PowerShellin muuttujat ovat nimettyjä objekteja. Niiden nimet voivat sisältää alaviivamerkin sekä kirjaimia ja numeroita. $-symbolia käytetään aina ennen nimeä, ja muuttujan ilmoittamiseen riittää, että annat tulkille kelvollisen nimen:
Muuttujan alustamiseksi (arvon määrittämiseksi sille) käytetään määritysoperaattoria (symboli =):
$test = 100Voit ilmoittaa muuttujan määrittämällä sen tyypin hakasulkeissa (tyypin valuoperaattori) ennen nimeä tai arvoa:
[int]$test = 100
$test = [int]100On tärkeää ymmärtää, että PowerShellin muuttujat ovat täysimittaisia objekteja (luokkia), joilla on ominaisuuksia ja menetelmiä, joiden tyypit perustuvat .NET Coren vastaaviin. Luettelemme tärkeimmät:
Tyyppi (.NET-luokka)
Kuvaus
Esimerkki koodista
[merkkijono] System.StringUnicode-merkkijono
$test = "testi"
$test = 'testi'
Unicode-merkki (16 bittiä)
[char]$test = 'c' [bool] System.Booleanboolen tyyppi (totu tai epätosi)
[bool]$testi = $true [int] System.Int32kolmekymmentäkaksi bittiä kokonaisluku (32 bittiä)
[int]$test = 123456789 [pitkä] System.Int64kuusikymmentäneljä bittiä kokonaisluku (64 bittiä)
[pitkä]$testi = 12345678910 [single] System.Single32 bittiä pitkä liukuluku
[yksi]$testi = 12345.6789 [double]System.Doubleliukulukuluku, pituus 64 bittiä (8 tavua)
[double]$test = 123456789.101112 [desimaali]System.Decimal128-bittinen liukuluku (pakollinen päättymään d:hen)
[desimaali]$testi = 12345.6789d [DateTime]System.DateTimepäivämäärä ja aika
$test = GetDate
[array] System.Object[]taulukko, jonka elementtiindeksi alkaa nollasta
$test_array = 1, 2, "testi", 3, 4
[hashtable] System.Collections.Hashtablehash-taulukot ovat assosiatiivisia taulukoita nimetyillä avaimilla, jotka on rakennettu seuraavan periaatteen mukaisesti: @{key = "arvo"}
$test_hashtable = @{one="yksi"; two="kaksi"; three="kolme"}
PowerShell tukee implisiittistä tyyppimuunnosa, lisäksi muuttujan tyyppiä voidaan muuttaa lennossa (esim. osoitusoperaattorilla), jos sitä ei ole määritetty pakottamalla - tässä tapauksessa tulkki antaa virheen. Voit määrittää muuttujan tyypin edellisestä esimerkistä kutsumalla GetType()-metodia:
$test.GetType().FullName
Muuttujien manipulointiin on olemassa useita cmdlet-komentoja. Heidän luettelonsa kätevässä muodossa näytetään komennolla:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap
Voit tarkastella ilmoitettuja muuttujia ja niiden arvoja käyttämällä erityistä cmdlet-komentoa:
Get-Variable | moreTämä menetelmä vaikuttaa liian hankalalta, on paljon kätevämpää työskennellä muuttujien kanssa operaattoreiden kautta tai käyttämällä suoraan niiden ominaisuuksia ja menetelmiä. cmdletillä on kuitenkin oikeus olla olemassa, koska niiden avulla voit asettaa joitain lisäparametreja. On tärkeää ymmärtää, että käyttäjämuuttujat määritellään vain nykyisessä istunnossa. Kun konsoli suljetaan tai komentosarja päättyy, ne poistetaan.
Järjestelmän muuttujat
Käyttäjän ilmoittamien muuttujien lisäksi on sisäisiä (järjestelmä)muuttujia, joita ei poisteta nykyisen istunnon päätyttyä. Ne on jaettu kahteen tyyppiin, kun taas PowerShell-tilatiedot tallennetaan automaattisiin muuttujiin, joille ei voi antaa mielivaltaisia arvoja yksinään. Näitä ovat esimerkiksi $PWD:
$PWD.Path
Asetusmuuttujia tarvitaan tallentamaan käyttäjän mieltymyksiä, joiden arvoja voidaan muuttaa. Esimerkiksi käyttämällä $ErrorActionPreference -toimintoa komentotulkin reaktio ei-vakavien virheiden esiintymiseen asetetaan.
Operaattoreiden ja cmdlet-komentojen lisäksi ilmoitettuihin muuttujiin pääsemiseksi on olemassa Variable: pseudo-akku. Voit työskennellä sen kanssa analogisesti muiden asemien kanssa, ja muuttujat tässä tapauksessa muistuttavat tiedostojärjestelmäobjekteja:
Get-ChildItem Variable: | moretai
ls Variable: | more
Soveltamisalat
PowerShellin muuttujille on olemassa laajuuden käsite (Scope). Globaalin laajuuden (Global) toiminta koskee koko nykyistä istuntoa - se sisältää esimerkiksi järjestelmämuuttujia. Paikalliset (paikalliset) muuttujat ovat käytettävissä vain siinä laajuudessa, jossa ne on määritelty: esimerkiksi funktion sisällä. On myös käsite skriptin laajuudesta (Script), mutta komentosarjakomentoille se on olennaisesti paikallinen. Oletuksena muuttujia määritettäessä niille annetaan paikallinen laajuus, ja tämän muuttamiseksi tarvitset erityisen rakenteen, kuten: $Global: muuttuja = arvo.
Esimerkiksi:
$Global:test = 100
Ympäristömuuttujat (ympäristö)
Toinen pseudoasema, Env:, on saatavana PowerShellistä, ja sitä voidaan käyttää ympäristömuuttujien käyttöön. Kun komentotulkki käynnistyy, ne kopioidaan pääprosessista (eli ohjelmasta, joka aloitti nykyisen istunnon) ja yleensä niiden alkuarvot ovat samat kuin ohjauspaneelin arvot. Jos haluat tarkastella ympäristömuuttujia, käytä Get-ChildItem cmdlet-komentoa tai sen aliaksia (aliaksia): ls ja dir.
dir Env:
Nämä muuttujat ovat tavuja (tai merkkijonoja, jos haluat), joiden tulkinta riippuu vain niitä käyttävästä ohjelmasta. *-Variable-cmdlet-komento ei toimi ympäristömuuttujien kanssa. Päästäksesi niihin, sinun on käytettävä aseman etuliitettä:
$env:TEST = "Hello, World!"
Aritmeettiset ja vertailuoperaattorit
PowerShell tarjoaa seuraavat aritmeettiset operaattorit: + (lisäys), - (vähennys), * (kerto), / (jako) ja % (modulo tai modulo). Aritmeettisen lausekkeen tulos arvioidaan vasemmalta oikealle yleisesti hyväksytyn toimintojärjestyksen mukaisesti, ja lausekkeen osien ryhmittelyyn käytetään sulkeita. Operaattoreiden välisiä välilyöntejä ei oteta huomioon, niitä käytetään vain lukemisen helpottamiseksi. +-operaattori myös ketjuttaa ja *-operaattori toistaa merkkijonoja. Jos yrität lisätä merkkijonoon numeron, se muunnetaan merkkijonoksi. Lisäksi PowerShell-kielessä on monia vertailuoperaattoreita, jotka tarkistavat vastaavuuden kahden arvon välillä ja palauttavat loogisen arvon True tai False:
operaattori
Kuvaus
Esimerkki koodista
-ekv
Yhtä / yhtä kuin (samanlainen kuin = tai == muilla kielillä)
$testi = 100
$testi -eq 123
-ei
Ei yhtä suuri / Ei yhtä suuri (samanlainen kuin <> tai !=)
$testi = 100
$test -ne 123
-gt
Suurempi kuin / Enemmän (analoginen >)
$testi = 100
$test -gt 123
-ikää
Suurempi tai yhtä suuri / suurempi tai yhtä suuri (samanlainen kuin >=)
$testi = 100
$test -ge 123
-lt
Vähemmän kuin / Vähemmän (samanlainen kuin <)
$testi = 100
$testi -lt 123
Niitä
Pienempi tai yhtä suuri / Pienempi tai yhtä suuri (samanlainen kuin <=)
$testi = 100
$test -le 123
On olemassa muita samankaltaisia operaattoreita, joiden avulla voit esimerkiksi verrata merkkijonoja jokerimerkkien perusteella tai käyttää säännöllisiä lausekkeita vastaamaan kuviota. Käsittelemme niitä yksityiskohtaisesti tulevissa artikkeleissa. Symboleja <, > ja = ei käytetä vertailuun, koska niitä käytetään muihin tarkoituksiin.
Tehtäväoperaattorit
Yleisimmän =-operaattorin lisäksi on muitakin määritysoperaattoreita: +=, -=, *=, /= ja %=. Ne muuttavat arvoa ennen määritystä. Unaariset operaattorit ++ ja -, jotka lisäävät tai pienentävät muuttujan arvoa, käyttäytyvät samalla tavalla - ne pätevät myös osoitusoperaattoreihin.
Loogiset operaattorit
Pelkkä vertailu ei riitä kuvaamaan monimutkaisia olosuhteita. Voit kirjoittaa mitä tahansa loogisia lausekkeita käyttämällä operaattoreita -ja, -tai, -xor, -not and! .. Ne toimivat kuten muissa ohjelmointikielissä, kun taas voit käyttää sulkeita määrittämään arviointijärjestystä:
("Тест" -eq "Тест") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Ehdollinen hyppy
Haaraoperaattorit PowerShellissä ovat vakiona: IF(IF…ELSE, IF…ELSEIF…ELSE) ja SWITCH. Katsotaanpa niiden käyttöä esimerkein:
[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 или значение не определено"}
}
syklit
PowerShellillä on useita erilaisia silmukoita: WHILE, DO WHILE, DO UNTIL, FOR ja FOREACH.
Silmukka, jolla on ennakkoehto, toimii, jos/niin kauan kuin se on totta:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Silmukat, joissa on jälkiehto, suoritetaan vähintään kerran, koska ehto tarkistetaan iteroinnin jälkeen. Samaan aikaan DO WHILE toimii, kun ehto on tosi, ja DO UNTIL toimii, kun se on epätosi:
[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-silmukan iteraatioiden määrä tiedetään etukäteen:
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
FOREACH-silmukassa iteroidaan taulukon tai kokoelman elementtien yli (hash-taulukko):
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
taulukot
PowerShell-muuttujat eivät tallenna vain yksittäisiä objekteja (numero, merkkijono jne.), vaan myös useita. Yksinkertaisimpia tällaisia muuttujia ovat taulukot. Taulukko voi koostua useista elementeistä, yhdestä elementistä tai olla tyhjä, ts. ei sisällä elementtejä. Se ilmoitetaan @()-operaattorilla, jota tarvitsemme seuraavassa artikkelissa - se on erittäin tärkeä muiden taulukoiden lisäämiseksi taulukkoon (moniulotteisten taulukoiden luomiseksi), taulukoiden välittämiseksi funktioille argumenttina ja vastaaviin tehtäviin:
$test_array = @() #создаем пустой массивKun taulukko alustetaan, sen arvot luetellaan pilkuilla erotettuina (erikoisoperaattori ,):
$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов Useimmissa tapauksissa @()-operaattori voidaan jättää pois:
$test_array = 1, 2, 3, 4Tässä tapauksessa yhden elementin taulukko alustetaan seuraavasti
$test_array = , 1Matriisielementteihin päästään käyttämällä nollapohjaista kokonaislukuindeksiä ja indeksioperaattoria (hakasulkeet):
$test_array[0] = 1Voit määrittää useita pilkuilla erotettuja indeksejä, mm. toistuva:
$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]
operaattori .. (kaksi pistettä - alueoperaattori) palauttaa joukon kokonaislukuja määritetyissä ylä- ja alarajoissa. Esimerkiksi lauseke 1..4 tulostaa neljän elementin taulukon @(1, 2, 3, 4) ja lauseke 8..5 taulukon @(8, 7, 6, 5).
Alueoperaattorilla voit alustaa taulukon ($test_array = 1..4) tai saada viipaleen (slice), ts. joukon elementtejä yhdestä taulukosta ja indeksejä toisesta. Tässä tapauksessa negatiivinen luku -1 tarkoittaa taulukon viimeistä elementtiä, -2 - toiseksi viimeistä ja niin edelleen.
$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Huomaa, että kokonaislukutaulukon arvot voivat olla suurempia kuin datataulukon enimmäisindeksiarvo. Tässä tapauksessa kaikki arvot palautetaan viimeiseen:
$test_array[0..100]Jos yrität käyttää yhtä olematonta taulukkoelementtiä, palautetaan $null.
PowerShellissä taulukot voivat sisältää erityyppisiä elementtejä tai olla vahvasti kirjoitettuja:
$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
$test_array.count-ominaisuus on taulukon elementtien lukumäärä.
Esimerkki vahvasti kirjoitetun taulukon luomisesta:
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Hash-taulukot
Toinen PowerShell-kielen muuttujien perustyyppi ovat hash-taulukot, jotka tunnetaan myös assosiatiivisina taulukoina. Hashtables ovat samanlaisia kuin JSON-objektit, ja ne on rakennettu avainarvoperusteisesti. Toisin kuin tavallisissa taulukoissa, niiden elementteihin päästään nimetyillä avaimilla, jotka ovat objektin ominaisuuksia (voit käyttää myös indeksioperaattoria - hakasulkeet).
Tyhjä hash-taulukko ilmoitetaan @-symbolilla ja operaattorisuluilla:
$test_hashtable = @{}Ilmoittaessasi voit heti luoda avaimia ja määrittää niille arvoja:
$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}Jos haluat lisätä elementin hash-taulukkoon, sinun on määritettävä sille avain, jota ei vielä ole olemassa, tai käytettävä Lisää () -menetelmää. Jos olemassa olevalle avaimelle tehdään osoitus, sen arvo muuttuu. Remove()-menetelmää käytetään elementin poistamiseen hash-taulukosta.
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")
Tämän tyyppisiä muuttujia voidaan välittää argumentteina funktioille ja cmdleteille - seuraavassa artikkelissa tutkimme, kuinka tämä tehdään, ja harkitsemme myös toista samanlaista tyyppiä - PSCustomObject.
Tehtävät
PowerShellissä on kaikki mitä tarvitset prosessiohjelmointiin, mukaan lukien toiminnot. Niiden kuvaamiseen käytetään funktiosanaa Function, jonka jälkeen on määritettävä funktion nimi ja operaattorisuluissa oleva runko. Jos funktiolle on välitettävä argumentteja, voit määrittää ne heti suluissa olevan nimen jälkeen.
function имя-функции (аргумент1, ..., аргументN)
{
тело-функции
}
Funktio palauttaa aina tuloksen - se on joukko kaikkien lauseidensa tuloksia, jos niitä on enemmän kuin yksi. Jos lauseita on vain yksi, palautetaan ainoa vastaavan tyypin arvo. Palautettava $arvokonstrukti lisää elementin arvolla $arvo tulosjonoon ja keskeyttää käskyluettelon suorittamisen, ja tyhjä funktio palauttaa $null.
Luodaan esimerkiksi funktio luvun neliöimiseksi:
function sqr ($number)
{
return $number * $number
}
Huomaa, että funktion rungossa voit käyttää mitä tahansa muuttujia, jotka on ilmoitettu ennen kutsumista, ja funktioiden kutsuminen PowerShellissä saattaa tuntua epätavalliselta: argumentteja (jos sellaisia on) ei ole suljettu suluissa ja ne erotetaan välilyönneillä.
sqr 2tai niin:
sqr -number 2Argumenttien välitystavasta johtuen itse funktio on joskus lisättävä sulkeisiin:
function test_func ($n) {}
test_func -eq $null # функция не вызывалась
(test_func) -eq $null # результат выражения — $true
Kun kuvailet funktiota, voit määrittää argumenteille oletusarvot:
function func ($arg = value) {
#тело функции
}
Funktioargumenttien kuvaamiseen on toinenkin syntaksi, lisäksi parametrit voidaan lukea liukuhihnasta - kaikki tämä on hyödyllistä seuraavassa artikkelissa, kun tarkastelemme vietyjä moduuleja ja luomme omia cmdlettejä.
Käsittelyvirhe
PowerShellissä on Try...Catch...Lopuksi -mekanismi poikkeusten käsittelemiseksi. Try-lohko sisältää koodin, jossa virhe voi tapahtua, ja Catch-lohko sisältää sen käsittelijän. Jos virhettä ei ole, sitä ei suoriteta. Lopuksi-lohko suoritetaan Try-lohkon jälkeen virheen esiintymisestä riippumatta, ja Catch-lohkoja voi olla useita erityyppisiä poikkeuksia varten. Itse poikkeus kirjoitetaan ilmoittamattomaan oletusmuuttujaan ($_) ja se voidaan hakea helposti. Alla olevassa esimerkissä toteutamme suojauksen virheellisen arvon syöttämistä vastaan:
try {
[int]$test = Read-Host "Введите число"
100 / $test
} catch {
Write-Warning "Некорректное число"
Write-Host $_
}
Tämä päättää ohjelmoinnin perusteiden tarkastelun PowerShell-kielellä. Seuraavissa artikkeleissa tutkimme tarkemmin erityyppisten muuttujien, kokoelmien, säännöllisten lausekkeiden, funktioiden, moduulien ja mukautettujen cmdlet-komentojen luomista sekä olio-ohjelmointia.
Lähde: will.com