Vad är Windows PowerShell och vad äts det med? Del 2: Introduktion till programmeringsspråket

Historiskt sett är kommandoradsverktyg på Unix-system bättre utvecklade än på Windows, men med tillkomsten av en ny lösning har situationen förändrats.

PowerShell kan skriptas i ett tolkat språk med flera paradigm som har inslag av klassisk procedur, objektorienterad och till och med funktionell programmering: villkorlig förgrening, loopar, variabler, arrayer, hashtabeller, klasser, felhantering, såväl som funktioner, cmdlets och pipelines . Föregående artikel ägnades åt grunderna för att arbeta i miljön, och nu erbjuder vi våra läsare en liten uppslagsbok för programmerare.

Innehållsförteckning:

kommentarer
Variabler och deras typer
Systemvariabler
Omfattningar
Miljövariabler (miljö)
Aritmetiska och jämförelseoperatorer
Uppdragsoperatörer
Logiska operatörer
Villkorligt hopp
cykler
Matriser
Hash tabeller
funktioner
Fel vid bearbetning

Du kan skriva kod i vilken textredigerare som helst eller med hjälp av en integrerad utvecklingsmiljö - det enklaste sättet är att ta Windows PowerShell ISE som följer med Microsofts serveroperativsystem. Detta är bara nödvändigt för ganska komplexa skript: korta uppsättningar kommandon är lättare att köra interaktivt.

kommentarer

Att använda kommentarer anses vara en del av en bra programmeringsstil tillsammans med korrekt indrag och blanksteg:

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

<# 

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

#>

Variabler och deras typer

Variabler i PowerShell är namngivna objekt. Deras namn kan innehålla understreck, såväl som bokstäver och siffror. Symbolen $ används alltid före namnet, och för att deklarera en variabel räcker det med att ge tolken ett giltigt namn:

För att initiera en variabel (tilldela ett värde till den), används tilldelningsoperatorn (symbol =):

$test = 100

Du kan deklarera en variabel genom att ange dess typ inom hakparenteser (typ casting-operator) före namnet eller värdet:

[int]$test = 100

$test = [int]100

Det är viktigt att förstå att variabler i PowerShell är fullfjädrade objekt (klasser) med egenskaper och metoder vars typer är baserade på de i .NET Core. Vi listar de viktigaste:

Typ (.NET-klass)

beskrivning

Kodexempel

[sträng] System.String

Unicode-sträng 

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

[char]System.Char

Unicode-tecken (16 bitar)

[char]$test = 'c'

[bool] System.Boolean

boolesk typ (boolesk sant eller falskt)

[bool]$test = $true

[int] System.Int32

trettiotvå bitars heltal (32 bitar)

[int]$test = 123456789

[lång] System.Int64

sextiofyra bitars heltal (64 bitar)

[lång]$test = 12345678910

[enkel] System.Singel

flyttal nummer 32 bitar lång

[single]$test = 12345.6789

[dubbel]System.Dubbel

flyttal antal längd 64 bitar (8 byte)

[dubbel]$test = 123456789.101112

[decimal]System.Decimal

128-bitars flyttal (krävs för att sluta med d)

[decimal]$test = 12345.6789d

[DateTime]System.DateTime

datum och tid 

$test = GetDate

[array] System.Object[]

en matris vars elementindex börjar på 0

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

[hashtable] System.Collections.Hashtable

hashtabeller är associativa arrayer med namngivna nycklar, byggda enligt principen: @{nyckel = "värde"}

$test_hashtable = @{one="one"; two="två"; three="tre"}

PowerShell stöder implicit typkonvertering, dessutom kan typen av en variabel ändras i farten (till exempel med hjälp av en tilldelningsoperatör), om den inte anges med tvång - i det här fallet kommer tolken att ge ett fel. Du kan bestämma typen av variabel från föregående exempel genom att anropa metoden GetType():

$test.GetType().FullName

