Hvad er Windows PowerShell, og hvad spises det med? Del 2: Introduktion til programmeringssproget

Historisk set er kommandolinjeværktøjer på Unix-systemer bedre udviklet end på Windows, men med fremkomsten af ​​en ny løsning har situationen ændret sig.

PowerShell kan scriptes i et fortolket, multi-paradigme sprog, der har elementer af klassisk proceduremæssig, objektorienteret og endda funktionel programmering: betinget forgrening, loops, variabler, arrays, hash-tabeller, klasser, fejlhåndtering, såvel som funktioner, cmdlets og pipelines . Forrige artikel var viet til det grundlæggende i at arbejde i miljøet, og nu tilbyder vi vores læsere en lille opslagsbog til programmører.

Indholdsfortegnelse:

Kommentarer
Variabler og deres typer
Systemvariabler
Omfang
Miljøvariabler (miljø)
Aritmetiske og sammenligningsoperatorer
Opgaveoperatører
Logiske operatører
Betinget hop
cykler
Arrays
Hash tabeller
Funktioner
Fejl ved behandling

Du kan skrive kode i enhver teksteditor eller ved at bruge et integreret udviklingsmiljø - den nemmeste måde er at tage Windows PowerShell ISE, der følger med Microsofts serveroperativsystemer. Dette er kun nødvendigt for ret komplekse scripts: korte sæt kommandoer er nemmere at udføre interaktivt.

Kommentarer

Brug af kommentarer betragtes som en del af god programmeringsstil sammen med korrekt indrykning og mellemrum:

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

<# 

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

#>

Variabler og deres typer

Variabler i PowerShell er navngivne objekter. Deres navne kan indeholde understregningstegn samt bogstaver og tal. $-symbolet bruges altid før navnet, og for at erklære en variabel er det nok at give fortolkeren et gyldigt navn:

For at initialisere en variabel (tildele den en værdi), bruges tildelingsoperatoren (symbol =):

$test = 100

Du kan erklære en variabel ved at angive dens type i firkantede parenteser (type casting-operator) før navnet eller værdien:

[int]$test = 100

$test = [int]100

Det er vigtigt at forstå, at variabler i PowerShell er fuldgyldige objekter (klasser) med egenskaber og metoder, hvis typer er baseret på dem i .NET Core. Vi lister de vigtigste:

Type (.NET klasse)

beskrivelse

Kode eksempel

[streng] System.String

Unicode streng 

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

[char]System.Char

Unicode-tegn (16 bit)

[char]$test = 'c'

[bool] System.Boolean

boolesk type (boolesk sand eller falsk)

[bool]$test = $true

[int] System.Int32

toogtredive bit heltal (32 bit)

[int]$test = 123456789

[lang] System.Int64

64 bit heltal (XNUMX bit)

[lang]$test = 12345678910

[enkelt] System.Single

flydende komma nummer 32 bit lang

[enkelt]$test = 12345.6789

[dobbelt]System.Dobbelt

flydende komma antal af længde 64 bit (8 bytes)

[dobbelt]$test = 123456789.101112

[decimal]System.Decimal

128-bit flydende kommanummer (kræves for at slutte med d)

[decimal]$test = 12345.6789d

[DateTime]System.DateTime

dato og tid 

$test = GetDate

[array] System.Object[]

et array, hvis elementindeks starter ved 0

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

[hashtable] System.Collections.Hashtable

hash-tabeller er associative arrays med navngivne nøgler, bygget efter princippet: @{key = "value"}

$test_hashtable = @{one="one"; to="to"; three="tre"}

PowerShell understøtter implicit typekonvertering, derudover kan typen af ​​en variabel ændres i farten (for eksempel ved hjælp af en tildelingsoperator), hvis den ikke er specificeret med magt - i dette tilfælde vil tolken give en fejl. Du kan bestemme typen af ​​variablen fra det forrige eksempel ved at kalde GetType() metoden:

$test.GetType().FullName

Der er en række cmdlets til at manipulere variabler. Deres liste i en bekvem form vises ved hjælp af kommandoen:

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

