8. Příkazy

Redakční poznámka

Důležitý

specifikace jazyka Windows PowerShell 3.0 byla publikována v prosinci 2012 a je založená na prostředí Windows PowerShell 3.0. Tato specifikace neodráží aktuální stav PowerShellu. Tato dokumentace se neplánuje aktualizovat tak, aby odrážela aktuální stav. Tato dokumentace je zde uvedena pro historické reference.

Dokument specifikace je k dispozici jako dokument aplikace Microsoft Word z webu Microsoft Download Center na adrese: https://www.microsoft.com/download/details.aspx?id=36389 Dokument aplikace Word byl převeden pro prezentaci zde na webu Microsoft Learn. Během převodu byly provedeny některé redakční změny tak, aby vyhovovaly formátování pro platformu Docs. Některé překlepy a menší chyby byly opraveny.

8.1 Bloky příkazů a seznamy

Syntax:

Spropitné

Zápis ~opt~ v definicích syntaxe označuje, že lexikální entita je v syntaxi nepovinná.

statement-block:
    new-lines~opt~ { statement-list~opt~ new-lines~opt~ }

statement-list:
    statement
    statement-list statement

statement:
    if-statement
    label~opt~ labeled-statement
    function-statement
    flow-control-statement statement-terminator
    trap-statement
    try-statement
    data-statement
    inlinescript-statement
    parallel-statement
    sequence-statement
    pipeline statement-terminator

statement-terminator:
    ;
    new-line-character

Popis:

Příkaz určuje určitý druh akce, která se má provést. Pokud není v této klauzuli uvedeno jinak, příkazy se provádějí v lexikálním pořadí.

Blok příkazů umožňuje seskupit sadu příkazů do jedné syntaktické jednotky.

8.1.1 Příkazy s popisky

Syntax:

labeled-statement:
    switch-statement
    foreach-statement
    for-statement
    while-statement
    do-statement

Popis:

Iterační příkaz (§8.4) nebo příkaz přepínače (§8.6) může být volitelně bezprostředně předcházen jedním štítkem příkazu, štítek. Popisek příkazu se používá jako volitelný cíl příkaz přerušení (§8.5.1) nebo pokračovací příkaz (§8.5.2). Popisek ale nezmění tok řízení.

Mezi dvojtečkou (:) a tokenem, který ji následuje, nejsou povoleny žádné prázdné znaky.

Příklady:

:go_here while ($j -le 100) {
    # ...
}

:labelA
for ($i = 1; $i -le 5; ++$i) {
    :labelB
    for ($j = 1; $j -le 3; ++$j) {
        :labelC
        for ($k = 1; $k -le 2; ++$k) {
            # ...
        }
    }
}

8.1.2 Hodnoty výroku

Hodnota příkazu je kumulativní sada hodnot, které zapisuje do potrubí. Pokud příkaz zapíše jednu skalární hodnotu, jedná se o hodnotu příkazu. Pokud příkaz zapíše více hodnot, hodnota příkazu je sada hodnot uložených v prvcích neomezeného jednorozměrného pole, a to v pořadí, v jakém byly zapsány. Podívejte se na následující příklad:

$v = for ($i = 10; $i -le 5; ++$i) { }

Smyčka neobsahuje žádné iterace a do kanálu se nic nezapisuje. Hodnota příkazu je $null.

$v = for ($i = 1; $i -le 5; ++$i) { }

I když smyčka iteruje pětkrát, nic není zapsáno do potrubí. Hodnota příkazu je $null.

$v = for ($i = 1; $i -le 5; ++$i) { $i }

Smyčka iteruje pětkrát, přičemž pokaždé zapisuje do kanálu hodnotu int$i. Hodnota výrazu je object[] o délce 5.

$v = for ($i = 1; $i -le 5; ) { ++$i }

I když smyčka iteruje pětkrát, nic není zapsáno do potrubí. Hodnota příkazu je $null.

$v = for ($i = 1; $i -le 5; ) { (++$i) }

Smyčka iteruje pětkrát a každá hodnota je zapsána do potrubí. Hodnota výrazu je object[] o délce 5.

$i = 1; $v = while ($i++ -lt 2) { $i }

Smyčka se iteruje jednou. Hodnota výroku je int s hodnotou 2.

Tady je několik dalších příkladů:

# if $count is not currently defined then define it with int value 10
$count = if ($count -eq $null) { 10 } else { $count }

$i = 1
$v = while ($i -le 5) {
    $i                   # $i is written to the pipeline
    if ($i -band 1) {

        "odd"            # conditionally written to the pipeline

    }

    ++$i                 # not written to the pipeline

}
# $v is object[], Length 8, value 1,"odd",2,3,"odd",4,5,"odd"

8.2 Příkazy kanálu

Syntax:

pipeline:
    assignment-expression
    expression redirections~opt~ pipeline-tail~opt~
    command verbatim-command-argument~opt~ pipeline-tail~opt~

assignment-expression:
    expression assignment-operator statement

pipeline-tail:
    | new-lines~opt~ command
    | new-lines~opt~ command pipeline-tail

command:
    command-name command-elements~opt~
    command-invocation-operator command-module~opt~ command-name-expr command-elements~opt~

command-invocation-operator: one of
    &   .

command-module:
    primary-expression

command-name:
    generic-token
    generic-token-with-subexpr

generic-token-with-subexpr:
    No whitespace is allowed between ) and command-name.
    generic-token-with-subexpr-start statement-list~opt~ )

command-namecommand-name-expr:
    command-name

primary-expressioncommand-elements:
    command-element
    command-elements command-element

command-element:
    command-parameter
    command-argument
    redirection

command-argument:
    command-name-expr

verbatim-command-argument:
    --% verbatim-command-argument-chars

Popis:

přesměrování je popsáno v §7.12; výraz přiřazení je popsán v §7.11; a operátor příkazu tečka (.) je popsán v §3.5.5. Diskuzi o mapování argumentů na parametr při vyvolání příkazů najdete v tématu §8.14.

Prvním příkazem v kanálu je výraz nebo vyvolání příkazu. Vyvolání příkazu obvykle začíná názvem příkazu, což je obvykle holý identifikátor. elementy příkazového řádku představuje seznam argumentů příkazu. Nový řádek nebo neošetřený středník ukončí řetězení.

Vyvolání příkazu se skládá z názvu příkazu následovaného nulou nebo více argumenty. Pravidla, která řídí argumenty, jsou následující:

• Argument, který není výrazem, ale který obsahuje libovolný text bez prázdné mezery, je považován za dvojitý uvozovek. Písmena se zachovají.

• Uvnitř rozbalitelného řetězcového literálu a rozbalitelného zde-řetězcového literálu se provádí nahrazování proměnných a rozšiřování podvýrazů (§2.3.5.2).

• Text uvnitř uvozovek umožňuje zahrnout počáteční, koncové a vložené prázdné znaky do hodnoty argumentu. [Poznámka: Přítomnost prázdných znaků v argumentu v uvozování nemění jeden argument na více argumentů. koncová poznámka]

• Umístění závorek kolem argumentu způsobí, že se výraz vyhodnotí tak, že se předá výsledek namísto textu původního výrazu.

• Chcete-li předat argument, který vypadá jako parametr přepínače (§2.3.4) ale není tak zamýšlen, uzavřete tento argument do uvozovek.

• Při zadávání argumentu, který odpovídá parametru, který má omezení typu [switch] (§8.10.5), přítomnost názvu argumentu sama o sobě způsobí, že parametr bude nastaven na $true. Hodnotu parametru ale můžete explicitně nastavit tak, že k argumentu připojíte příponu. Například vzhledem k omezenému parametru typu p, argument -p:$true nastaví p na Hodnotu True, zatímco -p:$false nastaví p na False.