Det finns ett antal cmdlets för att manipulera variabler. Deras lista i en bekväm form visas med kommandot:

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

För att se deklarerade variabler och deras värden kan du använda en speciell cmdlet:

Get-Variable | more

Denna metod verkar överdrivet besvärlig, det är mycket bekvämare att arbeta med variabler via operatorer eller genom att komma åt deras egenskaper och metoder direkt. Men cmdlets har rätt att existera eftersom de tillåter dig att ställa in några ytterligare parametrar. Det är viktigt att förstå att användarvariabler endast definieras inom den aktuella sessionen. När konsolen stängs eller skriptet slutar raderas de.

Systemvariabler

Utöver de som användaren deklarerat finns det inbyggda (system)variabler som inte tas bort efter att den aktuella sessionen avslutas. De är uppdelade i två typer, medan PowerShell-tillståndsdata lagras i automatiska variabler som inte kan tilldelas godtyckliga värden på egen hand. Dessa inkluderar till exempel $PWD:

$PWD.Path

Preferensvariabler behövs för att lagra användarpreferenser, vars värden kan ändras. Med till exempel $ErrorActionPreference ställs kommandotolkarens reaktion på förekomsten av icke-fatala fel in.

Förutom operatorer och cmdlets för att komma åt deklarerade variabler finns det en Variable: pseudo-ackumulator. Du kan arbeta med det analogt med andra enheter, och variablerna i det här fallet liknar filsystemobjekt:

Get-ChildItem Variable: | more

eller

ls Variable: | more

Omfattningar

För variabler i PowerShell finns begreppet scope (Scope). Åtgärden för det globala omfånget (Global) gäller för hela den aktuella sessionen - den inkluderar till exempel systemvariabler. Lokala (lokala) variabler är endast tillgängliga i det omfång där de definierades: säg inuti en funktion. Det finns också konceptet med skriptets omfattning (Script), men för skriptkommandon är det i huvudsak lokalt. Som standard, när du deklarerar variabler, ges de ett lokalt omfattning, och för att ändra detta behöver du en speciell konstruktion som: $Global: variabel = värde.

Till exempel, så här:

$Global:test = 100

Miljövariabler (miljö)

En annan pseudo-enhet, Env:, är tillgänglig från PowerShell och kan användas för att komma åt miljövariabler. När skalet startar kopieras de från den överordnade processen (det vill säga från programmet som initierade den aktuella sessionen) och vanligtvis är deras initiala värden desamma som värdena i kontrollpanelen. För att visa miljövariabler, använd Get-ChildItem cmdlet eller dess alias (alias): ls och dir.

dir Env:

Dessa variabler är sekvenser av byte (eller tecken, om du vill), vars tolkning beror bara på programmet som använder dem. *-Variable cmdlets fungerar inte med miljövariabler. För att komma åt dem måste du använda enhetsprefixet:

$env:TEST = "Hello, World!"

Aritmetiska och jämförelseoperatorer

PowerShell tillhandahåller följande aritmetiska operatorer: + (addition), - (subtraktion), * (multiplicera), / (division) och % (modulo eller modulo). Resultatet av ett aritmetiskt uttryck utvärderas från vänster till höger i enlighet med den allmänt accepterade operationsordningen, och parenteser används för att gruppera delar av uttrycket. Mellanslag mellan operatörer ignoreras, de används endast för att göra det lättare att läsa. Operatören + sammanfogar också, och operatorn * upprepar strängar. Om du försöker lägga till ett nummer i en sträng kommer det att konverteras till en sträng. Dessutom har PowerShell-språket många jämförelseoperatorer som letar efter en matchning mellan två värden och returnerar det booleska Sant eller Falskt:

Operatör

beskrivning

Kodexempel

-ekv

Lika / Lika (liknar = eller == på andra språk)

$test = 100
$test -eq 123 

-född

Inte lika / Inte lika (liknar <> eller !=)