For at se deklarerede variabler og deres værdier kan du bruge en speciel cmdlet:

Get-Variable | more

Denne metode virker alt for besværlig, det er meget mere bekvemt at arbejde med variabler gennem operatører eller ved at få direkte adgang til deres egenskaber og metoder. Men cmdlets har ret til at eksistere, fordi de giver dig mulighed for at indstille nogle yderligere parametre. Det er vigtigt at forstå, at brugervariabler kun defineres inden for den aktuelle session. Når konsollen lukkes, eller scriptet slutter, slettes de.

Systemvariabler

Ud over dem, der er erklæret af brugeren, er der indbyggede (system)variabler, som ikke slettes efter den aktuelle session slutter. De er opdelt i to typer, mens PowerShell-tilstandsdata gemmes i automatiske variabler, der ikke kan tildeles vilkårlige værdier alene. Disse inkluderer for eksempel $PWD:

$PWD.Path

Præferencevariabler er nødvendige for at gemme brugerpræferencer, hvis værdier kan ændres. For eksempel, ved at bruge $ErrorActionPreference, indstilles kommandofortolkerens reaktion på forekomsten af ​​ikke-fatale fejl.

Ud over operatorer og cmdlets til at få adgang til deklarerede variabler, er der en Variable: pseudo-akkumulator. Du kan arbejde med det analogt med andre drev, og variablerne i dette tilfælde ligner filsystemobjekter:

Get-ChildItem Variable: | more

eller

ls Variable: | more

Omfang

For variabler i PowerShell er der konceptet scope (Scope). Handlingen af ​​det globale omfang (Global) gælder for hele den aktuelle session - den inkluderer f.eks. systemvariable. Lokale (lokale) variabler er kun tilgængelige i det omfang, hvor de blev defineret: sige inde i en funktion. Der er også konceptet om omfanget af scriptet (Script), men for script-kommandoer er det i det væsentlige lokalt. Som standard, når de erklærer variable, får de et lokalt omfang, og for at ændre dette skal du bruge en speciel konstruktion som: $Global: variabel = værdi.

For eksempel sådan her:

$Global:test = 100

Miljøvariabler (miljø)

Et andet pseudo-drev, Env:, er tilgængeligt fra PowerShell og kan bruges til at få adgang til miljøvariabler. Når skallen starter, kopieres de fra den overordnede proces (det vil sige fra det program, der startede den aktuelle session), og normalt er deres startværdier de samme som værdierne i kontrolpanelet. For at se miljøvariabler, brug Get-ChildItem cmdlet'en eller dens aliaser (aliaser): ls og dir.

dir Env:

Disse variabler er sekvenser af bytes (eller tegn, hvis du vil), hvis fortolkning kun afhænger af det program, der bruger dem. *-Variable cmdlet'erne virker ikke med miljøvariabler. For at få adgang til dem skal du bruge drevpræfikset:

$env:TEST = "Hello, World!"

Aritmetiske og sammenligningsoperatorer

PowerShell giver følgende aritmetiske operatorer: + (addition), - (subtraktion), * (multiplikér), / (division) og % (modulo eller modulo). Resultatet af et aritmetisk udtryk evalueres fra venstre mod højre i overensstemmelse med den almindeligt accepterede rækkefølge af operationer, og parenteser bruges til at gruppere dele af udtrykket. Mellemrum mellem operatører ignoreres, de bruges kun for at gøre det nemmere at læse. Operatoren + kædes også sammen, og operatoren * gentager strenge. Hvis du forsøger at tilføje et tal til en streng, vil det blive konverteret til en streng. Derudover har PowerShell-sproget mange sammenligningsoperatorer, der kontrollerer for et match mellem to værdier og returnerer det boolske True eller False:

operatør

beskrivelse

Kode eksempel

-ækv

Lige / Lige til (ligner = eller == på andre sprog)

$test = 100
$test -eq 123 

-Født

Ikke ens / Ikke ens (ligner <> eller !=)

$test = 100
$test -ne 123   

