8. Utasítások

  • Cikk

8.1 Utasításblokkok és listák

Szintaxis:

Tipp

A ~opt~ szintaxisdefiníciókban szereplő jelölés azt jelzi, hogy a lexikális entitás nem kötelező a szintaxisban.

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

Leírás:

Az utasítás valamilyen végrehajtandó műveletet határoz meg. Ha a záradék másként nem rendelkezik, az utasítások lexikális sorrendben lesznek végrehajtva.

Az utasításblokkok lehetővé teszik, hogy egy utasításkészlet egyetlen szintaktikai egységbe legyen csoportosítva.

8.1.1 Címkézett utasítások

Szintaxis:

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

Leírás:

Az iterációs utasítást (8.4.§) vagy kapcsolóutasítást (8.6. §) igény szerint közvetlenül egy utasításcímke, címke előzheti meg. A megszakítás (8.5.1. §) vagy a folytatás (8.5.2. §) utasítás nem kötelező céljaként utasításcímkét használunk. A címkék azonban nem módosítják a vezérlőfolyamatot.

A kettőspont (:) és az azt követő jogkivonat között nincs szabad térköz.

Példák:

: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 Utasításértékek

Az utasítás értéke a folyamatba írt értékek kumulatív készlete. Ha az utasítás egyetlen skaláris értéket ír, az az utasítás értéke. Ha az utasítás több értéket ír, az utasítás értéke az, hogy egy nem korlátozott egydimenziós tömb elemeiben tárolt értékek készlete a megírásuk sorrendjében. Tekintse meg a következő példát:

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

A huroknak nincsenek iterációi, és semmi sem íródik a folyamatba. Az utasítás értéke .$null

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

Bár a hurok ötször iterál, semmit sem írnak a folyamatba. Az utasítás értéke $null.

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

A hurok minden alkalommal ötször iterál, amikor a folyamatba írja az int értéket $i. Az utasítás object[] értéke 5. hossz.

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

Bár a hurok ötször iterál, semmit sem írnak a folyamatba. Az utasítás értéke .$null

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

A hurok ötször iterál, és minden értéket a folyamatba ír. Az utasítás object[] értéke 5. hossz.

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

A hurok egyszer iterál. Az utasítás értéke a int 2 értékkel.

Íme néhány további példa:

# 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 Folyamat utasítások

Szintaxis:

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

Leírás:

átirányításokat a 7.12. a hozzárendelés-kifejezésről a 7.11. és a parancs-invocation-operátor pont (.) a 3.5.5. A parancsmeghívások argumentum-paraméter leképezésének ismertetéséhez lásd a 8.14.

A folyamat első parancsa egy kifejezés vagy parancshívás. A parancshívások általában egy parancsnévvel kezdődnek, amely általában egy operációs rendszer nélküli azonosító. parancselemek a parancs argumentumlistáját jelölik. Egy új vonal vagy n kibontatlan pontosvessző megszakítja a folyamatot.

A parancshívás a parancs nevéből, majd nulla vagy több argumentumból áll. Az argumentumokra vonatkozó szabályok a következők:

  • Egy argumentum, amely nem kifejezés, de tetszőleges szöveget tartalmaz, szóköz nélkül, úgy lesz kezelve, mintha dupla idézőjel lenne. A kisbetűk megmaradnak.

  • A változók helyettesítése és a kifejezésbővítés (2.3.5.2. §) a bővíthető-sztring-literál s és a kibontható-itt-sztringkonstans s-ben történik.

  • Az idézőjeleken belüli szöveg lehetővé teszi a kezdő, záró és beágyazott térköz hozzáadását az argumentum értékében. [Megjegyzés: A szóköz jelenléte egy idézőjeles argumentumban nem alakít át egyetlen argumentumot több argumentummá. végjegyzet]

  • Ha zárójeleket helyez egy argumentum köré, a kifejezés kiértékelése az eredmény átadásával történik az eredeti kifejezés szövege helyett.

  • Ha olyan argumentumot szeretne átadni, amely kapcsolóparaméternek tűnik (2.3.4.§), de nem ilyen, foglalja idézőjelek közé az argumentumot.

  • Ha olyan argumentumot ad meg, amely megfelel egy típuskényszerrel rendelkező [switch] paraméternek (8.10.5.§), az argumentum nevének jelenléte önmagában okozza a paraméter beállítását $true. A paraméter értéke azonban explicit módon beállítható úgy, hogy hozzáfűz egy utótagot az argumentumhoz. Például egy korlátozott p típusú paraméter esetén a p halmazok argumentuma -p:$true Igaz, míg -p:$false a p értéke Hamis.

  • Egy argumentum -- azt jelzi, hogy az azt követő összes argumentumot a tényleges formájukban kell átadni, mintha idézőjelek lettek volna körülöttük.

  • Az argumentum --% azt jelzi, hogy az azt követő összes argumentumot minimális elemzéssel és feldolgozással kell átadni. Ezt az argumentumot verbatim paraméternek nevezzük. A szó szerinti paraméter utáni argumentumok nem PowerShell-kifejezések, még akkor sem, ha szintaktikailag érvényes PowerShell-kifejezések.

Ha a parancs típusa Application, a paraméter --% nem lesz átadva a parancsnak. A környezeti változók (sztringek) kibontása %után --% az argumentumok. Például:

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

Az argumentumok kiértékelésének sorrendje nincs meghatározva.

További információ a paraméterkötésről: §8.14. A névkeresésről a 3.8.

Az argumentumfeldolgozás befejezése után a rendszer meghívja a parancsot. Ha a meghívott parancs normál módon leáll (8.5.4. §), a vezérlő a parancshívást követően azonnal visszaáll a szkript vagy függvény pontra. A rendellenes megszüntetés viselkedésének leírását lásd break : (8.5.1. §), continue (8.5.2. §), throw (8.5.3. §), exit (8.5.5. §), try (8.7. §) és trap (8.8. §).

