Megosztás a következőn keresztül:

7. Kifejezések

  • Cikk

Szerkesztői megjegyzés

Fontos

A Windows PowerShell Language Specification 3.0 2012 decemberében jelent meg, és a Windows PowerShell 3.0-n alapul. Ez a specifikáció nem tükrözi a PowerShell aktuális állapotát. Nincs terv a dokumentáció frissítésére az aktuális állapotnak megfelelően. Ezt a dokumentációt itt mutatjuk be a történelmi referenciaként.

A specifikációs dokumentum Microsoft Word-dokumentumként érhető el a Microsoft Letöltőközpontból a következő címen: https://www.microsoft.com/download/details.aspx?id=36389 A Word-dokumentumot itt, a Microsoft Learnben bemutatóra konvertálták. Az átalakítás során néhány szerkesztői módosítás történt a Docs-platform formázásának megfelelően. Kijavítottunk néhány elírást és kisebb hibát.

Szintaxis:

expression:
    primary-expression
    bitwise-expression
    logical-expression
    comparison-expression
    additive-expression
    multiplicative-expression

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

dashdash:
    dash dash

Leírás:

A kifejezés egy metódust, függvényt, írható helyet vagy értéket meghatározó operátorok és operandusok sorozata; meghatározza egy érték számítását; egy vagy több mellékhatást okoz; vagy annak valamilyen kombinációját hajtja végre. Például

  • A 123-as literál egy kifejezés, amely az egész szám 123 értékét jelöli.
  • A kifejezés 1,2,3,4 a megjelenített értékeket tartalmazó 4 elemes tömbobjektumot jelöli.
  • A 10.4 * $a kifejezés számítást ad meg.
  • A $a++ kifejezés mellékhatást okoz.
  • A $a[$i--] = $b[++$j] kifejezés ezek kombinációját hajtja végre.

Egyes operátorok kivételével a kifejezések kiértékelési sorrendje és a mellékhatások sorrendje nem határozható meg. A meghatározatlan viselkedés például a következő: $i++ + $i, $i + --$iés $w[$j++] = $v[$j].

A PowerShell implementációja támogatást nyújthat a felhasználó által definiált típusok számára, és ezek a típusok rendelkezhetnek rajtuk meghatározott műveletekkel. Az ilyen típusok és műveletek minden részlete implementálásra kerül.

A legfelső szintű kifejezés olyan kifejezés, amely nem része egy nagyobb kifejezésnek. Ha egy legfelső szintű kifejezés mellékhatás-operátort tartalmaz, a kifejezés értéke nem íródik be a folyamatba; ellenkező esetben igen. Lásd a részletes ismertetésért a §7.1.1-t.

Általában, egy kifejezés, ami egy gyűjteményt jelöl ([§4§4]), felsorolásra kerül az alkotó elemeként, amikor a kifejezés értékét használják. Ez azonban nem így van, ha a kifejezés egy parancsmag-meghívás. Például

$x = 10,20,30
$a = $($x; 99)                     # $a.Length is 4

$x = New-Object 'int[]' 3
$a = $($x; 99)                     # equivalent, $a.Length is 4

$a = $(New-Object 'int[]' 3; 99)   # $a.Length is 2

A $(...) operátor első két használatánál a gyűjteményt kijelölő kifejezés a $xváltozó, amelyeket felsorolva eredményül három int érték adódik, plusz egy int 99. A harmadik esetben azonban a kifejezés egy parancsmag közvetlen hívása, így az eredmény nem lesz számba adva, és $a két elemből álló tömb, int[3] és int.

Ha a PowerShell nem definiál egy műveletet, a bal oldali operandus által kijelölt érték típusát ellenőrzi, hogy rendelkezik-e megfelelő op_<operation> metódussal.

7.1 Elsődleges kifejezések

Szintaxis:

primary-expression:
    value
    member-access
    element-access
    invocation-expression
    post-increment-expression
    post-decrement-expression

value:
    parenthesized-expression
    sub-expression
    array-expression
    script-block-expression
    hash-literal-expression
    literal
    type-literal
    variable

7.1.1 Zárójelek csoportosítása

Szintaxis:

Borravaló

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

parenthesized-expression:
    ( new-lines~opt~ pipeline new-lines~opt~ )

Leírás:

A zárójeles kifejezés olyan elsődleges kifejezés, amelynek típusa és értéke megegyezik a zárójel nélküli kifejezésével. Ha a kifejezés egy változót jelöl ki, akkor a zárójeles kifejezés ugyanazt a változót jelöli ki. A $x.m és a ($x).m például egyenértékűek.

A zárójelek csoportosítása használható egy kifejezésben az alapértelmezett elsőbbség és asszociativitás dokumentálására az adott kifejezésen belül. Az alapértelmezett elsőbbség és asszociativitás felülbírálásához is használhatók. Például

4 + 6 * 2    # 16
4 + (6 * 2)  # 16 document default precedence
(4 + 6) * 2  # 20 override default precedence

A zárójelek csoportosítása általában a legfelső szinten redundáns. Ez azonban nem mindig így van. Vegye figyelembe a következő példát:

2,4,6       # Length 3; values 2,4,6
(2,4),6     # Length 2; values [object[]],int

A második esetben a zárójelek megváltoztatják a szemantikát, ami egy tömböt eredményez, amelynek két eleme egy 2 ints tömb és a skaláris int 6.

Íme egy másik kivétel:

23.5/2.4          # pipeline gets 9.79166666666667
$a = 1234 * 3.5   # value not written to pipeline
$a                # pipeline gets 4319

Az első és a harmadik esetben az eredmény értéke a csővezetékbe lesz írva. Bár a második esetben a kifejezés kiértékelésre kerül, a rendszer nem írja az eredményt a csővezetékbe, mert a mellékhatás operátor = a felső szinten található. (A $a = rész eltávolítása lehetővé teszi az érték írását, mivel * nem mellékhatás-operátor.)

Ha szeretné megakadályozni, hogy egy kifejezés értéke, amely nem tartalmaz felső szintű mellékhatásokat, íródjon a folyamatba, explicit módon törölje azt az alábbiak szerint:

# None of these value are written to pipeline
[void](23.5/2.4)
[void]$a
$null = $a
$a > $null

Ha a folyamatba szeretné írni a felső szintű mellékhatásokat tartalmazó kifejezések értékét, zárójelbe kell írnia ezt a kifejezést az alábbiak szerint:

($a = 1234 * 3.5) # pipeline gets 4319

Ezért a csoportosítási zárójelek ebben az esetben nem redundánsak.

Az alábbi példában a változó helyettesítése (§2.3.5.2) egy szöveges literálban történik.

">$($a = -23)<"    # value not written to pipeline, get ><
">$(($a = -23))<"  # pipeline gets >-23<

Az első esetben a zárójelek egy alkifejezést jelölnek,"elválasztójelek nem csoportosítási zárójelek, és mivel a felső szintű kifejezés tartalmaz egy mellékhatás-operátort, a kifejezés értéke nem kerül be a csővezetékbe. Természetesen a > és < karakterek még meg vannak írva.) Ha zárójelet adunk a csoportosításhoz – ahogyan a második esetben is látható –, az írás engedélyezett.

Az alábbi példák felső szintű mellékhatás-operátorokat tartalmaznak:

$a = $b = 0      # value not written to pipeline
$a = ($b = 0)    # value not written to pipeline
($a = ($b = 0))  # pipeline gets 0

++$a             # value not written to pipeline
(++$b)           # pipeline gets 1

$a--             # value not written to pipeline
($b--)           # pipeline gets 1

A zárójelek csoportosítása olyan kifejezés köré, amely nem tartalmaz felső szintű mellékhatásokat, redundánssá teszi ezeket a zárójeleket. Például;

$a      # pipeline gets 0
($a)    # no side effect, so () redundant

Vegyük az alábbi példát, amelynek két mellékhatása van, amelyek közül egyik sem áll a legfelső szinten:

12.6 + ($a = 10 - ++$b) # pipeline gets 21.6.

Az eredmény a folyamatba van írva, mivel a felső szintű kifejezésnek nincsenek mellékhatásai.

7.1.2 Tagok hozzáférése

Szintaxis:

member-access:
    primary-expression . new-line~opt~ member-name
    primary-expression :: new-line~opt~ member-name

Jegyezze meg, hogy a elsődleges kifejezésután nem engedélyezett a szóköz.

Leírás:

A . operátor egy objektum egy példánytagjának vagy egy Hashtablekulcsának kiválasztására szolgál. A bal operandusnak ki kell jelölnie egy objektumot, a jobb operandusnak pedig egy akadálymentes példánytagot kell kijelölnie.

A jobb operandus kijelöl egy akadálymentes példánytagot a bal operandus által kijelölt objektum típusán belül, vagy ha a bal operandus egy tömböt jelöl ki, a jobb operandus kijelöli a tömb egyes elemein belül az akadálymentes példánytagokat.

A szabad tér nem engedélyezett a . operátor előtt.

Ez az operátor bal asszociatív.

Az operátor :: egy statikus tag egy adott típusból való kiválasztására szolgál. A bal operandusnak típust kell kijelölnie, a jobb oldali operandusnak pedig egy akadálymentes statikus tagot kell kijelölnie az adott típuson belül.

A szabad tér nem engedélyezett a :: operátor előtt.

Ez az operátor bal asszociatív.

Ha a jobb oldali operandus írható helyet jelöl ki a bal operandus által kijelölt objektum típusán belül, akkor a teljes kifejezés írható helyet jelöl ki.

Példák:

$a = 10, 20, 30
$a.Length                    # get instance property

(10, 20, 30).Length

$property = "Length"
$a.$property                 # property name is a variable

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123
}
$h1.FirstName                # designates the key FirstName
$h1.Keys                     # gets the collection of keys

[int]::MinValue              # get static property
[double]::PositiveInfinity   # get static property
$property = "MinValue"
[long]::$property            # property name is a variable

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

$a = @{ID = 1 }, @{ID = 2 }, @{ID = 3 }
$a.ID                        # get ID from each element in the array

7.1.3 Meghívási kifejezések

Szintaxis:

invocation-expression:
    primary-expression . new-line~opt~ member-name argument-list
    primary-expression :: new-line~opt~ member-name argument-list

argument-list:
    ( argument-expression-list~opt~ new-lines~opt~ )

Vegye figyelembe, hogy a elsődleges kifejezés után aelőtt nem megengedett a szóköz.

Leírás:

Egy meghívási kifejezés végrehajtja a primary-expression.member-name vagy primary-expression::member-nameáltal kiválasztott metódust. A argumentumlista zárójelei olyan kifejezéseket tartalmazhatnak, amelyek a metódusnak átadott argumentumokat jelölik. A metódus meghívása előtt az argumentumok kiértékelése és átalakítása 6. §-szabályai szerint történik, ha szükséges, a metódus által várt típusoknak megfelelően. A primary-expression.member-name, primary-expression::member-nameés az argumentumok kiértékelésének sorrendje nem meghatározott.

Ez az operátor balról asszociatív.

A meghívási kifejezés eredményének típusa egy metódus kijelölő (§4.5.24).

Példák:

[math]::Sqrt(2.0)            # call method with argument 2.0
[char]::IsUpper("a")         # call method
$b = "abc#$%XYZabc"
$b.ToUpper()                 # call instance method

[math]::Sqrt(2)              # convert 2 to 2.0 and call method
[math]::Sqrt(2D)             # convert 2D to 2.0 and call method
[math]::Sqrt($true)          # convert $true to 1.0 and call method
[math]::Sqrt("20")           # convert "20" to 20 and call method

$a = [math]::Sqrt            # get method descriptor for Sqrt
$a.Invoke(2.0)               # call Sqrt via the descriptor
$a = [math]::("Sq"+"rt")     # get method descriptor for Sqrt
$a.Invoke(2.0)               # call Sqrt via the descriptor
$a = [char]::ToLower         # get method descriptor for ToLower
$a.Invoke("X")               # call ToLower via the descriptor

7.1.4 Elem hozzáférés

Szintaxis:

element-access:
    primary-expression [ new-lines~opt~ expression new-lines~opt~ ]

Leírás:

Az elsődleges kifejezés és a bal oldali szögletes zárójel ([) között nem lehet szóköz.

7.1.4.1 Tömb indexelése

Leírás:

A tömbök részletes ismertetését a 9. § tárgyalja. Ha kifejezés egydimenziós tömb, lásd §7.1.4.5.

Ha a elsődleges kifejezés egy egydimenziós tömböt Ajelöl, az operátor [] a A[0 + expression] helyen található elemet adja vissza, miután a kifejezés értéke konvertálódott int-ra. Az eredmény a leírandó tömb elemtípusával rendelkezik. Ha kifejezés negatív, A[expression] a A[A.Length + expression]helyen található elemet jelöli ki.

Amikor elsődleges kifejezési kétdimenziós tömböt Bjelöl ki, az operátor a sor és oszlop (vesszővel tagolt listaként megadott) összetevőinek lesz konvertálva. Az eredmény a hivatkozott tömb elemtípusával rendelkezik. Az 1 dimenziós tömböktől eltérően a negatív pozícióknak nincs különleges jelentése.

Ha elsődleges kifejezési három vagy több dimenzióból álló tömböt jelöl ki, a kétdimenziós tömbökre vonatkozó szabályok érvényesek, a dimenziópozíciók pedig vesszővel tagolt értéklistaként vannak megadva.

Ha nem létező elem olvasási hozzáférését kísérli meg, az eredmény $null. Hiba történt egy nem létező elembe való íráskor.

A többdimenziós tömb alindexeinek kifejezése esetében a dimenzió pozícióinak kifejezései kiértékelésének sorrendje nincs meghatározva. Például, ha adott egy 3 dimenziós tömb, mint a $a, akkor a $a[$i++,$i,++$i] viselkedése meghatározatlan.

Ha a kifejezés egy tömb, tekintse meg a §7.1.4.5-t.

Ez az operátor bal asszociatív.

Példák:

$a = [int[]](10,20,30) # [int[]], Length 3
$a[1] # returns int 20
$a[20] # no such position, returns $null
$a[-1] # returns int 30, i.e., $a[$a.Length-1]
$a[2] = 5 # changes int 30 to int 5
$a[20] = 5 # implementation-defined behavior

$a = New-Object 'double[,]' 3,2
$a[0,0] = 10.5 # changes 0.0 to 10.5
$a[0,0]++ # changes 10.5 to 10.6

$list = ("red",$true,10),20,(1.2, "yes")
$list[2][1] # returns string "yes"

$a = @{ A = 10 },@{ B = $true },@{ C = 123.45 }
$a[1]["B"] # $a[1] is a Hashtable, where B is a key

$a = "red","green"
$a[1][4] # returns string "n" from string in $a[1]

Ha nem létező elemhez próbál írási hozzáférést adni, akkor IndexOutOfRange kivétel keletkezik.

7.1.4.2 Karakterlánc indexelése

Leírás:

Ha elsődleges kifejezés egy sztringet Sjelöl, az operátor [] a kifejezésáltal jelzett nulla alapú pozícióban lévő karaktert adja vissza karakterként. Ha kifejezés nagyobb vagy egyenlő az adott sztring hosszánál, az eredmény $null. Ha kifejezés negatív, S[expression] a S[S.Length + expression]helyen található elemet jelöli ki.

Példák:

$s = "Hello"   # string, Length 5, positions 0-4
$c = $s[1]     # returns "e" as a string
$c = $s[20]    # no such position, returns $null
$c = $s[-1]    # returns "o", i.e., $s[$s.Length-1]

7.1.4.3 Hashtable alsó indexelése

Leírás:

Ha elsődleges kifejezés hashtablet jelöl ki, az operátor [] visszaadja a kifejezésáltal kijelölt kulcs(ok) által megadott érték(ek)et. A kifejezés típusa nincs korlátozva.

Ha kifejezés egyetlen kulcsnév, az eredmény a társított érték, és ilyen típusú, kivéve, ha nincs ilyen kulcs, ebben az esetben az eredmény $null. Ha a $null kulcsként használja, a viselkedés definiálva van. Ha a(z) kifejezés kulcsnevek sorozata, tekintse meg §7.1.4.5.

Ha a kifejezés tömb, lásd §7.1.4.5.

Példák:

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1['FirstName']     # the value associated with key FirstName
$h1['BirthDate']     # no such key, returns $null

$h1 = @{ 10 = "James"; 20.5 = "Anderson"; $true = 123 }
$h1[10]              # returns value "James" using key 10
$h1[20.5]            # returns value "Anderson" using key 20.5
$h1[$true]           # returns value 123 using key $true

Ha a kifejezés egyetlen kulcsnév, és a $null-t használjuk kizárólagos értékként egy Hashtable indexelésére, NullArrayIndex kivétel keletkezik.

7.1.4.4 XML-dokumentum tagelése

Leírás:

Ha elsődleges kifejezés xml típusú objektumot jelöl ki, a kifejezés szükség esetén sztringgé alakul, és az [] operátor az kifejezésáltal megadott nevet tartalmazó első gyermekelemet adja vissza. A kifejezés típusának sztringnek kell lennie. Az eredmény típusa a megvalósítástól függően határozott. Az eredményt alindexeléssel lehet lekérni, hogy visszaadja az első gyermekelemet. Ha nem létezik gyermekelem a(z) kifejezés által meghatározottnévvel, az eredmény $nulllesz. Az eredmény nem jelöl meg írható helyet.

Példák:

$x = [xml]@"
<Name>
<FirstName>Mary</FirstName>
<LastName>King</LastName>
</Name>
"@

$x['Name']                # refers to the element Name
$x['Name']['FirstName']   # refers to the element FirstName within Name
$x['FirstName']           # No such child element at the top level, result is $null

Az eredmény típusa System.Xml.XmlElement vagy System.String.

7.1.4.5 Tömbszeletek létrehozása

Ha a elsődleges kifejezés egy enumerable típusú objektumot (4. §) vagy egy hash-táblát jelöl, és a kifejezés egy egydimenziós tömb, akkor az eredmény egy tömbszelet (§9.9), amely a kifejezéselemei által jelölt elsődleges kifejezés elemeit tartalmazza.

A Hashtable esetén a tömbszelet a megadott kulcsokhoz tartozó értékeket tartalmazza, hacsak nincs ilyen kulcs, ebben az esetben a megfelelő elem $null. Ha $null kulcsnévként van használva, a viselkedés implementációként van definiálva.

Példák:

$a = [int[]](30,40,50,60,70,80,90)
$a[1,3,5]                 # slice has Length 3, value 40,60,80
$a[,5]                    # slice with Length 1
$a[@()]                   # slice with Length 0
$a[-1..-3]                # slice with Length 3, value 90,80,70
$a = New-Object 'int[,]' 3,2
$a[0,0] = 10; $a[0,1] = 20; $a[1,0] = 30
$a[1,1] = 40; $a[2,0] = 50; $a[2,1] = 60
$a[(0,1),(1,0)]           # slice with Length 2, value 20,30, parens needed
$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1['FirstName']          # the value associated with key FirstName
$h1['BirthDate']          # no such key, returns $null
$h1['FirstName','IDNum']  # returns [object[]], Length 2 (James/123)
$h1['FirstName','xxx']    # returns [object[]], Length 2 (James/$null)
$h1[$null,'IDNum']        # returns [object[]], Length 2 ($null/123)

Windows PowerShell: Ha a kifejezés két vagy több kulcsnévből álló gyűjtemény, akkor ha $null kulcsnévként szerepel, azt figyelmen kívül hagyják, és az eredményül kapott tömbnek nincs hozzá tartozó eleme.

7.1.5 A postfix növekményes és csökkentő operátorai

Szintaxis:

post-increment-expression:
    primary-expression ++

post-decrement-expression:
    primary-expression dashdash

Leírás:

A elsődleges kifejezési numerikus típusú írható helyet (4. §) vagy $nullértéket kell kijelölnie. Ha az operandus által kijelölt érték $null, akkor az érték az operátor kiértékelése előtt int és nulla értékű lesz. Az elsődleges kifejezés által megadott érték típusa változhat az eredmény tárolásakor. Lásd a §7.11 részt a típusváltozás hozzárendelés útján történő megvitatásához.

A postfix ++ operátor által előállított eredmény az operandus által megadott érték. Az eredmény megszerzése után az operandus által kijelölt érték a megfelelő típus 1-ével növekszik. A E++ kifejezés eredményének típusa megegyezik a E + 1 kifejezés eredményével (7.7. §).

A postfix -- operátor által előállított eredmény az operandus által megadott érték. Az eredmény megszerzése után az operandus által kijelölt értéket a megfelelő típus 1-ével csökkentik. A E-- kifejezés eredményének típusa megegyezik a E - 1 kifejezés eredményével (7.7. §).

Ezek az operátorok asszociatívak.

Példák:

$i = 0                # $i = 0
$i++                  # $i is incremented by 1
$j = $i--             # $j takes on the value of $i before the decrement

$a = 1,2,3
$b = 9,8,7
$i = 0
$j = 1
$b[$j--] = $a[$i++]   # $b[1] takes on the value of $a[0], then $j is
                      # decremented, $i incremented

$i = 2147483647       # $i holds a value of type int
$i++                  # $i now holds a value of type double because
                      # 2147483648 is too big to fit in type int

[int]$k = 0           # $k is constrained to int
$k = [int]::MaxValue  # $k is set to 2147483647
$k++                  # 2147483648 is too big to fit, imp-def behavior

$x = $null            # target is unconstrained, $null goes to [int]0
$x++                  # value treated as int, 0->1

7.1.6 $(...) operátor

Szintaxis:

sub-expression:
    $( new-lines~opt~ statement-list~opt~ new-lines~opt~ )

Leírás:

Ha utasításlista nincs megadva, az eredmény $nulllesz. Ellenkező esetben a utasításlista kiértékelése történik. A folyamatba a kiértékelés részeként írt összes objektumot egy nem korlátozott egydimenziós tömbben gyűjtjük össze, rendezett sorrendben. Ha az összegyűjtött objektumok tömbje üres, az eredmény $null. Ha az összegyűjtött objektumok tömbje egyetlen elemet tartalmaz, az eredmény az elem; ellenkező esetben az eredmény az összegyűjtött eredmények nem betanított 1 dimenziós tömbje.

Példák:

$j = 20
$($i = 10) # pipeline gets nothing
$(($i = 10)) # pipeline gets int 10
$($i = 10; $j) # pipeline gets int 20
$(($i = 10); $j) # pipeline gets [object[]](10,20)
$(($i = 10); ++$j) # pipeline gets int 10
$(($i = 10); (++$j)) # pipeline gets [object[]](10,22)
$($i = 10; ++$j) # pipeline gets nothing
$(2,4,6) # pipeline gets [object[]](2,4,6)

7.1.7 @(...) operátor

Szintaxis:

array-expression:
    @( new-lines~opt~ statement-list~opt~ new-lines~opt~ )

Leírás:

Ha utasításlista nincs megadva, az eredmény egy nem betanított, nulla hosszúságú egydimenziós tömb. Ellenkező esetben a rendszer kiértékeli utasításlista-, és a folyamatba a kiértékelés részeként írt összes objektumot egy nem konfigurált 1 dimenziós tömbben gyűjti össze, sorrendben. Az eredmény a (esetleg üres) nem betanított 1 dimenziós tömb.

Példák:

$j = 20
@($i = 10)             # 10 not written to pipeline, result is array of 0
@(($i = 10))           # pipeline gets 10, result is array of 1
@($i = 10; $j)         # 10 not written to pipeline, result is array of 1
@(($i = 10); $j)       # pipeline gets 10, result is array of 2
@(($i = 10); ++$j)     # pipeline gets 10, result is array of 1
@(($i = 10); (++$j))   # pipeline gets both values, result is array of 2
@($i = 10; ++$j)       # pipeline gets nothing, result is array of 0

$a = @(2,4,6)          # result is array of 3
@($a)                  # result is the same array of 3
@(@($a))               # result is the same array of 3

7.1.8 Szkriptblokk kifejezés

Szintaxis:

script-block-expression:
    { new-lines~opt~ script-block new-lines~opt~ }

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

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

Leírás:

param-blokkról a 8.10.9 §-banvan szó. elnevezett blokklistát a 8.10.7 §-ban írják le.

A szkriptblokk egy meg nem nevezett utasításblokk, amely egyetlen egységként használható. A szkriptblokkok olyan kódblokkok meghívására használhatók, mintha egyetlen parancs lenne, vagy hozzárendelhetők végrehajtható változókhoz.

A elnevezett blokklista vagy a utasításlista kerül végrehajtásra, és az eredmény típusa és értéke(i) azoknak az utasításkészleteknek a típusával és értékeivel azonos, amelyeket végrehajtottak.

Egy szkriptblokk-kifejezés szkriptblokktípusú (§4.3.7).

Ha paramblokkos nincs megadva, a szkriptblokknak átadott argumentumok $args (§8.10.1) keresztül érhetők el.

A paraméterkötés során a szkriptblokkok átadhatók parancsfájlblokk-objektumként vagy a szkriptblokk kiértékelése után kapott eredményként. Lásd a §6.17 részleteket további információkért.

7.1.9 Hash literál kifejezés

Szintaxis:

hash-literal-expression:
    @{ new-lines~opt~ hash-literal-body~opt~ new-lines~opt~ }

hash-literal-body:
    hash-entry
    hash-literal-body statement-terminators hash-entry

hash-entry:
    key-expression = new-lines~opt~ statement

key-expression:
    simple-name
    unary-expression

statement-terminators:
    statement-terminator
    statement-terminators statement-terminator

statement-terminator:
    ;
    new-line-character

Leírás:

A hash-literal kifejezés egy olyan hash táblát (10. §) hoz létre, amely nulla vagy több elemből áll, és ezek mindegyike egy kulcs-érték pár.

A kulcsnak bármilyen típusa lehet, kivéve a null értéket. A társított értékek bármilyen típusúak lehetnek, beleértve a null típust is, és ezek mindegyike lehet bármilyen kifejezés, amely a kívánt értéket jelöli, beleértve a $null.

A kulcs/érték párok sorrendje nem jelentős.

Példák:

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$last = "Anderson"; $IDNum = 120
$h2 = @{ FirstName = "James"; LastName = $last; IDNum = $IDNum + 3 }
$h3 = @{ }
$h4 = @{ 10 = "James"; 20.5 = "Anderson"; $true = 123 }

amely két kivonattáblát hoz létre, $h1 és $h2, amelyek mindegyike három kulcs/érték párból áll, a harmadik pedig $h3, amely üres. A hash tábla $h4 különböző típusú kulcsokkal rendelkezik.

7.1.10 Literális kifejezés beírása

Szintaxis:

type-literal:
    [ type-spec ]

type-spec:
    array-type-name new-lines~opt~ dimension~opt~ ]
    generic-type-name new-lines~opt~ generic-type-arguments ]
    type-name