$test = 100
$test -ne 123   

-gt

Större än / Mer (analogt >)

$test = 100
$test -gt 123

-ge

Större än eller lika / Större än eller lika (liknande >=)

$test = 100
$test -ge 123

-lt

Mindre än / Mindre (liknar <)

$test = 100
$test -lt 123  

Them

Mindre än eller lika / Mindre än eller lika (liknande <=)

$test = 100
$test -le 123

Det finns andra liknande operatorer som gör att du till exempel kan jämföra strängar baserat på ett jokertecken eller använda reguljära uttryck för att matcha ett mönster. Vi kommer att täcka dem i detalj i framtida artiklar. Symbolerna <, > och = används inte för jämförelse eftersom de används för andra ändamål.

Uppdragsoperatörer

Förutom den vanligaste = operatorn finns det andra tilldelningsoperatorer: +=, -=, *=, /= och %=. De ändrar värdet före tilldelning. De unära operatorerna ++ och -, som ökar eller minskar värdet på en variabel, beter sig på liknande sätt - de gäller även för tilldelningsoperatorer.

Logiska operatörer

Enbart jämförelse räcker inte för att beskriva komplexa förhållanden. Du kan skriva vilka logiska uttryck som helst med hjälp av operatorerna: -och, -eller, -xor, -not och! .. De fungerar som i andra programmeringsspråk, medan du kan använda parenteser för att specificera utvärderingsordningen:

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

-not (123 -gt 321) 

!(123 -gt 321)

Villkorligt hopp

Filialoperatörer i PowerShell är standard: IF(IF…ELSE, IF…ELSEIF…ELSE) och SWITCH. Låt oss titta på deras användning med exempel:

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

cykler

PowerShell har flera varianter av loopar: WHILE, DO WHILE, DO TILL, FOR och FOREACH.

En loop med en förutsättning fungerar om/så länge den är sann:

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

Slingor med ett postvillkor kommer att köras minst en gång, eftersom villkoret kontrolleras efter iterationen. Samtidigt fungerar DO WHILE medan villkoret är sant, och DO TILL fungerar medan det är falskt:

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

Antalet iterationer av FOR-slingan är känt i förväg:

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

I FOREACH-loopen, itererar över elementen i en array eller samling (hashtabell):

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

Matriser

PowerShell-variabler lagrar inte bara enstaka objekt (nummer, sträng, etc.), utan även flera. Den enklaste typen av sådana variabler är arrayer. En array kan bestå av flera element, ett element, eller vara tom, d.v.s. innehåller inga element. Det deklareras med @()-operatorn, som vi kommer att behöva i nästa artikel - det är mycket viktigt för att lägga till andra arrayer till en array (skapa flerdimensionella arrayer), skicka arrayer till funktioner som ett argument och liknande uppgifter:

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

När en array initieras listas dess värden separerade med kommatecken (speciell operator ,):

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

I de flesta fall kan @()-operatorn utelämnas:

$test_array = 1, 2, 3, 4

I detta fall initieras en array av ett element enligt följande

$test_array = , 1

Matriselement nås med hjälp av ett nollbaserat heltalsindex och indexoperatorn (hakparenteser):

$test_array[0] = 1

Du kan ange flera index separerade med kommatecken, inkl. återkommande:

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

Operatör .. (två punkter - områdesoperator) returnerar en matris med heltal inom de angivna övre och nedre gränserna. Till exempel, uttryck 1..4 matar ut en matris med fyra element @(1, 2, 3, 4), och uttryck 8..5 matar ut en matris @(8, 7, 6, 5).

Med hjälp av intervalloperatorn kan du initiera en array ($test_array = 1..4) eller få en slice (slice), d.v.s. en sekvens av element från en array med index från en annan. I det här fallet anger ett negativt tal -1 det sista elementet i arrayen, -2 - det näst sista, och så vidare.

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