A parancsokat általában a neve és az argumentumok használatával hívja meg a rendszer. A & parancshívási operátor azonban használható. Ha a parancsnév üres szóközt tartalmaz, az operátorral idézni és meghívni kell. Mivel a szkriptblokknak nincs neve, az operátorral is meg kell hívni. A parancshívások Get-Factorial alábbi hívásai például egyenértékűek:

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

A közvetlen és közvetett rekurzív függvényhívások engedélyezettek. Példa:

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

Példák:

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 Az if utasítás

Szintaxis:

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

Leírás:

A folyamatszabályozási kifejezéseknek bool típusúnak kell lenniük, vagy implicit módon konvertálhatóknak kell lenniük erre a típusra. Az else záradék megadása nem kötelező. Lehet, hogy nulla vagy több elseif-záradék van.

Ha a legfelső szintű folyamat true (igaz) tesztet végez, akkor az utasításblokk végrehajtása és az utasítás végrehajtása leáll. Ellenkező esetben, ha egy elseif-záradék van jelen, ha a folyamat true (igaz) tesztet végez, akkor az utasításblokk végrehajtása és az utasítás végrehajtása leáll. Ellenkező esetben, ha egy else-záradék van jelen, a rendszer végrehajtja az utasításblokkját .

Példák:

$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 Iterációs utasítások

8.4.1 A while utasítás

Szintaxis:

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

while-condition:
    new-lines~opt~ pipeline

Leírás:

A vezérlőkifejezésnek a feltétel alatt bool típusúnak kell lennie, vagy implicit módon konvertálhatónak kell lennie erre a típusra. A ciklus törzse, amely utasításblokkból áll, többször lesz végrehajtva, amíg a vezérlőkifejezés false (Hamis) tesztet nem végez. A vezérlőkifejezés kiértékelése a hurok törzsének minden végrehajtása előtt történik.

Példák:

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

8.4.2 A do utasítás

Szintaxis:

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

Leírás:

A vezérlési kifejezésnek logikai típusúnak kell lennie, vagy implicit módon konvertálhatónak kell lennie erre a típusra. A while formában a ciklus törzse, amely utasításblokkból áll, többször is végre lesz hajtva, miközben a vezérlőkifejezés true (igaz) tesztet végez. Az addigi formában a ciklus törzse többször lesz végrehajtva, amíg a vezérlőkifejezés nem teszteli az Igaz értéket. A kontrolling kifejezés kiértékelése a hurok törzsének minden végrehajtása után történik.

Példák:

$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 A for utasítás

Szintaxis:

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

Leírás:

A feltétel vezérlőkifejezésének bool típusúnak kell lennie, vagy implicit módon konvertálhatónak kell lennie erre a típusra. Az utasításblokkból álló huroktörzset a rendszer ismételten végrehajtja, miközben a vezérlőkifejezés true (igaz) tesztet végez. A vezérlőkifejezés kiértékelése a hurok törzsének minden végrehajtása előtt történik.

Az inicializáló kifejezés kiértékelése a vezérlőkifejezés első kiértékelése előtt történik. Az expression for-initializer csak a mellékhatásokra van kiértékelve; az általa előállított értékek elvesznek, és nem lesznek a folyamatba írva.

Az iterátor kifejezésének kiértékelése a hurok törzsének minden végrehajtása után történik. Az iterátor kifejezése csak a mellékhatásokra van kiértékelve; az általa előállított értékek elvesznek, és nem lesznek a folyamatba írva.

Ha nem adja meg a feltétel kifejezését , a vezérlőkifejezés true (igaz) értéket ad vissza.

Példák:

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 A foreach utasítás

Szintaxis:

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

Leírás:

A ciklus törzse, amely utasításblokkból áll, a folyamat által kijelölt gyűjtemény változóváltozója által kijelölt minden elemhez végrehajtja. A változó hatóköre nem korlátozódik a foreach utasításra. Így megőrzi a végső értékét, miután a hurok törzse befejezte a végrehajtást. Ha a folyamat gyűjtemény helyett skalárt jelöl ki (a $null érték kivételével), akkor a skaláris elem egyetlen elemből álló gyűjteményként lesz kezelve. Ha a folyamat kijelöli az értéket $null, a folyamat nulla elemgyűjteményként lesz kezelve.

Ha a foreach-paraméter -parallel meg van adva, a viselkedés implementálásra van definiálva.

A foreach-paraméter ‑parallel csak munkafolyamatokban engedélyezett (8.10.2. §).

Minden foreach utasításnak saját enumerátora $foreach van (§2.3.2.2, §4.5.16), amely csak a hurok végrehajtása közben létezik.

A folyamat által létrehozott objektumokat a rendszer az utasításblokk végrehajtása előtt gyűjti össze. A ForEach-Object parancsmaggal azonban az utasításblokk minden objektumon végrehajtásra kerül a létrehozásakor.

Példák:

$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 Flow vezérlő utasítások

Szintaxis:

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

Leírás:

A folyamatvezérlési utasítás a vezérlés feltétel nélküli átvitelét okozza egy másik helyre.

8.5.1 A megszakítási utasítás

Leírás:

A címkekifejezéssel rendelkező törésutasításokat címkézett törésutasításnak nevezzük. A címkekifejezés nélküli törésutasításokat címkézetlen törésutasításnak nevezzük.

A trap utasításon kívül a címkézetlen törésutasítás közvetlenül egy iterációs utasításon belül (8.4. §) leállítja a legkisebb beágyazási iterációs utasítás végrehajtását. A címke nélküli megszakítási utasítás közvetlenül egy kapcsolóutasításon belül (8.6. §) leállítja az aktuális kapcsoló kapcsolófeltételének megfelelő mintát. Lásd a (8.8.8) bekezdést a megszakítás traputasításon belüli használatáról.

Az iterációs utasítást vagy kapcsolóutasítást igény szerint közvetlenül egy utasításcímke előzheti meg (8.1.1.1. §). Ilyen utasításcímke használható a címkézett megszakítási utasítás céljaként, amely esetben ez az utasítás leállítja a célzott beágyazási iterációs utasítás végrehajtását.