gt

Større end / Mere (analog>)

$test = 100
$test -gt 123

-give

Større end eller lig / Større end eller lig (ligner >=)

$test = 100
$test -ge 123

-lt

Mindre end / Mindre (ligner <)

$test = 100
$test -lt 123  

Them

Mindre end eller lig / Mindre end eller lig (ligner <=)

$test = 100
$test -le 123

Der er andre lignende operatorer, som giver dig mulighed for for eksempel at sammenligne strenge baseret på et jokertegn eller bruge regulære udtryk til at matche et mønster. Vi vil dække dem i detaljer i fremtidige artikler. Symbolerne <, > og = bruges ikke til sammenligning, fordi de bruges til andre formål.

Opgaveoperatører

Ud over den mest almindelige = operator er der andre tildelingsoperatorer: +=, -=, *=, /= og %=. De ændrer værdien før tildeling. De unære operatorer ++ og -, som øger eller mindsker værdien af ​​en variabel, opfører sig på samme måde - de gælder også for tildelingsoperatorer.

Logiske operatører

Sammenligning alene er ikke nok til at beskrive komplekse forhold. Du kan skrive alle logiske udtryk ved at bruge operatorerne: -og, -eller, -xor, -not and! .. De fungerer ligesom i andre programmeringssprog, mens du kan bruge parenteser til at angive evalueringsrækkefølgen:

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

-not (123 -gt 321) 

!(123 -gt 321)

Betinget hop

Filialoperatører i PowerShell er standard: IF(IF…ELSE, IF…ELSEIF…ELSE) og SWITCH. Lad os se på deres brug med eksempler:

[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 flere varianter af loops: WHILE, DO WHILE, DO TILL, FOR og FOREACH.

En løkke med en forudsætning virker, hvis/så længe den er sand:

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

Sløjfer med en postcondition vil køre mindst én gang, fordi betingelsen kontrolleres efter iterationen. På samme tid virker DO WHILE, mens betingelsen er sand, og DO TILL virker, mens den er falsk:

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

Antallet af iterationer af FOR-løkken er kendt på forhånd:

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

I FOREACH-løkken itereres over elementerne i en matrix eller samling (hash-tabel):

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

Arrays

PowerShell-variabler gemmer ikke kun enkelte objekter (tal, streng osv.), men også flere. Den enkleste form for sådanne variabler er arrays. Et array kan bestå af flere elementer, et element, eller være tomt, dvs. indeholder ingen elementer. Det erklæres ved hjælp af @()-operatoren, som vi skal bruge i den næste artikel - det er meget vigtigt for at tilføje andre arrays til et array (oprettelse af multidimensionelle arrays), sende arrays til funktioner som et argument og lignende opgaver:

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

Når et array initialiseres, vises dets værdier adskilt af kommaer (særlig operator ,):

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

I de fleste tilfælde kan @()-operatoren udelades:

$test_array = 1, 2, 3, 4

I dette tilfælde initialiseres et array af ét element som følger

$test_array = , 1

Array-elementer tilgås ved hjælp af et nul-baseret heltalsindeks og indeksoperatoren (kantede parenteser):

$test_array[0] = 1

Du kan angive flere indekser adskilt af kommaer, inkl. tilbagevendende:

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

operatør .. (to prikker - områdeoperator) returnerer en matrix af heltal inden for de angivne øvre og nedre grænser. For eksempel udsender udtryk 1..4 en matrix med fire elementer @(1, 2, 3, 4), og udtryk 8..5 udsender en matrix @(8, 7, 6, 5).

Ved at bruge range-operatoren kan du initialisere et array ($test_array = 1..4) eller få en slice (slice), dvs. en sekvens af elementer fra et array med indekser fra et andet. I dette tilfælde angiver et negativt tal -1 det sidste element i arrayet, -2 - det næstsidste og så videre.

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

Bemærk, at heltals array-værdier kan være større end den maksimale indeksværdi for dataarrayet. I dette tilfælde returneres alle værdier op til den sidste:

$test_array[0..100]

Hvis du forsøger at få adgang til et enkelt ikke-eksisterende array-element, returneres $null.

I PowerShell kan arrays indeholde elementer af forskellige typer eller være stærkt indtastet:

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

Hvor $test_array.count egenskaben er antallet af array-elementer.

Et eksempel på oprettelse af et stærkt indtastet array:

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

Hash tabeller

En anden grundlæggende type variabler i PowerShell-sproget er hash-tabeller, også kendt som associative arrays. Hashtables ligner JSON-objekter og er bygget på en nøgleværdi-basis. I modsætning til almindelige arrays tilgås deres elementer af navngivne nøgler, som er egenskaber for objektet (du kan også bruge indeksoperatoren - firkantede parenteser).

En tom hash-tabel erklæres ved hjælp af @-symbolet og operatorparenteser:

$test_hashtable = @{}

Når du deklarerer, kan du straks oprette nøgler og tildele værdier til dem:

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

For at tilføje et element til en hash-tabel skal du tildele en nøgle, der endnu ikke eksisterer, til den, eller bruge metoden Tilføj (). Hvis der tildeles en eksisterende nøgle, ændres dens værdi. Metoden Remove() bruges til at fjerne et element fra en hash-tabel.

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

Variabler af denne type kan overføres som argumenter til funktioner og cmdlets - i den næste artikel vil vi studere, hvordan dette gøres, og også overveje en anden lignende type - PSCustomObject.

Funktioner

PowerShell har alt hvad du behøver til proceduremæssig programmering, inklusive funktioner. Til at beskrive dem bruges funktionsordet Funktion, hvorefter du skal angive navnet på funktionen og kroppen omgivet af operatørparenteser. Hvis du skal sende argumenter til funktionen, kan du angive dem umiddelbart efter navnet i parentes.

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

Funktionen returnerer altid et resultat - det er en matrix af resultaterne af alle dens udsagn, hvis der er mere end én. Hvis der kun er et udsagn, returneres den eneste værdi af den tilsvarende type. Return $value-konstruktionen tilføjer et element med værdien $value til resultatarrayet og afbryder udførelsen af ​​sætningslisten, og den tomme funktion returnerer $null.

Lad os for eksempel oprette en funktion til at kvadrere et tal:

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

Bemærk, at i en funktions brødtekst kan du bruge alle variabler, der er erklæret før du kalder den, og at kalde funktioner i PowerShell kan virke usædvanlige: argumenterne (hvis nogen) er ikke indesluttet i parentes og er adskilt af mellemrum.

sqr 2

eller sådan her:

sqr -number 2

På grund af den måde, argumenter sendes på, skal selve funktionen nogle gange være indeholdt i parentes:

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

Når du beskriver en funktion, kan du tildele standardværdier til argumenter:

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

Der er en anden syntaks til at beskrive funktionsargumenter, derudover kan parametre læses fra pipelinen - alt dette vil være nyttigt i næste artikel, når vi ser på eksporterede moduler og laver vores egne cmdlets.

Fejl ved behandling

PowerShell har en Try...Catch...Endelig mekanisme til at håndtere undtagelser. Try-blokken indeholder koden, hvori der kan opstå en fejl, og Catch-blokken indeholder dens handler. Hvis der ikke var nogen fejl, udføres den ikke. Finally-blokken udføres efter Try-blokken, uanset forekomsten af ​​en fejl, og der kan være flere Catch-blokke for forskellige typer undtagelser. Selve undtagelsen er skrevet til en ikke-erklæret standardvariabel ($_) og kan let hentes. I eksemplet nedenfor implementerer vi beskyttelse mod at indtaste en ugyldig værdi:

try {

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

} catch {

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

}

Dette afslutter gennemgangen af ​​det grundlæggende i programmering i PowerShell-sproget. I de følgende artikler vil vi studere mere detaljeret arbejdet med variabler af forskellige typer, samlinger, regulære udtryk, oprettelse af funktioner, moduler og brugerdefinerede cmdlets samt objektorienteret programmering.

Kilde: www.habr.com