Historisch gezien zijn opdrachtregelhulpprogramma's op Unix-systemen beter ontwikkeld dan op Windows, maar met de komst van een nieuwe oplossing is de situatie veranderd.
PowerShell kan worden geschreven in een geïnterpreteerde taal met meerdere paradigma's die elementen bevat van klassieke procedurele, objectgeoriënteerde en zelfs functionele programmering: voorwaardelijke vertakking, lussen, variabelen, arrays, hash-tabellen, klassen, foutafhandeling, evenals functies, cmdlets en pijplijnen . was gewijd aan de basisprincipes van werken in de omgeving, en nu bieden we onze lezers een klein naslagwerk voor programmeurs.
авление:
U kunt code schrijven in elke teksteditor of met behulp van een geïntegreerde ontwikkelomgeving - de gemakkelijkste manier is om de Windows PowerShell ISE te gebruiken die wordt geleverd met Microsoft-serverbesturingssystemen. Dit is alleen nodig voor vrij complexe scripts: korte reeksen commando's zijn gemakkelijker interactief uit te voeren.
Reacties
Het gebruik van opmerkingen wordt beschouwd als onderdeel van een goede programmeerstijl, samen met de juiste inspringing en witruimte:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Variabelen en hun typen
Variabelen in PowerShell zijn benoemde objecten. Hun namen kunnen het onderstrepingsteken bevatten, evenals letters en cijfers. Het $-symbool wordt altijd voor de naam gebruikt en om een variabele te declareren, volstaat het om de interpreter een geldige naam te geven:
Om een variabele te initialiseren (er een waarde aan toe te kennen), wordt de toewijzingsoperator (symbool =) gebruikt:
$test = 100U kunt een variabele declareren door het type tussen vierkante haken te specificeren (type casting-operator) voor de naam of waarde:
[int]$test = 100
$test = [int]100Het is belangrijk om te begrijpen dat variabelen in PowerShell volwaardige objecten (klassen) zijn met eigenschappen en methoden waarvan de typen zijn gebaseerd op die in .NET Core. We zetten de belangrijkste op een rijtje:
Type (.NET-klasse)
beschrijving
Codevoorbeeld
[string] Systeem.StringUnicode-reeks
$testen = "testen"
$testen = 'testen'
Unicode-teken (16 bits)
[char]$test = 'c' [bool] Systeem.Booleaansboolean type (boolean True of False)
[bool]$test = $waar [int] Systeem.Int32tweeëndertig bit geheel getal (32 bits)
[int]$test = 123456789 [lang] Systeem.Int64vierenzestig bit integer (64 bits)
[lang]$test = 12345678910 [single] Systeem.Singledrijvende-kommagetal 32 bits lang
[enkel]$test = 12345.6789 [dubbel]Systeem.Dubbeldrijvende komma aantal lengte 64 bits (8 bytes)
[dubbel]$test = 123456789.101112 [decimaal]Systeem.Decimaal128-bits getal met drijvende komma (vereist om te eindigen op d)
[decimaal]$test = 12345.6789d [DateTime]Systeem.DateTimedatum en tijd
$test = GetDatum
[array] Systeem.Object[]een array waarvan de elementindex begint bij 0
$test_array = 1, 2, "testen", 3, 4
[hashtabel] Systeem.Verzamelingen.Hashtabelhash-tabellen zijn associatieve arrays met benoemde sleutels, gebouwd volgens het principe: @{key = "value"}
$test_hashtable = @{one="one"; twee="twee"; drie="drie"}
PowerShell ondersteunt impliciete typeconversie, bovendien kan het type van een variabele direct worden gewijzigd (bijvoorbeeld met behulp van een toewijzingsoperator), als het niet geforceerd wordt gespecificeerd - in dit geval geeft de interpreter een foutmelding. U kunt het type variabele uit het vorige voorbeeld bepalen door de methode GetType() aan te roepen:
$test.GetType().FullName
Er zijn een aantal cmdlets voor het manipuleren van variabelen. Hun lijst in een handige vorm wordt weergegeven met behulp van de opdracht:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap
Om gedeclareerde variabelen en hun waarden te bekijken, kunt u een speciale cmdlet gebruiken:
Get-Variable | moreDeze methode lijkt overdreven omslachtig, het is veel handiger om met variabelen te werken via operators of door rechtstreeks toegang te krijgen tot hun eigenschappen en methoden. Cmdlets hebben echter bestaansrecht omdat u hiermee enkele aanvullende parameters kunt instellen. Het is belangrijk om te begrijpen dat gebruikersvariabelen alleen binnen de huidige sessie worden gedefinieerd. Wanneer de console wordt gesloten of het script wordt beëindigd, worden ze verwijderd.
Systeemvariabelen
Naast de variabelen die door de gebruiker zijn opgegeven, zijn er ingebouwde (systeem)variabelen die niet worden verwijderd nadat de huidige sessie is beëindigd. Ze zijn onderverdeeld in twee typen, terwijl PowerShell-statusgegevens worden opgeslagen in automatische variabelen waaraan op zichzelf geen willekeurige waarden kunnen worden toegewezen. Deze omvatten bijvoorbeeld $PWD:
$PWD.Path
Voorkeursvariabelen zijn nodig om gebruikersvoorkeuren op te slaan, waarvan de waarden kunnen worden gewijzigd. Met $ErrorActionPreference wordt bijvoorbeeld de reactie van de commando-interpreter op het optreden van niet-fatale fouten ingesteld.
Naast operators en cmdlets voor toegang tot gedeclareerde variabelen, is er een variabele: pseudo-accumulator. U kunt ermee werken naar analogie met andere stations, en de variabelen lijken in dit geval op bestandssysteemobjecten:
Get-ChildItem Variable: | moreof
ls Variable: | more
Bereiken
Voor variabelen in PowerShell is er het concept van scope (Scope). De actie van het globale bereik (Global) is van toepassing op de gehele huidige sessie - het omvat bijvoorbeeld systeemvariabelen. Lokale (lokale) variabelen zijn alleen beschikbaar in het bereik waarin ze zijn gedefinieerd: bijvoorbeeld binnen een functie. Er is ook het concept van de reikwijdte van het script (Script), maar voor scriptopdrachten is dit in wezen lokaal. Bij het declareren van variabelen krijgen ze standaard een lokaal bereik, en om dit te veranderen heb je een speciale constructie nodig zoals: $Global: variabele = waarde.
Bijvoorbeeld als volgt:
$Global:test = 100
Omgevingsvariabelen (omgeving)
Een andere pseudo-drive, Env:, is beschikbaar via PowerShell en kan worden gebruikt om toegang te krijgen tot omgevingsvariabelen. Wanneer de shell start, worden ze gekopieerd van het bovenliggende proces (dat wil zeggen, van het programma dat de huidige sessie heeft gestart) en meestal zijn hun beginwaarden hetzelfde als de waarden in het configuratiescherm. Gebruik de cmdlet Get-ChildItem of de bijbehorende aliassen (aliassen): ls en dir om omgevingsvariabelen te bekijken.
dir Env:
Deze variabelen zijn reeksen bytes (of tekens, zo u wilt), waarvan de interpretatie alleen afhangt van het programma dat ze gebruikt. De cmdlets *-Variable werken niet met omgevingsvariabelen. Om toegang te krijgen, moet u het stationsvoorvoegsel gebruiken:
$env:TEST = "Hello, World!"
Reken- en vergelijkingsoperatoren
PowerShell biedt de volgende rekenkundige operatoren: + (optellen), - (aftrekken), * (vermenigvuldigen), / (delen) en % (modulo of modulo). Het resultaat van een rekenkundige uitdrukking wordt van links naar rechts geëvalueerd in overeenstemming met de algemeen aanvaarde volgorde van bewerkingen, en haakjes worden gebruikt om delen van de uitdrukking te groeperen. Spaties tussen operatoren worden genegeerd, ze worden alleen gebruikt om het lezen te vergemakkelijken. De + operator voegt ook samen, en de * operator herhaalt strings. Als u probeert een getal toe te voegen aan een tekenreeks, wordt dit omgezet in een tekenreeks. Daarnaast zijn er veel vergelijkingsoperatoren in PowerShell die testen op een overeenkomst tussen twee waarden en de boolean True of False retourneren:
operator
beschrijving
Codevoorbeeld
-vgl
Gelijk aan / Is gelijk aan (vergelijkbaar met = of == in andere talen)
$toets = 100
$test-eq 123
-do
Niet gelijk / Niet gelijk (vergelijkbaar met <> of !=)
$toets = 100
$test-ne 123
- gt
Groter dan / Meer (analoog>)
$toets = 100
$test-gt 123
-geven
Groter dan of gelijk aan / Groter dan of gelijk aan (vergelijkbaar met >=)
$toets = 100
$test-ge 123
-lt
Minder dan / Minder (vergelijkbaar met <)
$toets = 100
$ test -lt 123
Ze
Kleiner dan of gelijk aan / Kleiner dan of gelijk aan (vergelijkbaar met <=)
$toets = 100
$test -le 123
Er zijn andere vergelijkbare operatoren waarmee u bijvoorbeeld tekenreeksen kunt vergelijken op basis van een jokerteken of waarmee u reguliere expressies kunt gebruiken om een patroon te matchen. We zullen ze in detail behandelen in toekomstige artikelen. De symbolen <, > en = worden niet ter vergelijking gebruikt omdat ze voor andere doeleinden worden gebruikt.
Toewijzing operators
Naast de meest voorkomende =-operator zijn er nog andere toewijzingsoperatoren: +=, -=, *=, /= en %=. Ze veranderen de waarde vóór toewijzing. De unaire operatoren ++ en -, die de waarde van een variabele verhogen of verlagen, gedragen zich op dezelfde manier - ze zijn ook van toepassing op toewijzingsoperatoren.
Logische operatoren
Vergelijking alleen is niet voldoende om complexe omstandigheden te beschrijven. U kunt elke logische uitdrukking schrijven met behulp van de operatoren: -and, -or, -xor, -not and! .. Ze werken net als in andere programmeertalen, terwijl u haakjes kunt gebruiken om de volgorde van evaluatie te specificeren:
("Тест" -eq "Тест") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Voorwaardelijke sprong
Filiaaloperators in PowerShell zijn standaard: IF(IF…ELSE, IF…ELSEIF…ELSE) en SWITCH. Laten we eens kijken naar hun gebruik met voorbeelden:
[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 или значение не определено"}
}
cycli
Power shell heeft verschillende soorten lussen: WHILE, DO WHILE, DO until, FOR en FOREACH.
Een lus met een voorwaarde werkt als/zolang deze waar is:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Lussen met een postcondition worden minimaal één keer uitgevoerd, omdat de conditie na de iteratie wordt gecontroleerd. Tegelijkertijd werkt DO WHILE terwijl de voorwaarde waar is, en DOEN TOT wanneer deze onwaar is:
[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)
Het aantal iteraties van de FOR-lus is vooraf bekend:
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
Herhaalt in de FOREACH-lus de elementen van een array of verzameling (hashtabel):
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Arrays
PowerShell-variabelen slaan niet alleen enkele objecten op (nummer, tekenreeks, enz.), maar ook meerdere. De eenvoudigste soort van dergelijke variabelen zijn arrays. Een array kan uit meerdere elementen bestaan, één element, of leeg zijn, d.w.z. bevatten geen elementen. Het wordt gedeclareerd met behulp van de @()-operator, die we in het volgende artikel nodig zullen hebben - het is erg belangrijk voor het toevoegen van andere arrays aan een array (het maken van multidimensionale arrays), het doorgeven van arrays aan functies als een argument en soortgelijke taken:
$test_array = @() #создаем пустой массивWanneer een array wordt geïnitialiseerd, worden de waarden ervan weergegeven, gescheiden door komma's (speciale operator ,):
$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов In de meeste gevallen kan de operator @() worden weggelaten:
$test_array = 1, 2, 3, 4In dit geval wordt een array van één element als volgt geïnitialiseerd
$test_array = , 1Array-elementen zijn toegankelijk met behulp van een op nul gebaseerde integerindex en de indexoperator (vierkante haken):
$test_array[0] = 1U kunt meerdere indexen specificeren, gescheiden door komma's, incl. terugkerend:
$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]
operator .. (twee punten - bereikoperator) retourneert een reeks gehele getallen binnen de opgegeven boven- en ondergrenzen. Expressie 1..4 geeft bijvoorbeeld een array van vier elementen @(1, 2, 3, 4) weer, en expressie 8..5 geeft een array @(8, 7, 6, 5) weer.
Met behulp van de bereikoperator kunt u een array initialiseren ($test_array = 1..4) of een slice (slice) krijgen, d.w.z. een opeenvolging van elementen uit de ene array met indices uit een andere. In dit geval geeft een negatief getal -1 het laatste element van de array aan, -2 - het voorlaatste, enzovoort.
$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Merk op dat integer-arraywaarden groter kunnen zijn dan de maximale indexwaarde van de data-array. In dit geval worden alle waarden geretourneerd tot de laatste:
$test_array[0..100]Als u toegang probeert te krijgen tot een enkel niet-bestaand array-element, wordt $null geretourneerd.
In PowerShell kunnen arrays elementen van verschillende typen bevatten of sterk getypeerd zijn:
$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
Waarbij de eigenschap $test_array.count het aantal array-elementen is.
Een voorbeeld van het maken van een sterk getypeerde array:
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Hash-tabellen
Een ander basistype variabelen in de PowerShell-taal zijn hashtabellen, ook wel associatieve arrays genoemd. Hashtabellen zijn vergelijkbaar met JSON-objecten en zijn gebouwd op basis van sleutelwaarden. In tegenstelling tot gewone arrays, zijn hun elementen toegankelijk via benoemde sleutels, die eigenschappen zijn van het object (u kunt ook de indexoperator gebruiken - vierkante haken).
Een lege hashtabel wordt gedeclareerd met behulp van het @-symbool en operatorhaakjes:
$test_hashtable = @{}Bij het declareren kunt u direct sleutels aanmaken en er waarden aan toewijzen:
$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}Om een element aan een hashtabel toe te voegen, moet u er een sleutel aan toewijzen die nog niet bestaat, of u kunt de methode Add() gebruiken. Als er een toewijzing wordt gedaan aan een bestaande sleutel, verandert de waarde ervan. De methode Remove() wordt gebruikt om een element uit een hashtabel te verwijderen.
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")
Variabelen van dit type kunnen worden doorgegeven als argumenten voor functies en cmdlets - in het volgende artikel zullen we bestuderen hoe dit wordt gedaan, en ook een ander vergelijkbaar type overwegen - PSCustomObject.
functies
PowerShell heeft alles wat je nodig hebt voor procedureel programmeren, inclusief functies. Om ze te beschrijven, wordt het functiewoord Functie gebruikt, waarna u de naam van de functie en de hoofdtekst tussen operatorhaakjes moet specificeren. Als u argumenten aan de functie moet doorgeven, kunt u deze direct na de naam tussen haakjes specificeren.
function имя-функции (аргумент1, ..., аргументN)
{
тело-функции
}
De functie retourneert altijd een resultaat - het is een array van de resultaten van al zijn instructies, als er meer dan één zijn. Als er slechts één instructie is, wordt de enige waarde van het overeenkomstige type geretourneerd. De return $value-constructie voegt een element met de waarde $value toe aan de resultaatarray en beëindigt de uitvoering van de instructielijst, en de lege functie retourneert $null.
Laten we bijvoorbeeld een functie maken voor het kwadrateren van een getal:
function sqr ($number)
{
return $number * $number
}
Houd er rekening mee dat u in de hoofdtekst van een functie alle variabelen kunt gebruiken die zijn gedeclareerd voordat u deze aanroept, en het aanroepen van functies in PowerShell kan ongebruikelijk lijken: de argumenten (indien aanwezig) staan niet tussen haakjes en worden gescheiden door spaties.
sqr 2of zo:
sqr -number 2Vanwege de manier waarop argumenten worden doorgegeven, moet de functie zelf soms tussen haakjes worden geplaatst:
function test_func ($n) {}
test_func -eq $null # функция не вызывалась
(test_func) -eq $null # результат выражения — $true
Bij het beschrijven van een functie kunt u standaardwaarden toewijzen aan argumenten:
function func ($arg = value) {
#тело функции
}
Er is nog een syntaxis voor het beschrijven van functieargumenten, bovendien kunnen parameters uit de pijplijn worden gelezen - dit komt allemaal van pas in het volgende artikel, wanneer we kijken naar geëxporteerde modules en het maken van onze eigen cmdlets.
Fout bij verwerking
PowerShell heeft een Try...Catch...Finally mechanisme om uitzonderingen af te handelen. Het Try-blok bevat de code waarin een fout kan optreden en het Catch-blok bevat de handler. Als er geen fout is opgetreden, wordt deze niet uitgevoerd. Het blok Final wordt uitgevoerd na het blok Try, ongeacht het optreden van een fout, en er kunnen verschillende Catch-blokken zijn voor verschillende typen uitzonderingen. De uitzondering zelf wordt naar een niet-gedeclareerde standaardvariabele ($_) geschreven en kan eenvoudig worden opgehaald. In het onderstaande voorbeeld implementeren we bescherming tegen het invoeren van een ongeldige waarde:
try {
[int]$test = Read-Host "Введите число"
100 / $test
} catch {
Write-Warning "Некорректное число"
Write-Host $_
}
Hiermee is het overzicht van de basisprincipes van programmeren in de PowerShell-taal afgesloten. In de volgende artikelen zullen we in meer detail het werken met variabelen van verschillende typen, verzamelingen, reguliere expressies, het maken van functies, modules en aangepaste cmdlets bestuderen, evenals objectgeoriënteerd programmeren.
Bron: www.habr.com