7. Kifejezések

Szintaxis:

expression:
    logical-expression

Leírás:

A kifejezés operátorok és operandusok sorozata, amelyek metódust, függvényt, írható helyet vagy értéket jelölnek ki; az érték számítását adja meg; egy vagy több mellékhatást hoz létre; vagy valamilyen kombinációt hajt végre. Példa:

• A 123-as literál egy olyan kifejezés, amely az int 123 értéket jelöli.
• A kifejezés 1,2,3,4 kijelöli a 4 elemű tömbobjektumot, amelynek az értékei megjelennek.
• A kifejezés 10.4 * $a számítást ad meg.
• A kifejezés $a++ mellékhatást hoz létre.
• A kifejezés $a[$i--] = $b[++$j] ezek kombinációját végzi el.

Egyes operátorok kivételével a kifejezések kifejezésben való kiértékelési sorrendje és a mellékhatások sorrendje sem lesz meghatározva. Nem meghatározott viselkedés például a következők: $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ípusokhoz, és ezekhez a típusokhoz meghatározott műveletek is lehetnek definiálva. Az ilyen típusok és műveletek minden részlete definiálva van.

A legfelső szintű kifejezés nem része egy nagyobb kifejezésnek. Ha egy legfelső szintű kifejezés tartalmaz egy mellékhatás-operátort, a kifejezés értéke nem lesz beírva a folyamatba; ellenkező esetben igen. Erről részletesen a 7.1.1-es cikk nyújt részletes tájékoztatást.

A gyűjteményt kijelölő kifejezéseket (*4) általában a rendszer az azt alkotó elemekbe sorolja, amikor az adott kifejezés értékét használja. Ez azonban nem így van, ha a kifejezés egy parancsmag meghívása. Példa:

$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

Az operátor első $(...) $x``int int két használatában a gyűjteményt megtervező kifejezés a változó, amely három érték, valamint a 99 érték számbavétele. A harmadik esetben azonban a kifejezés egy parancsmag közvetlen hívása, így az eredmény nem lesz enumerálva, $a és két elemből álló tömb, int[3] a és inta .

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

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:

Tipp

A ~opt~ szintaxisdefiníciókban a jel 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 ugyanaz, mint a zárójelek nélküli kifejezésé. 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 és a például $x.m egyenértékű ($x).m .

A zárójelek csoportosítása kifejezésekben használható a kifejezésen belüli alapértelmezett elsőbbség és asszociativitás dokumentálása érdekében. Az alapértelmezett elsőbbség és az asszociativitás felülbírálása is használható. Példa:

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

A zárójelek legfelső szintű csoportosítása általában redundáns. Ez azonban nem mindig így van. Tekintse meg 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 módosítják a szemantikát, ami egy tömböt eredményez, amelynek két eleme egy 2 int tömb, a skaláris int 6.

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 harmadik esetben az eredmény értéke a folyamatba lesz írva. Bár a második esetben a kifejezés kiértékelése meg van írva, a rendszer nem írja az eredményt a folyamatba a mellékhatás operátor = a legfelső szinten való jelenléte miatt. (A rész eltávolítása $a = lehetővé teszi az érték írását, mivel * az nem egy mellékhatás-operátor.)

Ha meg szeretné akadályozni, hogy egy olyan kifejezés értéke, amely nem tartalmaz legfelső szintű mellékhatást, ne íródott a folyamatba, explicit módon vesse el az alábbiak szerint:

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

A folyamatba való íráshoz a legfelső szintű mellékhatásokat tartalmazó kifejezések értékét zárójelek közé kell írni az alábbiak szerint:

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

Ebben az esetben a csoportosítási zárójelek nem redundánsak.

A következő példában változóhelyettesítést (rendszerünk 2.3.5.2) követ egy sztring-literálban:

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

Az első esetben a zárójelek a részkifejezés elválasztóit jelentik, amelyek nem zárójeleket csoportosítnak, és mivel a felső szintű kifejezés egy mellékhatás operátort tartalmaz, a kifejezés értéke nem lesz beírva a folyamatba. A és a karakter > < természetesen továbbra is meg van írva.) Ha csoportosítási zárójeleket ad hozzá – a második esetben látható módon –, az írás engedélyezve van.

Az alábbi példák legfelső 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 legfelső szintű mellékhatásokat nem tartalmazó kifejezések zárójelek köré való csoportosítása redundánssé teszi ezeket a zárójeleket. Például:

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

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

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

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

7.1.2 Tagi hozzáférés

Szintaxis:

member-access: Note no whitespace is allowed after primary-expression. 
    primary-expression . member-name
    primary-expression :: member-name

Leírás:

Az operátorral . egy példánytag választható ki egy objektumból, vagy egy kulcsból Hashtable. A bal oldali operandusnak ki kell jelölnie egy objektumot, a jobb oldali operandusnak pedig egy hozzáférhető példánytagot kell kijelölnie.

A jobb oldali operandus kijelöl egy akadálymentes példánytagot a bal oldali operandus által kijelölt objektum típusán belül, vagy – ha a bal oldali operandus tömböt jelöl ki – a jobb oldali operandus kijelöli az elérhető példánytagokat a tömb minden elemében.

A szóköz nem engedélyezett az operátor . előtt.

Ez az operátor asszociatív marad.

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

A szóköz nem engedélyezett az operátor :: előtt.

Ez az operátor asszociatív marad.

Ha a jobb oldali operandus írható helyet jelöl ki a bal oldali 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: Note no whitespace is allowed after primary-expression. 
    primary-expression . member-name argument-list
    primary-expression :: member-name argument-list

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

Leírás:

Az invocation-expression az elsődleges-kifejezés által kijelölt metódust hívja meg. tag-név vagy elsődleges-kifejezés::tag-név. Az argumentum-lista zárójelei valószínűleg üres, vesszővel elválasztott kifejezéslistát tartalmaznak, amely azokat az argumentumokat jelöli, amelyeknek az értékei át vannak küldve a metódusnak. A metódus hívata előtt a rendszer kiértékeli és konvertálja az argumentumokat a -6 szabályának megfelelően, hogy megfeleljen a metódus által várt típusoknak. Az elsődleges kifejezés kiértékelési sorrendje. tag-név, elsődleges-kifejezés::tag-név, és az argumentumok nincs meghatározva.

