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, flerparadigmespråk som har elementer av klassisk prosedyremessig, objektorientert og til og med funksjonell programmering: betinget forgrening, løkker, variabler, arrayer, hash-tabeller, klasser, feilhåndtering, samt funksjoner, cmdleter og pipelines. var viet til det grunnleggende om å jobbe i miljøet, og nå tilbyr vi leserne våre en liten oppslagsbok for programmerere.
Bekreftelse:
Du kan skrive kode i et hvilket som helst tekstredigeringsprogram eller ved hjelp av et integrert utviklingsmiljø – den enkleste måten er å hente Windows PowerShell ISE fra leveringssettet for Microsofts serveroperativsystem. Dette er bare nødvendig for ganske komplekse skript: korte sett med kommandoer er enklere å utføre interaktivt.
kommentarer
Bruk av kommentarer regnes som en del av god programmeringsstil, sammen med riktig innrykk og avstand:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Variabler og deres typer
Variabler i PowerShell er navngitte objekter. Navnene deres kan inneholde understrekninger, samt bokstaver og tall. Navnet innledes alltid av $-symbolet, og for å deklarere en variabel trenger du bare å gi tolken et gyldig navn:
For å initialisere en variabel (tildele den en verdi), brukes tildelingsoperatoren (symbolet =):
$test = 100Du kan deklarere en variabel ved å spesifisere typen i hakeparenteser (type casting-operator) før navnet eller verdien:
[int]$test = 100
$test = [int]100Det er viktig å forstå at variabler i PowerShell er fullverdige objekter (klasser) med egenskaper og metoder, hvis typer er basert på de i .NET Core. La oss liste opp de viktigste:
Type (.NET-klasse)
beskrivelse
Kode eksempel
[streng] System.StringUnicode-streng
$test = "test"
$test = 'test'
Unicode-tegn (16 bit)
[char]$test = 'c' [bool] System.Booleanboolsk type (logisk verdi Sann eller Usann)
[bool]$test = $true [int] System.Int32trettito-bits heltall (32 bits)
[int]$test = 123456789 [long] System.Int64sekstifire-bits heltall (64 bit)
[long]$test = 12345678910 [single] System.Single32-bit flyttall
[single]$test = 12345.6789 [double] System.Double64-bit (8-byte) flyttall
[double]$test = 123456789.101112 [desimal] System.Decimal128-bit flyttall (krever d på slutten)
[desimal]$test = 12345.6789d [Dato og klokkeslett] System.Dato og klokkeslettdato og klokkeslett
$test = Hent-dato
[array]System.Object[]matrise hvis elementindeks starter fra 0
$test_array = 1, 2, "test", 3, 4
[hashtabell] System.Collections.HashtabellHash-tabeller er assosiative matriser med navngitte nøkler, bygget i henhold til prinsippet: @{key = "value"}
$test_hashtable = @{one="one"; two="to"; three="tre"}
PowerShell støtter implisitt typekonvertering, og variabeltypen kan endres umiddelbart (for eksempel ved å bruke tildelingsoperatoren) hvis den ikke er spesifisert med tvang – i dette tilfellet vil tolken returnere en feil. Du kan bestemme variabeltypen fra forrige eksempel ved å kalle GetType()-metoden:
$test.GetType().FullName 
Det finnes en rekke cmdleter for å administrere variabler. En liste over dem i en praktisk form vises ved hjelp av kommandoen:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap 
For å se deklarerte variabler og verdiene deres, kan du bruke en spesiell cmdlet:
Get-Variable | moreDenne metoden virker for tungvint; det er mye mer praktisk å jobbe med variabler gjennom operatorer eller ved å få direkte tilgang til egenskapene og metodene deres. Cmdlets har imidlertid en rett til å eksistere, siden de lar deg angi noen tilleggsparametere. Det er viktig å forstå at brukervariabler bare defineres i den gjeldende økten. Etter at konsollen er lukket eller skriptet er fullført, slettes de.
Systemvariabler
I tillegg til de som er deklarert av brukeren, finnes det innebygde (system)variabler som ikke slettes etter at den gjeldende økten er avsluttet. De er delt inn i to typer, med PowerShell-tilstandsdata lagret i automatiske variabler som ikke kan tildeles vilkårlige verdier. Disse inkluderer for eksempel $PWD:
$PWD.Path 
Preferansevariabler er nødvendige for å lagre brukerinnstillinger, hvis verdier kan endres. For eksempel brukes $ErrorActionPreference til å angi kommandotolkens reaksjon på ikke-kritiske feil.
I tillegg til operatorer og cmdleter for tilgang til deklarerte variabler, finnes det en pseudo-stasjonsvariabel:. Du kan jobbe med den på samme måte som med andre stasjoner, og variablene i dette tilfellet ligner på filsystemobjekter:
Get-ChildItem Variable: | moreeller
ls Variable: | more 
Omfang av synlighet
Det finnes et konsept med omfang for variabler i PowerShell. Det globale omfanget gjelder for hele den gjeldende økten – det inkluderer for eksempel systemvariabler. Lokale variabler er bare tilgjengelige i omfanget der de ble definert: for eksempel inne i en funksjon. Det finnes også et konsept med skriptomfang, men for skriptkommandoer er det i hovedsak lokalt. Som standard, når variabler deklareres, tildeles de et lokalt omfang, og for å endre dette trenger du en spesiell konstruksjon av formen: $Global: variabel = verdi.
For eksempel, slik som dette:
$Global:test = 100
Miljøvariabler
En annen pseudodriver, Env:, er tilgjengelig fra PowerShell, som gir deg tilgang til miljøvariabler. Når skallet starter, kopieres de fra den overordnede prosessen (dvs. fra programmet som startet gjeldende økt), og vanligvis er startverdiene deres de samme som verdiene i kontrollpanelet. For å vise miljøvariabler, bruk Get-ChildItem-cmdleten eller aliasene: ls og dir.
dir Env: 
Disse variablene er sekvenser av byte (eller tegn, om du foretrekker det) hvis tolkning avhenger helt av programmet som bruker dem. *-Variable cmdlets fungerer ikke med miljøvariabler. For å få tilgang til dem må du bruke stasjonsprefikset:
$env:TEST = "Hello, World!" 
Aritmetiske og sammenligningsoperatorer
PowerShell har følgende aritmetiske operatorer: + (addisjon), - (subtraksjon), * (multiplikasjon), / (divisjon) og % (modulus eller rest). Resultatet av et aritmetisk uttrykk evalueres fra venstre mot høyre i henhold til den konvensjonelle rekkefølgen av operasjoner, og parenteser brukes til å gruppere deler av uttrykket. Mellomrom mellom operatorer ignoreres og brukes kun for lesbarhet. + -operatoren sammenkobler også, og * -operatoren gjentar strenger. Hvis du prøver å legge til et tall i en streng, vil det bli konvertert til en streng. PowerShell har også en rekke sammenligningsoperatorer som sammenligner to verdier og returnerer et logisk Sann eller Usann:
Operatør
beskrivelse
Kode eksempel
-ekv.
Lik / Lik (analogt med = eller == på andre språk)
$test = 100
$test -eq 123
-NE
Ikke lik / Ikke lik (analogt med <> eller !=)
$test = 100
$test -ne 123
-gt
Større enn / Большое (analog >)
$test = 100
$test -gt 123
-ge
Større enn eller lik / Større enn eller lik (analog >=)
$test = 100
$test -ge 123
-lt
Mindre enn / Mindre (analog <)
$test = 100
$test -lt 123
-de
Mindre enn eller lik / Mindre enn eller lik (analog <=)
$test = 100
$test -le 123
Det finnes andre lignende operatorer som for eksempel tillater sammenligning av strenger ved å ta hensyn til jokertegnet eller bruk av regulære uttrykk for å søke etter et mønstersamsvar. Vi vil se nærmere på dem i de følgende artiklene. Symbolene <, > og = brukes ikke til sammenligning, siden de brukes til andre formål.
Tildelingsoperatorer
I tillegg til den vanligste operatoren =, finnes det andre tildelingsoperatorer: +=, -=, *=, /= og %=. De endrer verdien før tildeling. De unære operatorene ++ og —, som øker eller reduserer verdien av en variabel, oppfører seg på lignende måte; de tilhører også tildelingsoperatorer.
Logiske operatorer
For å beskrive komplekse forhold er ikke sammenligning alene nok. Alle logiske uttrykk kan skrives ved hjelp av operatorer: -og, -eller, -xeller, -ikke og!. De fungerer som i andre programmeringsspråk, og du kan bruke parenteser for å angi beregningsrekkefølgen:
("Тест" -eq "Тест") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Betinget hopp
Forgreningsoperatorene 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
Det finnes flere typer løkker i PowerShell: WHILE, DO WHILE, DO UNTIL, FOR og FOREACH.
En løkke med en forutsetning fungerer hvis/mens forutsetningen er sann:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Lopper med en etterbetingelse vil fungere minst én gang, fordi betingelsen kontrolleres etter at iterasjonen er fullført. I dette tilfellet fungerer DO WHILE mens betingelsen er sann, og DO UNTIL 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
}
FOREACH-løkken itererer gjennom 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 osv.), men også flere. Den enkleste typen slike variabler er arrayer. En array kan bestå av flere elementer, ett element, eller være tom, dvs. ikke inneholde noen elementer. For å deklarere den brukes @()-operatoren, som vi trenger i neste artikkel – den er svært viktig for å legge til andre arrayer i en array (opprette flerdimensjonale arrayer), sende arrayer til funksjoner som et argument, og lignende oppgaver:
$test_array = @() #создаем пустой массивNår du initialiserer en matrise, vises verdiene atskilt med komma (spesiell operator ,):
$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов I de fleste tilfeller kan @()-operatoren utelates:
$test_array = 1, 2, 3, 4I dette tilfellet initialiseres en matrise med ett element som følger
$test_array = , 1For å få tilgang til arrayelementer, bruk en nullbasert heltallsindeks og indeksoperatoren (hakeparenteser):
$test_array[0] = 1Du kan angi flere indekser atskilt med komma, inkludert gjentakende indekser:
$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0] 
Operatør .. (to prikker - områdeoperatoren) returnerer en matrise med heltall på et segment definert av dets øvre og nedre grenser. For eksempel gir uttrykket 1..4 en matrise med fire elementer @(1, 2, 3, 4), og uttrykket 8..5 gir en matrise @(8, 7, 6, 5).
Ved å bruke range-operatoren kan du initialisere en matrise ($test_array = 1..4) eller få et stykke, dvs. en sekvens av elementer i én matrise med indekser fra en annen. I dette tilfellet betegner det negative tallet -1 det siste elementet i matrisen, -2 det nest siste, osv.
$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Merk at verdiene i en heltallsmatrise 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 element i en array, returneres verdien $null.
I PowerShell kan arrayer inneholde elementer av forskjellige typer eller være sterkt typebestemte:
$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
Der $test_array.count-egenskapen er antall elementer i arrayet.
Eksempel på å lage en sterkt typet array:
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Hash-tabeller
En annen grunnleggende variabeltype i PowerShell-språket er en hashtabell, også kalt en assosiativ array. Hashtabeller ligner på JSON-objekter og er bygget på nøkkel-verdi-prinsippet. I motsetning til vanlige arrayer, nås elementene deres via navngitte nøkler, som er egenskaper ved objektet (du kan også bruke indeksoperatoren - hakeparenteser).
En tom hash-tabell deklareres ved hjelp av @-symbolet og operatorparenteser:
$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 det en nøkkel som ikke finnes ennå, eller bruke Add()-metoden. Hvis tilordningen gjøres med en eksisterende nøkkel, vil verdien endres. For å fjerne et element fra en hashtabell, bruk Remove()-metoden.
$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 cmdleter – i neste artikkel skal vi studere hvordan man gjør dette, og også vurdere en annen lignende type – PSCustomObject.
funksjoner
PowerShell har alle elementene som er nødvendige for prosedyreprogrammering, inkludert funksjoner. For å beskrive dem, bruk tjenesteordet Function, etterfulgt av funksjonsnavnet og brødteksten omsluttet av operatorparenteser. Hvis du trenger å sende argumenter til funksjonen, kan du spesifisere dem rett etter navnet i parentes.
function имя-функции (аргумент1, ..., аргументN)
{
тело-функции
}
Funksjonen returnerer alltid et resultat, som er en matrise av resultatene av alle setningene hvis det er mer enn én. Hvis det bare er én setning, returneres én verdi av den tilsvarende typen. Return $value-konstruksjonen legger til et element med verdien $value i resultatmatrisen og avslutter utførelsen av setningslisten, og en tom funksjon returnerer $null.
Som et eksempel, la oss lage en funksjon for å kvadrere et tall:
function sqr ($number)
{
return $number * $number
}
Merk at du kan bruke alle variabler som er deklarert før du kaller funksjonen i funksjonsdelen, og det kan virke uvanlig å kalle funksjoner i PowerShell: argumenter (hvis noen) er ikke omsluttet av parenteser og er atskilt med mellomrom.
sqr 2eller så:
sqr -number 2På grunn av måten argumenter sendes på, må selve funksjonen noen ganger omsluttes av parenteser:
function test_func ($n) {}
test_func -eq $null # функция не вызывалась
(test_func) -eq $null # результат выражения — $true 
Når du beskriver en funksjon, kan du tilordne standardverdier til argumenter:
function func ($arg = value) {
#тело функции
}
Det finnes også en annen syntaks for å beskrive funksjonsargumenter, og parametere kan leses fra pipelinen – alt dette vil komme 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…Finally-mekanisme som lar deg håndtere eksepsjonelle situasjoner. Try-blokken inneholder kode som kan forårsake en feil, og Catch-blokken inneholder dens behandler. Hvis det ikke var noen feil, blir den ikke utført. Finally-blokken utføres etter Try-blokken uavhengig av om det oppsto en feil, og det kan være flere Catch-blokker for unntak av forskjellige typer. Selve unntaket skrives til en standardvariabel ($_) som ikke krever deklarasjon og enkelt kan hentes. I eksemplet nedenfor implementerer vi beskyttelse mot å angi feil verdi:
try {
[int]$test = Read-Host "Введите число"
100 / $test
} catch {
Write-Warning "Некорректное число"
Write-Host $_
}
Dette avslutter vår diskusjon av det grunnleggende om programmering i PowerShell. I de følgende artiklene skal vi se nærmere på å jobbe med variabler av forskjellige typer, samlinger, regulære uttrykk, opprette funksjoner, moduler og tilpassede cmdleter, samt objektorientert programmering.
Kilde: www.habr.com