A címkézett törést nem kell feloldani egy helyi hatókörben sem; az egyező címke keresése a hívási vermet akár szkript- és függvényhívási határok között is folytathatja. Ha nem található egyező címke, az aktuális parancshívás leáll.

A címkekifejezéssel jelölt címke nevének nem kell állandó értékkel rendelkeznie.

Ha a címkekifejezés egy unáris kifejezés, a rendszer sztringgé alakítja.

Példák:

$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 A folytatásról szóló nyilatkozat

Leírás:

A continue címkekifejezést tartalmazó utasításokat címkézett folytatási utasításnak nevezzük. A címkekifejezés nélküli folytatási utasítást címkézetlen folytatási utasításnak nevezzük.

A traputasításban való használatról continue a 8.8.

A hurokban lévő címkézetlen continue utasítás megszakítja az aktuális hurok végrehajtását, és a legkisebb iterációs utasítás záró kapcsos zárójelére továbbítja az irányítást (8.4. §). A kapcsolón belüli címkézetlen continue utasítás megszakítja az aktuális switch iteráció végrehajtását, és átviszi az irányítást a legkisebb belefoglaló switchkapcsolófeltételbe (8.6. §).

Az iterációs utasítást vagy utasítást switch (8.6. §) igény szerint egy utasításcímke előzheti meg (8.1.1.1. §). Az ilyen utasításcímke használható egy zárt címkével ellátott continue utasítás céljaként, amely esetben ez az utasítás leállítja az aktuális ciklus vagy switch iteráció végrehajtását, és átviszi a vezérlést a megcélzott iterációba vagy switch utasításcímkére.

A címkével ellátott continue címkéket nem kell feloldani egy helyi hatókörben sem; az egyező címke continue keresése még a szkriptek és függvényhívások határán keresztül is növelheti a hívási vermet. Ha nem található egyező címke, az aktuális parancshívás leáll.

A címkekifejezéssel jelölt címke nevének nem kell állandó értékkel rendelkeznie.

Ha a címkekifejezés egy unáris kifejezés, a rendszer sztringgé alakítja.

Példák:

$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 A dobás utasítása

Leírás:

Kivételt képeznek a rendszer- vagy alkalmazásszintű hibaállapotok kezelésének módjai. A dobás utasítás kivételt jelez. (A kivételkezelésről lásd a 8.7. §-t .)

Ha a folyamat nincs megadva, és a dobási utasítás nem szerepel a catch-záradékban, a viselkedés implementálásra kerül. Ha a folyamat jelen van, és a dobás utasítása egy catch-záradékban található, a catch-záradék által elkapott kivételt a rendszer a catch-záradékhoz társított összes utolsó záradék végrehajtása után újra eldobja.

Ha a folyamat jelen van, a kivétel típusát implementálás határozza meg.

Kivétel esetén a vezérlő átkerül az első catch záradékba egy olyan belefoglaló try utasításba, amely képes kezelni a kivételt. Az a hely, ahol a kivételt kezdetben dobják, a dobáspontnak nevezzük. A kivételt követően a 8.7. pontban leírt lépéseket a rendszer többször követi, amíg a kivételnek megfelelő fogási záradékot nem talál, vagy nem talál egyet sem.

Példák:

throw
throw 100
throw "No such record in file"

Ha a folyamat nincs megadva, és a dobás utasítása nem egy catch-záradékból származik, a "ScriptHalted" szöveg a folyamatba lesz írva, és a létrehozott kivétel típusa .System.Management.Automation.RuntimeException

Ha a folyamat jelen van, a létrehozott kivétel egy objektumtípusba System.Management.Automation.RuntimeExceptionvan csomagolva, amely a kivétellel kapcsolatos információkat tartalmazza objektumként System.Management.Automation.ErrorRecord (elérhető $_).

  1. példa: throw 123 RuntimeException típusú kivételt eredményez. A fogási blokkon $_.TargetObject belülről tartalmazza a 123-at tartalmazó, ebben az esetben System.Int32 a burkolt objektumot.

  2. példa: throw "xxx" RuntimeException típusú kivételt eredményez. A catch blokkon $_.TargetObject belülről tartalmazza a burkolt objektumot, ebben az esetben egy System.String "xxx" értékkel.

  3. példa: throw 10,20 RuntimeException típusú kivételt eredményez. A fogási blokkon $_.TargetObject belülről tartalmazza a becsomagolt objektumot, ebben az esetben egy System.Object[], a két elemből álló, nem korlátozott tömböt a System. Az Int32 10 és 20 értékei.

8.5.4 A visszautalási utasítás

Leírás:

Az return utasítás beírja a folyamatba a folyamat által megadott értéket (ha van), és visszaadja az irányítást a függvény vagy a szkript hívójának. Egy függvény vagy szkript nulla vagy több return utasítással rendelkezhet.

Ha a végrehajtás eléri egy függvény záró zárójelét, a függvény folyamat nélküli vélelmezett return értéket feltételez.

Az return állítás egy kis "szintaktikai cukor", amely lehetővé teszi a programozók számára, hogy úgy fejezzék ki magukat, ahogy más nyelveken is. A függvényből vagy szkriptből visszaadott érték azonban valójában az adott függvény vagy szkript által a folyamatba írt összes érték, valamint a folyamat által megadott bármely érték(ek). Ha csak egy skaláris értéket ír a folyamatba, annak típusa a visszaadott érték típusa; ellenkező esetben a visszatérési típus egy nem korlátozott egydimenziós tömb, amely a folyamatba írt összes értéket tartalmazza.

Példák:

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

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

A hívó kap Get-Factorial vissza egy 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
}

A hívó egy Test nem korlátozott, három elemből álló egydimenziós tömböt kap vissza.

8.5.5 A kilépési utasítás

Leírás:

A kilépési utasítás leállítja az aktuális szkriptet, és visszaadja a vezérlést és egy kilépési kódot a gazdakörnyezetnek vagy a hívó szkriptnek. Ha a folyamat meg van adva, a rendszer szükség esetén int értékké alakítja át az általa kijelölt értéket. Ha nem létezik ilyen átalakítás, vagy ha a folyamat nincs megadva, a függvény a nulla int értéket adja vissza.

Példák:

exit $count # terminate the script with some accumulated count

8.6 A kapcsolóutasítás

Szintaxis:

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

Leírás:

Ha a kapcsolófeltétel egyetlen értéket jelöl ki, a vezérlő egy vagy több egyező mintautasítás-blokknak lesz átadva. Ha nem egyeznek a minták, néhány alapértelmezett művelet is végrehajtható.

A kapcsolónak tartalmaznia kell egy vagy több kapcsoló-záradékot, amelyek mindegyike egy mintával ( nem alapértelmezett kapcsoló záradékkal) vagy a kulcsszóval default ( alapértelmezett kapcsoló záradékkal) kezdődik. A kapcsolóknak nulla vagy egy default kapcsoló záradékot, valamint nulla vagy több nem alapértelmezett kapcsolófeltételt kell tartalmazniuk. A kapcsoló záradékok bármilyen sorrendben megírhatók.

Több minta is rendelkezhet ugyanazzal az értékkel. A mintának nem kell literálnak lennie, és a kapcsolók különböző típusú mintákkal rendelkezhetnek.

Ha a kapcsolófeltétel értéke megfelel egy mintaértéknek, a rendszer végrehajtja a minta utasításblokkját . Ha több mintaérték felel meg a kapcsolófeltétel értékének, a rendszer minden egyező minta utasításblokkját lexikális sorrendben hajtja végre, kivéve, ha az utasításblokkok bármelyike utasítást break tartalmaz (8.5.1. §).

Ha a kapcsolófeltétel értéke nem egyezik meg a mintaértékekkel, ha létezik kapcsolófeltétel default , a rendszer végrehajtja annak utasításblokkját ; ellenkező esetben a kapcsolófeltételhez tartozó mintaegyeztetés leáll.

A kapcsolók egymásba ágyazhatók, és mindegyik kapcsolóhoz saját kapcsolófeltételek vannak beállítva. Ilyen esetekben a switch záradék a hatókör legbelső kapcsolójához tartozik.

Az egyes utasításblokkokra való belépéskor a rendszer automatikusan hozzárendeli annak a kapcsolófeltételnek az értékét, $_ amely miatt a vezérlőelem az adott utasításblokkra váltott. $_ A az utasításblokk kapcsoló-záradék-feltételében is elérhető.

A nem sztringek egyeztetése az egyenlőség tesztelésével történik (7.8.1. §).

Ha az egyezés sztringeket tartalmaz, az összehasonlítás alapértelmezés szerint nem megkülönbözteti a kis- és nagybetűket. A kapcsolóparaméter -casesensitive jelenléte megkülönbözteti az összehasonlítási kis- és nagybetűt.

A minták tartalmazhatnak helyettesítő karaktereket (3.15. §), ebben az esetben a helyettesítő karakterek összehasonlítására kerül sor, de csak akkor, ha a switch-parameter -wildcard szerepel. Alapértelmezés szerint az összehasonlítás nem megkülönbözteti a kis- és nagybetűket.

A minták tartalmazhatnak reguláris kifejezést (§3.16), amely esetben reguláriskifejezés-sztring-összehasonlításokat végeznek, de csak akkor, ha a kapcsolóparaméter -regex megtalálható. Alapértelmezés szerint az összehasonlítás nem megkülönbözteti a kis- és nagybetűket. Ha -regex jelen van, és egy minta megfeleltetve van, $matches akkor az adott mintához tartozó switch-clause utasításblokkban van definiálva.

A kapcsolóparaméter rövidítve is lehet; a paraméterek bármely különálló kezdő része használható. Például, ‑regex, ‑rege, ‑reg, ‑reés ‑r egyenértékűek.

Ha egymással ütköző kapcsolóparaméterek vannak megadva, a lexikálisan végső az irányadó. A letiltások és a; jelenléte ‑exact azonban nincs hatással rá‑case.-regex -wildcard

Ha a kapcsolóparaméter ‑parallel meg van adva, a viselkedés implementálásra van definiálva.

A kapcsolóparaméter ‑parallel csak munkafolyamatokban engedélyezett (8.10.2. §).

Ha egy minta egy szkriptblokk-kifejezés, akkor a rendszer kiértékeli a blokkot, és szükség esetén boolná alakítja az eredményt. Ha az eredmény értéke $truemegegyezik, a megfelelő utasításblokk lesz végrehajtva, ellenkező esetben nem.

Ha a kapcsolófeltétel több értéket jelöl, a kapcsolót lexikális sorrendben alkalmazza a rendszer az egyes értékekre a fent leírt szabályokkal egy egyetlen értéket megjelölő kapcsolófeltételre . Minden kapcsolóutasításnak saját enumerátora $switch van (§2.3.2.2, §4.5.16), amely csak a kapcsoló végrehajtása közben létezik.

A kapcsolóutasítás címkével rendelkezhet, címkével ellátott és címkézetlen törést (8.5.1. §) és folytatást (8.5.2. §) is tartalmazhat.

Ha a -file switch-condition kapcsoló-fájlnév, ahelyett, hogy egy kifejezés értékeit iterálja, a kapcsoló a switch-filename által kijelölt fájlban lévő értékeket iterálja. A fájl egy sorba van beolvasva, és mindegyik sor tartalmaz egy értéket. A soridőzítő karakterek nem szerepelnek az értékekben.

Példák:

$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 A try/finally utasítás

Szintaxis:

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

Leírás:

A try utasítás egy mechanizmust biztosít a blokk végrehajtása során előforduló kivételek elfogására. A try utasítás egy kódblokk megadását is lehetővé teszi, amely mindig akkor lesz végrehajtva, amikor a vezérlő elhagyja a try utasítást. A kivétel dobás utasításon keresztüli emelésének folyamatát a 8.5.3.

