7. Kifejezések
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 $x
vá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 Hashtable
kulcsá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
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 $null
lesz. 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
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 $null
lesz. 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 -not
unary-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 -not
alternatí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 -bnot
unary-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 0
int
tí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 int
tí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,8
haszná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 -notcontains
esetén az értéket a jobb operandus, a tömböt pedig a bal operandus jelöli ki. A -in és -notin
eseté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 -replace
eseté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 $3
stb. 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 bool
tí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 bool
tí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 bool
tí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