• Argument -- označuje, že všechny argumenty, které následují, mají být předány ve skutečné podobě, jako by se kolem nich umístily dvojité uvozovky.

• Argument --% označuje, že všechny argumenty, které následují, se předávají s minimální analýzou a zpracováním. Tento argument se nazývá doslovný parametr. Argumenty za doslovnými parametry nejsou výrazy PowerShellu, i když jsou syntakticky platné výrazy PowerShellu.

Pokud je typ příkazu Application, parametr --% se do příkazu nepředá. Argumenty po --% mají rozšířené všechny proměnné prostředí (řetězce obklopené %). Například:

echoargs.exe --% "%path%" # %path% is replaced with the value $Env:path

Pořadí vyhodnocení argumentů není zadané.

Informace o vazbě parametru naleznete v §8.14. Informace o vyhledávání jmen naleznete v §3.8.

Po dokončení zpracování argumentů se vyvolá příkaz. Pokud se vyvoláný příkaz ukončí normálně (§8.5.4), ovládací prvek se vrátí k bodu ve skriptu nebo funkci bezprostředně po vyvolání příkazu. Popis chování při neobvyklém ukončení viz break (§8.5.1), continue (§8.5.2), throw (§8.5.3), exit (§8.5.5), try (§8.7) a trap (§8.8).

Obvykle se příkaz vyvolá pomocí názvu následovaného libovolnými argumenty. Lze však použít operátor volání příkazů, &. Pokud název příkazu obsahuje nekrytou mezeru, musí být v uvozovkách a spuštěn pomocí tohoto operátoru. Blok skriptu nemá žádný název, musí být také vyvolán pomocí tohoto operátoru. Například následující volání příkazu Get-Factorial jsou ekvivalentní:

Get-Factorial 5
& Get-Factorial 5
& "Get-Factorial" 5

Přímá a nepřímá rekurzivní volání funkcí jsou povolená. Například

function Get-Power([int]$x, [int]$y) {
    if ($y -gt 0) { return $x * (Get-Power $x (--$y)) }
    else { return 1 }
}

Příklady:

New-Object 'int[,]' 3,2
New-Object -ArgumentList 3,2 -TypeName 'int[,]'

dir E:\PowerShell\Scripts\*statement*.ps1 | ForEach-Object {$_.Length}

dir E:\PowerShell\Scripts\*.ps1 |
    Select-String -List "catch" |
    Format-Table Path, LineNumber -AutoSize

8.3 Příkaz if

Syntax:

if-statement:
    if new-lines~opt~ ( new-lines~opt~ pipeline new-lines~opt~ ) statement-block
        elseif-clauses~opt~ else-clause~opt~

elseif-clauses:
    elseif-clause
    elseif-clauses elseif-clause

elseif-clause:
    new-lines~opt~ elseif new-lines~opt~ ( new-lines~opt~ pipeline new-lines~opt~ ) statement-block

else-clause:
    new-lines~opt~ else statement-block

Popis:

potrubí řídicí výrazy musí mít typ bool nebo musí být implicitně konvertibilní na tento typ. Klauzule else- je nepovinná. Může být nula nebo více elseif-podmínek.

Pokud kanál nejvyšší úrovně při testování vyhodnotí hodnotu True, provede se blok příkazů a spuštění příkazu se ukončí. Jinak, pokud je přítomna elseif-klauzule, a její potrubí vyhodnotí jako True, pak se vykoná její blok příkazů a spuštění příkazu se ukončí. Jinak platí, že pokud existuje klauzule else-, spustí se její blok příkazů.

Příklady:

$grade = 92
if ($grade -ge 90) { "Grade A" }
elseif ($grade -ge 80) { "Grade B" }
elseif ($grade -ge 70) { "Grade C" }
elseif ($grade -ge 60) { "Grade D" }
else { "Grade F" }

8.4 Příkazy iterace

8.4.1 Příkaz while

Syntax:

while-statement:
    while new-lines~opt~ ( new-lines~opt~ while-condition new-lines~opt~ ) statement-block

while-condition:
    new-lines~opt~ pipeline

Popis:

Řídicí výraz podmínka while musí mít typ bool nebo musí být implicitně převoditelný na tento typ. Tělo smyčky, které se skládá z bloku příkazů, se provádí opakovaně, dokud řídicí výraz není nepravdivý. Řídicí výraz se vyhodnotí před každým spuštěním těla smyčky.

Příklady:

$i = 1
while ($i -le 5) {                     # loop 5 times
    "{0,1}`t{1,2}" -f $i, ($i*$i)
    ++$i
}

8.4.2 Příkaz do

Syntax:

do-statement:
    do statement-block new-lines~opt~ while new-lines~opt~ ( while-condition new-lines~opt~ )
    do statement-block new-lines~opt~ until new-lines~opt~ ( while-condition new-lines~opt~ )

while-condition:
    new-lines~opt~ pipeline

Popis:

Řídicí výraz podmínka while musí mít typ bool nebo musí být implicitně převoditelný na tento typ. Ve formě while se tělo smyčky, které se skládá z bloku příkazů, provádí opakovaně, zatímco řídicí výraz testuje true. V podobě until se tělo smyčky provádí opakovaně, dokud není řídicí výraz vyhodnocen jako True. Řídicí výraz se vyhodnotí po každém spuštění těla smyčky.

Příklady:

$i = 1
do {
    "{0,1}`t{1,2}" -f $i, ($i * $i)
}
while (++$i -le 5)                 # loop 5 times

$i = 1
do {
    "{0,1}`t{1,2}" -f $i, ($i * $i)
}
until (++$i -gt 5)                 # loop 5 times

8.4.3 Příkaz for

Syntax:

for-statement:
    for new-lines~opt~ (
        new-lines~opt~ for-initializer~opt~ statement-terminator
        new-lines~opt~ for-condition~opt~ statement-terminator
        new-lines~opt~ for-iterator~opt~
        new-lines~opt~ ) statement-block

    for new-lines~opt~ (
        new-lines~opt~ for-initializer~opt~ statement-terminator
        new-lines~opt~ for-condition~opt~
        new-lines~opt~ ) statement-block

    for new-lines~opt~ (
        new-lines~opt~ for-initializer~opt~
        new-lines~opt~ ) statement-block

for-initializer:
    pipeline

for-condition:
    pipeline

for-iterator:
    pipeline

Popis:

Řídicí výraz pro podmínku musí mít typ bool nebo musí být implicitně konvertibilní na tento typ. Tělo smyčky, která se skládá z bloku příkazů, se provádí opakovaně, zatímco řídicí výraz testuje true. Řídicí výraz se vyhodnotí před každým spuštěním těla smyčky.

Výraz pro inicializátor se vyhodnotí před prvním vyhodnocením řídicího výrazu. Výraz pro inicializátor je vyhodnocen pouze pro své vedlejší účinky; jakákoli hodnota, kterou vytvoří, se zahodí a do potrubí se nezapíše.

Výraz iterátoru se vyhodnotí po každém spuštění těla smyčky. Výraz pro iterátor je vyhodnocen pouze pro jeho vedlejší účinky; jakákoli hodnota, kterou vytvoří, se zahodí a nezapíše se do pipelinu.

Pokud je výraz pro podmínku vynechán, řídicí výraz testuje hodnotu True.

Příklady:

for ($i = 5; $i -ge 1; --$i) { # loop 5 times
    "{0,1}`t{1,2}" -f $i, ($i * $i)
}

