Hva er Windows PowerShell og hva spises det med? Del 2: Introduksjon til programmeringsspråket

Historisk sett er kommandolinjeverktøy på Unix-systemer bedre utviklet enn på Windows, men med ankomsten av en ny løsning har situasjonen endret seg.

PowerShell lar deg skrive skript i et tolket språk med flere paradigmer som inneholder elementer av klassisk prosedyremessig, objektorientert og til og med funksjonell programmering: betinget gren, løkker, variabler, arrays, hashtabeller, klasser, feilhåndtering, samt funksjoner, cmdlets og pipelines . Forrige artikkel var viet til det grunnleggende om å jobbe i miljøet, og nå tilbyr vi våre lesere en liten oppslagsbok for programmerere.

Bekreftelse:

kommentarer
Variabler og deres typer
Systemvariabler
Omfang
Miljøvariabler (miljø)
Aritmetiske og sammenligningsoperatorer
Oppdragsoperatører
Logiske operatører
Betinget hopp
Sykler
arrays
Hash-tabeller
funksjoner
Feil under behandling

Du kan skrive kode i et hvilket som helst tekstredigeringsprogram eller ved å bruke et integrert utviklingsmiljø - den enkleste måten er å ta Windows PowerShell ISE som følger med Microsofts serveroperativsystemer. Dette er bare nødvendig for ganske komplekse skript: korte sett med kommandoer er lettere å utføre interaktivt.

kommentarer

Å bruke kommentarer anses som en del av god programmeringsstil sammen med riktig innrykk og mellomrom:

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

<# 

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

#>

Variabler og deres typer

Variabler i PowerShell er navngitte objekter. Navnene deres kan inneholde understrek, samt bokstaver og tall. $-symbolet brukes alltid foran navnet, og for å deklarere en variabel er det nok å gi tolken et gyldig navn:

For å initialisere en variabel (tilordne en verdi til den), brukes tilordningsoperatoren (symbol =):

$test = 100

Du kan erklære en variabel ved å spesifisere typen i hakeparenteser (type casting-operator) før navnet eller verdien:

[int]$test = 100

$test = [int]100

Det er viktig å forstå at variabler i PowerShell er fullverdige objekter (klasser) med egenskaper og metoder hvis typer er basert på de i .NET Core. Vi lister opp de viktigste:

Type (.NET-klasse)

beskrivelse

Kode eksempel

[streng] System.String

Unicode-streng 

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

[char]System.Char

Unicode-tegn (16 bits)

[char]$test = 'c'

[bool] System.Boolean

boolsk type (boolsk verdi sant eller usant)

[bool]$test = $true

[int] System.Int32

trettito bits heltall (32 bits)

[int]$test = 123456789

[lang] System.Int64

sekstifire bits heltall (64 bits)

[lang]$test = 12345678910

[single] System.Single

flytende komma nummer 32 biter lang

[single]$test = 12345.6789

[double]System.Double

flytende komma antall lengde 64 bits (8 byte)

[dobbel]$test = 123456789.101112

[desimal]System.Desimal

128-bits flyttallnummer (påkrevd for å slutte med d)

[desimal]$test = 12345.6789d

[DateTime] System.DateTime

dato og klokkeslett 

$test = GetDate

[array] System.Object[]

en matrise hvis elementindeks starter på 0

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

[hashtable] System.Collections.Hashtable

hash-tabeller er assosiative arrays med navngitte nøkler, bygget i henhold til prinsippet: @{key = "value"}

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

PowerShell støtter implisitt typekonvertering, i tillegg kan typen til en variabel endres i farten (for eksempel ved å bruke en tilordningsoperatør), hvis den ikke er spesifisert med makt - i dette tilfellet vil tolken gi en feil. Du kan bestemme typen av variabelen fra forrige eksempel ved å kalle GetType()-metoden:

$test.GetType().FullName

Det finnes en rekke cmdlets for å manipulere variabler. Listen deres i en praktisk form vises ved hjelp av kommandoen:

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