A try blokk a try utasításhoz társított utasításblokk . A catch blokk a catch-záradékhoz társított utasításblokk. A végül blokk a végfeltételhez társított utasításblokk.

A catch-type-list nélküli catch-záradékot általános catch záradéknak nevezzük.

Minden catch-záradék egy kivételkezelő, és egy catch-záradék , amelynek catch-type-listája tartalmazza a kiváltott kivétel típusát, egy egyező catch záradék. Az általános catch záradék megfelel az összes kivételtípusnak.

Bár a catch-clauses és a finally-clause nem kötelező, legalább az egyiknek jelen kell lennie.

A dobott kivétel feldolgozása a következő lépések ismételt kiértékelését foglalja magában, amíg a kivételnek megfelelő catch záradékot nem talál.

  • Az aktuális hatókörben minden olyan try utasítást megvizsgál, amely a dobáspontot foglalja magában. Minden S try utasítás esetében, kezdve a legbelső try utasítással, és a legkülső try utasítással végződik, a rendszer a következő lépéseket értékeli ki:

    • Ha az try S blokk a dobópontot foglalja magában, és az S egy vagy több catch záradékkal rendelkezik, a catch záradékokat lexikális sorrendben kell megvizsgálni, hogy megtalálja a kivétel megfelelő kezelőjét. A kivételtípust vagy a kivételtípus alaptípusát megadó első catch záradék egyezésnek minősül. Az általános catch záradék bármely kivételtípus esetén egyezésnek minősül. Ha egyező catch záradék található, a kivételfeldolgozás úgy fejeződik be, hogy átadja az irányítást az adott catch záradék blokkjának. Az egyező catch záradékban a változó $_ az aktuális kivétel leírását tartalmazza.

    • Ellenkező esetben, ha a try blokk vagy egy catch S blokk a dobópontot foglalja magában, és S blokkja van finally , a vezérlő átkerül a végső blokkba. Ha a finally blokk egy másik kivételt jelez, az aktuális kivétel feldolgozása leáll. Ellenkező esetben, ha a vezérlés eléri a finally blokk végét, az aktuális kivétel feldolgozása folytatódik.

  • Ha egy kivételkezelő nem található az aktuális hatókörben, a fenti lépéseket a rendszer megismétli a beágyazási hatókörhöz egy olyan eldobási ponttal, amely annak az utasításnak felel meg, amelyből az aktuális hatókört meghívták.

  • Ha a kivételfeldolgozás az összes hatókört megszakítja, jelezve, hogy nincs kezelő a kivételhez, akkor a viselkedés nincs meghatározva.

A próbablokkok nem elérhető fogási záradékainak elkerülése érdekében előfordulhat, hogy a catch záradék nem határoz meg olyan kivételtípust, amely megegyezik az adott próbablokk korábbi catch záradékában megadott vagy abból származtatott kivételtípussal.

A blokkok utasításai finally mindig akkor lesznek végrehajtva, amikor a vezérlő utasítást try hagy. Ez igaz arra, hogy a vezérlés átvitele a normál végrehajtás eredményeként, egy break, continue, vagy utasítás végrehajtása miatt történik, vagy return az utasításból kidobott try kivétel eredményeként.

Ha egy blokk végrehajtása finally során kivételt ad vissza, a kivétel a következő beágyazási try utasításba kerül. Ha egy másik kivétel kezelése folyamatban volt, a kivétel elveszik. A kivétel létrehozásának folyamatát az utasítás leírásában is tárgyaljuk throw .

try utasításokkal trap együtt létezhet; részletekért lásd a 8.8 .

Példák:

$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 {
        # ...
    }
}

A rendszer minden egyes kivételt System.Management.Automation.RuntimeExceptionegy . Ha a blokkban try típusspecifikus catch-záradékok találhatók, a rendszer megvizsgálja a kivétel InnerException tulajdonságát, hogy megpróbáljon megtalálni egyezést, például a fenti típussalSystem.IndexOutOfRangeException.

8.8 A trap utasítás

Szintaxis:

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

Leírás:

A trap típuskonstanssal és anélkül rendelkező állítások hasonlóak a catch blokkhoz (8.7. §) a catch-type-listával és anélkül, azzal a kivétellel, hogy egy trap utasítás egyszerre csak egy típust tud csapdába ejteni.

Több trap utasítás is definiálható ugyanabban az utasításblokkban, és a definíciójuk sorrendje irreleváns. Ha két trap azonos típuskonstansú utasítás van definiálva ugyanabban a hatókörben, akkor a lexikális első az egyező típus kivételének feldolgozására szolgál.

catch A blokkoktól eltérően egy trap utasítás pontosan egyezik egy kivételtípussal; nem történik származtatott típusegyeztetés.

Kivétel esetén, ha nincs egyező trap utasítás az aktuális hatókörben, a rendszer egyező traputasítást keres a beágyazási hatókörben, amely magában foglalhatja a hívó szkript, a függvény vagy a szűrő, majd a hívója és így tovább. Ha a keresés végül megszakítja az összes hatókört, jelezve, hogy nincs kezelő a kivételhez, akkor a viselkedés nincs meghatározva.

Egy trap utasítás utasítás-törzse csak a megfelelő kivétel feldolgozásához hajtja végre a végrehajtást, ellenkező esetben a végrehajtás átadja azt.

Ha egy traputasítástörzs alapértelmezés szerint kilép, a rendszer hibaobjektumot ír a hibastreambe, a kivételt kezeltnek tekinti, és a végrehajtás a kivételt jelző utasítást tartalmazó trap hatókörben lévő utasítást közvetlenül követő utasítással folytatódik. A kivétel oka lehet az utasítást tartalmazó trap parancs által meghívott parancsban.