Ez az operátor asszociatív marad.

Az invocation-expression eredményének típusa egy metódustervező ([].4.5.24]§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 elérése

Szintaxis:

element-access: Note no whitespace is allowed between primary-expression and [.
    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 indexe

Leírás:

A tömbök részletesen a következőben vannak részletezve: .9. Ha a kifejezés egy egydimenziós tömb, lásd: .7.1.4.5.

Ha az elsődleges-kifejezés egy 1 dimenziós A tömböt jelöl ki, [] A[0 + expression] az operátor a következő helyen található elemet adja vissza: , miután a kifejezés értékké lett konvertálvaint. Az eredményben a feliratkozás alatt található tömb elemtípusa van. Ha a kifejezés negatív, A[expression] a a helyen található elemet jelöli A[A.Length + expression].

Amikor az elsődleges-kifejezés egy kétdimenziós B tömböt jelöl ki, [] B[0 + row,0 + column] az operátor visszaadja a következő helyen található elemet: , miután a kifejezés sor- és oszlopösszetevői (amelyek vesszővel elválasztott listaként vannak megadva) intértékké konvertálva. Az eredményben a feliratkozás alatt található tömb elemtípusa van. Az 1 dimenziós tömböktől eltérően a negatív pozícióknak nincs különleges jelentése.

Ha az elsődleges-kifejezés egy három vagy több dimenziót tartalmazó tömböt jelöl ki, a kétdimenziós tömbökre vonatkozó szabályok és a dimenziópozíciók értékek vesszővel elválasztott listájaként vannak megadva.

Ha egy nem létező elem olvasási hozzáférését kísérelik meg, az eredmény .$null Nem létező elembe való írási hiba.

Többdimenziós tömbhöz való alárendelt indexkifejezések a dimenziópozíciós kifejezések kiértékelési sorrendjének nincs meghatározva. Például egy 3 dimenziós tömbben $a``$a[$i++,$i,++$i] a viselkedése nincs meghatározva.

Ha a kifejezés egy tömb, tekintse meg a következőt: .7.1.4.5.

Ez az operátor asszociatív marad.

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 egy nem létező elem írási hozzáférését kísérelik meg, indexOutOfRange kivételt hoz létre.

7.1.4.2 Sztringek indexbe való besorolása

Leírás:

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

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 Kivonattábla subscripting (7.1.4.3)

Leírás:

Amikor az elsődleges-kifejezés hashtable-t jelöl ki, [] az operátor visszaadja a kifejezés által kijelölt kulcs(oka)hez társított értéket/ értékeket. A kifejezés típusa nincs korlátozva.

Ha a kifejezés egyetlen kulcsnév, az eredmény a társított érték, és a típusa , kivéve, ha nem létezik ilyen kulcs, amely esetben az eredmény $null. Ha $null a kulcsként van használva, a viselkedés implementációja definiálva van. Ha a kifejezés kulcsnevek tömbje, lásd: .7.1.4.5.

Ha a kifejezés egy tömb, tekintse meg a következőt: .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, $null és a hashtable-indexek egyetlen értékeként van használva, NullArrayIndex kivételt vált ki a függvény.

7.1.4.4 XML-dokumentum indexbe való besorolása

Leírás:

Ha az elsődleges-kifejezés xml típusú objektumot jelöl ki, a rendszer szükség esetén sztringgé konvertálja a kifejezést, [] és az operátor visszaadja az első gyermekelemet, amelynek a neve meg van adva az kifejezéssel. A kifejezés típusának sztringnek kell lennie. Az eredmény típusa implementáció definiálva van. Az eredmény az első gyermekelem visszaadás érdekében alsó indexbe is be lehet ásni. Ha nem létezik gyermekelem a kifejezés által megadott névvel, az eredmény .$null Az eredmény nem írható helyet jelöl ki.

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 vagy System.Xml.XmlElement System.String.

7.1.4.5 Tömbszeletek létrehozása

When primary-expression designates an object of a type that is enumerable (§4) or a Hashtable, and expression is a 1-dimensional array, the result is an array slice (§9.9) containing the elements of primary-expression designated by the elements of expression.

Kivonattábla esetén a tömbszelet tartalmazza a megadott kulcsokhoz társított értékeket, kivéve, ha nem létezik ilyen kulcs, amely esetben a megfelelő elem $nulla . Ha $null a bármilyen kulcsnévként van használva, a viselkedés implementációja definiálva van.

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[1,3,5][1]            # preincrement 60 in array 40,60,80
$a[,5]                    # slice with Length 1
$a[@()]                   # slice with Length 0
$a[-1..-3]                # slice with Length 0, 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 1 (123)

Windows PowerShell: Ha a kifejezés két vagy több kulcsnév gyűjteménye, $null akkor a rendszer figyelmen kívül hagyja ezt a kulcsot, és nem rendelkezik megfelelő elemmel az eredményül kapott tömbben.

7.1.5 Utótag-növelés és -növelés operátorok

Szintaxis:

post-increment-expression:
    primary-expression ++

post-decrement-expression:
    primary-expression dashdash

dashdash:
    --

Leírás:

The primary-expression must designate a writable location having a value of numeric type (§4) or the value $null. Ha az operandus által $nullkijelölt érték , akkor a rendszer az értéket int típusra és nulla értékre konvertálja az operátor kiértékelése előtt. Az elsődleges kifejezés által kijelölt érték típusa az eredmény tárolásakor változhat. See §7.11 for a discussion of type change via assignment.

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

A postfix operátor által előállított eredmény -- az operandus által kijelölt érték. Az eredmény lekért értéke után az operandus által kijelölt értéket a megfelelő típus 1-ével kell leírni. A kifejezés eredményének típusa E-- megegyezik E - 1 a kifejezés eredményének típusától (").7.7).

Ezek az operátorok asszociatívak maradnak.

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 bahavior

$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 a statement-list nincs megadva, az eredmény .$null Ellenkező esetben a statement-list lesz kiértékelve. A kiértékelés részeként a folyamatba írt objektumokat a rendszer egy nem korlátozott, 1 dimenziós tömbben gyűjti össze 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, hogy az elem; Ellenkező esetben az eredmény a begyűjtött eredmények nem korlátozott 1 dimenziós tömbje lesz.

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 az statement-list nincs megadva, az eredmény egy nulla hosszúságú, nem korlátozott, 1 dimenziós tömb. Ellenkező esetben a rendszer kiértékeli az utasításlistát, és a folyamatba a kiértékelés részeként írt objektumokat egy nem korlátozott, 1 dimenziós tömbben gyűjti össze a rendszer sorrendben. Az eredmény az (esetleg üres) nem korlátozott 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 Szkript blokkkifejezése

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-block is described in §8.10.9. named-block-list is described in §8.10.7.

A szkriptblokk egy egyetlen egységként használható utasítások név nélküli blokkja. A szkriptblokkok használatával úgy hívható meg egy kódblokk, mintha egyetlen parancs lenne, vagy a végrehajtható változókhoz is hozzárendelhetőek.

A rendszer végrehajtja a named-block-list vagy statement-list parancsot, és az eredmény típusa és értéke(i) az utasításkészletek eredményeinek típusa és értéke(i).

A script-block-expression a scriptblock típussal rendelkezik (").4.3.7).

Ha a param-block nincs megadva, $args a szkriptblokknak átadott argumentumok a következőn keresztül érhetők el : (").8.10.1).

A paraméterkötés során a szkriptblokkok parancsfájlblokk-objektumként vagy a szkriptblokk kiértékelése utáni eredményként is átküldhetőek. See §6.17 for further information.

7.1.9 Kivonat literális 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 kivonat-literál-kifejezés nulla vagy több elemből áll kivonattáblát (expression 10) hoz létre, amelyek mind kulcs/érték párok.

A kulcsnak a null típuson kívül bármilyen típusa lehet. A társított értékeknek bármilyen típusa lehet, beleértve a null típust is, és ezek az értékek lehetnek bármely olyan kifejezés, amely kijelöli a kívánt értéket, beleértve a értéket is $null.

A kulcs/érték párok sorrendbe rendelése 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 létrehoz két kivonattáblát ( $h1 és $h2) is, amelyek mind három kulcs/érték párt tartalmaznak, és egy harmadik , $h3amely üres. A kivonattábla $h4 különböző típusú kulcsokkal rendelkezik.

7.1.10 Típus literális kifejezés

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ípus-literálokat egy implementációban egy nem meghatározott mögöttes típus képviseli. Ennek eredményeképpen a típusnév az alapul szolgáló típus szinonimája.

A típus-literálok több kontextusban is használhatók:

• Explicit konverzió megadása (*6, 7.2.9)
• Típus által korlátozott tömb létrehozása (rendszer 9.4)
• Egy objektum statikus tagjainak elérése (*7.1.2)
• Típusmegkötés megadása egy változóra (ft.5.3) vagy függvényparaméterre (*8.10.2)

Példák:

Példák a típusú literálok típusra: [int], [object[]és [int[,,]]. A sztringek számára speciális általános veremtípus (a 4.4-es), [Stack[string]]``int a pedig egy általános szótártípus, amely a társított sztringértékekkel társított kulcsokra van specializált, a következőként írható meg: [Dictionary[int,string]].

A típus-literál típusa .System.Type A fent javasolt típus teljes Stack[string] neve System.Collections.Generic.Stack[int]. A fent javasolt típus teljes Dictionary[int,string] neve System.Collections.Generic.Dictionary[int,string].

7.2 Unáris 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

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

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

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

cast-expression:
    type-literal unary-expression

dashdash:
    dash dash

7.2.1 Unáris vessző operátor

Leírás:

Ez az operátor létrehoz egy nem korlátozott 1 dimenziós tömböt, amely egy elemmel rendelkezik, amelynek típusa és értéke az unáris-kifejezésé.

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

Leírás:

A -not operátor szükség esetén bool (a 6.2) típusra konvertálja az unáris-kifejezés által kijelölt értéket, és ennek a típusnak az eredményét állítja elő. Ha az unáris-kifejezés értéke Igaz, az eredmény Hamis, és fordítva. A operátor! A egy alternatív helyesírás a -not helyett.

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 Bitwise NOT

Leírás:

A -bnot operátor szükség esetén egész szám típusúvá (("6.4) konvertálja az unáris-kifejezés által kijelölt értéket. Ha a konvertált érték az int típusban is ábrázolható, akkor ez az eredmény típusa. Ha a konvertált érték hosszú típussal is ábrázolható, akkor ez az eredmény típusa. Ellenkező esetben a kifejezés nem megfelelő. Az eredményül kapott érték a konvertált érték egy-egy kiegészítése.

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 Unáris plusz

Leírás:

A +unáris-kifejezés űrlap kifejezését a rendszer úgy kezeli, mintha a következőként íródott volna: 0 + unary-expression (").7.7). A 0 egész szám típusú literál típussal rendelkezik int.

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 Unáris mínusz

Leírás:

Az -unáris-kifejezés űrlap kifejezését a rendszer úgy kezeli, mintha a következőként íródott volna: 0 - unary-expression (").7.7). A 0 egész szám típusú literál típussal rendelkezik int.

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övelés és -növelés operátorok

Leírás:

Az unáris-kifejezésnek ki kell jelölnie egy írható helyet, amelynek numerikus típusa (:)4) vagy értéke .$null Ha az unáris-kifejezése által kijelölt érték , a unáris-kifejezés$null értéke int típusra és nulla értékre lesz konvertálva az operátor kiértékelése előtt.

Megjegyzés

Az unáris-kifejezés által kijelölt érték típusa megváltozhat az eredmény tárolásakor. See §7.11 for a discussion of type change via assignment.

Az előtag operátor ++ esetében az unáris-kifejezés értéke a megfelelő típus 1-ével növekszik. Az eredmény az új érték a növekményes növelés után. A kifejezés ++E egyenértékű a következővelE += 1: (").7.11.2).

Az előtag operátor -- esetében az unáris-kifejezés értékét a megfelelő típus 1-ével kell visszaszorni. Az eredmény az új érték, miután a igazításra került sor. A kifejezés --E egyenértékű a következővelE -= 1: (").7.11.2).

Ezek az operátorok helyes társítások.

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

7.2.7 Az unáris -join operátor

Leírás:

Az unáris operátor -join olyan sztringet állít elő, amely egy egykifejezéssel kijelölt egy vagy több objektum értékének össze van va. (Elválasztó ennek az operátornak a bináris verziójával szúrható be (").7.8.4.4).)

Az unáris-kifejezés lehet skaláris érték vagy gyűjtemény.

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 unáris -split operátor

Leírás:

Az unáris -split operátor feloszt egy vagy több, unáris-kifejezés által kijelölt sztringet, és az alrészeket egy korlátozott, 1 dimenziós sztringtömbben adja vissza. A térköz karakterek minden összefüggő csoportját elválasztóként kezeli az egymást követő alrészek között. (Explicit elválasztó sztring ennek az operátornak a bináris verziójával (azaz 7.8.4.5) is megadva lehet.) Ennek az operátornak két változata van (").7.8).

Az elválasztó szöveg nem szerepel az eredményül kapott sztringek között. A bemeneti sztring kezdő és záró szóközét a rendszer figyelmen kívül hagyja. Egy üres vagy üres szóközt tartalmazó bemeneti sztring csak egy sztringből álló tömböt ad vissza, amely üres.

Az unáris-kifejezés skaláris értéket vagy sztringtömböt jelölhet ki.

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 Cast operátor

Leírás:

Ez az operátor explicit módon (("6") konvertálja az unáris-kifejezés által kijelölt értéket a típus-literál által kijelölt típusra. Ha a típus-literál nem void, akkor az eredmény típusa a nevesített típus, az érték pedig az átalakítás utáni érték. Ha a type-literal érvénytelen, a folyamat nem ír objektumot, és nincs eredmény.

Ha bármilyen típusú kifejezést ugyanolyan típusúra ír át, az eredményül kapott típus és érték az unáris-kifejezés tí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 vessző operátor

Szintaxis:

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

Leírás:

A bináris vessző operátor egy egydimenziós tömböt hoz létre, amelynek elemei az operandusai által kijelölt é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

Ha zárójeleket ad néhány bináris vessző kifejezéshez, az nem dokumentálja az alapértelmezett sorrendet; ehelyett az eredményt módosítja.

7.4 Tartomány operátor

Szintaxis:

range-expression:
array-literal-expression
range-expression *..* new-lines~opt~
array-literal-expression

Leírás:

A tartomány-kifejezés létrehoz egy nem korlátozott 1 dimenziós tömböt, amelynek elemei a tartományhatárok által megadott int sorozat értékei. Az operandusok által kijelölt értékeket a rendszer szükség esetén int értékké konvertálja (").6.4). Az alacsonyabb értéket az átalakítás után az operandus az alsó, az operandus pedig a magasabb értéket a konverzió után megtervezése a felső határ. Mindkét határ azonos lehet, ebben az esetben az eredményül kapott tömb hossza 1. Ha a bal oldali operandus az alsó korlátot jelöli, a sorozat növekvő sorrendben van. Ha a bal oldali operandus jelöli a felső határt, a sorozat csökkenő sorrendben lesz.

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

A tartomány-kifejezés tömbszelet megadására használható (").9.9).

Példák:

1..10        # ascending range 1..10
-500..-495   # descending range -500..-495
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:
    range-expression
    format-expression 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átum-kifejezés egy vagy több, tartomány-kifejezés által kijelölt értéket formáz egy formátumspecifikációs sztringnek megfelelően, amelyet a formátum-kifejezés jelöl ki. A tartomány-kifejezés által kijelölt értékek pozíciói nullától kezdődően vannak megszámzva, és lexikális sorrendben növekednek. Az eredmény típusa string.

A formátumspecifikációs sztring nulla vagy több formátumspecifikációt tartalmazhat, amelyek mindegyikének formátuma a következő:

{N [ ,M ][ : FormatString ]}

Az N egy (kötelező) tartomány-kifejezés értékpozíciót, az M a minimális megjelenítési szélességet jelöli, a FormatString pedig a (nem kötelező) formátumot. Ha egy formázott érték szélessége meghaladja a megadott szélességet, a szélesség ennek megfelelően nő. Azok az értékek, amelyek pozícióira nem hivatkozik a FormatStringben , figyelmen kívül lesz hagyva, miután a rendszer kiértékeli a mellékhatásokat. Ha az N nem létező pozícióra hivatkozik, a viselkedés definiálva van. A típus és $null a void érték üres sztringekként van formázva. A tömbök a következő formátumban vannak formázva: részkifejezés (").7.1.6). Ha a "{" és a "}" karaktereket formátumelválasztóként való értelmezésük nélkül is bele kell foglalni egy formátumspecifikációba, írja őket "{{" és "}}" formátumban.

A formátumsértelmek teljes definícióját System.IFormattable az Ecma Technical Report TR/84 típusában láthatja.

Példák:

`$i` = 10; $j = 12
"{2} <= {0} + {1}\`n" -f $i,$j,($i+$j)  # 22 <= 10 + 12
">{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 % <
$format = ">{0:x8}<"
$format -f 123455                       # >0001e23f<

Egy formátumspecifikációban, ha az N nem létező pozícióra hivatkozik, a FormatError megemelked.

7.6 Szorzó operátorok

Szintaxis:

multiplicative-expression:
    format-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ás * operátor eredménye a két operandus által a szokásos aritmetikai konverziók (*6.15) alkalmazása után kijelölt értékek szorzása.

Ez az operátor asszociatív marad.

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 Sztringreplikáció

Leírás:

Amikor a bal oldali operandus * kijelöl egy sztringet, a bináris operátor létrehoz egy új sztringet, amely a bal oldali operandus által kijelölt sztringet tartalmazza, és a jobb oldali operandus értéke által jelölt időket egész szám típusúvá konvertáltként replikálta (").6.4).

Ez az operátor asszociatív marad.

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 oldali operandus * kijelöl egy tömböt, a bináris operátor létrehoz egy új, nem korlátozott, 1 dimenziós tömböt, amely a bal oldali operandus által kijelölt értéket tartalmazza, és a jobb oldali operandus értéke által egész szám típusúra konvertált számmal replikálta (").6.4). A nulla replikációs szám egy 1 hosszúságú tömböt ad vissza. Ha a bal oldali operandus egy többdimenziós tömböt jelöl ki, a rendszer a használat előtt el simítást ($9.12) használ.

Ez az operátor asszociatív marad.

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ás

Leírás:

/ Az osztás operátor eredménye az a hányados, amikor a bal oldali operandus által kijelölt értéket elosztja a jobb oldali operandus által jelölt értékkel a szokásos aritmetikai konverziók (%6.15) alkalmazása után.

Ha a rendszer egész számot vagy tizedes törtet próbál nullával osztásra végezni, implementáció által definiált megszakítási hiba történik.

Ez az operátor asszociatív marad.

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 a rendszer egész számot vagy tizedes törtet próbál nullával osztásra végezni, a rendszer RuntimeException kivételt ad ki.

7.6.5 Maradék

Leírás:

A maradék % operátor eredménye a maradék, amikor a bal oldali operandus által kijelölt értéket elosztja a jobb oldali operandus által a szokásos aritmetikai konverziók ([6.15) alkalmazása után kijelölt értékkel.

Ha a rendszer egész számot vagy tizedes törtet próbál nullával osztásra végezni, implementáció által definiált megszakítási hiba történik.

Példák:

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

Ha a rendszer egész számot vagy tizedes törtet próbál nullával osztásra végezni, a rendszer RuntimeException kivételt ad ki.

7.7 Additív operátorok

Szintaxis:

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

7.7.1 Összeadás

Leírás:

Az összeadás + operátor eredménye a két operandus által jelölt értékek összege a szokásos aritmetikai konverziók (*6,15) alkalmazása után.

Ez az operátor asszociatív marad.

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-összetartás

Leírás:

Amikor a bal oldali operandus + kijelöl egy sztringet, a bináris operátor létrehoz egy új sztringet, amely tartalmazza a bal oldali operandus által jelölt értéket, majd közvetlenül a jobb oldali operandus által sztring típusra konvertált érték(6.8) értékeket.

Ez az operátor asszociatív marad.

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ök össze concatenációja

Leírás:

Amikor a bal oldali operandus + kijelöl egy tömböt, a bináris operátor létrehoz egy új, nem korlátozott 1 dimenziós tömböt, amely tartalmazza a bal oldali operandus által kijelölt elemeket, majd közvetlenül a jobb oldali operandus által kijelölt érték(ök)et. A két operandusban található többdimenziós tömbök a használat előtt el vannak simításon (azaz 9,12).

Ez az operátor asszociatív marad.

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 Kivonattáblák összecsatása

Leírás:

Amikor mindkét operandus hashtable-t + jelöl ki, a bináris operátor létrehoz egy új kivonattáblát, amely tartalmazza a bal oldali operandus által kijelölt elemeket, majd közvetlenül a jobb oldali operandus által kijelölt elemeket.

Ha a kivonattáblák ugyanazt a kulcsot tartalmazzák, implementáció által definiált megszakítási hiba történik.

Ez az operátor asszociatív marad.

Példák:

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

Ha a kivonattáblák ugyanazt a kulcsot tartalmazzák, a BadOperatorArgument típus kivételt vált ki.

7,7,5 Kivonás

Leírás:

- A kivonás operátor eredménye az a különbség, amikor a jobb oldali operandus által kijelölt értéket kivonjuk a bal oldali operandus által jelölt értékből a szokásos aritmetikai konverziók (*6,15) alkalmazása után.

Ez az operátor asszociatív marad.

Példák:

12 - -10L      # long result 2c
-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-operator: one of
    dash as           dash ccontains     dash ceq
    dash cge          dash cgt           dash cle
    dash clike        dash clt           dash cmatch
    dash cne          dash cnotcontains  dash cnotlike
    dash cnotmatch    dash contains      dash creplace
    dash csplit       dash eq            dash ge
    dash gt           dash icontains     dash ieq
    dash ige          dash igt           dash ile
    dash ilike        dash ilt           dash imatch
    dash in           dash ine           dash inotcontains
    dash inotlike     dash inotmatch     dash ireplace
    dash is           dash isnot         dash isplit
    dash join         dash le            dash like
    dash lt           dash match         dash ne
    dash notcontains  dash notin         dash notlike
    dash notmatch     dash replace       dash shl
    dash shr          dash split

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

Leírás:

A bal oldali operandus által kijelölt érték típusa határozza meg, hogy a rendszer szükség esetén hogyan konvertálja a jobb oldali operandus által kijelölt értéket (*6) az összehasonlítás előtt.

Egyes összehasonlító operátorok (amelyek itt -op-ként vannak megírva) két változatban vannak, amelyek közül az egyik megkülönbözteti a kis- és nagybetűket (-cop), a másik pedig nem (-iop). Az -op verzió az -iop műveletnek felel meg. A kis- és nagybetűk érzékenysége csak sztring típusú értékek összehasonlításával értelmezhető. Nem sztring összehasonlítási környezetben a két változat ugyanúgy viselkedik.

Ezek az operátorok asszociatívak maradnak.

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

Leírás:

Két egyenlőségi operátor van: egyenlőség (-eq) és egyenlőtlenség (-ne); és négy relációs operátor: kisebb mint (-lt), kisebb vagy egyenlő (),-le nagyobb, mint (-gt), és nagyobb vagy egyenlő (-ge). Ezek mindegyikének két változata van (a 7.8-as verzió).

Ahhoz, hogy két sztring egyenlő legyen, azonos hosszúságúnak és tartalmának, valamint betűbetűnek kell lennie, ha szükséges.

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 egy üres, nem korlátozott 1 dimenziós tömb, amely a gyűjtemény igaz tesztelemét tartalmazza a jobb operandus által kijelölt értékhez képest.

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 Tartalmazottság operátorai

Leírás:

Négy tartalmazottság-operátor van: contains (-contains), does-not-contain (), in (-in``‑notcontains) és not-in (-notin). Ezek mindegyikének két változata van (a 7.8-as verzió).

A tartalmazottság operátorok bool típusú eredményt ad vissza, amely azt jelzi, hogy egy érték legalább egyszer bekövetkezik (vagy nem fordul elő) egy tömb elemeiben. A -contains és ‑notcontainsa értékeket a jobb oldali operandus jelöli, a tömböt pedig a bal oldali operandus. Az -in és -notina az operandusok fordított sorrendben vannak megfordulva. Az értéket a bal oldali operandus, a tömböt pedig a jobb oldali operandus jelöli ki.

Ezen operátorok esetén, ha a tömb operandusa 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
"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ési és -konverziós operátorok

Leírás:

A típus operátor -is azt teszteli, hogy a bal oldali operandus által kijelölt érték típusú-e, vagy olyan típusból származik, amely a jobb oldali operandus által kijelölt típussal rendelkezik. A jobb operandusnak ki kell jelölnie egy típust vagy értéket, amely típusra konvertálható (például egy típust neveső sztring). Az eredmény típusa bool. A type operátor -isnot a megfelelő űrlap logikai negálását adja -is vissza.

A típus operátor -as megkísérli a bal oldali operandus által kijelölt értéket a jobb oldali operandus által kijelölt típusra konvertálni. A jobb operandusnak ki kell jelölnie egy típust vagy értéket, amely típusra konvertálható (például egy típust neveső sztring). Ha az átalakítás sikertelen, $null a lesz visszaadva; ellenkező esetben a visszaadott érték lesz visszaadva, és az eredmény visszatérési típusa a konvertált érték futásidejű 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ési és szövegmanipulációs operátorok

7.8.4.1 A -like és -notlike operátorok

Leírás:

Ha a bal oldali operandus nem jelöl ki gyűjteményt, az eredmény típusa bool. Ellenkező esetben az eredmény valószínűleg egy üres, nem korlátozott 1 dimenziós tömb, amely a gyűjtemény igaz tesztelésű elemeit tartalmazza a jobb operandus által kijelölt értékhez képest. A jobb operandus kijelölhet egy sztringet, amely helyettesítő karaktereket tartalmazó kifejezéseket tartalmaz (").3.15). Ezeknek az operátornak két változata van (a 7.8-as verzió).

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

Leírás:

Ha a bal oldali operandus nem jelöl ki gyűjteményt, bool $trueaz eredmény típusa , és ha az eredmény , $matches akkor a kivonattábla elemei olyan sztringekra vannak beállítva, amelyek megfelelnek a jobb oldali operandus által megadott értéknek (vagy nem egyeznek meg). Ellenkező esetben az eredmény valószínűleg egy üres, nem korlátozott 1 dimenziós tömb, amely a gyűjtemény igaz tesztelésű elemeit tartalmazza a jobb operandus által kijelölt értékhez képest, $matches és nincs beállítva. A jobb operandus kijelölhet egy sztringet, amely reguláris kifejezéseket tartalmaz (("3.16"), amely esetben mintázatnak nevezzük. Ezeknek az operátornak két változata van (a 7.8-as verzió).

Ezek az operátorok támogatják az alcsoportokat (").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

Leírás:

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

• A megtalálható sztring, amely reguláris kifejezéseket tartalmazhat (").3.16). Ebben az esetben a helyettesítő sztring implicit módon "" lesz.
• Egy 2 objektumot tartalmazó tömb, amely a sztringet tartalmazza, amelyet a helyettesítő sztring követ.

Ha a bal oldali operandus kijelöl egy sztringet, az eredmény sztring típusú lesz. Ha a bal operandus egy egydimenziós sztringtömböt jelöl ki, az eredmény egy nem korlátozott 1 dimenziós tömb, amelynek hossza megegyezik a bal oldali operandus tömbje hosszával, és a helyettesítő művelet befejezése után tartalmazza a bemeneti sztringeket.

Ez az operátor támogatja az alcsoportokat (").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

Leírás:

A bináris -join operátor olyan sztringet állít elő, amely a bal oldali operandus által kijelölt egy vagy több objektum értékének össze van concatened értéke, ha szükséges, miután át lett alakítva sztringgé (*6.7). A jobb operandus által kijelölt sztring az eredményül kapott sztringben található (esetleg üres) értékek elválasztása.

A bal oldali 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

Leírás:

A bináris -split operátor egy vagy több, a bal oldali operandus által kijelölt sztringet oszt fel, és az alrészeket egy korlátozott 1 dimenziós sztringtömbben adja vissza. Ennek az operátornak két változata van (").7.8). A bal oldali operandus skaláris értéket vagy sztringtömböt jelölhet ki. A jobb operandus az alábbi űrlapok egyikével rendelkezik:

• Elválasztó sztring
• Egy 2 objektumot tartalmazó tömb, amely elválasztó sztringet, majd egy numerikus felosztási számot tartalmaz
• Egy 3 objektumból álló tömb, amely egy elválasztó sztringet, egy numerikus felosztási számot és egy beállítási sztringet tartalmaz
• Egy szkriptblokk
• Egy 2 objektumból áll tömb, amely egy szkriptblokkot és egy numerikus felosztási számot tartalmaz

Az elválasztó sztring reguláris kifejezéseket tartalmazhat (").3.16. A bemeneti sztringekkel együtt megkeresi az alrészeket. Az elválasztó karakter nem szerepel az eredményül kapott sztringek között. Ha a bal oldali operandus üres sztringet jelöl ki, az üres sztringelemet ad vissza. Ha az elválasztó sztring üres sztring, akkor a bemeneti sztringek minden karakterpozíciója 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 a bemeneti sztringben található alrészek száma, minden alrész külön elembe kerül. Ha ez a szám kevesebb, mint a bemeneti sztringben található alrészek száma, akkor az eredményben count elemek is vannak, az utolsó elem pedig az első darabszámon túl az összes alrészet tartalmazza – 1 alrész.

A beállítási sztring nulla vagy több beállításnevet tartalmaz, és minden szomszédos párt vessző választ el egymástól. A kezdő, záró és beágyazott térköz figyelmen kívül lesz hagyva. A beállításnevek bármilyen sorrendben lehetnek, és megkülönböztetik a kis- és nagybetűket.

Ha egy beállítási sztring tartalmazza a SimpleMatch beállításnevet, akkor az IgnoreCase beállításnevet is tartalmazhatja. Ha egy beállítási sztring tartalmazza a RegexMatch beállításnevet, vagy nem tartalmazza sem a RegexMatch, sem a SimpleMatch értékeket, akkor a SimpleMatch kivételével bármilyen beállításnevet tartalmazhat. Nem tartalmazhat azonban többsoros és egysoros vonalat is.

A beállításnevek a következőek:

Beállítás	Leírás
CultureInvariant	Az elválasztó kiértékeléskor figyelmen kívül hagyja a nyelvi kulturális különbségeket.
ExplicitCapture	Figyelmen kívül hagyja a nem elnevezett egyezéscsoportokat, így csak explicit rögzítési csoportokat ad vissza az eredménylistában.
IgnoreCase	A kis- és a kis -csplit - és a nagy- és kis-
IgnorePatternWhitespace (PatternWhitespace figyelmen kívül hagyása)	Figyelmen kívül hagyja a be nem foglalatlan térközt és a számjelekkel (#) jelölt megjegyzéseket.
Multiline (Többsoros)	Ez a mód felismeri a sorok és sztringek kezdő és záró karakterét. Az alapértelmezett mód az Egysoros.
RegexMatch (RegexMatch)	Az elválasztó kiértékeléséhez használjon reguláriskifejezés-egyeztetést. Ez az alapértelmezett beállítás.
SimpleMatch (Egyszerű egyező)	Az elválasztó kiértékeléskor használjon egyszerű sztring-összehasonlítást.
Egysoros	Ez a mód csak a sztringek kezdő és záró karakterét ismeri fel. Ez az alapértelmezett mód.

A szkriptblokk ([7.1.8) meghatározza az elválasztó karakter meghatározásának szabályait, és ki kell értékelnie a bool típust.

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 Alkategóriák

A , a és -match``-notmatch``-replace a minta zárójelekkel elválasztott alrészeket (más néven alcsoportokat ) tartalmazhat. Tekintse meg a következő példát:

"red" -match "red"

Az eredmény és $true a 0 $matches kulcsa tartalmazza a "piros" részt, amely a bal oldali operandus által kijelölt sztringnek a jobb oldali operandus által kijelölt mintával pontosan megegyezik.

A következő példában a teljes minta egy alcsoport:

"red" -match "(red)"

Ahogy korábban, a 0 kulcs is "red" (piros) adatokat tartalmaz; Az 1. kulcs azonban a "red" (vörös) részt is tartalmazza, amely a bal oldali operandus által kijelölt sztringnek az a része, amely pontosan megfelelt az alcsoportnak.

Vegyük például a következő, összetettebb mintát:

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

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

A 0 kulcs itt is "red" (vörös) adatokat tartalmaz. Az 1. kulcs tartalmazza az "re"-t, a 2. kulcs az "r"-t, a 3. kulcs pedig a "d" betűt. A kulcs/érték párok a mintázat balról jobbra, a hosszabb sztringek pedig a rövidebbek előtt egyező sorrendben vannak.

A esetében -replace``$na helyettesítő szöveg az űrlap neveivel férhet hozzá az alrészekhez, $1ahol az első egyezés , $3a második a , és így tovább. Példa:

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

Az eredményül kapott sztring a "hétfő reggel".

Ahelyett, hogy a kulcsok $matches nulla alapú indexek lenne, az almatmatikák a következő formában neveződnek el: ?<*name*>. A például "((r)e)(d)" három elnevezett alcsoportból (m1, m2 és m3) írható, a következőképpen: "(?<m1>(?<m2>r)e)(?<m3>d)".

7.8.5 Shift-operátorok

Leírás:

A shift left (-shl) operátor és a shift right (-shr) operátor a bal oldali operandus által tervezett értéket egész szám típusúvá, a jobb oldali operandus által kijelölt értéket pedig szükség esetén int értékre konvertálja a szokásos aritmetikai konverziók használatával ([6.15).

A balra tolódás operátor az alább leírt módon kiszámított bitekkel balra tolja el a bal oldali operandusokat. Az alacsony rendű üres bitpozíciók nullára vannak állítva.

A jobb oldali shift operátor az alább leírt módon kiszámított bitekkel jobbra tolja el a bal oldali operandusokat. A bal oldali operandus alacsony rendű bitje el lesz vetve, a fennmaradó bitek pedig jobbra tolnak el. Ha a bal oldali operandus egy aláírt érték, akkor a magas rendű üres bitpozíciók nullára vannak állítva, ha a bal oldali operandus nem negatív, és ha a bal oldali operandus negatív, akkor egy értéket ad meg. Ha a bal oldali operandus aláíratlan érték, a magas rendű üres bitpozíciók nullára vannak állítva.

Ha a bal oldali operandus type int (int) típusú, a shift (eltolás) számát a jobb oldali operandus alacsony rendű öt bitje adja meg. Ha a jobb operandus hosszú típusú, a shift (eltolás) számát a jobb operandus alacsony rendű hat bitje adja 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 Bitwise operátor

Szintaxis:

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

Leírás:

A bitenkénti AND -bandoperátor, a bitenkénti OR -boroperátor és a bitenkénti XOR operátor -bxor az operandusok által kijelölt értékeket szükség esetén egész szám típusúvá alakítja a szokásos aritmetikai konverziók használatával (").6.15). Az átalakítás után, ha mindkét érték típus int típusú, akkor ez az eredmény típusa. Ellenkező esetben, ha mindkét értéknek hosszú a típusa, akkor ez az eredmény típusa. Ha az egyik érték int típusú, a másik pedig hosszú, akkor az eredmény típusa hosszú. Ellenkező esetben a kifejezés nem megfelelő. Az eredmény az esetleg konvertált operandusértékek bitenkénti AND, bitenkénti OR vagy bitenkénti XOR értéke.

Ezek az operátorok asszociatívak maradnak. Akkor kommutatí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:
    bitwise-expression
    logical-expression -and new-lines~opt~ bitwise-expression
    logical-expression -or new-lines~opt~ bitwise-expression
    logical-expression -xor new-lines~opt~ bitwise-expression

Leírás:

A logikai AND operátor -and az operandusai booláltal kijelölt értékeket szükség esetén értékké alakítja (").6.2). Az eredmény a valószínűleg konvertált operandusértékek logikai ÉS értéke, és típussal rendelkezik bool. Ha a bal oldali operandus kiértékelése Hamis, a jobb oldali operandus nincs kiértékelve.

A logikai VAGY operátor -or az operandusai booláltal kijelölt értékeket szükség esetén értékké alakítja (").6.2). Az eredmény a valószínűleg konvertált operandusértékek logikai VAGY értéke, és típussal rendelkezik bool. Ha a bal oldali operandus igaz értéket ad vissza, a jobb oldali operandus nincs kiértékelve.

A logikai XOR operátor -xor az operandusai bool által kijelölt értékeket a következőre konvertálja: (").6.2). Az eredmény a valószínűleg konvertált operandusértékek logikai XOR-értéke, és booltípusa .

Ezek az operátorok asszociatívak maradnak.

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 Értékt kiosztási operátorok

Szintaxis:

assignment-expression:
    expression assignment-operator statement

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

Leírás:

A hozzárendelési operátor egy értéket tárol a kifejezés által kijelölt írható helyen. For a discussion of assignment-operator = see §7.11.1. Az összes többi érték-hozzárendelési operátort lásd: .7.11.2.

A hozzárendelési kifejezés a hozzárendelés után a kifejezés által kijelölt értékkel rendelkezik; Ez a hozzárendelési kifejezés azonban nem jelöl ki írható helyet. If expression is type-constrained (§5.3), the type used in that constraint is the type of the result; otherwise, the type of the result is the type after the usual arithmetic conversions (§6.15) have been applied.

Ez az operátor megfelelő asszociatív.

7.11.1 Egyszerű hozzárendelés

Leírás:

Egyszerű hozzárendelésben (=) a utasítás által kijelölt érték lecseréli a kifejezés által kijelölt írható helyen tárolt értéket. Ha azonban a kifejezés nem létező kulcsot jelöl ki egy kivonattáblában, a kivonattábla a utasítás által kijelölt érték társított értékével lesz hozzáadva a kivonattáblához.

Ahogy az a nyelvtanban is látható, a kifejezés írható helyek vesszővel elválasztott listáját jelölheti meg. Ezt többszörös hozzárendelésnek nevezik. A utasítás egy vagy több vesszővel elválasztott érték listáját jelöli. A két operandus-listában szereplő vesszők a többszörös hozzárendelési szintaxis részei, és nem a bináris vessző operátort képviselik. Az értékek a utasítás által kijelölt listából vannak lexikális sorrendben, és a kifejezés által kijelölt megfelelő írható helyen vannak tárolva. Ha a utasítás által kijelölt lista kevesebb értéket tartalmaz, mint a kifejezés írható helyei, a felesleges helyek a értéket veszi fel$null. Ha a utasítás által kijelölt lista több értékkel rendelkezik, mint a kifejezés írható helyei, akkor a megfelelő utasításértéken kívül az összes kifejezés helye a megfelelő utasításértéken kívül minden más, nem korlátozott, 1 dimenziós tömb lesz, amely a fennmaradó utasításértékeket elemként tartalmazza.

Az értékekkel (*8.1.2) való utasítások esetén az utasítás lehet egy utasí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ések formája E1 op= E2, E1 = E1 op (E2) és egyenértékű az egyszerű hozzárendelési kifejezéssel, azzal a kivételel, hogy az összetett hozzárendelési esetben az E1 kifejezés csak egyszer lesz kiértékelve. If expression is type-constrained (§5.3), the type used in that constraint is the type of the result; otherwise, the type of the result is determined by op. For *=, see §7.6.1, §7.6.2, §7.6.3; for /=, see §7.6.4; for %=, see §7.6.5; for +=, see §7.7.1, §7.7.2, §7.7.3; for -=, see §7.7.5.

Megjegyzés

A numerikus típus nem korlátozott értékét kitervező operandus típusát egy érték-hozzárendelési operátor is megváltozhatja 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:
    assignment-expression
    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 standard kimenetét átirányítja az á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 standard kimenetét átirányítja az átirányított fájlnév által kijelölt helyre, hozzáfűzve az adott hely aktuális tartalmához, ha van ilyen. Ha ez a hely nem létezik, létrejön.

Az űrlap n> átirányítási operátora az n adatfolyam kimenetét veszi át a folyamatból, és átirányítja az átirányított fájlnév által kijelölt helyre, felülírva a hely aktuális tartalmát.

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

Az űrlap átirányítási operátora m>&n az m stream kimenetét írja ugyanoda, mint az n stream.

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

Stream	Leírás
1	Standard kimeneti stream
2	Hiba kimeneti streame
3	Figyelmeztető kimeneti stream
4	Részletes kimeneti stream
5	Kimeneti stream hibakeresése
*	Standard kimenet, hibakimenet, figyelmeztető kimenet, részletes kimenet és hibakeresési kimeneti streamek

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

Ha a kimeneten a redirected-file-name $nullértéke , a kimenet el lesz vetve.

A legfelső szintű mellékhatást tartalmazó kifejezés értéke általában nem írható a folyamatba, kivéve, ha a kifejezés zárójelek között van. Ha azonban egy ilyen kifejezés egy szabványos kimenetet átirányító operátor bal oldali operandusa, a rendszer az értéket írja.

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