For å se deklarerte variabler og deres verdier, kan du bruke en spesiell cmdlet:

Get-Variable | more

Denne metoden virker altfor tungvint, det er mye mer praktisk å jobbe med variabler gjennom operatører eller ved å få direkte tilgang til egenskapene og metodene deres. Men cmdlets har rett til å eksistere fordi de lar deg angi noen ekstra parametere. Det er viktig å forstå at brukervariabler bare er definert i den gjeldende økten. Når konsollen lukkes eller skriptet avsluttes, slettes de.

Systemvariabler

I tillegg til de som er deklarert av brukeren, er det innebygde (system)variabler som ikke slettes etter at den gjeldende økten avsluttes. De er delt inn i to typer, mens PowerShell-tilstandsdata lagres i automatiske variabler som ikke kan tildeles vilkårlige verdier på egen hånd. Disse inkluderer for eksempel $PWD:

$PWD.Path

Preferansevariabler er nødvendige for å lagre brukerpreferanser, hvis verdier kan endres. For eksempel, ved å bruke $ErrorActionPreference, settes reaksjonen til kommandotolkeren på forekomsten av ikke-fatale feil.

I tillegg til operatorer og cmdlets for tilgang til deklarerte variabler, er det en Variable: pseudo-akkumulator. Du kan jobbe med det analogt med andre stasjoner, og variablene i dette tilfellet ligner filsystemobjekter:

Get-ChildItem Variable: | more

eller

ls Variable: | more

Omfang

For variabler i PowerShell er det konseptet scope (Scope). Handlingen til det globale omfanget (Global) gjelder for hele den gjeldende økten - den inkluderer for eksempel systemvariabler. Lokale (lokale) variabler er kun tilgjengelige i omfanget der de ble definert: si innenfor en funksjon. Det er også konseptet med omfanget av skriptet (Script), men for skriptkommandoer er det i hovedsak lokalt. Som standard, når du deklarerer variabler, får de et lokalt omfang, og for å endre dette trenger du en spesiell konstruksjon som: $Global: variabel = verdi.

For eksempel slik:

$Global:test = 100

Miljøvariabler (miljø)

En annen pseudo-stasjon, Env:, er tilgjengelig fra PowerShell og kan brukes til å få tilgang til miljøvariabler. Når skallet starter, blir de kopiert fra den overordnede prosessen (det vil si fra programmet som startet den gjeldende økten) og vanligvis er de opprinnelige verdiene de samme som verdiene i kontrollpanelet. For å vise miljøvariabler, bruk Get-ChildItem-cmdleten eller dens aliaser (aliaser): ls og dir.

dir Env:

Disse variablene er sekvenser av byte (eller tegn, hvis du vil), tolkningen av disse avhenger bare av programmet som bruker dem. *-Variable cmdletene fungerer ikke med miljøvariabler. For å få tilgang til dem må du bruke stasjonsprefikset:

$env:TEST = "Hello, World!"

Aritmetiske og sammenligningsoperatorer

PowerShell gir følgende aritmetiske operatorer: + (addisjon), - (subtraksjon), * (multipliker), / (divisjon) og % (modulo eller modulo). Resultatet av et aritmetisk uttrykk evalueres fra venstre til høyre i samsvar med den allment aksepterte rekkefølgen av operasjoner, og parenteser brukes til å gruppere deler av uttrykket. Mellomrom mellom operatører ignoreres, de brukes kun for å gjøre det lettere å lese. Operatoren + kobles også sammen, og operatoren * gjentar strenger. Hvis du prøver å legge til et tall i en streng, vil det bli konvertert til en streng. I tillegg har PowerShell-språket mange sammenligningsoperatorer som sjekker for samsvar mellom to verdier og returnerer boolsk True eller False:

Operatør

beskrivelse

Kode eksempel

-eq

Lik / Lik (lik = eller == på andre språk)

$test = 100
$test -eq 123 

-NE

Ikke lik / Ikke lik (lik <> eller !=)

$test = 100
$test -ne 123   

-gt

Større enn / Mer (analog >)

$test = 100
$test -gt 123