$i = 5
for (; $i -ge 1; ) { # equivalent behavior
    "{0,1}`t{1,2}" -f $i, ($i * $i)
    --$i
}

8.4.4 Příkaz foreach

Syntax:

foreach-statement:
    foreach new-lines~opt~ foreach-parameter~opt~ new-lines~opt~
        ( new-lines~opt~ variable new-lines~opt~ *in* new-lines~opt~ pipeline
        new-lines~opt~ ) statement-block

foreach-parameter:
    -parallel

Popis:

Tělo smyčky, které se skládá z bloku příkazů, se spouští pro každý prvek určený proměnnou v kolekci určené kanálem . Rozsah proměnné není omezen na příkaz foreach. Proto si zachová konečnou hodnotu po dokončení provádění těla smyčky. Pokud kanál určí skalár (s výjimkou hodnoty $null) místo kolekce, bude tento skalár považován za kolekci jednoho prvku. Pokud kanál určí hodnotu $null, kanál se považuje za kolekci nulových prvků.

Pokud je zadán foreach-parameter-parallel, je chování určeno implementací.

Parametr foreach‑parallel je povolen pouze ve workflow (§8.10.2).

Každý příkaz foreach má vlastní enumerátor, $foreach (§2.3.2.2, §4.5.16), který existuje pouze při provádění smyčky.

Objekty vytvořené potrubím se shromažďují před zahájením spuštění bloku příkazů. Pomocí cmdletu ForEach-Object je však blok příkazů spuštěn na každém objektu, jakmile je vytvořen.

Příklady:

$a = 10, 53, 16, -43
foreach ($e in $a) {
    ...
}
$e # the int value -43

foreach ($e in -5..5) {
    ...
}

foreach ($t in [byte], [int], [long]) {
    $t::MaxValue # get static property
}

foreach ($f in Get-ChildItem *.txt) {
    ...
}

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
foreach ($e in $h1.Keys) {
    "Key is " + $e + ", Value is " + $h1[$e]
}

8.5 Příkazy řízení toku

Syntax:

flow-control-statement:
    break label-expression~opt~
    continue label-expression~opt~
    throw pipeline~opt~
    return pipeline~opt~
    exit pipeline~opt~

label-expression:
    simple-name
    unary-expression

Popis:

Příkaz řízení toku způsobí nepodmíněný přenos řízení do jiného umístění.

8.5.1 Příkaz break

Popis:

Příkaz break s výrazem štítku se označuje jako příkaz break s označením. Příkaz break bez výrazu label-expression se označuje jako neoznačený příkaz break.

Mimo příkaz zachytávání, příkaz break bez označení přímo v rámci příkazu iterace (§8.4) ukončí provádění této nejmenší obalující iterace. Neoznačený příkaz break přímo v rámci příkazu přepínače (§8.6) ukončí vyhodnocení vzorů pro aktuální podmínku přepínače. Podrobnosti o použití break v příkazu 'trap' naleznete v části (§8.8).

Příkaz iterace nebo příkaz switch může být volitelně bezprostředně předcházena jednou značkou (§8.1.1). Taková značka se může použít jako cíl označeného break příkazu, v takovém případě tento příkaz ukončí provádění cílového příkazu iterace.

Není nutné vyřešit označený přechod v žádném místním oboru. Hledání odpovídajícího štítku může pokračovat směrem nahoru zásobníkem volání, i přes hranice skriptu a volání funkce. Pokud se nenajde žádný odpovídající popisek, aktuální vyvolání příkazu se ukončí.

Název štítku určený výrazem štítku nemusí mít konstantní hodnotu.

Pokud je výraz unárním výrazem , převede se na řetězec.

Příklady:

$i = 1
while ($true) { # infinite loop
    if ($i * $i -gt 100) {
        break # break out of current while loop
    }
    ++$i
}

$lab = "go_here"
:go_here
for ($i = 1; ; ++$i) {
    if ($i * $i -gt 50) {
        break $lab # use a string value as target
    }
}

:labelA
for ($i = 1; $i -le 2; $i++) {

    :labelB
    for ($j = 1; $j -le 2; $j++) {

        :labelC
        for ($k = 1; $k -le 3; $k++) {
            if (...) { break labelA }
        }
    }
}

8.5.2 Příkaz continue

Popis:

Příkaz s výrazem popisku se označuje jako příkazu continue. Příkaz continue bez výrazu label-expression se označuje jako neoznačený příkaz continue.

Použití continue v rámci příkazu pro záchyt je popsáno v §8.8.

Neoznačený příkaz continue v rámci smyčky ukončí provádění aktuální smyčky a přenese řízení k zavírací složené závorce nejmenšího uzavírajícího bloku iterace (§8.4). Neoznačený continue příkaz v rámci přepínače ukončí provádění aktuální iterace switch a předá řízení nejmenšímu uzavřenému switchpodmínce přepínače (§8.6).

Iterační příkaz nebo příkaz switch (§8.6) může být volitelně bezprostředně předcházen jedním popiskem příkazu (§8.1.1). Takový popisek příkazu může být použit jako cíl uzavřeného příkazu continue. V takovém případě tento příkaz ukončí provádění aktuální smyčky nebo iterace switch a přenese řízení na cílový popisek příkazu uzavírající iterace nebo switch.

Označený continue nemusí být vyřešen v žádném místním oboru; hledání odpovídajícího označení může pokračovat nahoru po zásobníku volání, dokonce i přes hranice skriptu a volání funkce. Pokud se nenajde žádný odpovídající popisek, aktuální vyvolání příkazu se ukončí.

Název štítku určený výrazem štítku nemusí mít konstantní hodnotu.

Pokud je výraz unárním výrazem , převede se na řetězec.

Příklady:

$i = 1
while (...) {
    ...
    if (...) {
        continue # start next iteration of current loop
    }
    ...
}

$lab = "go_here"
:go_here
for (...; ...; ...) {
    if (...) {
        continue $lab # start next iteration of labeled loop
    }
}

:labelA
for ($i = 1; $i -le 2; $i++) {

    :labelB
    for ($j = 1; $j -le 2; $j++) {

        :labelC
        for ($k = 1; $k -le 3; $k++) {
            if (...) { continue labelB }
        }
    }
}

8.5.3 Příkaz throw

Popis:

Výjimkou je způsob zpracování chybového stavu na úrovni systému nebo aplikace. Příkaz throw vyvolá výjimku. (Informace o zpracování výjimek najdete v §8.7.)

Pokud je kanál vynechán a příkaz throw není v klauzuli catch, chování je definováno implementací. Pokud je kanál přítomen a příkaz throw je v klauzuli catch, výjimka zachycená touto klauzulí catch je znovu vyvolána po provedení jakékoli klauzule finally přidružené k klauzuli catch.

Pokud je přítomen kanál , je typ vyvolané výjimky definován implementací.

Při vyvolání výjimky se ovládací prvek přenese do první zachytácí klauzule v uzavřeném příkazu try, který dokáže zpracovat výjimku. Místo, kde je výjimka zpočátku vyvolána, se nazývá bod vyhození. Jakmile je vyvolána výjimka, kroky popsané v §8.7 jsou opakovány, dokud se nenajde klauzule catch, která odpovídá výjimce, nebo se nenajde žádná.

Příklady:

throw
throw 100
throw "No such record in file"

Pokud je kanál vynechán a příkaz throw není uvnitřcatch-klauzule, je text "ScriptHalted" zapsán do kanálu a typ vyvolané výjimky je .