Ha az utasítás törzsében trapvégrehajtott végleges utasítás folytatódik (8.5.2.§), a hibaobjektum hibafolyamba írása el lesz tiltva, és a végrehajtás a kivételt jelző traputasítást tartalmazó hatókörben lévő utasítást közvetlenül követő utasítással folytatódik. Ha a "utasítástörzsbentrap" végrehajtott utolsó utasítás megszakad (8.5.1.§), a hibaobjektum hibafolyamba írása el lesz tiltva, és a kivétel vissza lesz dobva.

trap Egy utasításon belül a változó $_ az aktuális hiba leírását tartalmazza.

Vegyük azt az esetet, amikor egy blokkon belülről try származó kivétel nem rendelkezik egyező catch blokktal, de egy egyeztetési trap utasítás magasabb blokkszinten létezik. try A blokk utolsó záradékának végrehajtása után az trap utasítás akkor is szabályozható, ha bármely szülőhatókör rendelkezik egyező catch blokktal. Ha egy trap utasítás a blokkon belül try van definiálva, és ennek try a blokknak egyező catch blokkja van, akkor az utasítás lesz irányítva trap .

Példák:

A következő példában a hibaobjektum meg van írva, és a végrehajtás a trapet okozó utasítást közvetlenül követő utasítással folytatódik; vagyis a "Kész" szöveg a folyamatba van írva.

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

A következő példában a hibaobjektum írása le lesz tiltva, és a végrehajtás a trapet okozó utasítást közvetlenül követő utasítással folytatódik; vagyis a "Kész" szöveg a folyamatba van írva.

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

Az alábbi példában a hibaobjektum írása el lesz tiltva, és a kivétel újra lesz dobva.

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

A következő példában a trap és a kivételgeneráló utasítások ugyanabban a hatókörben vannak. A kivétel elfogása és kezelése után a végrehajtás folytatódik, és 1-et ír a folyamatba.

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

Az alábbi példában a trap és a kivételgeneráló utasítások különböző hatókörökben találhatók. A kivétel levétele és kezelése után a végrehajtás folytatódik a 2(nem 1) folyamatba írásával.

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

8.9 Az adatkezelési nyilatkozat

Szintaxis:

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

Leírás:

Az adatutasítások létrehoznak egy adatszakaszt, amely elkülöníti a szakasz adatait a kódtól. Ez az elkülönítés olyan lehetőségeket támogat, mint a szöveges sztringek erőforrásfájljai, például a hibaüzenetek és a súgósztringek. Emellett segít a nemzetközivé tétel támogatásában azáltal, hogy megkönnyíti a különböző nyelvekre lefordított sztringek elkülönítését, megkeresését és feldolgozását.

A szkriptek vagy függvények nulla vagy több adatszakaszt tartalmazhatnak.

Az adatszakasz utasításblokkja csak a következő PowerShell-funkciókat tartalmazza:

  • Minden operátor, kivéve -match
  • Az if utasítás
  • A következő automatikus változók: $PsCulture, $PsUICulture, $true, $falseés $null.
  • Megjegyzések
  • Pipelines
  • Pontosvesszővel elválasztott utasítások (;)
  • Literálok
  • A ConvertFrom-StringData parancsmag hívásai
  • A támogatottcommand paraméteren keresztül azonosított egyéb parancsmagok

ConvertFrom-StringData A parancsmag használata esetén a kulcs-érték párok bármilyen sztringkonstans használatával kifejezhetők. A bővíthető sztringkonstansok és a bővíthető-itt-sztringkonstansok azonban nem tartalmazhatnak változóhelyettesítéseket vagy kifejezésbővítéseket.

Példák:

A SupportedCommand paraméter azt jelzi, hogy a megadott parancsmagok vagy függvények csak adatokat hoznak létre. Az alábbi adatszakasz például tartalmaz egy felhasználó által írt parancsmagot, ConvertTo-XMLamely xml-fájlban formáz adatokat:

data -supportedCommand ConvertTo-XML {
    Format-XML -strings string1, string2, string3
}

Vegyük az alábbi példát, amelyben az adatszakasz tartalmaz egy ConvertFrom-StringData parancsot, amely kivonattáblává alakítja a sztringeket, amelynek az értéke hozzá van rendelve $messages.

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

A kivonattábla kulcsai és értékei a , $messages.Yesés $messages.Noa . használatával érhetők el$messages.Greeting.

Ez most angol nyelvű erőforrásként menthető. A német és spanyol nyelvű erőforrások külön fájlokban hozhatók létre, az alábbi adatszakaszokkal:

$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
"@
}

Ha az adatnév jelen van, annak a változónak a nevét adja meg (bevezető $nélkül), amelybe az adatutasítás értékét tárolni szeretné. Pontosabban a $name = data { ... } data name { ... }.

8.10 Függvénydefiníciók

Szintaxis:

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

Leírás:

A függvénydefiníció meghatározza a definiált függvény, szűrő vagy munkafolyamat nevét, és ha van ilyen, annak paramétereinek nevét. Nulla vagy több utasítást is tartalmaz, amelyeket a függvény céljának elérése érdekében hajtanak végre.

Minden függvény az osztály System.Management.Automation.FunctionInfoegy példánya.

8.10.1 Szűrőfüggvények

Míg a normál függvények egy folyamaton belül egyszer futnak, és a bemeneti gyűjteményt ezen keresztül $inputérik el, a szűrő egy speciális függvény, amely a bemeneti gyűjtemény minden objektumához egyszer hajt végre. A jelenleg feldolgozott objektum a változón $_keresztül érhető el.

A nevesített blokkokat nem tartalmazó szűrő (8.10.7. §) egyenértékű egy folyamatblokkot tartalmazó, de kezdő vagy záró blokk nélküli függvénnyel.

Vegye figyelembe a következő szűrőfüggvény-definíciót és -hívásokat:

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

Minden szűrő az osztály System.Management.Automation.FilterInfo egy példánya (4.5.11. §).

8.10.2 Munkafolyamat-függvények