-gi

Større enn eller lik / Større enn eller lik (ligner på >=)

$test = 100
$test -ge 123

-lt

Mindre enn / Mindre (analog <)

$test = 100
$test -lt 123  

-de

Mindre enn eller lik / Mindre enn eller lik (lik <=)

$test = 100
$test -le 123

Det finnes andre lignende operatorer som lar deg for eksempel sammenligne strenger basert på et jokertegn eller bruke regulære uttrykk for å matche et mønster. Vi vil dekke dem i detalj i fremtidige artikler. Symbolene <, > og = brukes ikke til sammenligning fordi de brukes til andre formål.

Oppdragsoperatører

I tillegg til den vanligste operatoren =, er det andre tilordningsoperatorer: +=, -=, *=, /= og %=. De endrer verdien før tildeling. De unære operatorene ++ og -, som øker eller reduserer verdien av en variabel, oppfører seg på samme måte - de tilhører også tilordningsoperatorer.

Logiske operatører

Sammenligning alene er ikke nok til å beskrive komplekse forhold. Du kan skrive alle logiske uttrykk ved å bruke operatorene: -og, -eller, -xor, -not and! .. De fungerer som i andre programmeringsspråk, mens du kan bruke parenteser for å spesifisere evalueringsrekkefølgen:

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

-not (123 -gt 321) 

!(123 -gt 321)

Betinget hopp

Forgreningsoperatører i PowerShell er standard: IF(IF...ELSE, IF...ELSEIF...ELSE) og SWITCH. La oss se på bruken av dem 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 или значение не определено"}
}

Sykler

PowerShell har flere varianter av løkker: WHILE, DO WHILE, DO TILL, FOR og FOREACH.

En sløyfe med en forutsetning kjører hvis/mens den er sann:

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

Sløyfer med en postbetingelse vil kjøre minst én gang, fordi tilstanden kontrolleres etter iterasjonen. Samtidig fungerer DO WHILE mens tilstanden er sann, og DO TIL fungerer mens den er usann:

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

Antall iterasjoner av FOR-løkken er kjent på forhånd:

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

I FOREACH-løkken, itererer over elementene i en matrise eller samling (hash-tabell):

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

arrays

PowerShell-variabler lagrer ikke bare enkeltobjekter (tall, streng, etc.), men også flere. Den enkleste typen slike variabler er matriser. En matrise kan bestå av flere elementer, ett element, eller være tom, dvs. inneholder ingen elementer. Det er deklarert ved å bruke @()-operatoren, som vi trenger i neste artikkel - det er veldig viktig for å legge til andre arrays til en array (opprette flerdimensjonale arrays), sende arrays til funksjoner som et argument og lignende oppgaver:

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

Når en matrise initialiseres, er verdiene oppført atskilt med kommaer (spesiell operator ,):

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

I de fleste tilfeller kan @()-operatoren utelates:

$test_array = 1, 2, 3, 4

I dette tilfellet initialiseres en matrise med ett element som følger

$test_array = , 1

Matriseelementer åpnes ved å bruke en nullbasert heltallsindeks og indeksoperatoren (firkantede parenteser):

$test_array[0] = 1

Du kan angi flere indekser atskilt med komma, inkl. gjentakende:

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

Operatør .. (to prikker - områdeoperator) returnerer en rekke heltall innenfor de angitte øvre og nedre grensene. For eksempel gir uttrykk 1..4 ut en matrise med fire elementer @(1, 2, 3, 4), og uttrykk 8..5 gir ut en matrise @(8, 7, 6, 5).

Ved å bruke områdeoperatoren kan du initialisere en matrise ($test_array = 1..4) eller få en skive (slice), dvs. en sekvens av elementer fra en matrise med indekser fra en annen. I dette tilfellet angir et negativt tall -1 det siste elementet i matrisen, -2 - det nest siste, og så videre.

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

Merk at heltallsmatriseverdier kan være større enn den maksimale indeksverdien til datamatrisen. I dette tilfellet returneres alle verdier opp til den siste:

$test_array[0..100]

Hvis du prøver å få tilgang til et enkelt ikke-eksisterende array-element, returneres verdien $null.

I PowerShell kan arrays inneholde elementer av forskjellige typer eller være sterkt skrevet:

$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-egenskapen er antall array-elementer.

Et eksempel på å lage en sterkt skrevet matrise:

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

Hash-tabeller

En annen grunnleggende type variabler i PowerShell-språket er hash-tabeller, også kjent som assosiative arrays. Hashtabeller ligner på JSON-objekter og er bygget på nøkkelverdi-basis. I motsetning til vanlige arrays, er elementene deres tilgang til av navngitte nøkler, som er egenskapene til objektet (du kan også bruke indeksoperatoren - hakeparenteser).

En tom hash-tabell er deklarert ved å bruke @-symbolet og operatørparentesene:

$test_hashtable = @{}

Når du deklarerer, kan du umiddelbart opprette nøkler og tilordne verdier til dem:

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

For å legge til et element i en hashtabell, må du tilordne en nøkkel som ennå ikke eksisterer til den, eller bruke Add ()-metoden. Hvis en tilordning gjøres til en eksisterende nøkkel, vil verdien endres. Remove()-metoden brukes til å fjerne et element fra en hash-tabell.

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

Variabler av denne typen kan sendes som argumenter til funksjoner og cmdlets - i neste artikkel skal vi studere hvordan dette gjøres, og også vurdere en annen lignende type - PSCustomObject.

funksjoner

PowerShell har alt du trenger for prosedyreprogrammering, inkludert funksjoner. For å beskrive dem brukes funksjonsordet Funksjon, hvoretter du må spesifisere navnet på funksjonen og kroppen i operatørparentes. Hvis du trenger å sende argumenter til funksjonen, kan du spesifisere dem umiddelbart etter navnet i parentes.

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

Funksjonen returnerer alltid et resultat - det er en rekke av resultatene av alle setningene, hvis det er mer enn én. Hvis det bare er ett utsagn, returneres den eneste verdien av den tilsvarende typen. Return $value-konstruksjonen legger til et element med verdien $value til resultatmatrisen og avbryter utførelsen av setningslisten, og den tomme funksjonen returnerer $null.

La oss for eksempel lage en funksjon for å kvadrere et tall:

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

Legg merke til at i brødteksten til en funksjon kan du bruke alle variabler som er deklarert før den kalles, og å kalle funksjoner i PowerShell kan virke uvanlig: argumentene (hvis noen) er ikke omsluttet av parentes og er atskilt med mellomrom.

sqr 2

eller så:

sqr -number 2

På grunn av måten argumenter sendes på, må selve funksjonen noen ganger omsluttes i parentes:

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

Når du beskriver en funksjon, kan du tilordne standardverdier til argumentene:

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

Det er en annen syntaks for å beskrive funksjonsargumenter, i tillegg kan parametere leses fra pipelinen - alt dette kommer godt med i neste artikkel, når vi ser på eksporterte moduler og lager våre egne cmdlets.

Feil under behandling

PowerShell har en Try...Catch...Endelig-mekanisme for å håndtere unntak. Try-blokken inneholder koden der en feil kan oppstå, og Catch-blokken inneholder behandleren. Hvis det ikke var noen feil, blir den ikke utført. Finally-blokken utføres etter Try-blokken, uavhengig av forekomsten av en feil, og det kan være flere Catch-blokker for ulike typer unntak. Selve unntaket er skrevet til en ikke-erklært standardvariabel ($_) og kan enkelt hentes. I eksemplet nedenfor implementerer vi beskyttelse mot å angi en ugyldig verdi:

try {

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

} catch {

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

}

Dette avslutter gjennomgangen av det grunnleggende om programmering i PowerShell-språket. I de følgende artiklene vil vi studere mer detaljert arbeid med variabler av ulike typer, samlinger, regulære uttrykk, lage funksjoner, moduler og tilpassede cmdlets, samt objektorientert programmering.

Kilde: www.habr.com