Pokud je kanál přítomen, výjimka je vyvolána a zabalena do objektu typu System.Management.Automation.RuntimeException, který obsahuje informace o výjimce jako objekt System.Management.Automation.ErrorRecord (přístupné prostřednictvím $_).

Příklad 1: výsledkem throw 123 je výjimka typu RuntimeException. V rámci bloku catch $_.TargetObject obsahuje objekt zabalený uvnitř, v tomto případě System.Int32 s hodnotou 123.

Příklad 2: výsledkem throw "xxx" je výjimka typu RuntimeException. V rámci bloku catch $_.TargetObject obsahuje objekt zabalený uvnitř, v tomto případě System.String s hodnotou xxx.

Příklad 3: výsledkem throw 10,20 je výjimka typu RuntimeException. Z bloku catch $_.TargetObject obsahuje objekt zabalený uvnitř, v tomto případě System.Object[], což je neomezené pole dvou prvků s hodnotami typu System.Int32, konkrétně 10 a 20.

8.5.4 Příkaz return

Popis:

Příkaz return zapíše do kanálu hodnoty určené kanálem , pokud nějaké existují, a vrátí řízení volajícímu skriptu nebo funkci. Funkce nebo skript můžou mít nulové nebo více příkazů return.

Pokud provádění dosáhne závěrečné složené závorky funkce, předpokládá se implicitní return bez potrubí .

Příkaz return je určitým druhem 'syntaktického cukru', který umožňuje programátorům vyjádřit se tak, jak mohou v jiných jazycích. Vrácená hodnota funkcí nebo skriptem je ve skutečnosti tvořena všemi hodnotami zapsanými do kanálu pomocí této funkce nebo skriptu, plus jakékoliv hodnoty zadané kanálem . Je-li do datového toku zapsána pouze skalární hodnota, její typ je typ vrácené hodnoty; v opačném případě je návratovým typem neomezené jednorozměrné pole obsahující všechny hodnoty zapsané do datového toku.

Příklady:

function Get-Factorial ($v) {
    if ($v -eq 1) {
        return 1 # return is not optional
    }

    return $v * (Get-Factorial ($v - 1)) # return is optional
}

Při volání na Get-Factorial se vrátí int.

function Test {
    "text1" # "text1" is written to the pipeline
    # ...
    "text2" # "text2" is written to the pipeline
    # ...
    return 123 # 123 is written to the pipeline
}

Volajícímu na Test se vrátí neomezené 1rozměrné pole se třemi prvky.

8.5.5 Příkaz exit

Popis:

Příkaz exit ukončí aktuální skript a vrátí ovládací prvek a ukončovací kód do hostitelského prostředí nebo volajícího skriptu. Pokud je poskytnut kanál , hodnota, kterou označuje, se v případě potřeby převede na int. Pokud neexistuje žádný takový převod nebo pokud kanál vynecháte, vrátí se hodnota int nula.

Příklady:

exit $count # terminate the script with some accumulated count

8.6 Příkaz "switch"

Syntax:

switch-statement:
    switch new-lines~opt~ switch-parameters~opt~ switch-condition switch-body

switch-parameters:
    switch-parameter
    switch-parameters switch-parameter

switch-parameter:
    -Regex
    -Wildcard
    -Exact
    -CaseSensitive
    -Parallel

switch-condition:
    ( new-lines~opt~ pipeline new-lines~opt~ )
    -File new-lines~opt~ switch-filename

switch-filename:
    command-argument
    primary-expression

switch-body:
    new-lines~opt~ { new-lines~opt~ switch-clauses }

switch-clauses:
    switch-clause
    switch-clauses switch-clause

switch-clause:
    switch-clause-condition statement-block statement-terimators~opt~

switch-clause-condition:
    command-argument
    primary-expression

Popis:

Pokud switch-condition určí jednu hodnotu, předá se řízení do jednoho nebo více bloků příkazů, které odpovídají vzoru. Pokud se žádné vzory neshodují, je možné provést nějakou výchozí akci.

Přepínač musí obsahovat jednu nebo více klauzulí switch, přičemž každá začíná vzorem (nedefaultní switch klauzule) nebo klíčovým slovem (výchozí switch klauzule). Přepínač musí obsahovat nula nebo jednu default klauzuli switch a nula nebo více nevýchozích klauzulí switch. Klauzule Switch mohou být zapsány v libovolném pořadí.

Více vzorů může mít stejnou hodnotu. Vzor nemusí být literál a přepínač může mít vzory s různými typy.

Pokud hodnota podmínky přepínače odpovídá vzorové hodnotě, spustí se blok příkazů vzoru . Pokud více hodnot vzorku odpovídá hodnotě switch-condition, provede se blok příkazů každého odpovídajícího vzoru v lexikálním pořadí, pokud některý z těchto bloků příkazů neobsahuje break příkaz (§8.5.1).

Pokud hodnota switch-condition neodpovídá žádné hodnotě vzoru, a pokud existuje klauzule default switch, provede se její blok příkazů; jinak se ukončí porovnávání vzorů pro tuto switch-condition.

Přepínače mohou být vnořené a každý přepínač má svou vlastní sadu příkazů switch. V takových případech příkaz switch patří k nejvnitřnějšímu přepínači, který je aktuálně v rozsahu.

Při vstupu do každého bloku příkazů je automaticky přiřazená hodnota $_, která způsobila přenesení ovládání na tento blok příkazů. $_ je také k dispozici v tom bloku příkazůve podmínce přepínače.

Porovnávání neřetězcových hodnot se provádí testováním rovnosti (§7.8.1).

Pokud porovnávání zahrnuje řetězce, porovnání je ve výchozím nastavení nerozlišující malá a velká písmena. Přítomnost parametru přepínače -CaseSensitive způsobuje, že porovnání rozlišuje malá a velká písmena.

Vzor může obsahovat zástupné znaky (§3.15), v takovém případě se provádějí porovnání řetězců se zástupnými znaky, ale pouze v případě, že je k dispozici parametr přepínače -Wildcard. Ve výchozím nastavení porovnání nerozlišuje malá a velká písmena.

Vzor může obsahovat regulární výraz (§3.16), v takovém případě se provádí porovnání řetězců regulárních výrazů, ale pouze v případě, že je k dispozici přepínač-parametr -Regex. Ve výchozím nastavení porovnání nerozlišuje malá a velká písmena. Pokud je přítomen -Regex a vzor se zachytí, $Matches se definuje v klauzuli switchbloku příkazů pro tento vzor.

Parametr přepínače může být zkrácen; lze použít libovolnou jedinečnou úvodní část parametru. Například ‑Regex, ‑Rege, ‑Reg, ‑Rea ‑R jsou ekvivalentní.

Pokud jsou zadány konfliktní parametry přepínače , převládne ten, který je lexikálně poslední. Přítomnost ‑Exact zakáže -Regex a -Wildcard; nemá však žádný vliv na ‑Case.

Pokud je zadán parametr přepínače‑Parallel, je chování definováno implementací.

Parametr přepínače ‑Parallel je povolen pouze v pracovním postupu (§8.10.2).

Pokud je vzor script-block-expression, tento blok se v případě potřeby vyhodnotí a výsledek se převede na logickou hodnotu. Pokud má výsledek hodnotu $true, provede se odpovídající blok příkazů; jinak to není.

Pokud podmínka přepínače určí více hodnot, použije se přepínač na každou hodnotu v lexikálním pořadí pomocí pravidel popsaných výše pro podmínku přepínače , která určuje jednu hodnotu. Každý příkaz přepínače má vlastní enumerátor, $switch (§ 2.3.2.2, §4.5.16), který existuje pouze při provádění daného přepínače.

