Historisk set har kommandolinjeværktøjer i Unix-systemer været bedre udviklet end i Windows, men med fremkomsten af en ny løsning har situationen ændret sig.
For PowerShell, you can write scripts in an interpreted multi-paradigm language that includes elements of classic procedural, object-oriented, and even functional programming: conditional statements, loops, variables, arrays, hash tables, classes, error handling, as well as functions, cmdlets, and pipelines. was dedicated to the basics of working in the environment, and now we offer readers a small guide for programmers.
Indholdsfortegnelse:
You can write code in any text editor or using an integrated development environment — it's easiest to take Windows PowerShell ISE from the server operating systems package from Microsoft. This is only necessary for sufficiently complex scripts: short command sets are easier to execute in interactive mode.
Comments
Using comments is considered part of good programming style alongside proper indentation and spacing:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Variables and their types
Variables in PowerShell are named objects. Their names can include underscores, as well as letters and numbers. A $ symbol is always used before the name, and to declare a variable, simply specify a valid name to the interpreter:
To initialize a variable (assign a value to it), the assignment operator (the = symbol) is used:
$test = 100A variable can be declared with its type specified in square brackets (type casting operator) before the name or value:
[int]$test = 100
$test = [int]100It's important to understand that variables in PowerShell are full-fledged objects (classes) with properties and methods, the types of which are based on those present in .NET Core. Let's list the main ones:
Type (class .NET)
Description
Code example
[string]
System.String
Unicode string
$test = "test"
$test = 'test'
[char]
System.Char
Unicode character (16 bits)
[char]$test = 'c'
[bool]
System.Boolean
Boolean type (logical value True or False)
[bool]$test = $true
[int]
System.Int32
Thirty-two bit integer (32 bits)
[int]$test = 123456789
[long]
System.Int64
Sixty-four bit integer (64 bits)
[long]$test = 12345678910
[single]
System.Single
32-bit flydende punkt tal
[single]$test = 12345.6789
[double]
System.Double
64-bit flydende punkt tal (8 byte)
[double]$test = 123456789.101112
[decimal]
System.Decimal
128-bit flydende punkt tal (d skal angives til slut)
[decimal]$test = 12345.6789d
[DateTime]
System.DateTime
dato og tid
$test = Get-Date
[array]
System.Object[]
array, hvor indeks for elementer starter fra 0
$test_array = 1, 2, «test», 3, 4
[hashtable]
System.Collections.Hashtable
hash-tabeller - associative arrays med navngivne nøgler, bygget på princippet: @{nøgle = «værdi»}
$test_hashtable = @{one=«en»; two=«to»; three=«tre»}
PowerShell understøtter implicit typekonvertering, derudover kan typen af en variabel ændres on-the-fly (for eksempel ved hjælp af tildelingsoperatoren), hvis den ikke er angivet tvunget - i så fald vil fortolkeren give en fejl. For at bestemme typen af variablen fra det foregående eksempel kan metoden GetType() bruges:
$test.GetType().FullName 
Der findes et antal cmdlets til at håndtere variabler. Listen over dem vises i et praktisk format ved hjælp af kommandoen:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap 
For at se de erklærede variabler og deres værdier kan det specielle cmdlet bruges:
Get-Variable | moreDenne metode virker noget klodset, det er meget lettere at arbejde med variabler gennem operatorer eller ved direkte at tilgå deres egenskaber og metoder. Ikke desto mindre har cmdlets ret til at eksistere, da de tillader at angive nogle ekstra parametre. Det er vigtigt at forstå, at brugerdefinerede variabler kun er defineret inden for den aktuelle session. Efter lukning af konsollen eller afslutning af scriptet slettes de.
System variables
Ud over brugerdefinerede variabler findes der indbyggede (system) variabler, som ikke slettes efter afslutningen af den aktuelle session. De opdeles i to typer, idet oplysninger om PowerShell-status opbevares i automatiske variabler, som ikke kan tildeles vilkårlige værdier. Blandt dem er for eksempel $PWD:
$PWD.Path 
For at gemme brugerindstillinger kræves præferencevariabler, hvis værdier kan ændres. For eksempel angives reaktionen fra kommandofortolkeren på opståede ikke-kritiske fejl ved hjælp af $ErrorActionPreference.
Udover operatorer og cmdlets til at tilgå de erklærede variabler findes der en pseudolager Variable:. Man kan arbejde med det på samme måde som med andre lagre, og variablerne ligner i denne sammenhæng objekter i filsystemet:
Get-ChildItem Variable: | moreeller
ls Variable: | more 
Scopes
Der findes et begreb om synlighed (Scope) for variabler i PowerShell. Den globale synlighed (Global) gælder for hele den nuværende session — det inkluderer for eksempel systemvariabler. Lokale (Local) variabler er kun tilgængelige inden for det område, hvor de blev defineret: for eksempel inde i en funktion. Der er også et begreb om script-synlighed (Script), men for scriptkommandoer er det i realiteten lokalt. Som standard får variabler, der erklæres, lokal synlighed, men for at ændre dette kræves en særlig konstruktion af typen: $Global: variabel = værdi.
For eksempel sådan her:
$Global:test = 100
Environment variables
Fra PowerShell er der også en anden pseudolager Env:, som gør det muligt at tilgå miljøvariabler. Ved opstart af shell'en kopieres de fra den overordnede proces (dvs. fra programmet, der startede den nuværende session) og deres oprindelige værdier svarer normalt til værdierne i kontrolpanelet. For at se miljøvariablerne bruges cmdleten Get-ChildItem eller dens aliaser: ls og dir.
dir Env: 
Disse variable repræsenterer sekvenser af bytes (eller tegn, hvis man vil), hvis fortolkning kun afhænger af det program, der bruger dem. Cmdlets *-Variable fungerer ikke med miljøvariabler. For at tilgå dem skal man bruge diskpræfikset:
$env:TEST = "Hello, World!" 
Arithmetic operators and comparison operators
I PowerShell er der følgende aritmetiske operatører: + (addition), - (subtraktion), * (multiplikation), / (division) og % (modulus eller rester fra division). Resultatet af et aritmetisk udtryk beregnes fra venstre mod højre i overensstemmelse med almindeligt accepterede rækkefølger for operationer, og for at gruppere dele af udtrykket anvendes parenteser. Mellemrum mellem operatører ignoreres, de bruges kun til at lette læsbarheden. Operatøren + kan også sammenføje, og operatøren * gentager strenge. Når du forsøger at lægge et tal til en streng, vil det blive konverteret til en streng. Derudover er der mange sammenligningsoperatorer i PowerShell, der kontrollerer overensstemmelse mellem to værdier og returnerer logiske True eller False:
Operator
Description
Code example
-eq
Lige med / Ravn til (analog = eller == i andre sprog)
$test = 100
$test -eq 123
-ne
Ikke lig med / Ikke Ravn til (analog eller !=)
$test = 100
$test -ne 123
-gt
Større end / Større end (analog >)
$test = 100
$test -gt 123
-ge
Større end eller lig med / Større end eller lig med (analog >=)
$test = 100
$test -ge 123
-lt
Mindre end / Mindre end (analog <)
$test = 100
$test -lt 123
-le
Mindre end eller lig med / Mindre end eller lig med (analog <=)
$test = 100
$test -le 123
Der findes også andre lignende operatører, der for eksempel tillader sammenligning af strenge med hensyn til wildcard-tegn eller bruger regulære udtryk til at finde overensstemmelse med et mønster. Disse vil vi gennemgå i de kommende artikler. Tegnene og = til sammenligning anvendes ikke, da de er reserveret til andre formål.
Assignment operators
Udover den mest almindelige operator = findes der også andre tildelingsoperatorer: +=, -=, *=, /= og %= . Disse ændrer værdien før tildeling. Tilsvarende opfører de unære operatorer ++ og -- sig, som øger eller formindsker værdien af en variabel; de hører også til tildelingsoperatorerne.
Logical operators
For at beskrive komplekse betingelser er det ikke nok kun at bruge sammenligning. Enhver logisk udtryk kan skrives med operatorerne: -and, -or, -xor, -not og!.. De fungerer ligesom i andre programmeringssprog, og du kan bruge parenteser for at angive rækkefølgen af beregningen:
("Test" -eq "Test") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Conditional statements
Betingelsesoperatorerne 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 5 eller værdi er ikke defineret"}
}
Loops
I PowerShell findes der flere typer af loops: WHILE, DO WHILE, DO UNTIL, FOR og FOREACH.
Et loop med en betingelse fungerer, hvis/så længe det er sandt:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Loops med en post-betingelse kører mindst én gang, fordi betingelsen kontrolleres efter iterationen. DO WHILE fungerer så længe betingelsen er sand, og DO UNTIL — så længe 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 i FOR-loopen er kendt på forhånd:
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
I FOREACH-loopen gennemgår man elementerne i et array eller samling (hash-tabeller):
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Arrays
I PowerShell-variabler gemmes ikke kun enkeltobjekter (tal, strenge osv.), men også flere. Den simpleste type af sådanne variabler er arrays. Et array kan bestå af flere elementer, et enkelt element eller være tomt, det vil sige indeholde ingen elementer. For at erklære det bruges operatoren @(), som vi får brug for i næste artikel — den er meget vigtig for at tilføje andre arrays (oprette multidimensionale arrays), overføre arrays til funktioner som argument og lignende opgaver:
$test_array = @() #opretter et tomt arrayNår et array initialiseres, listes dets værdier adskilt af komma (specialoperator ,):
$test_array = @(1, 2, 3, 4) # opretter et array med fire elementer I de fleste tilfælde kan operatoren @() udelades:
$test_array = 1, 2, 3, 4I dette tilfælde initialiseres et array med et enkelt element som følger:
$test_array = , 1For at få adgang til elementerne i et array bruges en nulbaseret heltalsindeks og indeksoperatoren (klammeparenteser):
$test_array[0] = 1Man kan angive flere indekser adskilt af komma, herunder gentagne:
$test_array = "en", "to", "tre", "fire"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0] 
Operator .. (to punkter — intervaloperator) returnerer et array af heltal inden for et bestemt bølgelængdeinterval. For eksempel returnerer udtrykket 1..4 et array med fire elementer @(1, 2, 3, 4), mens udtrykket 8..5 returnerer arrayet @(8, 7, 6, 5).
Med intervaloperatoren kan du initialisere et array ($test_array = 1..4) eller få et udsnit (slice), dvs. en sekvens af elementer fra ét array med indekser fra et andet. Her betyder det negative tal -1 det sidste element i arrayet, -2 det næstsidste osv.
$test_array = "en", "to", "tre", "fire"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Bemærk, at værdierne i det heltals-array kan være større end det maksimale indeks for arrayet med data. I så fald returneres alle værdier op til den sidste:
$test_array[0..100]Hvis du forsøger at tilgå et enkelt ikke-eksisterende element i arrayet, returneres værdien $null.
I PowerShell kan arrays indeholde elementer af forskellige typer eller være strengt typede.
$test_array = 1, 2, "test", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
Hvor egenskaben $test_array.count er antallet af elementer i arrayet.
Eksempel på oprettelse af et strengt typet array:
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Hash tables
En anden grundlæggende variabeltype i PowerShell-sproget er hash-tabeller, som også kaldes associative arrays. Hashtable ligner et JSON-objekt og er bygget efter princippet nøgle-værdi. I modsætning til almindelige arrays tilgås deres elementer via navngivne nøgler, som er egenskaber for objektet (du kan også bruge indeksoperatoren — firkantede parenteser).
En tom hash-tabel deklareres ved hjælp af serveringssymbolet @ og operatorparenteser:
$test_hashtable = @{}Ved deklarationen kan du straks oprette nøgler og tildele værdier til dem:
$test_hashtable = @{one="en"; two="to"; three="tre"; "some key"="some value"}For at tilføje et element til hash-tabellen skal du tildele den en endnu ikke eksisterende nøgle eller bruge metoden Add(). Hvis tildelingen foretages med en eksisterende nøgle, ændres dens værdi. For at fjerne et element fra hash-tabellen bruges metoden Remove().
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "fire")
$test_hashtable.five = "fem"
$test_hashtable['five'] = "ændre værdi"
$test_hashtable.Remove("one") 
Variabler af denne type kan overføres som argumenter til funktioner og cmdlets — vi vil i den næste artikel undersøge, hvordan dette gøres, samt se på en anden lignende type — PSCustomObject.
Functions
I PowerShell-sproget findes der alle de nødvendige elementer til proceduremæssig programmering, herunder funktioner. For at beskrive dem bruges nøgleordet Function, efterfulgt af funktionsnavnet og en krop indkapslet i parenteser. Hvis det er nødvendigt at overføre argumenter til funktionen, kan de angives umiddelbart efter navnet i parenteserne.
function funktions-navn (argument1, ..., argumentN)
{
funktions-krop
}
En funktion returnerer altid et resultat — det er et array af resultater fra alle dens udsagn, hvis der er mere end ét. Hvis der kun er ét udsagn, returneres én værdi af den tilsvarende type. Konstruktøren return $value tilføjer et element med værdien $value til resultat-arrayet og stopper udførelsen af statement-listen, mens en tom funktion returnerer $null.
Som et eksempel lad os oprette en funktion til at kvadrere et tal:
function sqr ($number)
{
return $number * $number
}
Bemærk, at i funktionen kan der bruges enhver variabel, der er erklæret før dens kald, og kald af funktioner i PowerShell kan virke uvant: argumenter (hvis de findes) er ikke indkapslede i parenteser og adskilt af mellemrum.
sqr 2eller på denne måde:
sqr -number 2På grund af den måde, argumenter overføres på, er det nogle gange nødvendigt at indkapsle selve funktionen i parenteser:
function test_func ($n) {}
test_func -eq $null # funktionen er ikke blevet kaldt
(test_func) -eq $null # resultatet af udtrykket er — $true 
Ved at beskrive en funktion kan man tildele værdier til argumenterne som standardværdier:
function func ($arg = value) {
#krop af funktionen
}
Der findes også en anden syntaks til at beskrive funktionens argumenter, desuden kan parametre læses fra pipelinen — alt dette bliver nyttigt i den næste artikel, hvor vi vil se på eksporterede moduler og oprettelsen af egne cmdlets.
Error handling
I PowerShell findes der en Try…Catch…Finally mekanisme, der muliggør håndtering af undtagelsesforhold. Koden, der potentielt kan medføre en fejl, placeres i Try-blokken, mens Catch-blokken indeholder fejlbehandleren. Hvis der ikke opstod nogen fejltagelse, udføres Catch ikke. Finally-blokken udføres altid efter Try-blokken, uanset om der opstod en fejl, og der kan være flere Catch-blokke til forskellige typer undtagelser. Selve undtagelsen gemmes i en variabel, der ikke kræver deklaration som standard ($_) og kan nemt hentes. I eksemplet nedenfor implementerer vi beskyttelse mod indtastning af ugyldige værdier:
try {
[int]$test = Read-Host "Indtast et tal"
100 / $test
} catch {
Write-Warning "Ugyldigt tal"
Write-Host $_
}
Dermed afslutter vi gennemgangen af grundlæggende programmering i PowerShell. I de næste artikler vil vi dykke dybere ned i arbejdet med variabler af forskellige typer, kollektioner, regulære udtryk, oprettelse af funktioner, moduler og egne cmdlets, samt objektorienteret programmering.
Kilde: habr.com