Observera att heltalsmatrisvärden kan vara större än det maximala indexvärdet för datamatrisen. I det här fallet returneras alla värden upp till det sista:

$test_array[0..100]

Om du försöker komma åt ett enda icke-existerande arrayelement returneras $null.

I PowerShell kan arrayer innehålla element av olika typer eller vara starkt typade:

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

Där egenskapen $test_array.count är antalet arrayelement.

Ett exempel på att skapa en starkt skriven array:

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

Hash tabeller

En annan grundläggande typ av variabler i PowerShell-språket är hashtabeller, även kända som associativa arrayer. Hashtabeller liknar JSON-objekt och är byggda på nyckel-värde-basis. Till skillnad från vanliga arrayer nås deras element med namngivna nycklar, som är egenskaper för objektet (du kan också använda indexoperatorn - hakparenteser).

En tom hashtabell deklareras med @-symbolen och operatorparenteser:

$test_hashtable = @{}

När du deklarerar kan du omedelbart skapa nycklar och tilldela dem värden:

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

För att lägga till ett element i en hashtabell måste du tilldela en nyckel som ännu inte finns till den, eller använda metoden Lägg till (). Om en tilldelning görs till en befintlig nyckel kommer dess värde att ändras. Metoden Remove() används för att ta bort ett element från en hashtabell.

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

Variabler av denna typ kan skickas som argument till funktioner och cmdlets - i nästa artikel kommer vi att studera hur detta går till, och även överväga en annan liknande typ - PSCustomObject.

funktioner

PowerShell har allt du behöver för procedurprogrammering, inklusive funktioner. För att beskriva dem används funktionsordet Funktion, varefter du behöver ange namnet på funktionen och kroppen inom operatörsparentes. Om du behöver skicka argument till funktionen kan du ange dem direkt efter namnet inom parentes.

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

Funktionen returnerar alltid ett resultat - det är en uppsättning av resultaten av alla dess uttalanden, om det finns fler än en. Om det bara finns en sats returneras det enda värdet av motsvarande typ. Return $value-konstruktionen lägger till ett element med värdet $value till resultatmatrisen och avbryter exekveringen av satslistan, och den tomma funktionen returnerar $null.

Låt oss till exempel skapa en funktion för att kvadrera ett tal:

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

Observera att i en funktions brödtext kan du använda alla variabler som deklarerats innan du anropar den, och att anropa funktioner i PowerShell kan verka ovanligt: ​​argumenten (om några) är inte omgivna inom parentes och separeras med mellanslag.

sqr 2

eller så här:

sqr -number 2

På grund av hur argument skickas måste själva funktionen ibland vara innesluten inom parentes:

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

När du beskriver en funktion kan du tilldela standardvärden till argument:

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

Det finns en annan syntax för att beskriva funktionsargument, dessutom kan parametrar läsas från pipelinen - allt detta kommer väl till pass i nästa artikel, när vi tittar på exporterade moduler och skapar våra egna cmdlets.

Fel vid bearbetning

PowerShell har en Try...Catch...Äntligen mekanism för att hantera undantag. Try-blocket innehåller koden där ett fel kan uppstå, och Catch-blocket innehåller dess hanterare. Om det inte fanns något fel exekveras det inte. Finally-blocket exekveras efter Try-blocket, oavsett förekomsten av ett fel, och det kan finnas flera Catch-block för olika typer av undantag. Själva undantaget skrivs till en odeklarerad standardvariabel ($_) och kan enkelt hämtas. I exemplet nedan implementerar vi skydd mot att ange ett ogiltigt värde:

try {

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

} catch {

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

}

Detta avslutar genomgången av grunderna för programmering i PowerShell-språket. I följande artiklar kommer vi att studera mer i detalj att arbeta med variabler av olika typer, samlingar, reguljära uttryck, skapa funktioner, moduler och anpassade cmdlets, samt objektorienterad programmering.

Källa: will.com