Příkaz přepínače může mít popisek a může obsahovat označené a neoznačené příkazy přerušení (§8.5.1) a pokračování (§8.5.2).

Pokud je přepínač-podmínka-Filenázev-souboru, místo iterace přes hodnoty ve výrazu přepínač iteruje přes hodnoty v souboru určeném název-souboru. Soubor se čte po řádcích, přičemž každý řádek obsahuje hodnotu. V hodnotách nejsou zahrnuty znaky ukončení řádku.

Příklady:

$s = "ABC def`nghi`tjkl`fmno @#$"
$charCount = 0; $pageCount = 0; $lineCount = 0; $otherCount = 0
for ($i = 0; $i -lt $s.Length; ++$i) {
    ++$charCount
    switch ($s[$i]) {
        "`n" { ++$lineCount }
        "`f" { ++$pageCount }
        "`t" { }
        " " { }
        default { ++$otherCount }
    }
}

switch -Wildcard ("abc") {
    a* { "a*, $_" }
    ?B? { "?B? , $_" }
    default { "default, $_" }
}

switch -Regex -CaseSensitive ("abc") {
    ^a* { "a*" }
    ^A* { "A*" }
}

switch (0, 1, 19, 20, 21) {
    { $_ -lt 20 } { "-lt 20" }
    { $_ -band 1 } { "Odd" }
    { $_ -eq 19 } { "-eq 19" }
    default { "default" }
}

8.7 Příkaz try/finally

Syntax:

try-statement:
    try statement-block catch-clauses
    try statement-block finally-clause
    try statement-block catch-clauses finally-clause

catch-clauses:
    catch-clause
    catch-clauses catch-clause

catch-clause:
    new-lines~opt~ catch catch-type-list~opt~
    statement-block

catch-type-list:
    new-lines~opt~ type-literal
    catch-type-list new-lines~opt~ , new-lines~opt~

type-literalfinally-clause:
    new-lines~opt~ finally statement-block

Popis:

Příkaz try poskytuje mechanismus pro zachytávání výjimek, ke kterým dochází během provádění bloku. Příkaz try také umožňuje určit blok kódu, který se vždy spustí, když ovládací prvek opustí příkaz try. Proces vyvolání výjimky prostřednictvím příkazu throw je popsán v §8.5.3.

try block je blok příkazů přidružený k příkazu try. Blok catch je blok příkazů přidružený ke klauzule catch. A nakonec blok je blok příkazů přidružený k klauzuli finally.

Klauzule catch bez seznamu typů catch se nazývá obecná klauzule catch.

Každá catch-klauzule je obslužná rutina pro výjimky, a catch-klauzule, jejíž catch-type-list obsahuje typ vyvolané výjimky, je odpovídající platná klauzule catch. Obecná klauzule catch odpovídá všem typům výjimek.

I když catch klauzule a finally klauzule jsou volitelné, musí existovat alespoň jedna z nich.

Zpracování vyvolané výjimky spočívá v opakovaném vyhodnocování následujících kroků, dokud se nenajde klauzule typu catch, která odpovídá výjimce.

• V aktuálním kontextu se zkoumá každý příkaz try, který zahrnuje bod vyvolání. Pro každý příkaz try S, počínaje nejvnitřnějším příkazem try a končícím nejkrajnějším příkazem try, jsou vyhodnoceny následující kroky:

  • Pokud blok try z S zahrnuje bod vyvolání a pokud S obsahuje jednu nebo více klauzulí catch, jsou klauzule catch zkoumány v lexikálním pořadí, aby se našla vhodná obsluha pro výjimku. První klauzule catch, která určuje typ výjimky nebo základní typ výjimky, se považuje za shodu. Obecná klauzule catch se považuje za platnou pro jakýkoli typ výjimky. Pokud se nachází odpovídající klauzule catch, zpracování výjimek se dokončí přenesením ovládacího prvku do bloku této klauzule catch. V rámci odpovídající klauzule catch obsahuje proměnná $_ popis aktuální výjimky.

  • Jinak platí, že pokud blok try nebo blok catchS uzavře bod vyvolání a pokud S má blok finally, ovládací prvek se přenese do bloku finally. Pokud finally blok vyvolá jinou výjimku, zpracování aktuální výjimky se ukončí. V opačném případě, když ovládací prvek dosáhne konce finally bloku, zpracování aktuální výjimky bude pokračovat.

• Pokud nebyla nalezena obslužná rutina výjimky v aktuálním oboru, výše uvedené kroky se opakují pro nadřazený obor s bodem vyvolání odpovídajícím příkazu, z něhož byl vyvolán aktuální obor.

• Pokud zpracování výjimek skončí tím, že ukončí všechny obory, což znamená, že pro výjimku neexistuje obsluha, chování není určeno.

Pokud chcete zabránit nedostupným klauzulím catch v bloku try, nesmí klauzule catch určit typ výjimky, který je roven nebo odvozen z typu zadaného v dřívější klauzuli catch v rámci stejného bloku try.

Příkazy bloku finally se vždy provádějí, když ovládací prvek opustí příkaz try. To platí, ať už dochází k přenosu řízení v důsledku normálního spuštění programu, provedení příkazů break, continue nebo return, nebo v důsledku vyvolání výjimky v příkazu try.

Pokud se při provádění bloku finally vyvolá výjimka, je předána do nejbližšího obalujícího příkazu try. Pokud v procesu zpracování došlo k jiné výjimce, dojde ke ztrátě této výjimky. Proces generování výjimky je podrobněji popsán v popisu příkazu throw.

try příkazy mohou existovat společně s příkazy trap; podrobnosti naleznete v §8.8.

Příklady:

$a = New-Object 'int[]' 10
$i = 20 # out-of-bounds subscript

while ($true) {
    try {
        $a[$i] = 10
        "Assignment completed without error"
        break
    }

    catch [IndexOutOfRangeException] {
        "Handling out-of-bounds index, >$_<`n"
        $i = 5
    }

    catch {
        "Caught unexpected exception"
    }

    finally {
        # ...
    }
}

Každá vyvolaná výjimka je vyvolána jako System.Management.Automation.RuntimeException. Pokud existují klauzule specifické pro konkrétní typ v rámci bloku , zkontroluje se vlastnost try výjimky, aby se pokusilo nalézt shodu, například s typem uvedeným výše.

8.8 Příkaz trapu

Syntax:

trap-statement:
    *trap* new-lines~opt~ type-literal~opt~ new-lines~opt~ statement-block

Popis:

Příkaz s a bez typu-literal je podobný bloku (§8.7) s a bez seznamu typů catch , s tím rozdílem, že příkaz může zachytit pouze jeden typ současně.

Více příkazů trap lze definovat ve stejném bloku příkazůa jejich pořadí definice je irelevantní. Pokud jsou dva příkazy trap se stejným literálem typu definovány ve stejném oboru, použije se lexicky první příkaz ke zpracování výjimky odpovídajícího typu.

Na rozdíl od bloku catchtrap příkaz přesně odpovídá typu výjimky; Neprovádí se žádné porovnávání odvozených typů.

Pokud dojde k výjimce, a v aktuálním oboru není k dispozici žádný odpovídající příkaz trap, vyhledá se odpovídající příkaz trap v nadřazeném oboru, což může zahrnovat hledání ve volajícím skriptu, funkci nebo filtru, a potom ve volajícím, atd. Pokud vyhledávání nakonec vede k ukončení všech rozsahů a naznačuje, že pro výjimku neexistuje žádný obslužný kód, výsledné chování není specifikováno.