A munkafolyamat-függvények olyan, mint egy hagyományos függvény, amelynek implementációja definiált szemantikával rendelkezik. A munkafolyamat-függvények Windows Workflow Foundation-tevékenységek sorozatára lesznek lefordítva, és a Windows Workflow Foundation motorban lesznek végrehajtva.

8.10.3 Argumentumfeldolgozás

Vegye figyelembe a következő definíciót egy függvényhez:Get-Power

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

Ez a függvény két paramétert $base és $exponent. Emellett olyan utasításkészletet is tartalmaz, amely nem negatív kitevő értékek esetén kiszámítja $base^$exponent^ és visszaadja az eredményt a hívónak Get-Power.

Amikor egy szkript, függvény vagy szűrő elkezdi a végrehajtást, a program minden paramétert inicializál a megfelelő argumentum értékére. Ha nincs megfelelő argumentum, és egy alapértelmezett érték (8.10.4. §) van megadva, akkor a rendszer ezt az értéket használja; ellenkező esetben a rendszer az értéket $null használja. Így minden paraméter egy új változó, mintha hozzárendeléssel inicializálták volna a szkriptblokk elején.

Ha egy szkriptparaméter típuskényszert (például [long] vagy [int] újabb) tartalmaz, a megfelelő argumentum értéke szükség esetén erre a típusra lesz konvertálva; ellenkező esetben nem történik átalakítás.

Amikor egy szkript, függvény vagy szűrő elkezdi a végrehajtást, a változó $args egy nem korlátozott egydimenziós tömbként van definiálva, amely lexikális sorrendben tartalmazza a név vagy pozíció által nem kötött összes argumentumot.

Vegye figyelembe a következő függvénydefiníciót és -hívásokat:

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

További információ a paraméterkötésről: §8.14.

8.10.4 Paraméter-inicializálók

A p paraméter deklarációja tartalmazhat inicializálót, amely esetben az inicializáló értéke a p inicializálására szolgál, és a p paraméter nincs kötve a hívás argumentumaihoz.

Vegye figyelembe a következő függvénydefiníciót és -hívásokat:

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

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

8.10.5 A [kapcsoló] típuskényszere

Ha egy kapcsolóparamétert ad át, a parancs megfelelő paraméterét a típuskapcsolónak kell korlátoznia. A típuskapcsoló két értékkel rendelkezik: True (Igaz) és False (Hamis).

Vegye figyelembe a következő függvénydefiníciót és -hívásokat:

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 Folyamatok és függvények

Ha szkriptet, függvényt vagy szűrőt használ egy folyamatban, a rendszer értékgyűjteményt továbbít az adott szkripthez vagy függvényhez. A szkript, függvény vagy szűrő az enumerátor $input (§2.3.2.2, §4.5.16) keresztül fér hozzá a gyűjteményhez, amely a szkriptbe, függvénybe vagy szűrőbe való belépéskor van meghatározva.

Vegye figyelembe a következő függvénydefiníciót és -hívásokat:

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 Nevesített blokkok

A szkriptblokkokban lévő utasítások egy nagy, névtelen blokkhoz tartozhatnak, vagy eloszthatók egy vagy több elnevezett blokkba. A nevesített blokkok lehetővé teszik a folyamatokból származó gyűjtemények egyéni feldolgozását; A megnevezett blokkok bármilyen sorrendben meghatározhatók.

A kezdő blokkban (azaz a kulcsszó kezdőbetűjével megjelölt) utasítások végrehajtása egyszer, az első folyamatobjektum kézbesítése előtt történik.

A folyamatblokkokban (azaz a kulcsszófolyamattal megjelölt) utasítások végrehajtása minden kézbesített folyamatobjektum esetében megtörténik. ($_ hozzáférést biztosít a folyamatból érkező bemeneti gyűjteményből feldolgozott aktuális objektumhoz.) Ez azt jelenti, hogy ha a folyamat nulla elemből álló gyűjteményt küld, a folyamatblokk egyáltalán nem lesz végrehajtva. Ha azonban a szkriptet vagy függvényt egy folyamatkörnyezeten kívül hívják meg, a blokk végrehajtása pontosan egyszer történik, és $_ a beállítás értéke $null, mivel nincs aktuális gyűjteményobjektum.

A végpontok (azaz a kulcsszóvégzéssel megjelöltek) utasításait a rendszer egyszer hajtja végre az utolsó folyamatobjektum kézbesítése után.

8.10.8 dynamicParam blokk

A 8.10. pont alszakaszai eddig a forráskód részeként definiált statikus paraméterekkel foglalkoznak. Dinamikus paraméterek definiálására is lehetőség van egy dynamicParam blokkon keresztül, amely a nevesített blokk egy másik formája (§8.10.7), amelyet a kulcsszó dynamicParamjelöl. Ennek a gépnek a nagy része implementálásra van meghatározva.

A dinamikus paraméterek olyan parancsmagok, függvények, szűrők vagy szkriptek paraméterei, amelyek csak bizonyos feltételek mellett érhetők el. Ilyen eset a parancsmag Kódolás paramétere Set-Item .

Az utasításblokkban egy if utasítás használatával adja meg azokat a feltételeket, amelyek mellett a paraméter elérhető a függvényben. A New-Object parancsmaggal hozzon létre egy implementáció által definiált típusú objektumot a paraméter ábrázolásához, és adja meg a nevét. New-Object Emellett létrehozhat egy másik implementáció által definiált típusú objektumot is, amely a paraméter implementáció által definiált attribútumait képviseli.

Az alábbi példa egy név és elérési út nevű standard paraméterekkel rendelkező függvényt, valamint egy DP1 nevű opcionális dinamikus paramétert mutat be. A DP1 paraméter a PSet1 paraméterkészletben található, és típusa Int32. A DP1 paraméter csak akkor érhető el a mintafüggvényben, ha a Path paraméter értéke tartalmazza a "HKLM:" értéket, ami azt jelzi, hogy a HKEY_LOCAL_MACHINE beállításjegyzék-meghajtóban használják.

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
        }
    }
}

