Historesch sinn Kommando-Linn Utilities op Unix Systemer besser entwéckelt wéi op Windows, awer mat der Entstoe vun enger neier Léisung huet d'Situatioun geännert.
PowerShell kann an enger interpretéierter, Multi-Paradigme Sprooch geschriwwe ginn, déi Elementer vu klassescher prozeduraler, objektorientéierter a souguer funktioneller Programméierung huet: bedingte Verzweigung, Loops, Variablen, Arrays, Hash-Tabellen, Klassen, Fehlerhandhabung, souwéi Funktiounen, cmdlets, a Pipelines. war un d'Basis vun der Aarbecht an der Ëmwelt gewidmet, an elo bidden mir de Lieser e klenge Guide fir Programméierer.
Beschreiwung:
Dir kënnt Code an all Texteditor schreiwen oder en integréierten Entwécklungsëmfeld benotzen - deen einfachste Wee ass de Windows PowerShell ISE ze huelen deen mat Microsoft Server Betribssystemer kënnt. Dëst ass nëmmen néideg fir zimlech komplex Scripten: kuerz Sätze vu Kommandoen si méi einfach interaktiv auszeféieren.
Comments
D'Benotzung vu Kommentare gëtt als Deel vu gudde Programméierungsstil ugesinn zesumme mat der korrekter Indentatioun a Wäissraum:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Variablen an hir Aarte
Variablen an PowerShell ginn Objekter genannt. Hir Nimm kënnen den Ënnerscore Charakter enthalen, souwéi Buschtawen an Zuelen. D'Symbol $ gëtt ëmmer virum Numm benotzt, a fir eng Variabel ze deklaréieren, geet et duer, dem Dolmetscher e gültege Numm ze ginn:
Fir eng Variabel ze initialiséieren (e Wäert derbäi ze ginn), gëtt den Uerderungsoperateur (Symbol =) benotzt:
$test = 100Dir kënnt eng Variabel deklaréieren andeems Dir seng Aart a Quadratklammern spezifizéiert (Typ Casting Operator) virum Numm oder Wäert:
[int]$test = 100
$test = [int]100Et ass wichteg ze verstoen datt Variabelen an PowerShell vollwäerteg Objeten (Klassen) sinn mat Eegeschaften a Methoden deenen hir Aarte baséiert op deenen am .NET Core. Mir lëschten déi wichtegst:
Typ (.NET class)
Beschreiwung
Code Beispill
[string] System.StringUnicode String
$test = "test"
$test = 'test'
Unicode Charakter (16 Bits)
[char] $test = 'c' [bool] System.Booleanboolesch Typ (boolesch richteg oder falsch)
[bool]$test = $true [int] System.Int32Drësseg-zwee-Bit Ganzt (32 Bits)
[int]$test = 123456789 [long] System.Int64Véieranzechzeg Bit Ganzt (64 Bits)
[laang] $test = 12345678910 [single] System.SingleSchwemmpunkt Nummer 32 Bits laang
[Single] $test = 12345.6789 [double] System.DoubleFloating Point Zuel vun der Längt 64 Bits (8 Bytes)
[duebel] $test = 123456789.101112 [decimal] System.Decimal128-Bit schwiewend Punkt Nummer (obligatoresch fir mat d opzehalen)
[Dezimal] $test = 12345.6789d [DateTime] System.DateTimeDatum an Zäit
$test = GetDate
[array] System.Object[]eng Array, deem säin Elementindex bei 0 ufänkt
$test_array = 1, 2, "test", 3, 4
[hashtable] System.Collections.HashtableHash Dëscher sinn assoziativ Arrays mat genannte Schlësselen, gebaut nom Prinzip: @{Schlëssel = "Wäert"}
$test_hashtable = @{one="one"; zwee="zwee"; dräi = "dräi"}
PowerShell ënnerstëtzt implizit Typ Konversioun, Zousätzlech kann d'Zort vun enger Variabel op der Flucht geännert ginn (zum Beispill mat engem Optragsbedreiwer), wann et net gezwongen ass - an dësem Fall gëtt den Dolmetscher e Feeler. Dir kënnt d'Art vun der Variabel aus dem virege Beispill bestëmmen andeems Dir d'GetType () Method nennt:
$test.GetType().FullName
Et ginn eng Zuel vu cmdlets fir Variabelen ze manipuléieren. Hir Lëscht an enger praktescher Form gëtt mat dem Kommando ugewisen:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap
Fir deklaréiert Variablen an hir Wäerter ze gesinn, kënnt Dir e spezielle cmdlet benotzen:
Get-Variable | moreDës Method schéngt iwwerdriwwen ëmständlech, et ass vill méi praktesch mat Verännerlechen duerch Betreiber ze schaffen oder duerch direkt Zougang zu hiren Eegeschaften a Methoden. Wéi och ëmmer, cmdlets hunn e Recht ze existéieren well se Iech erlaben e puer zousätzlech Parameteren ze setzen. Et ass wichteg ze verstoen datt Benotzervariablen nëmmen an der aktueller Sessioun definéiert sinn. Wann d'Konsole zou ass oder d'Skript eriwwer ass, gi se geläscht.
System Verännerlechen
Zousätzlech zu deenen, déi vum Benotzer deklaréiert sinn, ginn et agebaute (System) Variablen déi net geläscht ginn nodeems déi aktuell Sessioun eriwwer ass. Si sinn an zwou Zorte opgedeelt, während PowerShell Staatsdaten an automatesche Variablen gespäichert ginn, déi net eleng arbiträr Wäerter zougewisen kënne ginn. Dozou gehéieren zum Beispill $PWD:
$PWD.Path
Präferenzvariablen sinn néideg fir Benotzervirléiften ze späicheren, d'Wäerter vun deenen kënne geännert ginn. Zum Beispill, $ErrorActionPreference spezifizéiert wéi de Kommando Dolmetscher op net-fatale Feeler reagéiere soll.
Zousätzlech zu Betreiber an cmdlets fir Zougang zu deklaréierte Variablen ze kréien, gëtt et eng Variabel: Pseudo-Akkumulator. Dir kënnt mat der Analogie mat anere Drive schaffen, an d'Variabelen an dësem Fall ähnelen Dateiesystemobjekter:
Get-ChildItem Variable: | moreoder
ls Variable: | more
Ëmfang
Fir Variablen an PowerShell gëtt et d'Konzept vum Ëmfang (Scope). D'Aktioun vum globalen Ëmfang (Global) gëllt fir déi ganz aktuell Sessioun - et enthält zum Beispill Systemvariablen. Lokal (Lokal) Variablen sinn nëmme verfügbar am Ëmfang wou se definéiert goufen: sot an enger Funktioun. Et gëtt och d'Konzept vum Ëmfang vum Skript (Skript), awer fir Skriptbefehl ass et wesentlech lokal. Par défaut, wann Dir Variabelen deklaréiert, gi se e lokalen Ëmfang, a fir dëst z'änneren, braucht Dir e spezielle Konstrukt wéi: $Global: Variabel = Wäert.
Zum Beispill, wéi dëst:
$Global:test = 100
Ëmfeld Variablen (Ëmwelt)
En anere Pseudo-Drive, Env:, ass verfügbar vu PowerShell a ka benotzt ginn fir Zougang zu Ëmfeldvariablen. Wann d'Shell ufänkt, gi se aus dem Elterenprozess kopéiert (dat heescht aus dem Programm deen déi aktuell Sessioun initiéiert huet) an normalerweis sinn hir initial Wäerter d'selwecht wéi d'Wäerter an der Kontrollpanel. Fir Ëmfeldvariablen ze gesinn, benotzt de Get-ChildItem cmdlet oder seng Aliasen (Aliasen): ls an dir.
dir Env:
Dës Variablen si Sequenzen vu Bytes (oder Zeechen, wann Dir wëllt), d'Interpretatioun vun deenen hänkt nëmmen vum Programm of, deen se benotzt. D'*-Variable cmdlets funktionnéieren net mat Ëmfeldvariablen. Fir Zougang zu hinnen ze kréien, musst Dir de Drive Präfix benotzen:
$env:TEST = "Hello, World!"
Arithmetik a Vergläichsbedreiwer
PowerShell bitt déi folgend arithmetesch Betreiber: + (Additioun), - (Subtraktioun), * (Multiplizéieren), / (Divisioun), an % (Modulo oder Modulo). D'Resultat vun engem arithmeteschen Ausdrock gëtt vu lénks op riets am Aklang mat der allgemeng akzeptéierter Uerdnung vun Operatiounen evaluéiert, a Klammere gi benotzt fir Deeler vum Ausdrock ze gruppéieren. Plazen tëscht Betreiber ginn ignoréiert, si ginn nëmme benotzt fir et méi einfach ze liesen. Den + Bedreiwer koncatenéiert och, an den * Bedreiwer widderhëlt Strings. Wann Dir probéiert eng Zuel un eng String ze addéieren, gëtt se an eng String ëmgewandelt. Zousätzlech huet d'PowerShell Sprooch vill Vergläichsoperateuren déi no engem Match tëscht zwee Wäerter kontrolléieren an d'Boolesch True oder False zréckginn:
Betreiber
Beschreiwung
Code Beispill
-eq
Gläich / Gläich (ähnlech wéi = oder == an anere Sproochen)
$test = 100
$test -eq 123
- ass
Net gläich / Net gläich (ähnlech wéi <> oder !=)
$test = 100
$test -ne 123
-gt
Méi grouss wéi / Méi (analog>)
$test = 100
$test -gt 123
-ge
Méi grouss wéi oder gläich / Grouss wéi oder gläich (ähnlech wéi >=)
$test = 100
$test -ge 123
-lt
Manner wéi / Manner (ähnlech wéi <)
$test = 100
$test -lt 123
-den
Manner wéi oder gläich / Manner wéi oder gläich (ähnlech wéi <=)
$test = 100
$test -le 123
Et ginn aner ähnlech Bedreiwer, déi Iech erlaben, zum Beispill, Strings op Basis vun enger Wildcard ze vergläichen oder regelméisseg Ausdréck ze benotzen fir e Muster ze passen. Mir wäerten se am Detail an zukünfteg Artikelen Cover. D'Symboler <, > an = ginn net fir de Verglach benotzt well se fir aner Zwecker benotzt ginn.
Aufgab Opérateuren
Nieft dem heefegsten = Bedreiwer ginn et aner Aufgabebetreiber: +=, -=, *=, /= an %=. Si änneren de Wäert virun der Aufgab. D'unär Bedreiwer ++ an -, déi de Wäert vun enger Variabel erhéijen oder erofsetzen, behuelen sech ähnlech - si gëllen och fir Aufgabebetreiber.
Logesch Opérateuren
Vergläich eleng ass net genuch fir komplex Konditiounen ze beschreiwen. Dir kënnt all logesch Ausdréck mat den Bedreiwer schreiwen: -an, -oder, -xor, -net an! .. Si funktionnéieren wéi an anere Programméierungssproochen, während Dir Klammeren benotze kënnt fir d'Uerdnung vun der Evaluatioun ze spezifizéieren:
("Тест" -eq "Тест") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Conditionnelle Sprong
Branchbetreiber an PowerShell si Standard: IF(IF…ELSE, IF…ELSEIF…ELSE) a SWITCH. Loosst eis hir Notzung mat Beispiller kucken:
[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 или значение не определено"}
}
Zyklen
PowerShell huet verschidde Varietéiten vu Schleifen: WHILE, DO WHILE, DO BIS, FOR, a FOREACH.
Eng Loop mat enger Viraussetzung funktionnéiert wann/soulaang et wouer ass:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Loops mat enger Postkonditioun lafen op d'mannst eemol, well d'Konditioun no der Iteratioun gepréift gëtt. Zur selwechter Zäit, DO WHILE funktionnéiert wärend d'Konditioun wouer ass, a DO BIS funktionnéiert wann et falsch ass:
[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)
D'Zuel vun Iteratiounen vun der FOR Loop ass am Viraus bekannt:
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
An der FOREACH Loop, iteréiert iwwer d'Elementer vun enger Array oder Sammlung (Hash Tabell):
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Arrays
PowerShell Variablen späicheren net nëmmen eenzel Objeten (Nummer, String, etc.), awer och méi. Déi einfachst Aart vu sou Variablen sinn Arrays. Eng Array kann aus verschiddenen Elementer, engem Element, oder eidel sinn, d.h. enthalen keng Elementer. Et gëtt deklaréiert mam @() Bedreiwer, dee mir am nächsten Artikel brauchen - et ass ganz wichteg fir aner Arrays un eng Array ze addéieren (multidimensional Arrays erstellen), Arrays op Funktiounen als Argument weiderginn an ähnlech Aufgaben:
$test_array = @() #создаем пустой массивWann en Array initialiséiert gëtt, gi seng Wäerter getrennt vu Komma opgelëscht (speziell Bedreiwer ,):
$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов Am meeschte Fäll kann den @() Bedreiwer ausgeliwwert ginn:
$test_array = 1, 2, 3, 4An dësem Fall gëtt eng Array vun engem Element initialiséiert wéi follegt
$test_array = , 1Array Elementer ginn zougänglech mat engem null-baséierten ganzen Index an den Indexoperateur (quadratesch Klammern):
$test_array[0] = 1Dir kënnt verschidden Indexer spezifizéieren, getrennt duerch Komma, inkl. widderhuelend:
$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]
Betreiber .. (zwou Punkte - Rangeoperator) gëtt eng Array vun ganz Zuelen bannent de spezifizéierte ieweschte an ënneschte Grenzen zréck. Zum Beispill gëtt den Ausdrock 1..4 eng Array vu véier Elementer @(1, 2, 3, 4) eraus, an den Ausdrock 8..5 gëtt eng Array @(8, 7, 6, 5) eraus.
Mat dem Rangeoperateur kënnt Dir en Array initialiséieren ($test_array = 1..4) oder eng Slice (Slice) kréien, d.h. eng Sequenz vun Elementer aus engem Array mat Indizes vun engem aneren. An dësem Fall bezeechent eng negativ Zuel -1 dat lescht Element vun der Array, -2 - dat virläitst, a sou weider.
$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Notéiert datt ganz Zuelen Array Wäerter méi grouss kënne sinn wéi de maximalen Indexwäert vun der Datarray. An dësem Fall ginn all Wäerter bis op déi lescht zréckginn:
$test_array[0..100]Wann Dir probéiert op en eenzegt net existent Array-Element ze kommen, gëtt $null zréck.
An PowerShell kënnen Arrays Elementer vu verschiddenen Typen enthalen oder staark getippt ginn:
$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
Wou d'Eegeschaft $test_array.count d'Zuel vun den Arrayelementer ass.
E Beispill fir eng staark getippten Array ze kreéieren:
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Hash Dëscher
Eng aner Basisaart vu Variabel an PowerShell ass Hash-Tabellen, och bekannt als assoziativ Arrays. Hashtables sinn ähnlech wéi JSON Objekter a sinn op enger Schlësselwäertbasis gebaut. Am Géigesaz zu gewéinleche Arrays ginn hir Elementer zougänglech duerch genannt Schlësselen, déi Eegeschafte vum Objet sinn (Dir kënnt och den Indexoperateur benotzen - Quadratklammern).
Eng eidel Hash-Tabelle gëtt deklaréiert mat dem @ Symbol an de Bedreiwer Klammern:
$test_hashtable = @{}Wann Dir deklaréiert, kënnt Dir direkt Schlësselen erstellen an hinnen Wäerter zouginn:
$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}Fir en Element an eng Hash-Tabelle ze addéieren, musst Dir e Schlëssel zouginn, deen et nach net gëtt, oder d'Add () Method benotzen. Wann eng Uerderung un e bestehenden Schlëssel gemaach gëtt, ännert säi Wäert. D'Method Remove () gëtt benotzt fir en Element aus enger Hash-Tabelle ze läschen.
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")
Variablen vun dësem Typ kënnen als Argumenter u Funktiounen an cmdlets weidergeleet ginn - am nächsten Artikel wäerte mir studéieren wéi dëst gemaach gëtt, an och en aneren ähnlechen Typ betruechten - PSCustomObject.
Functions
PowerShell huet alles wat Dir braucht fir prozedural Programméierung, inklusiv Funktiounen. Fir se ze beschreiwen, gëtt d'Funktiounswuert Funktioun benotzt, duerno musst Dir den Numm vun der Funktioun an de Kierper an de Bedreiwer Klammern uginn. Wann Dir Argumenter un d'Funktioun weiderginn musst, kënnt Dir se direkt nom Numm an parentheses uginn.
function имя-функции (аргумент1, ..., аргументN)
{
тело-функции
}
D'Funktioun gëtt ëmmer e Resultat zréck - et ass eng Array vun de Resultater vun all sengen Aussoen, wann et méi wéi een ass. Wann et nëmmen eng Ausso gëtt, gëtt deen eenzege Wäert vum entspriechende Typ zréck. De Retour $value-Konstrukt füügt en Element mam Wäert $value un d'Resultatarray un an stoppt d'Ausféierung vun der Aussoelëscht, an déi eidel Funktioun gëtt $null zréck.
Zum Beispill, loosst eis eng Funktioun erstellen fir eng Zuel ze quadratéieren:
function sqr ($number)
{
return $number * $number
}
Notéiert datt Dir am Kierper vun enger Funktioun all Variabele benotze kënnt, déi deklaréiert ginn ier Dir se urufft, an d'Funktioune vun der PowerShell ruffen kënnen ongewéinlech schéngen: d'Argumenter (wann iwwerhaapt) sinn net an Klammeren zougemaach a gi vu Raum getrennt.
sqr 2oder sou:
sqr -number 2Wéinst der Aart a Weis wéi Argumenter passéiert ginn, muss d'Funktioun selwer heiansdo an Klammeren zougemaach ginn:
function test_func ($n) {}
test_func -eq $null # функция не вызывалась
(test_func) -eq $null # результат выражения — $true
Wann Dir eng Funktioun beschreiwt, kënnt Dir Standardwäerter un Argumenter zouginn:
function func ($arg = value) {
#тело функции
}
Et gëtt eng aner Syntax fir d'Funktiounsargumenter ze beschreiwen, zousätzlech kënnen d'Parameteren aus der Pipeline gelies ginn - all dat wäert am nächsten Artikel praktesch kommen, wa mir exportéiert Moduler kucken an eis eegen cmdlets kreéieren.
Feeler Veraarbechtung
PowerShell huet e Try ... Catch ... Endlech Mechanismus fir Ausnamen ze handhaben. De Try Block enthält de Code an deem e Feeler ka geschéien, an de Catch Block enthält säin Handler. Wann et kee Feeler war, gëtt et net ausgefouert. De Finally Block gëtt nom Try Block ausgefouert, onofhängeg vun der Optriede vun engem Feeler, an et kënne verschidde Catch Blocks fir verschidden Aarte vun Ausnahmen sinn. D'Ausnam selwer gëtt op eng net deklaréiert Standardvariabel ($_) geschriwwe a kann einfach zréckgezunn ginn. Am Beispill hei ënnen implementéiere mir Schutz géint en ongëlteg Wäert anzeginn:
try {
[int]$test = Read-Host "Введите число"
100 / $test
} catch {
Write-Warning "Некорректное число"
Write-Host $_
}
Dëst schléisst d'Iwwerpréiwung vun de Basics vun der Programméierung an der PowerShell Sprooch of. An de folgenden Artikelen wäerte mir méi am Detail studéieren mat Variabelen vu verschiddenen Typen, Sammlungen, reegelméissegen Ausdrock, Schafung vu Funktiounen, Moduler a personaliséiert cmdlets, souwéi objektorientéiert Programméierung.
Source: will.com