Tělo příkazu trap provede pouze zpracování odpovídající výjimky; jinak ho provádění předá.

Pokud traptext příkazu normálně ukončí, je ve výchozím nastavení zapsán do chybového proudu objekt chyby, výjimka je považována za zpracovanou a provádění pokračuje bezprostředně za příkazem v oboru, který obsahuje příkaz trap, jenž způsobil, že výjimka byla viditelná. Příčinou výjimky může být příkaz volaný příkazem obsahujícím příkaz trap.

Pokud je konečný příkaz proveden v trap's těle příkazu 'continue' (§8.5.2), zápis objektu chyby do chybového proudu je potlačen a provádění pokračuje příkazem přímo po tom v rozsahu, který obsahuje příkaz 'trap', jenž učinil výjimku viditelnou. Pokud je konečný příkaz spuštěný v traptextu příkazu příkazem break (§8.5.1), je zápis objektu chyby do datového proudu chyby potlačen a výjimka je znovu vyvolána.

Uvnitř příkazu trap proměnná $_ obsahuje popis aktuální chyby.

Vezměte v úvahu případ, kdy výjimka vyvolaná z bloku try nemá odpovídající blok catch, ale odpovídající příkaz trap existuje na vyšší úrovni bloku. Po provedení klauzule finally bloku try získá příkaz trap kontrolu, i když má některý nadřazený obor odpovídající blok catch. Pokud je příkaz trap definován v samotném bloku try a tento blok try má odpovídající blok catch, příkaz trap získá kontrolu.

Příklady:

V následujícím příkladu je objekt chyby zaznamenán a provádění pokračuje přímo příkazem následujícím za příkazem, který způsobil výjimku; to znamená, že "Hotovo" je zapsáno do pipeline.

$j = 0; $v = 10/$j; "Done"
trap { $j = 2 }

V následujícím příkladu je zápis objektu chyby potlačen a provádění pokračuje příkazem, který následuje bezprostředně po tom, který chybu způsobil; to znamená, že "Hotovo" je zapsáno do pipeline.

$j = 0; $v = 10/$j; "Done"
trap { $j = 2; continue }

V následujícím příkladu je zápis objektu chyby potlačen a výjimka je znovu vyvolána.

$j = 0; $v = 10/$j; "Done"
trap { $j = 2; break }

V následujícím příkladu jsou příkazy pasti a generování výjimek ve stejném oboru. Po zachycení a zpracování výjimky se provádění obnoví zápisem čísla 1 do kanálu.

&{trap{}; throw '\...'; 1}

V následujícím příkladu jsou příkazy pro zpracování výjimek a generování výjimek v různých úrovních. Po zachycení a zpracování výjimky se provádění obnoví zápisem 2 (ne 1) do potrubí.

trap{} &{throw '\...'; 1}; 2

8.9 Deklarace dat

Syntax:

data-statement:
    data new-lines~opt~ data-name data-commands-allowed~opt~ statement-block

data-name:
    simple-name

data-commands-allowed:
    new-lines~opt~ -SupportedCommand data-commands-list

data-commands-list:
    new-lines~opt~ data-command
    data-commands-list , new-lines~opt~ data-command

data-command:
    command-name-expr

Popis:

Příkaz data vytvoří oddíl dat, přičemž data daného oddílu jsou oddělená od kódu. Toto oddělení podporuje funkcionality, jako jsou samostatné soubory textových řetězců pro text, jako jsou chybové zprávy a řetězce nápověd. Pomáhá také podporovat internacionalizaci tím, že usnadňuje izolaci, vyhledání a zpracování řetězců, které budou přeloženy do různých jazyků.

Skript nebo funkce mohou mít nula nebo více datových sekcí.

Blok příkazů datového oddílu je omezen pouze na následující funkce PowerShellu:

• Všechny operátory kromě -match
• Příkaz if
• Následující automatické proměnné: $PSCulture, $PSUICulture, $true, $falsea $null.
• Komentáře
• Pipelines
• Výroky oddělené středníky (;)
• Literalové hodnoty
• Volání příkazu ConvertFrom-StringData
• Všechny ostatní cmdlety identifikované prostřednictvím parametru SupportedCommand

Pokud se používá rutina ConvertFrom-StringData, lze páry klíč/hodnota vyjádřit pomocí libovolné formy řetězcového literálu. expandable-string-literals a expandable-here-string-literals nesmí obsahovat žádné nahrazení proměnných ani rozšíření dílčích výrazů.

Příklady:

Parametr SupportedCommand indikuje, že dané rutiny nebo funkce generují pouze data. Například následující část dat obsahuje rutinu napsanou uživatelem, ConvertTo-Xml, která formátuje data v souboru XML:

data -SupportedCommand ConvertTo-Xml {
    Format-Xml -Strings string1, string2, string3
}

Podívejte se na následující příklad, ve kterém datový oddíl obsahuje příkaz ConvertFrom-StringData, který převádí řetězce na tabulku hash, jejíž hodnota je přiřazena k $messages.

$messages = data {
    ConvertFrom-StringData -StringData @'
    Greeting = Hello
    Yes = yes
    No = no
'@
}

K klíčům a hodnotám tabulky hash se přistupuje pomocí $messages.Greeting, $messages.Yesa $messages.No.

Nyní to můžete uložit jako anglický zdroj. Prostředky pro němčinu a španělštinu lze vytvářet v samostatných souborech s následujícími datovými částmi:

$messages = data {
    ConvertFrom-StringData -StringData @"
    Greeting = Guten Tag
    Yes = ja
    No = nein
"@
}

$messagesS = data {
    ConvertFrom-StringData -StringData @"
    Greeting = Buenos días
    Yes = sí
    No = no
"@
}

Pokud název dat existuje, pojmenuje proměnnou (bez použití úvodní $), do které se má uložit hodnota datového příkazu. Konkrétně $name = data { ... } odpovídá data name { ... }.

8.10 Definice funkcí

Syntax:

function-statement:
    function new-lines~opt~ function-name function-parameter-declaration~opt~ { script-block }
    filter new-lines~opt~ function-name function-parameter-declaration~opt~ { script-block }
    workflow new-lines~opt~ function-name function-parameter-declaration~opt~ { script-block }

function-name:
    command-argument

command-argument:
    command-name-expr

function-parameter-declaration:
    new-lines~opt~ ( parameter-list new-lines~opt~ )

parameter-list:
    script-parameter
    parameter-list new-lines~opt~ , script-parameter

script-parameter:
    new-lines~opt~ attribute-list~opt~ new-lines~opt~ variable script-parameter-default~opt~

script-block:
    param-block~opt~ statement-terminators~opt~ script-block-body~opt~

param-block:
    new-lines~opt~ attribute-list~opt~ new-lines~opt~ param new-lines~opt~
        ( parameter-list~opt~ new-lines~opt~ )

parameter-list:
    script-parameter
    parameter-list new-lines~opt~ , script-parameter

script-parameter-default:
    new-lines~opt~ = new-lines~opt~ expression

script-block-body:
    named-block-list
    statement-list

named-block-list:
    named-block
    named-block-list named-block

named-block:
    block-name statement-block statement-terminators~opt~

block-name: one of
    dynamicparam   begin   process   end

Popis:

Definice funkce určuje název funkce, filtru nebo pracovního postupu, který se definuje, a názvy jeho parametrů( pokud existuje). Obsahuje také nula či více příkazů, které se provádějí k dosažení účelu dané funkce.

Každá funkce je instance třídy System.Management.Automation.FunctionInfo.

Funkce filtru 8.10.1