dimension:
    ,
    dimension ,

generic-type-arguments:
    type-spec new-lines~opt~
    generic-type-arguments , new-lines~opt~ type-spec

array-type-name:
    type-name [

generic-type-name:
    type-name [

Leírás:

A típuskonstans egy implementációban valamilyen nem meghatározott mögöttes típusvan ábrázolva. Ennek eredményeképpen a típusnév a mögöttes típus szinonimája.

A típuskonstansok számos környezetben használhatók:

  • Explicit átalakítás megadása (§6, §7.2.9)
  • Típuskorlátozott tömb létrehozása (§9.4)
  • Hozzáférés egy objektum statikus tagjaihoz (§7.1.2)
  • Típuskorlátozás megadása változón (§5.3) vagy függvényparaméteren (§8.10.2)

Példák:

[int].IsPrimitive        # $true
[Object[]].FullName      # "System.Object[]"
[int[,,]].GetArrayRank() # 3

A stringek tárolására specializálódott általános veremtípus (§4.4) [Stack[string]], a int kulcsokhoz kapcsolódó stringértékek tárolására specializálódott általános szótártípus pedig [Dictionary[int,string]].

A típusú literális típusa System.Type. A fenti Stack[string] típus teljes neve System.Collections.Generic.Stack[int]. A fenti Dictionary[int,string] típus teljes neve System.Collections.Generic.Dictionary[int,string].

7.2 Unary operátorok

Szintaxis:

unary-expression:
    primary-expression
    expression-with-unary-operator

expression-with-unary-operator:
    , new-lines~opt~ unary-expression
    -not new-lines~opt~ unary-expression
    ! new-lines~opt~ unary-expression
    -bnot new-lines~opt~ unary-expression
    + new-lines~opt~ unary-expression
    dash new-lines~opt~ unary-expression
    pre-increment-expression
    pre-decrement-expression
    cast-expression
    -split new-lines~opt~ unary-expression
    -join new-lines~opt~ unary-expression

pre-increment-expression:
    ++ new-lines~opt~ unary-expression

pre-decrement-expression:
    dashdash new-lines~opt~ unary-expression

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

cast-expression:
    type-literal unary-expression

dashdash:
    dash dash

7.2.1 Unary vessző operátor

Leírás:

A vessző operátor (,) létrehoz egy szabad 1 dimenziós tömböt, amelynek egy eleme van, és amelynek típusa és értéke megegyezik a unáris kifejezésértékével.

Ez az operátor megfelelő asszociatív.

Példák:

$a = ,10         # create an unconstrained array of 1 element, $a[0],
                 # which has type int

$a = ,(10,"red") # create an unconstrained array of 1 element,
$a[0],
                 # which is an unconstrained array of 2 elements,
                 # $a[0][0] an int, and $a[0][1] a string

$a = ,,10        # create an unconstrained array of 1 element, which is
                 # an unconstrained array of 1 element, which is an int
                 # $a[0][0] is the int. Contrast this with @(@(10))

7.2.2 Logikai NEM

Szintaxis:

logical-not-operator:
    dash not

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

Az operátor -notunary-expression által kijelölt értéket bool (§6.2) típussá alakítja, ha szükséges, és ennek a típusnak az eredményét hozza létre. Ha a egyváltozós kifejezésértéke Igaz, akkor az eredmény Hamis, és fordítva. A ! operátor a -notalternatív helyesírása.

Ez az operátor megfelelő asszociatív.

Példák:

-not $true         # False
-not -not $false   # False
-not 0             # True
-not 1.23          # False
!"xyz"             # False

7.2.3 Bitenkénti NEM

Szintaxis:

bitwise-not-operator:
    dash bnot

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

Az operátor -bnotunary-expression által kijelölt értéket egész szám típusúra (§6.4) konvertálja, ha szükséges. Ha a konvertált érték int típusban jeleníthető meg, akkor ez az eredménytípus. Ha a konvertált érték hosszú típusban is megjeleníthető, akkor ez az eredménytípus. Ellenkező esetben a kifejezés helytelen. Az eredményül kapott érték a konvertált érték egyedkiegészítője.

Ez az operátor megfelelő asszociatív.

Példák:

-bnot $true         # int with value 0xFFFFFFFE
-bnot 10            # int with value 0xFFFFFFF5
-bnot 2147483648.1  # long with value 0xFFFFFFFF7FFFFFFF
-bnot $null         # int with value 0xFFFFFFFF
-bnot "0xabc"       # int with value 0xFFFFF543

7.2.4 Unary plus

Leírás:

A + unary-expression formájú kifejezést úgy kezeljük, mintha 0 + unary-expression-ként lenne írva (§7.7). Az egész szám konstans 0inttípusú.

Ez az operátor megfelelő asszociatív.

Példák:

+123L         # type long, value 123
+0.12340D     # type decimal, value 0.12340
+"0xabc"      # type int, value 2748

7.2.5 Egyargumentumú mínusz

Leírás:

A - unary-expression alakú kifejezést úgy kezeljük, mintha 0 - unary-expression formában lenne megírva (§7.7). A 0 egész számnak inttípusa van. A mínusz operátor a kötőjel karakterek bármelyike lehet, amelyek szerepelnek a §7.2részben.

Ez az operátor megfelelő asszociatív.

Példák:

-$true     # type int, value -1
-123L      # type long, value -123
-0.12340D  # type decimal, value -0.12340

7.2.6 Előtag-növekmény- és csökkentés operátorok

Leírás:

A kifejezés nélküli olyan írható helyet kell kijelölnie, amelynek értéke numerikus (§4) vagy a $null. Ha a unary-expression által kijelölt érték $null, akkor a unary-expressionértéke az operátor kiértékelése előtt int típusra és nulla értékre lesz konvertálva.

Jegyzet

Az unary-expression által megadott érték típusa változhat az eredmény tárolásakor. Lásd a §7.11 részt a típusváltozás hozzárendeléssel történő megvitatása kapcsán.

Az előtag növekmény operátora ++ esetén a egyoperandusú kifejezés értékét a megfelelő típusú 1 megnöveli. Az eredmény az új érték, amely a növekmény végrehajtása után jön létre. A ++E kifejezés egyenértékű a E += 1 (§7.11.2).

A -- előtagcsökkentő operátor esetében a kifejezés értékét a megfelelő típusú 1 értékkel csökkenti. Az eredmény az a megváltozott érték, ami a dekrementálás után jön létre. A --E kifejezés egyenértékű a E -= 1 (§7.11.2). Az előtét dekrementáló operátor bármely olyan mintázat lehet, amely egyezik az dashdash mintával a §7.2részben.

Ezek az operátorok megfelelő asszociatívak.

Példák:

$i = 0                # $i = 0
++$i                  # $i is incremented by 1
$j = --$i             # $i is decremented then $j takes on the value of $i

$a = 1,2,3
$b = 9,8,7
$i = 0;
$j = 1
$b[--$j] = $a[++$i]   # $j is # decremented, $i incremented, then $b[0]
                      # takes on the value of $a[1]

$i = 2147483647       # $i holds a value of type int
++$i                  # $i now holds a value of type double because
                      # 2147483648 is too big to fit in type int

[int]$k = 0           # $k is constrained to int
$k = [int]::MinValue  # $k is set to -2147483648
--$k                  # -2147483649 is too small to fit, imp-def behavior

$x = $null            # target is unconstrained, $null goes to [int]0
--$x                  # value treated as int, 0 becomes -1

7.2.7 Az unary -join operátor

Szintaxis:

join-operator:
    dash join

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

A -join unáris operátor olyan karakterláncot hoz létre, amely az unáris kifejezésáltal kijelölt egy vagy több objektum értékének összefűzése. (Az elválasztó az operátor bináris verziójával szúrható be (§7.8.4.4).)

kifejezés nélküli skaláris érték vagy gyűjtemény lehet.

Példák:

-join (10, 20, 30)             # result is "102030"
-join (123, $false, 19.34e17)  # result is "123False1.934E+18"
-join 12345                    # result is "12345"
-join $null                    # result is ""

7.2.8 Az -split unáris operátor

Szintaxis:

split-operator:
    dash split

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

A unary -split operátor feloszt egy vagy több, unary-expressionáltal kijelölt sztringet, és az alrészeiket egy korlátozott, egydimenziós sztringtömbben adja vissza. Az egymást követő alrészek közötti elválasztóként kezeli a szóközkarakterek egymással összefüggő csoportját. Explicit elválasztó sztringet az operátor bináris verziójával (§7.8.4.5) vagy annak két változatával (§7.8) lehet megadni.

Az elválasztó szöveg nem szerepel az eredményül kapott sztringekben. A bemeneti sztring kezdő és záró szóközét figyelmen kívül hagyják. Az üres vagy szóközt tartalmazó bemeneti sztring csak egy sztringből álló tömböt eredményez, amely üres.

egyváltozós kifejezés skaláris értéket vagy sztringtömböt jelezhet.

Példák:

-split " red`tblue`ngreen " # 3 strings: "red", "blue", "green"
-split ("yes no", "up down") # 4 strings: "yes", "no", "up", "down"
-split " " # 1 (empty) string

7.2.9 Öntött operátor

Leírás:

Ez az operátor explicit módon (§6) alakítja át a unary-expression által kijelölt értéket a típuskonstans által kijelölt típusra (§7.1.10). Ha típuskonstans érvénytelen, az eredmény típusa a névvel ellátott típus, az érték pedig az átalakítás utáni érték. Ha a típuskifejezés üres, a rendszer nem ír objektumot a csővezetékbe, és nincs eredmény.

Ha bármilyen típusú kifejezést ugyanarra a típusra vetnek, az eredményül kapott típus és érték a unary-expressiontípusa és értéke.

Ez az operátor megfelelő asszociatív.

Példák:

[bool]-10        # a bool with value True
[int]-10.70D     # a decimal with value -10
[int]10.7        # an int with value 11
[long]"+2.3e+3"  # a long with value 2300
[char[]]"Hello"  # an array of 5 char with values H, e, l, l, and o.

7.3 Bináris komma operátor

Szintaxis:

array-literal-expression:
    unary-expression , new-lines~opt~ array-literal-expression

Leírás:

A bináris vessző operátor egy 1 dimenziós tömböt hoz létre, amelynek elemei az operandusok által meghatározott értékek lexikális sorrendben. A tömb nem korlátozott típussal rendelkezik.

Példák:

2,4,6                    # Length 3; values 2,4,6
(2,4),6                  # Length 2; values [object[]],int
(2,4,6),12,(2..4)        # Length 3; [object[]],int,[object[]]
2,4,6,"red",$null,$true  # Length 6

A zárójelek egyes bináris vesszőkifejezésekhez való hozzáadása nem dokumentálja az alapértelmezett elsőbbséget; ehelyett módosítja az eredményt.

7.4 Tartomány operátor

Szintaxis:

range-expression:
    unary-expression .. new-lines~opt~ unary-expression

Leírás:

A tartománykifejezési létrehoz egy nem betanított egydimenziós tömböt, amelynek elemei a tartományhatárok által megadott int sorozat értékei. Szükség esetén az operandusok által kijelölt értékeket inttípusúra alakítják át (§6.4). Az átalakítás után az alacsonyabb értéket kijelölő operandus a alsó kötésű, míg az átalakítás után a magasabb értéket kijelölő operandus a felső kötött. Mindkét határ azonos lehet, ebben az esetben az eredményként kapott tömb hossza 1. Ha a bal operandus az alsó határt jelöli, a sorrend növekvő sorrendben van. Ha a bal operandus a felső határt jelöli, a sorrend csökkenő sorrendben van.

Elméletileg ez az operátor a megfelelő bináris vessző operátor-sorozat parancsikonja. A tartomány 5..8 például 5,6,7,8használatával is létrehozható. Ha azonban növekvő vagy csökkenő sorrendre van szükség tömb nélkül, előfordulhat, hogy egy implementáció nem hoz létre tényleges tömböt. Például a foreach ($i in 1..5) { ... }-ban nem kell tömböt létrehozni.

Egy tartománykifejezés használható egy tömbszelet megadására (§9.9).

Példák:

1..10        # ascending range 1..10
-495..-500   # descending range -495..-500
16..16       # sequence of 1

$x = 1.5
$x..5.40D    # ascending range 2..5

$true..3     # ascending range 1..3
-2..$null    # ascending range -2..0
0xf..0xa     # descending range 15..10

7.5 Formátum operátor

Szintaxis:

format-expression:
    format-specification-string format-operator new-lines~opt~ range-expression

format-operator:
    dash f

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

A formátumkifejezés a által kijelölt egy vagy több értéket a formátum-specifikációs sztring szerint formázza, amelyet a formátumkifejezéshatároz meg. A tartománykifejezési által kijelölt értékek pozíciói nullától kezdődően számozottak, és lexikális sorrendben növekednek. Az eredmény típusa string.

A formátummegadási sztring nulla vagy több formátummegadást tartalmazhat, amelyek mindegyike a következő alakot ölti:

{N [ ,M ][ : FormatString ]}

N egy (kötelező) tartománykifejezés értékpozícióját jelenti, M a (nem kötelező) minimális megjelenítési szélességet jelöli, a FormatString pedig a (nem kötelező) formátumot adja meg. Ha egy formázott érték szélessége meghaladja a megadott szélességet, a szélesség ennek megfelelően növekszik. Azokat az értékeket, amelyek pozíciói nincsenek hivatkozva a FormatString-ben, figyelmen kívül hagyják, miután kiértékelték őket bármilyen mellékhatás szempontjából. Ha N nem létező pozícióra hivatkozik, a viselkedés implementálásra van definiálva. A $null és a void típusú értékek üres sztringekként vannak formázva. A tömbök formázása a(z) alkifejezés alapján (§7.1.6). Ha a karaktereket { és } formátumspecifikációba szeretné foglalni anélkül, hogy formátumelválasztóként értelmezi őket, írja be őket {{ és }}ként.

A formátumspecifikációk teljes definíciójához lásd a System.IFormattable típust a Ecma Technical Report TR/84-ban.

Példák:

"__{0,3}__" -f 5                         # __ 5__
"__{0,-3}__" -f 5                        # __5 __
"__{0,3:000}__" -f 5                     # __005__
"__{0,5:0.00}__" -f 5.0                  # __ 5.00__
"__{0:C}__" -f 1234567.888               # __$1,234,567.89__
"__{0:C}__" -f -1234.56                  # __($1,234.56)__
"__{0,12:e2}__" -f 123.456e2             # __ 1.23e+004__
"__{0,-12:p}__" -f -0.252                # __-25.20 % __

$i = 5; $j = 3
"__{0} + {1} <= {2}__" -f $i,$j,($i+$j)  # __5 + 3 <= 8__

$format = "__0x{0:X8}__"
$format -f 65535                         # __0x0000FFFF__

Formátum specifikáció esetén, ha N nem létező pozícióra hivatkozik, FormatError keletkezik.

7.6 Multiplicative operátorok

Szintaxis:

multiplicative-expression:
    multiplicative-expression * new-lines~opt~ format-expression
    multiplicative-expression / new-lines~opt~ format-expression
    multiplicative-expression % new-lines~opt~ format-expression

7.6.1 Szorzás

Leírás:

A szorzási operátor * eredménye a két operandus által a szokásos számtani átalakítások (§6.15) alkalmazása után kijelölt értékek szorzata.

Ez az operátor bal asszociatív.

Példák:

12 * -10L      # long result -120
-10.300D * 12  # decimal result -123.600
10.6 * 12      # double result 127.2
12 * "0xabc"   # int result 32976

7.6.2 Sztring replikáció

Leírás:

Amikor a bal operandus egy sztringet jelöl, a bináris * operátor létrehoz egy új sztringet, amely a bal operandus által jelölt sztringet tartalmazza, és annyiszor ismétli meg, ahányszor a jobb operandus értékének egész számtípusra konvertált értéke megadja (§6.4).

Ez az operátor bal asszociatív.

Példák:

"red" * "3"       # string replicated 3 times
"red" * 4         # string replicated 4 times
"red" * 0         # results in an empty string
"red" * 2.3450D   # string replicated twice
"red" * 2.7       # string replicated 3 times

7.6.3 Tömbreplikáció

Leírás:

Amikor a bal operandus egy tömböt jelöl ki, a bináris * operátor létrehoz egy új, nem korlátozott egydimenziós tömböt, amely tartalmazza a bal operandus által kijelölt érték többszörösét, ahányszor a jobb operandus értéke egész számra konvertálva mutatja (§6.4). A nulla replikációs szám 1 hosszúságú tömböt eredményez. Ha a bal operandus többdimenziós tömböt jelöl ki, használat előtt a rendszer kiegyenesíti (§9.12).

Ez az operátor bal asszociatív.

Példák:

$a = [int[]](10,20)              # [int[]], Length 2*1
$a * "3"                         # [object[]], Length 2*3
$a * 4                           # [object[]], Length 2*4
$a * 0                           # [object[]], Length 2*0
$a * 2.3450D                     # [object[]], Length 2*2
$a * 2.7                         # [object[]], Length 2*3
(New-Object 'float[,]' 2,3) * 2  # [object[]], Length 2*2

7.6.4 Osztály

Leírás:

Az osztási operátor / eredménye az a hányados, amikor a bal operandus által kijelölt érték el van osztva a jobb operandus által a szokásos számtani átalakítások (§6.15) alkalmazása után kijelölt értékkel.

Ha egész vagy decimális osztást próbál végrehajtani nullával, a rendszer implementáció által definiált megszűnési hibát jelez.

Ez az operátor bal asszociatív.

Példák:

10/-10      # int result -1
12/-10      # double result -1.2
12/-10D     # decimal result 1.2
12/10.6     # double result 1.13207547169811
12/"0xabc"  # double result 0.00436681222707424

Ha egész vagy decimális osztást próbál végrehajtani nullával, RuntimeException kivétel keletkezik.

7.6.5 Fennmaradó rész

Leírás:

A fennmaradó operátor % eredménye az a maradék, amikor a bal operandus által kijelölt értéket a szokásos számtani átalakítások (6.15. §) alkalmazása után a jobb operandus által kijelölt értékkel osztja el.

Ha egész vagy decimális osztást próbál végrehajtani nullával, a rendszer implementáció által definiált megszűnési hibát jelez.

Példák:

10 % 3          # int result 1
10.0 % 0.3      # double result 0.1
10.00D % "0x4"  # decimal result 2.00

Ha egész vagy decimális osztást próbál végrehajtani nullával, RuntimeException kivétel keletkezik.

7.7 Additív operátorok

Szintaxis:

additive-expression:
    primary-expression + new-lines~opt~ expression
    primary-expression dash new-lines~opt~ expression

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

7.7.1 Hozzáadás

Leírás:

Az összeadási operátor + eredménye a két operandus által a szokásos számtani átalakítások (§6.15) alkalmazása után kijelölt értékek összege.

Ez az operátor bal asszociatív.

Példák:

12 + -10L       # long result 2
-10.300D + 12   # decimal result 1.700
10.6 + 12       # double result 22.6
12 + "0xabc"    # int result 2760

7.7.2 Sztringösszefűzés

Leírás:

Amikor a bal operandus egy karakterláncot jelöl, a bináris + operátor létrehoz egy új karakterláncot, amely tartalmazza a bal operandus által jelölt értéket, közvetlenül utána pedig a jobb operandus által típussztringgé konvertált érték(ek)et (§6.8).

Ez az operátor bal asszociatív.

Példák:

"red" + "blue"      # "redblue"
"red" + "123"       # "red123"
"red" + 123         # "red123"
"red" + 123.456e+5  # "red12345600"
"red" + (20,30,40)  # "red20 30 40"

7.7.3 Tömbösszefűzés

Leírás:

Amikor a bal operandus kijelöl egy tömböt, a bináris + operátor létrehoz egy új, nem korlátozott egydimenziós tömböt, amely tartalmazza a bal operandus által kijelölt elemeket, majd közvetlenül a jobb operandus által kijelölt érték(ek)et. A két operandusban található többdimenziós tömböket használat előtt összesimítjuk (§9.12).

Ez az operátor bal asszociatív.

Példák:

$a = [int[]](10,20)               # [int[]], Length 2
$a + "red"                        # [object[]], Length 3
$a + 12.5,$true                   # [object[]], Length 4
$a + (New-Object 'float[,]' 2,3)  # [object[]], Length 8
(New-Object 'float[,]' 2,3) + $a  # [object[]], Length 8

7.7.4 Kivonatoló összefűzés

Leírás:

Ha mindkét operandus hashtablest jelöl ki, a bináris + operátor létrehoz egy új hashtablet, amely tartalmazza a bal operandus által kijelölt elemeket, majd közvetlenül a jobb operandus által kijelölt elemeket.

Ha a hash táblák ugyanazt a kulcsot tartalmazzák, egy implementáció által definiált végleges hiba jelenik meg.

Ez az operátor bal asszociatív.

Példák:

$h1 = @{ FirstName = "James"; LastName = "Anderson" }
$h2 = @{ Dept = "Personnel" }
$h3 = $h1 + $h2      # new Hashtable, Count = 3

Ha a hasítótáblák ugyanazt a kulcsot tartalmazzák, akkor BadOperatorArgument típusú kivétel keletkezik.

7.7.5 Kivonás

Leírás:

A - kivonási operátor eredménye az a különbség, ha a jobb operandus által kijelölt értéket kivonják a bal operandus által kijelölt értékből a szokásos számtani átalakítások (6.15. §) alkalmazása után. A kivonási operátor lehet bármelyik a kötőjel karakter közül, amely a §7.7-ban felsorolva van.

Ez az operátor bal asszociatív.

Példák:

12 - -10L      # long result 22
-10.300D - 12  # decimal result -22.300
10.6 - 12      # double result -1.4
12 - "0xabc"   # int result -2736

7.8 Összehasonlító operátorok

Szintaxis:

comparison-expression:
    primary-expression comparison-operator new-lines~opt~ expression

comparison-operator:
    equality-operator
    relational-operator
    containment-operator
    type-operator
    like-operator
    match-operator

Leírás:

A bal operandus által kijelölt érték típusa határozza meg a jobb operandus által kijelölt érték konvertálását (6. §), ha szükséges, az összehasonlítás elvégzése előtt.

Egyes összehasonlító operátoroknak két változata van, az egyik különbséget tesz a kis- és nagybetűk között (-c<operator>), a másik pedig nem (-i<operator>). A -<operator> verziója egyenértékű a -i<operator>. A kis- és nagybetűk érzékenysége csak a típussztring értékeinek összehasonlításával értelmezhető. A nem sztringes összehasonlítási környezetekben a két változat ugyanúgy viselkedik.

Ezek az operátorok asszociatívak.

7.8.1 Egyenlőségi és relációs operátorok

Szintaxis:

equality-operator: one of
    dash eq     dash ceq    dash ieq
    dash ne     dash cne    dash ine

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

relational-operator: one of
    dash lt     dash clt    dash ilt
    dash le     dash cle    dash ile
    dash gt     dash cgt    dash igt
    dash ge     dash cge    dash ige

Leírás:

Két egyenlőségi operátor létezik: egyenlőség (-eq) és egyenlőtlenség (-ne); és négy relációs operátor: kisebb(-lt), kisebb, mint (-le), nagyobb, mint (-gt), és nagyobb, mint (-ge). Mindegyiknek két változata van (§7.8).

Ahhoz, hogy két sztring egyenlő legyen, azonos hosszúságúnak és tartalmúnak kell lenniük, és szükség esetén a nagy- és kisbetű különbség is számít.

Ha a bal oldali operandus által kijelölt érték nem gyűjtemény, az eredmény típusa bool. Ellenkező esetben az eredmény valószínűleg üres, nem konfigurált 1 dimenziós tömb, amely a gyűjtemény azon elemeit tartalmazza, amelyek az Igaz értéket tesztelik a jobb operandus által megadott értékkel összehasonlítva.

Példák:

10 -eq "010"           # True, int comparison
"010" -eq 10           # False, string comparison
"RED" -eq "Red"        # True, case-insensitive comparison
"RED" -ceq "Red"       # False, case-sensitive comparison
"ab" -lt "abc"         # True

10,20,30,20,10 -ne 20  # 10,30,10, Length 3
10,20,30,20,10 -eq 40  # Length 0
10,20,30,20,10 -ne 40  # 10,20,30,20,10, Length 5
10,20,30,20,10 -gt 25  # 30, Length 1
0,1,30 -ne $true       # 0,30, Length 2
0,"00" -eq "0"         # 0 (int), Length 1

7.8.2 Elszigetelési operátorok

Szintaxis:

containment-operator: one of
    dash contains       dash ccontains      dash icontains
    dash notcontains    dash cnotcontains   dash inotcontains
    dash in             dash cin            dash iin
    dash notin          dash cnotin         dash inotin

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

Négy tartalmazási operátor létezik: tartalmaz (-contains), nem tartalmaz (-notcontains), benne van (-in) és nincs benne (-notin). Mindegyiknek két változata van (§7.8).

Az elszigetelési operátorok olyan bool típusú eredményt adnak vissza, amely azt jelzi, hogy egy érték legalább egyszer előfordul-e (vagy nem fordul elő) egy tömb elemeiben. -contains és -notcontainsesetén az értéket a jobb operandus, a tömböt pedig a bal operandus jelöli ki. A -in és -notinesetében az operandusok sorrendje meg van fordítva. Az értéket a bal operandus, a tömböt pedig a jobb operandus jelöli ki.

Ezen operátorok esetében, ha a tömboperandus skaláris értékkel rendelkezik, a skaláris érték egy elem tömbjeként lesz kezelve.

Példák:

10,20,30,20,10 -contains 20     # True
10,20,30,20,10 -contains 42.9   # False
10,20,30 -contains "10"         # True
"10",20,30 -contains 10         # True
"010",20,30 -contains 10        # False
10,20,30,20,10 -notcontains 15  # True
"Red",20,30 -ccontains "RED"    # False

7.8.3 Típustesztelő és átalakítási operátorok

Szintaxis:

type-operator: one of
    dash is
    dash as

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

A típusoperátor -is ellenőrzi, hogy a bal operandus által kijelölt érték típussal rendelkezik-e, vagy a jobb operandus által kijelölt típusból származik. A jobb operandusnak meg kell jelölnie egy típust vagy értéket, amely típusra átalakítható (például egy típus nevét viselő karakterlánc). Az eredmény típusa bool. A típusoperátor -isnot a megfelelő -is űrlap logikai negációját adja vissza.

A típusoperátor -as megpróbálja átalakítani a bal operandus által kijelölt értéket a jobb operandus által kijelölt típusra. A jobb operandusnak egy típust vagy olyan értéket kell megjelölnie, amely típussá alakítható (például egy típus nevét tartalmazó sztring). Ha az átalakítás sikertelen, $null lesz visszaadva; ellenkező esetben a konvertált érték lesz visszaadva, és ennek az eredménynek a visszatérési típusa a konvertált érték futtatókörnyezeti típusa.

Példák:

$a = 10            # value 10 has type int
$a -is [int]       # True

$t = [int]
$a -isnot $t       # False
$a -is "int"       # True
$a -isnot [double] # True

$x = [int[]](10,20)
$x -is [int[]]     # True

$a = "abcd"        # string is derived from object
$a -is [object]    # True

$x = [double]
foreach ($t in [int],$x,[decimal],"string") {
    $b = (10.60D -as $t) * 2  # results in int 22, double 21.2
}                             # decimal 21.20, and string "10.6010.60"

7.8.4 Mintaegyeztető és szövegkezelő operátorok

7.8.4.1 A -like és -notlike operátorok

Szintaxis:

like-operator: one of
    dash like       dash clike      dash ilike
    dash notlike    dash cnotlike   dash inotlike

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

Ha a bal oldali operandus nem jelöl meg gyűjteményt, az eredmény típusa bool. Ellenkező esetben az eredmény valószínűleg üres, nem konfigurált 1 dimenziós tömb, amely a gyűjtemény azon elemeit tartalmazza, amelyek az Igaz értéket tesztelik a jobb operandus által megadott értékkel összehasonlítva. A jobb operandus lehet, hogy egy helyettesítő kifejezéseket (§3.15) tartalmazó karakterláncot jelöl. Ezek az operátoroknak két változata van (§7.8).

Példák:

"Hello" -like "h*"                   # True, starts with h
"Hello" -clike "h*"                  # False, does not start with lowercase h
"Hello" -like "*l*"                  # True, has an l in it somewhere
"Hello" -like "??l"                  # False, no length match

"-abc" -like "[-xz]*"                # True, - is not a range separator
"#$%\^&" -notlike "*[A-Za-z]"        # True, does not end with alphabetic character
"He" -like "h[aeiou]?*"              # False, need at least 3 characters
"When" -like "*[?]"                  # False, ? is not a wildcard character
"When?" -like "*[?]"                 # True, ? is not a wildcard character

"abc","abbcde","abcgh" -like "abc*"  # object[2], values
"abc" and "abcgh"

7.8.4.2 A -match és -notmatch operátorok

Szintaxis:

match-operator: one of
    dash match      dash cmatch     dash imatch
    dash notmatch   dash cnotmatch  dash inotmatch

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

Ha a bal oldali operandus nem gyűjteményt jelöl, akkor az eredmény típusa bool, és ha ez az eredmény $true, akkor a hasítótábla $matches elemei a jobb oldali operandus által megadott értékkel egyező (vagy nem egyező) karakterláncokra vannak beállítva. Ellenkező esetben az eredmény valószínűleg üres, nem konfigurált 1 dimenziós tömb, amely a gyűjtemény azon elemeit tartalmazza, amelyek az Igaz értéket tesztelik a jobb operandus által megadott értékkel összehasonlítva, és $matches nincs beállítva. Amennyiben a jobb operandus egy reguláris kifejezéseket tartalmazó sztringet jelöl ki (§3.16), azt mintánaknevezik. Ezek az operátorok két változata van (§7.8).

Ezek az operátorok támogatják a részillesztéseket (§7.8.4.6).

Példák:

"Hello" -match ".l"                    # True, $matches key/value is 0/"el"
"Hello" -match '\^h.*o$'               # True, $matches key/value is
0/"Hello"
"Hello" -cmatch '\^h.*o$'              # False, $matches not set
"abc\^ef" -match ".\\\^e"              # True, $matches key/value is 0/"c\^e"

"abc" -notmatch "[A-Za-z]"             # False
"abc" -match "[\^A-Za-z]"              # False
"He" -match "h[aeiou]."                # False, need at least 3 characters
"abc","abbcde","abcgh" -match "abc.*"  # Length is 2, values "abc", "abcgh"

7.8.4.3 A -replace operátor

Szintaxis:

binary-replace-operator: one of
    dash replace    dash creplace   dash ireplace

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

A -replace operátor lehetővé teszi a szöveg cseréjét a bal operandus által kijelölt egy vagy több sztringben a jobb operandus által kijelölt értékekkel. Ennek az operátornak két változata van (§7.8). A jobb operandus az alábbi formátumok egyikét öltheti:

  • A megkeresendő sztring, amely tartalmazhat reguláris kifejezéseket (§3.16). Ebben az esetben a helyettesítő karakterlánc implicit módon "".
  • Egy 2 objektumból álló tömb, amely a megtalálandó karakterláncot tartalmazza, majd a helyettesítő karakterláncot.

Ha a bal operandus egy sztringet jelöl ki, az eredmény típussztringet tartalmaz. Ha a bal operandus egy egydimenziós sztringtömböt jelöl, az eredmény egy nem betanított egydimenziós tömb, amelynek hossza megegyezik a bal operandus tömbjének hosszával, amely a csere befejezése után tartalmazza a bemeneti sztringeket.

Ez az operátor támogatja a részegyezéseket (§7.8.4.6).

Példák:

"Analogous","an apple" -replace "a","*"      # "*n*logous","*n *pple"
"Analogous" -creplace "[aeiou]","?"          # "An?l?g??s"
"Analogous","an apple" -replace '\^a',"%%A"  # "%%Analogous","%%An apple"
"Analogous" -replace "[aeiou]",'$&$&'        # "AAnaaloogoouus"

7.8.4.4 A bináris -join operátor

Szintaxis:

binary-join-operator: one of
    dash join

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

A bináris -join operátor olyan sztringet hoz létre, amely a bal operandus által meghatározott egy vagy több objektum értékének összefűzése azok sztringgé alakítása után, ha szükséges (§6.7). A jobb operandus által kijelölt karakterlánc szolgál az eredményül kapott karakterláncban található (esetleg üres) értékek elválasztására.

A bal operandus lehet skaláris érték vagy gyűjtemény.

Példák:

(10, 20, 30) -join "\|"    # result is "10\|20\|30"
12345 -join ","            # result is "12345", no separator needed
($null,$null) -join "<->"  # result is "<->", two zero-length values

7.8.4.5 A bináris -split operátor

Szintaxis:

binary-split-operator: one of
    dash split      dash csplit     dash isplit

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

A bináris -split operátor feloszt egy vagy több, a bal operandus által kijelölt sztringet, és az alrészeiket egy korlátozott, egydimenziós sztringtömbben adja vissza. Ennek az operátornak két változata van (§7.8). A bal operandus skaláris értéket vagy sztringtömböt jelölhet ki. A jobb operandus az alábbi formák egyikét veszi fel:

  • elválasztó karakterlánc
  • Elválasztó sztringet tartalmazó 2 objektumból álló tömb, amelyet numerikus felosztási szám követ
  • 3 objektumból álló tömb, amely elválasztó sztringet, numerikus felosztási számot és beállítási sztringet tartalmaz
  • Szkriptblokk
  • Egy szkriptblokkot tartalmazó 2 objektumból álló tömb, amelyet numerikus felosztási szám követ

A határoló sztring tartalmazhat reguláris kifejezéseket (§3.16). A bemeneti sztringekkel rendelkező alrészek megkeresésére szolgál. A határoló nem szerepel az eredményül kapott sztringekben. Ha a bal operandus üres sztringet jelöl ki, az üres sztringelemet eredményez. Ha a határoló sztring üres sztring, akkor a bemeneti sztringek minden karakterpozíciójában megtalálható.

Alapértelmezés szerint a bemeneti sztringek összes alrésze külön elemként kerül az eredménybe; a felosztási szám azonban használható ennek a viselkedésnek a módosítására. Ha ez a szám negatív, nulla vagy nagyobb, mint egy bemeneti sztring alrészeinek száma, minden alrész külön elembe kerül. Ha ez a szám kisebb, mint a bemeneti sztring alrészeinek száma, az eredményben vannak számelemek, amelyek az első számon túli összes alrészt tartalmazzák – 1 alrészt.

A beállítási sztring nulla vagy több beállításnevet tartalmaz, és az egyes szomszédos párokat vessző választja el egymástól. A rendszer figyelmen kívül hagyja a kezdő, záró és közbeékelt szóközt. A beállításnevek tetszőleges sorrendben lehetnek, és megkülönböztetik a kis- és nagybetűket.

Ha egy beállítási sztring tartalmazza a SimpleMatchbeállításnevet, akkor az is lehetséges, hogy a IgnoreCasebeállításnév is szerepel benne. Ha egy beállítási sztring tartalmazza a beállításnevet RegexMatch, vagy nem tartalmaz RegexMatch vagy SimpleMatch, az SimpleMatchkivételével bármilyen beállításnevet tartalmazhat. Nem tartalmazhat azonban többsoros és egysoros.

Íme a beállításnevek halmaza:

opció Leírás
Kulturától független Figyelmen kívül hagyja a nyelvi különbségeket a határoló kiértékelésekor.
ExplicitCapture Figyelmen kívül hagyja a nem elnevezett egyezéscsoportokat, így csak explicit rögzítési csoportok jelennek meg az eredménylistában.
IgnoreCase Kényszerítse a kis- és nagybetűk érzéketlen egyeztetését, még akkor is, ha -csplit használ.
IgnorePatternWhitespace Figyelmen kívül hagyja a lezáratlan szóközt és a számjellel (#) megjelölt megjegyzéseket.
Többsoros Ez a mód felismeri a sorok és sztringek kezdetét és végét. Az alapértelmezett mód az egysoros.
RegexMatch Használjon reguláris kifejezésmegfeleltetéseket a határoló kiértékeléséhez. Ez az alapértelmezett érték.
SimpleMatch Használjon egyszerű karakterlánc-összehasonlítást a határoló kiértékelésekor.
Egysoros Ez a mód csak a karakterláncok kezdetét és végét ismeri fel. Ez az alapértelmezett mód.

A szkriptblokk (§7.1.8) meghatározza az elválasztó kiválasztásának szabályait, és az eredménynek bool típusúnak kell lennie.

Példák:

"one,forty two,," -split ","              # 5 strings: "one" "forty two" "" ""

"abc","de" -split ""                      # 9 strings: "" "a" "b" "c" "" "" "d" "e" ""

"ab,cd","1,5,7,8" -split ",", 2           # 4 strings: "ab" "cd" "1" "5,7,8"

"10X20x30" -csplit "X", 0, "SimpleMatch"  # 2 strings: "10" "20x30"

"analogous" -split "[AEIOU]", 0, "RegexMatch, IgnoreCase"
                                          # 6 strings: "" "n" "l" "g" "" "s"

"analogous" -split { $_ -eq "a" -or $_ -eq "o" }, 4
                                          # 4 strings: "" "n" "l" "gous"

7.8.4.6 Részeltérések

A -match, -notmatchés -replace által egyeztetett minta zárójelekkel tagolt alrészeket (alrészeket) tartalmazhat. Vegye figyelembe a következő példát:

"red" -match "red"

Az eredmény $true, és a $matches 0. kulcsa "piros" értéket tartalmaz. Ez a bal operandus által kijelölt sztring olyan része, amely pontosan megfelel a jobb operandus által kijelölt mintának.

Az alábbi példában az egész minta egy részilleszkedés:

"red" -match "(red)"

Ahogyan korábban, a 0. kulcs "piros" értéket tartalmaz; az 1. kulcs azonban szintén "piros" szót tartalmaz, amely a bal operandus által kijelölt szövegrész, amely pontosan megfelelt az alegyeztetésnek.

Vegye figyelembe a következő, összetettebb mintát:

"red" -match "((r)e)(d)"

Ez a minta lehetővé teszi a "re", "r", "d" vagy "red" részegyezéseket.

A 0. kulcs ismét "piros" értéket tartalmaz. Az 1. kulcs az "re", a 2. kulcs az "r", a 3. kulcs pedig a "d" értéket tartalmazza. A kulcs-érték párok a mintában balról jobbra megfelelő sorrendben vannak, a hosszabb karakterláncegyezésekkel megelőzve a rövidebbeket.

Az -replaceesetén a helyettesítő szöveg az $nűrlap neveivel érheti el az alösszetűket, ahol az első egyezés $1, a második $3stb. Például

"Monday morning" -replace '(Monday|Tuesday) (morning|afternoon|evening)','the $2 of $1'

Az eredményül kapott szöveg "hétfő reggele".

Ahelyett, hogy a kulcsok $matches nulla alapú indexekként működnének, az alkulcsokat el is nevezhetjük a ?<*name*>formátumot használva. A "((r)e)(d)" például három elnevezett alegységgel, m1, m2és m3írható le az alábbiak szerint: "(?<m1>(?<m2>r)e)(?<m3>d)".

7.8.5 Műszak operátorai

Szintaxis:

shift-operator: one of
    dash shl
    dash shr

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Leírás:

A balra tolás (-shl) és a jobbra tolás (-shr) operátor a bal operandus által megjelölt értéket egész számtípussá, a jobb operandus által meghatározott értéket pedig szükség esetén int típusúvá alakítja a szokásos számtani átalakításokkal (§6.15).

A bal oldali shift operátor az alábbiak szerint kiszámított bitszámmal balra mozgatja a bal operandust. Az alacsony sorrendű üres bitpozíciók nullára vannak állítva.

A shift right operátor az alábbiak szerint kiszámított bitszámmal jobbra mozgatja a bal operandust. A bal operandus alacsonyrendű bitjei el lesznek vetve, a többi bit jobbra tolódik el. Ha a bal operandus aláírt érték, a magas sorrendű üres bitpozíciók nullára vannak állítva, ha a bal operandus nem negatív, és egyre van állítva, ha a bal operandus negatív. Ha a bal operandus egy aláíratlan érték, a magas sorrendű üres bitpozíciók nullára vannak állítva.

Ha a bal operandus int típusú, a műszakok számát a jobb operandus alacsony sorrendű öt bitje adja meg. Ha a jobb operandus típusa hosszú, az eltolás számát a jobb operandus alacsonyabb rendű hat bitje határozza meg.

Példák:

0x0408 -shl 1             # int with value 0x0810
0x0408 -shr 3             # int with value 0x0081
0x100000000 -shr 0xfff81  # long with value 0x80000000

7.9 Bitenkénti operátorok

Szintaxis:

bitwise-expression:
    unary-expression -band new-lines~opt~ unary-expression
    unary-expression -bor new-lines~opt~ unary-expression
    unary-expression -bxor new-lines~opt~ unary-expression

Leírás:

A bitenkénti ÉS operátor -band, a bitenkénti VAGY operátor -bor, a bitenkénti XOR operátor pedig -bxor az operandusok által kijelölt értékeket egész számtípussá konvertálni, ha szükséges, a szokásos számtani átalakításokkal (§6.15). Az átalakítás után, ha mindkét érték int típusú, akkor az eredmény típusa. Ellenkező esetben, ha mindkét érték hosszú, akkor ez az eredmény típusa. Ha az egyik érték típusa int, a másik pedig long, az eredmény típusa long. Ellenkező esetben a kifejezés formázatlan. Az eredmény az esetleg átalakított operandusértékek bitenkénti ÉS, bitenkénti VAGY vagy bitenkénti XOR értéke.

Ezek az operátorok asszociatívak. Inmutatívak, ha egyik operandus sem tartalmaz mellékhatást.

Példák:

0x0F0F -band 0xFE    # int with value 0xE
0x0F0F -band 0xFEL   # long with value 0xE
0x0F0F -band 14.6    # long with value 0xF

0x0F0F -bor 0xFE     # int with value 0xFFF
0x0F0F -bor 0xFEL    # long with value 0xFFF
0x0F0F -bor 14.40D   # long with value 0xF0F

0x0F0F -bxor 0xFE    # int with value 0xFF1
0x0F0F -bxor 0xFEL   # long with value 0xFF1
0x0F0F -bxor 14.40D  # long with value 0xF01
0x0F0F -bxor 14.6    # long with value 0xF00

7.10 Logikai operátorok

Szintaxis:

logical-expression:
    unary-expression -and new-lines~opt~ unary-expression
    unary-expression -or new-lines~opt~ unary-expression
    unary-expression -xor new-lines~opt~ unary-expression

Leírás:

A logikai ÉS operátor -and átalakítja az operandusok által jelölt értékeket bool, ha szükséges (§6.2). Az eredmény a lehetségesen átalakított operandusértékek logikai ÉS értéke, és booltípussal rendelkezik. Ha a bal operandus hamis értéket ad ki, a jobb operandus nem lesz kiértékelve.

A logikai VAGY operátor -or átalakítja az operandusai által kijelölt értékeket bool, ha szükséges (§6.2). Az eredmény az esetlegesen átalakított operandusértékek logikai VAGY műveletéből származik, és booltípusú. Ha a bal operandus Igaz értékre van kiértékelve, a jobb operandus nem lesz kiértékelve.

A logikai XOR operátor -xor az operandusok által kijelölt értékeket bool (§6.2) értékké alakítja. Az eredmény a lehetségesen átalakított operandusértékek logikai XOR-értéke, és booltípussal rendelkezik.

Ezek az operátorok asszociatívak.

Példák:

$j = 10
$k = 20
($j -gt 5) -and (++$k -lt 15)   # True -and False -> False
($j -gt 5) -and ($k -le 21)     # True -and True -> True
($j++ -gt 5) -and ($j -le 10)   # True -and False -> False
($j -eq 5) -and (++$k -gt 15)   # False -and True -> False

$j = 10
$k = 20
($j++ -gt 5) -or (++$k -lt 15)  # True -or False -> True
($j -eq 10) -or ($k -gt 15)     # False -or True -> True
($j -eq 10) -or (++$k -le 20)   # False -or False -> False

$j = 10
$k = 20
($j++ -gt 5) -xor (++$k -lt 15) # True -xor False -> True
($j -eq 10) -xor ($k -gt 15)    # False -xor True -> True
($j -gt 10) -xor (++$k -le 25)  # True -xor True -> False

7.11 Hozzárendelési operátorok

Szintaxis:

assignment-expression:
    expression assignment-operator statement

assignment-operator: *one of
    =   dash =   +=   *=   /=   %=

Leírás:

A hozzárendelési operátor a kifejezésáltal kijelölt írható helyen tárolja az értéket. A hozzárendelés-operátor=§7.11.1. Az összes többi hozzárendelési operátor megbeszéléséhez lásd a §7.11.2.

A hozzárendelési kifejezés kifejezés által a hozzárendelés végrehajtása után megadott értékkel rendelkezik; ez a hozzárendelési kifejezés azonban maga nem jelöl ki írható helyet. Ha kifejezés típuskorlátozással (§5.3), akkor a kényszerben használt típus az eredmény típusa; ellenkező esetben az eredmény típusa a szokásos számtani átalakítások (6.15.) alkalmazása utáni típus.

Ez az operátor megfelelő asszociatív.

7.11.1 Egyszerű hozzárendelés

Leírás:

egyszerű hozzárendelési (=) esetén az utasítás által kijelölt érték a kifejezésáltal kijelölt írható helyen tárolt értéket helyettesíti. Ha azonban kifejezés nem létező kulcsot jelöl ki egy Hash táblában, akkor a rendszer hozzáadja a kulcsot a Hash táblához azzal az értékkel, amelyet az utasításhatároz meg.

Ahogy a nyelvtan is mutatja, kifejezés vesszővel tagolt listát jelölhet ki a írható helyekről. Ez többszörös hozzárendelésnéven ismert. utasítás egy vagy több vesszővel elválasztott érték listáját jelöli ki. Az operandusok listájában szereplő vesszők a többszörös hozzárendelés szintaxisának részei, és nem a bináris vessző operátort jelölik. Az értékek az utasításáltal kijelölt listából származnak, lexikális sorrendben, és az kifejezésáltal kijelölt írható helyen vannak tárolva. Ha a utasítás által kijelölt lista kevesebb értékkel rendelkezik, mint kifejezés írható helyek, a felesleges helyek a $nullértéket veszik fel. Ha a utasítás által kijelölt lista több értékkel rendelkezik, mint kifejezés írható helyek, a jobb oldali kifejezés helyétől eltérően a megfelelő utasítás értéket veszi fel, és a jobb szélső kifejezés helye egy nem behatárolt 1 dimenziós tömb lesz, amelyben az összes fennmaradó utasítás elemként értéket.

Azokban az esetekben, amikor az állításoknak értékei vannak (§8.1.2), a állítás lehet állítás.

Példák:

$a = 20; $b = $a + 12L             # $b has type long, value 22
$hypot = [Math]::Sqrt(3*3 + 4*4)   # type double, value 5
$a = $b = $c = 10.20D              # all have type decimal, value 10.20
$a = (10,20,30),(1,2)              # type [object[]], Length 2
[int]$x = 10.6                     # type int, value 11
[long]$x = "0xabc"                 # type long, value 0xabc
$a = [float]                       # value type literal [float]
$i,$j,$k = 10,"red",$true          # $i is 10, $j is "red", $k is True
$i,$j = 10,"red",$true             # $i is 10, $j is [object[]], Length 2
$i,$j = (10,"red"),$true           # $i is [object[]], Length 2, $j is True
$i,$j,$k = 10                      # $i is 10, $j is $null, $k is $null

$h = @{}
[int] $h.Lower, [int] $h.Upper = -split "10 100"

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1.Dept = "Finance"               # adds element Finance
$h1["City"] = "New York"           # adds element City

[int]$Variable:v = 123.456         # v takes on the value 123
${E:output.txt} = "a"              # write text to the given file
$Env:MyPath = "x:\data\file.txt"   # define the environment variable
$Function:F = { param ($a, $b) "Hello there, $a, $b" }
F 10 "red"                         # define and invoke a function
function Demo { "Hi there from inside Demo" }
$Alias:A = "Demo"                  # create alias for function Demo
A                                  # invoke function Demo via the alias

7.11.2 Összetett hozzárendelés

Leírás:

Az összetett hozzárendelési alakja E1 op= E2, és egyenértékű az egyszerű hozzárendelési kifejezéssel E1 = E1 op (E2), azzal a különbséggel, hogy az összetett hozzárendelési esetben az E1 kifejezés csak egyszer lesz kiértékelve. Ha a kifejezés típuskorlátozással van (§5.3), akkor a korlátozásban használt típus az eredmény típusa; ellenkező esetben az eredmény típusát a művelethatározza meg. A *=lásd: §7.6.1, §7.6.2, §7.6.3; /=lásd 7.6.4. %=lásd 7.6.5. +=lásd §7.7.1, §7.7.2, §7.7.3; -=lásd: §7.7.5.

Jegyzet

Előfordulhat, hogy egy numerikus típusú, nem korlátozott értéket kijelölő operandus típusát egy hozzárendelési operátor módosítja az eredmény tárolásakor.

Példák:

$a = 1234; $a *= (3 + 2)  # type is int, value is 1234 * (3 + 2)
$b = 10,20,30             # $b[1] has type int, value 20
$b[1] /= 6                # $b[1] has type double, value 3.33...

$i = 0
$b = 10,20,30
$b[++$i] += 2             # side effect evaluated only once

[int]$Variable:v = 10     # v takes on the value 10
$Variable:v -= 3          # 3 is subtracted from v

${E:output.txt} = "a"     # write text to the given file
${E:output.txt} += "b"    # append text to the file giving ab
${E:output.txt} *= 4      # replicate ab 4 times giving abababab

7.12 Átirányítási operátorok

Szintaxis:

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

redirections:
    redirection
    redirections redirection

redirection:
    merging-redirection-operator
    file-redirection-operator redirected-file-name

redirected-file-name:
    command-argument
    primary-expression

file-redirection-operator: one of
    >   >>   2>   2>>   3>   3>>   4>   4>>
    5>  5>>  6>   6>>   >    >>    <

merging-redirection-operator: one of
    >&1   2>&1   3>&1   4>&1   5>&1   6>&1
    >&2   1>&2   3>&2   4>&2   5>&2   6>&2

Leírás:

Az átirányítási operátor > a folyamat szokásos kimenetét veszi át, és átirányítja a átirányított fájlnéváltal kijelölt helyre, felülírva a hely aktuális tartalmát.

Az átirányítási operátor >> a folyamat szokásos kimenetét veszi át, és átirányítja a átirányított fájlnéváltal kijelölt helyre, ha van ilyen, hozzáfűzve az adott hely aktuális tartalmához. Ha ez a hely nem létezik, létrejön.

Az n> formátumú átirányítási operátor a csővezetékben lévő n adatfolyam kimenetét veszi át, és átirányítja a átirányított fájlnéváltal kijelölt helyre, felülírva az adott hely aktuális tartalmát.

A n>> formával rendelkező átirányítási operátor a csővezetékből az n adatfolyam kimenetét veszi át, és átirányítja azt a átirányított fájlnéváltal kijelölt helyre, hozzáfűzve az adott hely aktuális tartalmához, ha van. Ha ez a hely nem létezik, létrejön.

Az m>&n űrlapot tartalmazó átirányítási operátor kimenetet ír a streamből m ugyanarra a helyre, mint a stream n.

Az érvényes streamek a következők:

Áramlat Leírás
1 Standard kimeneti adatfolyam
2 Hibaüzenet-folyam
3 Figyelmeztető kimeneti folyam
4 Részletes kimeneti adatfolyam
5 Hibakeresési kimeneti adatfolyam
* Standard kimenet, hibakimenet, figyelmeztető kimenet, részletes kimenet és hibakeresési kimeneti streamek

Az átirányítási operátorok 1>&2, 6>, 6>> és < jövőbeli használatra vannak fenntartva.

Ha a kimeneten átirányított fájlnév értéke $null, a kimenet el lesz dobva.

Általában a legfelső szintű mellékhatást tartalmazó kifejezések értéke nem íródik a folyamatba, kivéve, ha a kifejezés zárójelpárba van zárva. Ha azonban egy ilyen kifejezés egy szabványos kimenetet átirányító operátor bal operandusa, az érték meg lesz írva.

Példák:

$i = 200                       # pipeline gets nothing
$i                             # pipeline gets result
$i > output1.txt               # result redirected to named file
++$i >> output1.txt            # result appended to named file
type file1.txt 2> error1.txt   # error output redirected to named file
type file2.txt 2>> error1.txt  # error output appended to named file
dir -Verbose 4> verbose1.txt   # verbose output redirected to named file

# Send all output to output2.txt
dir -Verbose -Debug -WarningAction Continue *> output2.txt

# error output redirected to named file, verbose output redirected
# to the same location as error output
dir -Verbose 4>&2 2> error2.txt