Historiskt har kommandoradsverktyg i Unix-system utvecklats bättre än i Windows, men med nya lösningar har situationen förändrats.
För PowerShell kan man skriva skript på ett tolkande multiparadigm språk som innehåller element av klassisk procedur, objektorienterad och till och med funktionell programmering: villkorssatser, loopar, variabler, arrayer, hash-tabeller, klasser, felhantering samt funktioner, cmdlets och pipelines. dedikerades till grunderna för arbete i miljön, och nu erbjuder vi läsarna en liten handbok för programmerare.
Innehåll:
Man kan skriva kod i vilken textredigerare som helst eller använda en integrerad utvecklingsmiljö — det enklaste är att använda Windows PowerShell ISE från leveransen av Microsofts serveroperativsystem. Detta behövs bara för tillräckligt komplexa skript: korta kommandosatser är enklare att utföra interaktivt.
Kommentarer
Användningen av kommentarer anses vara en del av god programmeringsstandard tillsammans med rätt indragningar och mellanrum:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Variabler och deras typer
Variabler i PowerShell är namngivna objekt. Deras namn kan inkludera understreck samt bokstäver och siffror. Före namnet används alltid symbolen $, och för att deklarera en variabel räcker det med att ange ett giltigt namn till tolken:
För att initiera en variabel (tilldela den ett värde) används tilldelningsoperatorn (symbolen =):
$test = 100En variabel kan deklareras med att ange dess typ i hakparenteser (typomvandlingsoperatorn) före namnet eller värdet:
[int]$test = 100
$test = [int]100Det är viktigt att förstå att variabler i PowerShell är fullfjädrade objekt (klasser) med egenskaper och metoder vars typer baseras på de som finns i .NET Core. Låt oss räkna upp de viktigaste:
Typ (klass .NET)
Beskrivning
Kodexempel
[string]
System.String
Unicode-sträng
$test = "test"
$test = 'test'
[char]
System.Char
Unicode-tecken (16 bitar)
[char]$test = 'c'
[bool]
System.Boolean
Boolesk typ (logiskt värde True eller False)
[bool]$test = $true
[int]
System.Int32
ett 32-bit heltal
[int]$test = 123456789
[long]
System.Int64
ett 64-bit heltal
[long]$test = 12345678910
[single]
System.Single
ett 32-bit flyttal
[single]$test = 12345.6789
[double]
System.Double
ett 64-bit flyttal (8 byte)
[double]$test = 123456789.101112
[decimal]
System.Decimal
ett 128-bit flyttal (måste avslutas med d)
[decimal]$test = 12345.6789d
[DateTime]
System.DateTime
datum och tid
$test = Get-Date
[array]
System.Object[]
ett array där elementindexet börjar från 0
$test_array = 1, 2, 'test', 3, 4
[hashtable]
System.Collections.Hashtable
hashtabeller – associativa arrayer med namngivna nycklar, uppbyggda enligt principen: @{nyckel = 'värde'}
$test_hashtable = @{one='ett'; two='två'; three='tre'}
PowerShell stöder implicit typkonvertering, dessutom kan datatypen för en variabel ändras dynamiskt (till exempel genom tilldelning) om den inte anges explicit – i så fall ger tolken ett felmeddelande. Typen för variabeln i det föregående exemplet kan bestämmas med metoden GetType():
$test.GetType().FullName 
Det finns ett antal cmdlets för att hantera variabler. Listan visas i ett praktiskt format 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 särskild cmdlet:
Get-Variable | moreDenna metod känns lite omständlig, det är mycket enklare att arbeta med variabler direkt via operatorer eller genom att komma åt deras egenskaper och metoder. Men cmdlets har sin plats, eftersom de tillåter att ange vissa ytterligare parametrar. Det är viktigt att inse att användardeklarerade variabler endast är definierade inom den aktuella sessionen. Efter att konsolen har stängts eller skriptet har avslutats raderas de.
Systemvariabler
Förutom användardeklarerade finns det inbyggda (system) variabler som inte tas bort efter att den aktuella sessionen avslutas. De delas upp i två typer, där data om PowerShells tillstånd lagras i automatiska variabler som inte kan tilldelas slumpmässiga värden. Ett exempel på detta är $PWD:
$PWD.Path 
För att lagra användarinställningar behövs preferensvariabler vars värden kan ändras. Till exempel anges reaktionen hos kommandotolken på icke-kritiska fel med hjälp av $ErrorActionPreference.
Utöver operatörer och cmdlets för att komma åt deklarerade variabler finns pseudolagringen Variable:. Man kan arbeta med den på samma sätt som med andra lagringar, och variabler i detta fall påminner om objekt i filsystemet:
Get-ChildItem Variable: | moreeller
ls Variable: | more 
Område för synlighet
För variabler i PowerShell finns begreppet synlighet (Scope). Den globala zonen (Global) omfattar hela den aktuella sessionen — den inkluderar till exempel systemvariabler. Lokala (Local) variabler är endast tillgängliga inom det område där de definierats: till exempel inuti en funktion. Det finns också begreppet skriptets zons omfattning (Script), men för skriptkommandon är den i praktiken lokal. Som standard tilldelas variabler i PowerShell en lokal omfattning vid deklaration, och för att ändra detta behövs en speciell konstruktion av typen: $Global: variabel = värde.
Till exempel så här:
$Global:test = 100
Miljövariabler
Från PowerShell finns också en annan pseudolagring Env:, som används för att komma åt miljövariabler. När skalet startas kopieras dessa från förälderprocessen (dvs. från programmet som initierade den aktuella sessionen) och deras ursprungliga värden överensstämmer oftast med värdena i kontrollpanelen. För att visa miljövariabler kan man använda cmdlet Get-ChildItem eller dess synonym (alias): ls och dir.
dir Env: 
Dessa variabler representerar följd av byte (eller tecken, om så önskas), och deras tolkning beror endast på det program som använder dem. Cmdlets *-Variable fungerar inte med miljövariabler. För att komma åt dem måste man använda diskprefixet:
$env:TEST = "Hello, World!" 
Aritmetiska operatorer och jämförelseoperatorer
I PowerShell finns följande aritmetiska operatorer: + (addition), - (subtraktion), * (multiplikation), / (division) och % (modulus eller rest av division). Resultatet av ett aritmetiskt uttryck beräknas från vänster till höger enligt den vedertagna ordningen för operationer, och för att gruppera delar av uttrycket används parenteser. Mellanslag mellan operatorerna ignoreras, de används endast för att underlätta läsningen. Operatorn + sammanfogar också, och operatorn * upprepar strängar. När man försöker addera ett tal till en sträng kommer det att konverteras till en sträng. Dessutom finns det många jämförelseoperatorer i PowerShell som kontrollerar överensstämmelse mellan två värden och returnerar logiska True eller False:
Operator
Beskrivning
Kodexempel
-eq
Lika / Equals (motsvarande = eller == i andra språk)
$test = 100
$test -eq 123
-ne
Inte lika / Not equals (motsvarande eller !=)
$test = 100
$test -ne 123
-gt
Större än / Greater than (motsvarande >)
$test = 100
$test -gt 123
-ge
Större än eller lika med / Greater than or equal (motsvarande >=)
$test = 100
$test -ge 123
-lt
Mindre än / Less than (motsvarande <)
$test = 100
$test -lt 123
-le
Mindre än eller lika med / Less than or equal (motsvarande <=)
$test = 100
$test -le 123
Det finns även andra liknande operatorer som till exempel låter dig jämföra strängar med hänsyn till wildcard-tecken eller använda reguljära uttryck för att söka efter mönster. Dessa kommer vi att gå igenom i kommande artiklar. Tecknen och = används inte för jämförelse eftersom de används för andra syften.
Tilldelningsoperatorer
Förutom den mest använda operatorn = finns det också andra tilldelningsoperatorer: +=, -=, *=, /= och %= . De ändrar värdet före tilldelning. Unära operatorer ++ och - uppför sig på liknande sätt och ökar eller minskar värdet av en variabel — de räknas också som tilldelningsoperatorer.
Logiska operatorer
För att beskriva komplexa villkor räcker det inte med endast jämförelser. Alla logiska uttryck kan skrivas med hjälp av operatorerna: -and, -or, -xor, -not och !. De fungerar på samma sätt som i andra programmeringsspråk, och man kan använda rundparenteser för att ange beräkningsordningen:
("Test" -eq "Test") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Villkorssatser
Grenoperatorerna i PowerShell är standard: IF(IF…ELSE, IF…ELSEIF…ELSE) och SWITCH. Vi går igenom 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 eller värdet är inte definierat"}
}
Loopar
I PowerShell finns det flera typer av loopar: WHILE, DO WHILE, DO UNTIL, FOR och FOREACH.
En villkorsstyrd loop fungerar så länge som villkoret är uppfyllt:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Postvillkorsloopar körs åtminstone en gång, eftersom villkorskontrollen sker efter att iterationen har genomförts. DO WHILE körs så länge villkoret är sant och DO UNTIL så länge 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 i FOR-loopen är förutbestämt:
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
I FOREACH-loopen itererar man över elementen i en array eller samling (hash-tabell):
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Arrayer
I PowerShell-variabler kan man lagra enskilda objekt (antal, strängar etc.) samt multipla. Den enklaste typen av dessa variabler är arrayer. En array kan bestå av flera element, ett enda element eller vara tom, d.v.s. inte innehålla några element. För att deklarera detta används operatorn @(), som vi kommer att behöva i nästa artikel — den är mycket viktig för att lägga till andra arrayer (skapa flerdimensionella arrayer), skicka arrayer till funktioner som argument och liknande uppgifter:
$test_array = @() #skapa en tom arrayVid initialisering av en array anges dess värden med kommatecken (specialoperator ,):
$test_array = @(1, 2, 3, 4) # skapa en array med fyra element I de flesta fall kan operatorn @() utelämnas:
$test_array = 1, 2, 3, 4I detta fall initialiseras en array med ett enda element på följande sätt
$test_array = , 1För att komma åt elementen i en array används ett heltal index som börjar på noll och indexoperatören (fyrkantiga parenteser):
$test_array[0] = 1Flera index kan anges med kommatecken, inklusive duplicerade:
$test_array = "ett", "två", "tre", "fyra"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0] 
Operator .. (tvåpunktsoperator – intervalloperator) returnerar en array av heltal inom ett givet övre och nedre intervall. Till exempel ger uttrycket 1..4 en array med fyra element @(1, 2, 3, 4), medan uttrycket 8..5 ger en array @(8, 7, 6, 5).
Med hjälp av intervalloperatorn kan man initiera en array ($test_array = 1..4) eller hämta ett urval (slice), det vill säga en sekvens av element från en array med index från en annan. Här representerar ett negativt tal -1 det sista elementet i arrayen, -2 det näst sista, och så vidare.
$test_array = "ett", "två", "tre", "fyra"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Observera att värdena i heltalsarrayen kan vara större än det maximala indexet i arrayen med data. I så fall returneras alla värden fram till det sista:
$test_array[0..100]Om man försöker komma åt ett enda icke-existerande element i arrayen returneras värdet $null.
I PowerShell kan arrayer innehålla element av olika typer eller vara strikt typade:
$test_array = 1, 2, "test", 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 element i arrayen.
Exempel på skapande av en strikt typad 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 är hash-tabeller, som också kallas associativa arrayer. Hashtable liknar JSON-objekt och bygger på principen nyckel-värde. Till skillnad från vanliga arrayer får man tillgång till deras element via namngivna nycklar som är objektets egenskaper (man kan också använda indexoperatören – hakparenteser).
En tom hash-tabell deklareras med hjälp av specialsymbolen @ och klamrar:
$test_hashtable = @{}Vid deklarationen kan man direkt skapa nycklar och tilldela dem värden:
$test_hashtable = @{one="ett"; two="två"; three="tre"; "some key"="some value"}För att lägga till ett element i hash-tabellen behöver man tilldela det ett ännu icke-existerande nyckel eller använda metoden Add(). Om tilldelningen görs med en befintlig nyckel kommer dess värde att ändras. För att ta bort ett element från hash-tabellen används metoden Remove().
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "fyra")
$test_hashtable.five = "fem"
$test_hashtable['five'] = "ändrar värdet"
$test_hashtable.Remove("one") 
Variabler av denna typ kan överföras som argument till funktioner och cmdlets — i nästa artikel kommer vi att utforska hur detta görs, samt titta på en annan liknande typ — PSCustomObject.
Funktioner
I PowerShell finns alla nödvändiga element för procedurprogrammering, inklusive funktioner. För deras beskrivning används nyckelordet Function, följt av funktionsnamnet och dess kropp inom parenteser. Om du behöver överföra argument till funktionen kan du ange dem direkt efter namnet inom parentes.
function funktionsnamn (argument1, ..., argumentN)
{
funktionskropp
}
En funktion returnerar alltid ett resultat — detta är en array av resultaten från alla dess uttalanden, om det finns mer än ett. Om det bara finns ett uttalande returneras ett enda värde av motsvarande typ. Konstruktionen return $value lägger till ett element med värdet $value till resultatarrayen och avbryter utförandet av statement list, medan en tom funktion returnerar $null.
Som exempel skapar vi en funktion för att kvadrera ett tal:
function sqr ($number)
{
return $number * $number
}
Observera att i funktionskroppen kan du använda alla variabler som deklarerades före dess anrop, och anropet av funktioner i PowerShell kan verka ovanligt: argumenten (om det finns några) placeras inte inom parentes och separeras med mellanslag.
sqr 2eller så här:
sqr -number 2På grund av sättet argument överförs kan funktionen ibland behöva placeras inom parenteser:
function test_func ($n) {}
test_func -eq $null # funktionen har inte anropats
(test_func) -eq $null # resultatet av uttrycket — $true 
När du beskriver en funktion kan du tilldela argumenten standardvärden:
function func ($arg = value) {
#funktionskropp
}
Det finns också en annan syntax för att beskriva funktionsargument, dessutom kan parametrar läsas från rörledningar — allt detta kommer att vara användbart i nästa artikel när vi ska titta på exporterade moduler och skapa egna cmdlets.
Felhantering
I PowerShell finns en mekanism för Try…Catch…Finally som möjliggör hantering av undantagssituationer. I Try-blocket placeras koden där ett fel kan uppstå, och i Catch-blocket finns dess hanterare. Om det inte inträffade några fel körs inte detta block. Finally-blocket körs efter Try-blocket oavsett om ett fel inträffade, och det kan finnas flera Catch-block för olika typer av undantag. Själva undantaget sparas i en icke-deklarerad standardvariabel ($_) och kan enkelt extraheras. I exemplet nedan implementerar vi skydd mot ogiltig inmatning:
try {
[int]$test = Read-Host "Ange ett nummer"
100 / $test
} catch {
Write-Warning "Ogiltigt nummer"
Write-Host $_
}
Härmed avslutar vi grunderna i programmering med PowerShell. I kommande artiklar kommer vi att gå djupare in på att arbeta med variabler av olika typer, samlingar, reguljära uttryck, skapande av funktioner, moduler och egna cmdlets, samt objektorienterad programmering.
Källa: habr.com