Zatímco běžná funkce se spustí jednou v datovém kanálu a přistupuje ke vstupní kolekci přes $input, filtr je speciální druh funkce, která se spustí jednou pro každý objekt ve vstupní kolekci. Objekt, který se právě zpracovává, je k dispozici prostřednictvím proměnné $_.

Filtr bez pojmenovaných bloků (§8.10.7) je ekvivalentní funkci s blokem procesu, ale bez počátečního nebo koncového bloku.

Zvažte následující definici a volání funkce filtru:

filter Get-Square2 { # make the function a filter
    $_ * $_ # access current object from the collection
}

-3..3 | Get-Square2 # collection has 7 elements
6, 10, -3 | Get-Square2 # collection has 3 elements

Každý filtr je instance třídy System.Management.Automation.FilterInfo (§4.5.11).

8.10.2 Pracovní postupy

Funkce pracovního postupu je jako běžná funkce s implementací definovanou sémantikou. Funkce pracovního postupu se přeloží do posloupnosti aktivit Windows Workflow Foundation a provádí se v modulu Windows Workflow Foundation.

8.10.3 Zpracování argumentů

Zvažte následující definici funkce s názvem Get-Power:

function Get-Power ([long]$Base, [int]$Exponent) {
    $result = 1
    for ($i = 1; $i -le $Exponent; ++$i) {
        $result *= $Base
    }
    return $result
}

Tato funkce má dva parametry, $Base a $Exponent. Obsahuje také sadu příkazů, které pro nezáporné exponentové hodnoty vypočítá $Base^$Exponent^ a vrátí výsledek pro volajícího Get-Power.

Když skript, funkce nebo filtr zahájí provádění, každý parametr se inicializuje na odpovídající hodnotu argumentu. Pokud neexistuje žádný odpovídající argument a je zadána výchozí hodnota (§8.10.4) , použije se tato hodnota; v opačném případě se použije hodnota $null. Každý parametr je tedy nová proměnná stejně, jako kdyby byl inicializován přiřazením na začátku bloku skriptu .

Pokud parametr skriptu obsahuje omezení typu (například [long] a [int] výše), hodnota odpovídajícího argumentu se v případě potřeby převede na tento typ; jinak nedojde k žádnému převodu.

Když skript, funkce nebo filtr zahájí provádění, proměnná $args je uvnitř definována jako nekontrénované jednorozměrné pole, které obsahuje všechny argumenty, které nejsou vázané podle názvu nebo pozice, v lexikálním pořadí.

Zvažte následující definici funkce a volání:

function F ($a, $b, $c, $d) { ... }

F -b 3 -d 5 2 4       # $a is 2, $b is 3, $c is 4, $d is 5, $args Length 0
F -a 2 -d 3 4 5       # $a is 2, $b is 4, $c is 5, $d is 3, $args Length 0
F 2 3 4 5 -c 7 -a 1   # $a is 1, $b is 2, $c is 7, $d is 3, $args Length 2

Další informace o vazbě parametru naleznete §8.14.

8.10.4 Inicializátory parametrů

Deklarace parametru p může obsahovat inicializátor, v takovém případě se hodnota inicializátoru používá k inicializaci p za předpokladu, že p není vázán na žádné argumenty ve volání.

Zvažte následující definici funkce a volání:

function Find-Str ([string]$Str, [int]$StartPos = 0) { ... }

Find-Str "abcabc" # 2nd argument omitted, 0 used for $StartPos
Find-Str "abcabc" 2 # 2nd argument present, so it is used for $StartPos

8.10.5 Omezení typu [switch]

Při předání parametru přepínače musí být odpovídající parametr v příkazu omezen přepínačem typu. Přepínač typu má dvě hodnoty, Pravda a Nepravda.

Zvažte následující definici funkce a volání:

function Process ([switch]$Trace, $P1, $P2) { ... }

Process 10 20                # $Trace is False, $P1 is 10, $P2 is 20
Process 10 -Trace 20         # $Trace is True, $P1 is 10, $P2 is 20
Process 10 20 -Trace         # $Trace is True, $P1 is 10, $P2 is 20
Process 10 20 -Trace:$false  # $Trace is False, $P1 is 10, $P2 is 20
Process 10 20 -Trace:$true   # $Trace is True, $P1 is 10, $P2 is 20

8.10.6 Kanály a funkce

Při použití skriptu, funkce nebo filtru v potrubí se do tohoto skriptu, funkce nebo filtru doručí kolekce hodnot. Skript, funkce nebo filtr získá přístup k této kolekci prostřednictvím enumerátoru $input (§2.3.2.2, §4.5.16), který je definován při zadávání do tohoto skriptu, funkce nebo filtru.

Zvažte následující definici funkce a volání:

function Get-Square1 {
    foreach ($i in $input) {   # iterate over the collection
        $i * $i
    }
}

-3..3 | Get-Square1            # collection has 7 elements
6, 10, -3 | Get-Square1        # collection has 3 elements

8.10.7 Pojmenované bloky

Příkazy v bloku skriptu můžou patřit do jednoho velkého nepojmenovaného bloku nebo je lze distribuovat do jednoho nebo více pojmenovaných bloků. Pojmenované bloky umožňují vlastní zpracování kolekcí pocházejících z kanálů; pojmenované bloky lze definovat v libovolném pořadí.

Příkazy v begin block (tj. jeden označený klíčovým slovem begin) se spustí jednou před doručením prvního objektu zpracovatelského kanálu.

Příkazy v bloku procesu (tj. v jednom označeném s klíčovým slovem proces) se spouštějí pro každý zpracovávaný objekt potrubí. ($_ poskytuje přístup k aktuálnímu objektu zpracovávaným ze vstupní kolekce pocházející z kanálu.) To znamená, že pokud se prostřednictvím kanálu odešle kolekce nulových prvků, blok procesu se vůbec nespustí. Pokud je však skript nebo funkce volána mimo kontext potrubí, tento blok se provede přesně jednou a $_ je nastaven na $null, protože neexistuje žádný aktuální objekt kolekce.

Příkazy v koncovém bloku (tj. jeden označený koncem klíčového slova) se spustí jednou po doručení posledního objektu kanálu.

8.10.8 dynamický parametr blok

Pododdíly §8.10 dosud řeší statické parametry, které jsou definovány jako součást zdrojového kódu. Je také možné definovat dynamické parametry prostřednictvím dynamického bloku, jiné formy pojmenovaného bloku (§8.10.7), který je označen klíčovým slovem dynamicparam. Většina tohoto stroje je definována implementací.

Dynamické parametry jsou parametry rutiny, funkce, filtru nebo skriptu, které jsou k dispozici pouze za určitých podmínek. Jedním z takových případů je parametr kódování cmdletu Set-Item.

V bloku příkazůpoužijte příkaz if k určení podmínek, za kterých je parametr k dispozici ve funkci. Pomocí rutiny New-Object vytvořte objekt typu definovaného implementací, který představuje parametr, a zadejte jeho název. Pomocí New-Object také vytvořte objekt jiného typu definovaného implementací, který představuje atributy definované implementací parametru.

Následující příklad ukazuje funkci se standardními parametry s názvem Name a Path a volitelný dynamický parametr s názvem DP1. Parametr DP1 je v sadě parametrů PSet1 a má typ Int32. Parametr DP1 je k dispozici ve funkci Sample pouze v případě, že hodnota parametru Path obsahuje "HKLM:", což znamená, že se používá v jednotce registru HKEY_LOCAL_MACHINE.