A dinamikus paramétereket ábrázoló objektum létrehozásához használt típus a következő System.Management.Automation.RuntimeDefinedParameter: .

A paraméter attribútumait ábrázoló objektum létrehozásához használt típus a következő System.Management.Automation.ParameterAttribute: .

A paraméter implementáció által definiált attribútumai közé tartozik a Kötelező, a Pozíció és a ValueFromPipeline.

8.10.9 param blokk

A paramblokkok alternatív módszert biztosítanak a paraméterek deklarálására. A paraméterdeklarációk alábbi készletei például egyenértékűek:

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

A paramblokkok lehetővé teszik a paraméterblokk attribútumlistáját, míg a függvény-paraméter-deklaráció nem.

A szkriptek tartalmazhatnak paramblokkot , de függvény-paraméter-deklarációt nem. A függvény- vagy szűrődefiníciók tartalmazhatnak függvény-paraméterdeklarációt vagy paramblokkot, de mindkettőt nem.

Tekintse meg a következő példát:

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

Az egyetlen paraméter, $ComputerNameamely típussal string[]rendelkezik, kötelező, és bemenetet vesz fel a folyamatból.

A Paraméter attribútum ismertetését és további példákat a 12.3.7.-ben talál.

8.11 A párhuzamos utasítás

Szintaxis:

parallel-statement:
    *parallel* statement-block

A párhuzamos utasítás nulla vagy több utasítást tartalmaz, amelyek implementálás által meghatározott módon vannak végrehajtva.

Párhuzamos utasítás csak munkafolyamatban engedélyezett (8.10.2. §).

8.12 A sorozatutasítás

Szintaxis:

sequence-statement:
    *sequence* statement-block

A sorrendutasítás nulla vagy több utasítást tartalmaz, amelyek implementálás által meghatározott módon lesznek végrehajtva.

A sorrendutasítások csak munkafolyamatokban engedélyezettek (8.10.2. §).

8.13 Az inlinescript utasítás

Szintaxis:

inlinescript-statement:
    inlinescript statement-block

Az inlinescript utasítás nulla vagy több utasítást tartalmaz, amelyeket implementálás által meghatározott módon hajtanak végre.

Beágyazott utasítás csak munkafolyamatban engedélyezett (8.10.2.§).

8.14 Paraméterkötés

Parancsfájl, függvény, szűrő vagy parancsmag meghívásakor minden argumentumot pozíció szerint lehet a megfelelő paraméterhez kötni, az első paraméter pedig nulla pozícióval.

Vegye figyelembe a következő definíciórészletet a hívott Get-Powerfüggvényhez és a hozzá intézett hívásokhoz:

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

Parancsfájl, függvény, szűrő vagy parancsmag meghívásakor egy argumentum név alapján a megfelelő paraméterhez köthető. Ez egy argumentummal rendelkező paraméter használatával történik, amely egy argumentum, amely a paraméter neve egy kezdő kötőjellel (-), amelyet az argumentumhoz társított érték követ. A használt paraméternév bármilyen kis- és nagybetűket megkülönböztető helyesírást tartalmazhat, és bármilyen előtagot használhat, amely egyedileg jelöli meg a megfelelő paramétert. A paraméternevek kiválasztásakor kerülje a gyakori paraméterek neveinek használatát.

Vegye figyelembe a következő függvényhívásokat 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

Másfelől a következő függvény meghívása

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

paramétereket kell használnia -side1 , és -side2, mivel nincs olyan előtag, amely egyedileg kijelöli a paramétert.

Ugyanazt a paraméternevet nem lehet többször használni különböző argumentumértékekkel vagy anélkül.

A paraméterek attribútumokkal rendelkezhetnek (12. §). Az egyes attribútumokról a 12.3. A paraméterkészletekről a 12.3.7.

A szkriptek, függvények, szűrők vagy parancsmagok argumentumokat fogadhatnak a meghívási parancssorból, a folyamatból vagy mindkettőből. A paraméterkötés feloldásának lépései sorrendben a következők:

  1. Kösse össze az összes elnevezett paramétert, majd
  2. Kötési pozícióparaméterek, majd
  3. Kötés a folyamatból érték szerint (12.3.7. §) pontos egyezéssel, majd
  4. Kötés a folyamatból érték szerint (12.3.7. §) átalakítással, majd
  5. Kötés a folyamatból név szerint (12.3.7. §) pontos egyezéssel, majd
  6. Kötés a folyamatból név szerint (12.3.7.§) átalakítással

Ezen lépések közül több az átalakítást is magában foglalja a 6. A kötésben használt konverziók halmaza azonban nem pontosan ugyanaz, mint a nyelvi konverziókban. Ezek:

  • Bár az érték $null megadható bool értékre, $null nem köthető hozzá bool.
  • Amikor a parancsmag kapcsolóparaméterének adja át az értéket $null , a parancsmag úgy lesz kezelve, mintha $true át lett volna adva. Ha azonban egy függvény kapcsolóparaméterének adja át, a függvény úgy lesz kezelve, mintha $false át lett volna adva.
  • A bool vagy kapcsoló típusú paraméterek csak numerikus vagy bool argumentumokhoz köthetők.
  • Ha a paramétertípus nem gyűjtemény, de az argumentum valamilyen gyűjtemény, a rendszer csak akkor kísérli meg az átalakítást, ha a paraméter típusa objektum vagy PsObject. (A korlátozás fő célja, hogy letiltsa a gyűjtemény sztringparaméterre konvertálását.) Ellenkező esetben a rendszer megkísérli a szokásos konverziókat.

Ha a paraméter típusa a IList konstruktoron ICollection<T>keresztüli átalakítás, op_Implicit és op_Explicit lesz megkísérelve. Ha ilyen átalakítások nem léteznek, a rendszer speciális konverziót használ a "gyűjtemény" típusú paraméterekhez, beleértve a IList, ICollection<T>és a tömböket.

A pozicionálási paramétereket célszerű típuskonvertálás nélkül kötni, ha lehetséges. Példa:

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"