function Sample {
    param ([string]$Name, [string]$Path)
    dynamicparam {
        if ($Path -match "*HKLM*:") {
            $dynParam1 = New-Object System.Management.Automation.RuntimeDefinedParameter("dp1", [int32], $attributeCollection)

            $attributes = New-Object System.Management.Automation.ParameterAttribute
            $attributes.ParameterSetName = 'pset1'
            $attributes.Mandatory = $false

            $attributeCollection = New-Object -Type System.Collections.ObjectModel.Collection``1[System.Attribute]
            $attributeCollection.Add($attributes)

            $paramDictionary = New-Object System.Management.Automation.RuntimeDefinedParameterDictionary
            $paramDictionary.Add("dp1", $dynParam1)
            return $paramDictionary
        }
    }
}

Typ použitý k vytvoření objektu představující dynamický parametr je System.Management.Automation.RuntimeDefinedParameter.

Typ použitý k vytvoření objektu představující atributy parametru je System.Management.Automation.ParameterAttribute.

Atributy definované implementací parametru zahrnují Povinné, Positiona ValueFromPipeline.

Blok paramů 8.10.9

param-block poskytuje alternativní způsob deklarování parametrů. Například následující sady deklarací parametrů jsou ekvivalentní:

function FindStr1 ([string]$Str, [int]$StartPos = 0) { ... }
function FindStr2 {
    param ([string]$Str, [int]$StartPos = 0) ...
}

param-block umožňuje seznam atributů na param-block, zatímco deklarace parametru funkce to neumožňuje.

Skript může mít param-block , ale ne function-parameter-declaration . Definice funkce nebo filtru může mít deklaraci parametru funkce nebo param-block, ale ne obojí.

Podívejte se na následující příklad:

param ( [Parameter(Mandatory = $true, ValueFromPipeline=$true)]
        [string[]] $ComputerName )

Jeden parametr, $ComputerName, má typ string[], je povinný a přebírá vstup z kanálu.

Podívejte se na diskuzi o atributu parametru v §12.3.7 a na další příklady.

8.11 Paralelní příkaz

Syntax:

parallel-statement:
    *parallel* statement-block

Paralelní příkaz obsahuje nula nebo více příkazů, které se spouští definovaným způsobem implementace.

Paralelní příkaz je povolen pouze v pracovním postupu (§8.10.2).

8.12 Příkaz sekvence

Syntax:

sequence-statement:
    *sequence* statement-block

Příkaz sekvence obsahuje nula nebo více příkazů, které se spouští způsobem určeným implementací.

Příkaz sekvence je povolen pouze v pracovním postupu (§8.10.2).

8.13 Příkaz inlinescript

Syntax:

inlinescript-statement:
    inlinescript statement-block

Příkaz inline skriptu obsahuje nula nebo více příkazů, které se spouští způsobem definovaným implementací.

Příkaz Inlinescript je povolen pouze v pracovním postupu (§8.10.2).

8.14 Vazba parametru

Při vyvolání skriptu, funkce, filtru nebo rutiny může být každý argument svázán s odpovídajícím parametrem podle pozice s prvním parametrem, který má nulu pozice.

Zvažte následující fragment definice funkce nazvané Get-Powera její volání:

function Get-Power ([long]$Base, [int]$Exponent) { ... }

Get-Power 5 3       # argument 5 is bound to parameter $Base in position 0
                    # argument 3 is bound to parameter $Exponent in position 1
                    # no conversion is needed, and the result is 5 to the power 3

Get-Power 4.7 3.2   # double argument 4.7 is rounded to int 5, double argument
                    # 3.2 is rounded to int 3, and result is 5 to the power 3

Get-Power 5         # $Exponent has value $null, which is converted to int 0

Get-Power           # both parameters have value $null, which is converted to int 0

Při vyvolání skriptu, funkce, filtru nebo rutiny může být argument vázán na odpovídající parametr podle názvu. To se provádí pomocí parametru s argumentem, což je argument, který je název parametru s úvodní pomlčkou (-), následovanou přidruženou hodnotou tohoto argumentu. Použitý název parametru může mít libovolný tvar bez ohledu na velikost písmen a může využít libovolnou předponu, která jednoznačně určuje odpovídající parametr. Při volbě názvů parametrů nepoužívejte názvy běžných parametrů.

Zvažte následující volání funkce Get-Power:

Get-Power -Base 5 -Exponent 3   # -Base designates $Base, so 5 is
                                # bound to that, -Exponent designates
                                # $Exponent, so 3 is bound to that

Get-Power -Exp 3 -Bas 5         # $Base takes on 5 and $Exponent takes on 3

Get-Power -E 3 -B 5             # $Base takes on 5 and $Exponent takes on 3

Na druhou stranu volání následující funkce

function Get-Hypot ([double]$Side1, [double]$Side2) {
    return [Math]::Sqrt($Side1 * $Side1 + $Side2 * $Side2)
}

musí používat parametry -Side1 a -Side2, protože neexistuje žádná předpona, která jednoznačně určuje parametr.

Stejný název parametru nelze použít vícekrát s různými přidruženými hodnotami argumentů nebo bez ní.

Parametry mohou mít atributy (§12). Informace o jednotlivých atributech naleznete v oddílech v §12.3. Informace o sadách parametrů naleznete v §12.3.7.

Skript, funkce, filtr nebo cmdlet může přijímat argumenty prostřednictvím příkazového řádku vyvolání, z kanálu nebo z obou zdrojů. Tady jsou kroky v pořadí pro vyřešení vazby parametrů:

1. Všechny pojmenované parametry nejprve svázat a pak
2. Proveďte vazbu pozičních parametrů, a pak
3. Svázat z potrubí podle hodnoty (§12.3.7) s přesnou shodou, poté
4. Svázat z potrubí podle hodnoty (§ 12.3.7) s převodem, následně
5. Svázat z potrubí s přesnou shodou podle názvu (§12.3.7), pak
6. Vazba v rámci kanálu podle názvu (§12.3.7) s konverzí

Některé z těchto kroků zahrnují převod, jak je popsáno v §6. Sada převodů použitých ve vazbě však není úplně stejná jako u převodů jazyka. Konkrétně

• I když lze hodnotu $null přetypovat na logickou hodnotu, $null nelze svázat s bool.
• Když je hodnota $null předána jako parametr přepínače pro rutinu, je zacházeno, jako by byla předána hodnota $true. Nicméně při předání parametru přepínače funkce se s ním zachází, jako by bylo předáno $false.
• Parametry typu bool nebo přepínače se můžou svázat pouze s číselnými nebo logickými argumenty.
• Pokud typ parametru není kolekce, ale argument je nějaký druh kolekce, žádný převod se nepokusí, pokud typ parametru není objekt nebo PsObject. (Hlavním bodem tohoto omezení je zakázat převod kolekce na parametr řetězce.) V opačném případě se provádějí obvyklé převody.

Pokud je typ parametru IList nebo ICollection<T>, pokusí se o tyto převody pouze prostřednictvím konstruktora, op_Implicit a op_Explicit. Pokud neexistují žádné takové převody, použije se speciální převod parametrů typu "kolekce", který zahrnuje IList, ICollection<T>a pole.

Poziční parametry preferují vazbu bez převodu typu, pokud je to možné. Například

function Test {
    [CmdletBinding(DefaultParameterSetName = "SetB")]
    param([Parameter(Position = 0, ParameterSetName = "SetA")]
        [decimal]$Dec,
        [Parameter(Position = 0, ParameterSetName = "SetB")]
        [int]$In
    )
    $PSCmdlet.ParameterSetName
}

Test 42d   # outputs "SetA"
Test 42    # outputs "SetB"