Feedback

7. Expressies

  • Artikel
  • 53 minuten om te lezen

Syntaxis:

expression:
    logical-expression

Beschrijving:

Een expressie is een reeks operators en operanden die een methode, een functie, een beschrijfbare locatie of een waarde aanwijzen; geeft de berekening van een waarde aan; produceert een of meer neveneffecten; of voert een combinatie hiervan uit. Bijvoorbeeld:

  • De letterlijke waarde 123 is een expressie die de int-waarde 123 aanwijzen.
  • Met de expressie 1,2,3,4 wordt het matrixobject met vier elementen aangeduid met de waarden die worden weergegeven.
  • De expressie 10.4 * $a geeft een berekening aan.
  • De expressie $a++ produceert een neveneffect.
  • Met de $a[$i--] = $b[++$j] expressie wordt een combinatie van deze dingen uitgevoerd.

Behalve zoals opgegeven voor sommige operators, zijn de volgorde van de evaluatie van termen in een expressie en de volgorde waarin neveneffecten plaatsvinden beide niet opgegeven. Voorbeelden van niet-gespecificeerd gedrag zijn: $i++ + $i, $i + --$ien $w[$j++] = $v[$j].

Een implementatie van PowerShell biedt mogelijk ondersteuning voor door de gebruiker gedefinieerde typen, en op deze typen zijn mogelijk bewerkingen gedefinieerd. Alle details van dergelijke typen en bewerkingen zijn implementatie gedefinieerd.

Een expressie op het hoogste niveau is een expressie die geen deel uitmaakt van een grotere expressie. Als een expressie op het hoogste niveau een operator voor neveneffect bevat, wordt de waarde van die expressie niet naar de pijplijn geschreven; anders wel. Zie 7.1.1 voor een gedetailleerde bespreking van dit onderwerp.

Normaal gesproken wordt een expressie die een verzameling (*4) aanwijzen, geïndefeerd in de samenstellende elementen wanneer de waarde van die expressie wordt gebruikt. Dit is echter niet het geval wanneer de expressie een cmdlet-aanroep is. Bijvoorbeeld:

$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

In de eerste twee $(...) toepassingen van de operator is de expressie waarmee de verzameling wordt $xaangemaakt de variabele , die wordt geïnsemuleerd, wat resulteert in int drie waarden, plus int de 99. In het derde geval is de expressie echter een directe aanroep naar een cmdlet, zodat het resultaat niet wordt geïnsemuleerd $a en een matrix van twee elementen is, int[3] en int.

Als een bewerking niet is gedefinieerd door PowerShell, wordt het type van de waarde die is aangewezen door de linkeropend geïnspecteerd om te zien of deze een bijbehorende methode op_<operation> heeft.

7.1 Primaire expressies

Syntaxis:

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 Haakjes groeperen

Syntaxis:

Tip

De ~opt~ notatie in de syntaxisdefinities geeft aan dat de lexicale entiteit optioneel is in de syntaxis.

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

Beschrijving:

Een haakje-expressie is een primaire expressie waarvan het type en de waarde hetzelfde zijn als die van de expressie zonder de haakjes. Als de expressie een variabele aanwijzen, wijst de haakjes-expressie diezelfde variabele aan. Zo is $x.m bijvoorbeeld het equivalent van ($x).m.

Haakjes groeperen kan worden gebruikt in een expressie om de standaardvoorwaarde en associativiteit binnen die expressie te documenteren. Ze kunnen ook worden gebruikt om die standaard prioriteit en associativiteit te overschrijven. Bijvoorbeeld:

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

Normaal gesproken zijn haakjes op het hoogste niveau redundant. Dat is echter niet altijd het geval. Kijk eens naar het volgende voorbeeld:

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

In het tweede geval wijzigen de haakjes de semantiek, wat resulteert in een matrix waarvan de twee elementen een matrix van 2 ints en scalaire int 6 zijn.

Hier is nog een uitzondering:

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

In het eerste en derde geval wordt de waarde van het resultaat naar de pijplijn geschreven. Hoewel de expressie in het tweede geval echter wordt geëvalueerd, wordt het resultaat niet naar de pijplijn geschreven vanwege de aanwezigheid van de operator side-effect = op het hoogste niveau. (Door het onderdeel te $a = verwijderen, kan de waarde worden geschreven, omdat * dit geen operator voor neveneffect is.)

Als u wilt voorkomen dat een waarde van een expressie die geen neveneffecten op het hoogste niveau bevat, naar de pijplijn wordt geschreven, moet u deze als volgt expliciet verwijderen:

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

Als u naar de pijplijn wilt schrijven, moet u de waarde van een expressie met neveneffecten op het hoogste niveau als volgt tussen haakjes insluiten:

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

Daarom zijn de haakjes in dit geval niet redundant.

In het volgende voorbeeld wordt het vervangen van variabelen (2.3.5.2) in een letterlijke tekenreeks gebruikt:

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

In het eerste geval vertegenwoordigen de haakjes de scheidingstekens van een subexpressie die geen haakjes groeperen. Omdat de expressie op het hoogste niveau een operator voor neveneffect bevat, wordt de waarde van de expressie niet naar de pijplijn geschreven. Natuurlijk zijn de tekens > en < nog steeds geschreven.) Als er haakjes worden gegroepeerd , zoals wordt weergegeven in het tweede geval, is schrijven ingeschakeld.

De volgende voorbeelden bevatten beide operators voor neveneffect op het hoogste niveau:

$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

Het gebruik van het groeperen van haakjes rond een expressie zonder neveneffecten op het hoogste niveau maakt deze haakjes redundant. Bijvoorbeeld:

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

Kijk eens naar het volgende voorbeeld met twee neveneffecten, die geen van beide op het hoogste niveau zijn:

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

Het resultaat wordt naar de pijplijn geschreven, omdat de expressie op het hoogste niveau geen neveneffecten heeft.

7.1.2 Lidtoegang

Syntaxis:

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

Beschrijving:

De operator . wordt gebruikt om een exemplaarlid te selecteren uit een object of een sleutel uit een Hashtable. De linkeropeen moet een object aanwijzen en de rechteropeen moet een toegankelijk exemplaarlid aanwijzen.

De rechterope operand wijst een toegankelijk exemplaarlid aan binnen het type van het object dat is aangewezen door de linkeropend of, als de linkeropeen een matrix aanwijzen, de rechteropeener accessible instance-leden binnen elk element van de matrix aanwijzen.

Witruimte is niet toegestaan vóór de . operator.

Deze operator is aan de linkerkant associatief.

De operator :: wordt gebruikt om een statisch lid van een bepaald type te selecteren. De linkeropeen moet een type aanwijzen, en de rechteropend moet een toegankelijk statisch lid binnen dat type aanwijzen.

Witruimte is niet toegestaan vóór de :: operator.

Deze operator is aan de linkerkant associatief.

Als de rechteropeen een beschrijfbare locatie aanwijzen binnen het type van het object dat is aangewezen door de linkeropend, wijst de hele expressie een beschrijfbare locatie aan.

Voorbeelden:

$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 Aanroepexpressies

Syntaxis:

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~ )

Beschrijving:

Een aanroepexpressie roept de methode aan die is aangewezen door primary-expression. member-name of primary-expression::member-name. De haakjes in argument-list bevatten een mogelijk lege, door komma's gescheiden lijst met expressies, die de argumenten aanwijzen waarvan de waarden worden doorgegeven aan de methode . Voordat de methode wordt aangeroepen, worden de argumenten geëvalueerd en geconverteerd volgens de regels van .6, indien nodig, om te voldoen aan de typen die door de methode worden verwacht. De volgorde van de evaluatie van primary-expression. member-name, primary-expression::member-name en de argumenten zijn niet gespecificeerd.

Deze operator is aan de linkerkant associatief.

Het type van het resultaat van een aanroepexpressie is een methodeontwerpator (*4.5.24).

Voorbeelden:

[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 Element access

Syntaxis:

element-access: Note no whitespace is allowed between primary-expression and [.
    primary-expression [ new-lines~opt~ expression new-lines~opt~ ]

Beschrijving:

Er mag geen witruimte zijn tussen de primaire expressie en het vierkante haakje links ([).

7.1.4.1 Een matrix subscripting

Beschrijving:

Matrices worden in detail besproken in .9. Als expressie een 1-dimensionale matrix is, zie dan :7.1.4.5.

Wanneer primary-expression een 1-dimensionale matrix A aanwijzen, retourneert de operator [] het element A[0 + expression] dat zich bevindt op nadat de waarde van de expressie is geconverteerd naar int. Het resultaat heeft het elementtype van de matrix die wordt gesubscripteerd. Als de expressie negatief is, wijst A[expression] u het element aan dat zich bevindt in A[A.Length + expression].

Wanneer primary-expression een 2-dimensionale matrix B aanwijzen, retourneert de operator [] het element B[0 + row,0 + column] dat zich bevindt op nadat de waarde van de rij- en kolomonderdelen van de expressie (die zijn opgegeven als een door komma's gescheiden lijst) is geconverteerd naar .int Het resultaat heeft het elementtype van de matrix die wordt gesubscripteerd. In tegenstelling tot een 1-dimensionale matrix hebben negatieve posities geen speciale betekenis.

Wanneer primary-expression een matrix van drie of meer dimensies aanwijzen, zijn de regels voor tweedimensionale matrices van toepassing en worden de dimensieposities opgegeven als een door komma's gescheiden lijst met waarden.

Als een leestoegang voor een niet-bestaand element wordt geprobeerd, is het resultaat $null. Het is een fout bij het schrijven naar een niet-bestaand element.

Voor een subscriptexpressie met meerdere dimensionale matrices is de volgorde van de evaluatie van de expressies voor dimensieposities niet gespecificeerd. Als u bijvoorbeeld een 3-dimensionale matrix $agebruikt, $a[$i++,$i,++$i] is het gedrag van niet opgegeven.

Als expressie een matrix is, zie dan :7.1.4.5.

Deze operator is aan de linkerkant associatief.

Voorbeelden:

$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]

Als schrijftoegang tot een niet-bestaand element wordt geprobeerd, teert een IndexOutOfRange-uitzondering .

7.1.4.2 Een tekenreeks subscripting

Beschrijving:

Wanneer primary-expression een tekenreeks S aanwijzen, retourneert de operator [] het teken dat zich in de op nul gebaseerde positie bevindt die wordt aangegeven door expressie, als een teken. Als de expressie groter is dan of gelijk is aan de lengte van die tekenreeks, is het resultaat $null. Als de expressie negatief is, wijst S[expression] u het element aan dat zich bevindt in S[S.Length + expression].

Voorbeelden:

$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 Een hashtabel subscripting

Beschrijving:

Wanneer primary-expression een hashtabel aanwijzen, retourneert de operator [] de waarde(s) die zijn gekoppeld aan de sleutel(en) die door de expressie zijn aangewezen. Het type expressie is niet beperkt.

Wanneer expressie een enkele sleutelnaam is, is het resultaat de gekoppelde waarde en heeft dit type, tenzij een dergelijke sleutel niet bestaat. In dat geval is het resultaat $null. Als $null wordt gebruikt als sleutel, wordt het gedrag implementatie gedefinieerd. Als expressie een matrix met sleutelnamen is, zie dan :7.1.4.5.

Als expressie een matrix is, zie dan :7.1.4.5.

Voorbeelden:

$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

Wanneer expressie een enkele sleutelnaam is en $null wordt gebruikt als de enige waarde voor het subscript van een hashtabel, wordt er een NullArrayIndex-uitzondering gegenereerd.

7.1.4.4 Een XML-document subscripting

Beschrijving:

Wanneer primary-expression een object van het type xml aanwijzen , wordt de expressie indien nodig geconverteerd naar een tekenreeks en retourneert de operator [] het eerste onderliggende element met de naam die is opgegeven door de expressie. Het type expressie moet tekenreeks zijn. Het type van het resultaat is implementatie gedefinieerd. Het resultaat kan worden gesubscript om het eerste onderliggende element te retourneren. Als er geen onderliggend element bestaat met de naam die is opgegeven door de expressie, is het resultaat $null. Het resultaat wijst geen beschrijfbare locatie aan.

Voorbeelden:

$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`

Het type van het resultaat is System.Xml.XmlElement of System.String.

7.1.4.5 Matrixsegmenten genereren

Wanneer primary-expression een object van een type aanwijzen dat kan worden opgesierd (;4) of een hashtabel, en de expressie een 1-dimensionale matrix is, is het resultaat een matrixsegment (9,9) dat de elementen van de primaire expressie bevat die zijn aangewezen door de elementen van de expressie.

In het geval van een hashtabel bevat het matrixsegment de gekoppelde waarden voor de opgegeven sleutels, tenzij een dergelijke sleutel niet bestaat. In dat geval is $nullhet bijbehorende element . Als $null wordt gebruikt als een sleutelnaam, wordt het gedrag implementatie gedefinieerd.

Voorbeelden:

$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: Als expressie een verzameling van twee of meer sleutelnamen is, als wordt gebruikt als een sleutelnaam, $null wordt die sleutel genegeerd en heeft deze geen bijbehorend element in de resulterende matrix.

7.1.5 Operators voor incrementele en aflopende postfixen

Syntaxis:

post-increment-expression:
    primary-expression ++

post-decrement-expression:
    primary-expression dashdash

dashdash:
    --

Beschrijving:

De primary-expression moet een beschrijfbare locatie met een waarde van numeriek type (:4) of de waarde aanwijzen $null. Als de waarde die door de operand is aangewezen, is $null, wordt die waarde geconverteerd naar type int en waarde nul voordat de operator wordt geëvalueerd. Het type van de waarde die is aangewezen door primary-expression kan veranderen wanneer het resultaat wordt opgeslagen. Zie .7.11 voor een bespreking van typewijziging via toewijzing.

Het resultaat dat wordt geproduceerd door de postfix-operator ++ is de waarde die wordt aangeduid door de operand. Nadat dit resultaat is verkregen, wordt de waarde die is aangewezen door de operand verhoogd met 1 van het juiste type. Het type van het resultaat van de expressie E++ is hetzelfde als voor het resultaat van de expressie E + 1 (7,7).

Het resultaat dat wordt geproduceerd door de postfix-operator -- is de waarde die wordt aangeduid door de operand. Nadat dit resultaat is verkregen, wordt de waarde die door de operand is aangewezen, door 1 van het juiste type afgebouwd. Het type van het resultaat van de expressie E-- is hetzelfde als voor het resultaat van de expressie E - 1 (7,7).

Deze operators zijn associatief.

Voorbeelden:

$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

Operator 7.1.6 $(...)

Syntaxis:

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

Beschrijving:

Als statement-list wordt weggelaten, is het resultaat $null. Anders wordt statement-list geëvalueerd. Objecten die als onderdeel van de evaluatie naar de pijplijn worden geschreven, worden in volgorde verzameld in een niet-getrainde 1-dimensionale matrix. Als de matrix met verzamelde objecten leeg is, is het resultaat $null. Als de matrix met verzamelde objecten één element bevat, is het resultaat dat element; anders is het resultaat de ongeconstrainde 1-dimensionale matrix met verzamelde resultaten.

Voorbeelden:

$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 @(...) operator

Syntaxis:

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

Beschrijving:

Als statement-list wordt weggelaten, is het resultaat een ongeconstrainde 1-dimensionale matrix met lengte nul. Anders wordt de instructielijst geëvalueerd en worden alle objecten die naar de pijplijn worden geschreven als onderdeel van de evaluatie verzameld in een ongeconstrainde 1-dimensionale matrix, in volgorde. Het resultaat is de (mogelijk lege) onbeperkte 1-dimensionale matrix.

Voorbeelden:

$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 Scriptblokexpressie

Syntaxis:

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

Beschrijving:

param-block wordt beschreven in :8.10.9. named-block-list wordt beschreven in :8.10.7.

Een scriptblok is een naamloos blok instructies dat als één eenheid kan worden gebruikt. Scriptblokken kunnen worden gebruikt om een codeblok aan te roepen alsof het een enkele opdracht is, of ze kunnen worden toegewezen aan variabelen die kunnen worden uitgevoerd.

De named-block-list of statement-list wordt uitgevoerd en het type en de waarde(s) van het resultaat zijn het type en de waarde(s) van de resultaten van deze instructiesets.

Een script-block-expression heeft het type scriptblock (*4.3.7).

Als param-block wordt weggelaten, zijn alle argumenten die worden doorgegeven aan het scriptblok beschikbaar via $args (8.10.1).

Tijdens parameterbinding kan een scriptblok worden doorgegeven als een scriptblokobject of als het resultaat nadat het scriptblok is geëvalueerd. Zie voor meer informatie .6.17 .

Letterlijke expressie 7.1.9 Hash

Syntaxis:

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

Beschrijving:

Een hash-literal-expression wordt gebruikt voor het maken van een hashtabel (10) van nul of meer elementen die elk een sleutel-waardepaar zijn.

De sleutel kan elk type hebben, behalve het type null. De gekoppelde waarden kunnen elk type hebben, met inbegrip van het null-type, en elk van deze waarden kan een expressie zijn die de gewenste waarde aanwijzen, met inbegrip van $null.

De volgorde van de sleutel-waardeparen is niet belangrijk.

Voorbeelden:

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

hiermee worden twee hashtabels gemaakt, $h1 $h2en , die elk drie sleutel-waardeparen bevatten, en een derde, $h3, die leeg is. Hashtabel $h4 heeft sleutels van verschillende typen.

7.1.10 Type letterlijke expressie

Syntaxis:

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 [

Beschrijving:

Een type-literal wordt in een implementatie vertegenwoordigd door een niet-gespecificeerd onderliggend type. Als gevolg hiervan is een typenaam een synoniem voor het onderliggende type.

Letterlijke gegevens van het type worden gebruikt in een aantal contexten:

  • Een expliciete conversie opgeven (6, ,7.2.9)
  • Een type-beperkte matrix maken (;9.4)
  • Toegang tot de statische leden van een object (7.1.2)
  • Een typebeperking opgeven voor een variabele (5.3) of een functieparameter (8.10.2)

Voorbeelden:

Voorbeelden van letterlijke gegevens van het type zijn [int], [object[]en [int[,,]]. Een algemeen stacktype (4.4) [Stack[string]]dat is gespecialiseerd voor het bevatten van tekenreeksen kan worden geschreven als , en een algemeen woordenlijsttype dat is int [Dictionary[int,string]]gespecialiseerd voor het bevatten van sleutels met gekoppelde tekenreekswaarden kan worden geschreven als .

Het type van een type-letterlijke is System.Type. De volledige naam voor het hierboven voorgestelde type Stack[string] is System.Collections.Generic.Stack[int]. De volledige naam voor het hierboven voorgestelde type Dictionary[int,string] is System.Collections.Generic.Dictionary[int,string].

7.2 Unaire operators

Syntaxis:

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 Unaire kommaoperator

Beschrijving:

Met deze operator maakt u een onbeperkte 1-dimensionale matrix met één element, waarvan het type en de waarde die van unary-expression zijn.

Deze operator is juist associatief.

Voorbeelden:

$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 Logical NOT

Beschrijving:

De operator converteert de waarde die is aangewezen door unary-expression niet naar het type bool (6.2), indien nodig, en produceert een resultaat van dat type. Als de waarde van unary-expression True is, is het resultaat False en vice versa. De operator ! is een alternatieve spelling voor -not.

Deze operator is juist associatief.

Voorbeelden:

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

7.2.3 Bitwise NOT

Beschrijving:

De operator -bnot converteert de waarde die is aangewezen door unary-expression naar een geheel getal (6,4), indien nodig. Als de geconverteerde waarde kan worden weergegeven in type int, is dat het resultaattype. Anders, als de geconverteerde waarde in type lang kan worden weergegeven, is dat het resultaattype. Anders is de expressie onwel. De resulterende waarde is de enen-aanvulling van de geconverteerde waarde.

Deze operator is juist associatief.

Voorbeelden:

-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

Beschrijving:

Een expressie van het formulier +unary-expression wordt behandeld alsof deze is geschreven als 0 + unary-expression (+7.7). Het letterlijke geheel getal 0 heeft het type int.

Deze operator is juist associatief.

Voorbeelden:

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

7.2.5 Unaire min

Beschrijving:

Een expressie van de form -unary-expression wordt behandeld alsof deze is geschreven als 0 - unary-expression (*7.7). Het letterlijke geheel getal 0 heeft het type int.

Deze operator is juist associatief.

Voorbeelden:

-$true # type int, waarde -1 -123L # type long, waarde -123 -0,12340D # type decimaal, waarde -0,12340

7.2.6 Operators voor voorvoegselverhoging en -decrement

Beschrijving:

De unary-expression moet een beschrijfbare locatie met een waarde van numeriek type (4) of de waarde aanwijzen $null. Als de waarde die wordt aangeduid door de unary-expression is $null, wordt de waarde van unary-expression geconverteerd naar type int en waarde nul voordat de operator wordt geëvalueerd.

Notitie

Het type van de waarde die is aangewezen door unary-expression kan veranderen wanneer het resultaat wordt opgeslagen. Zie voor meer informatie over typewijziging via toewijzing .7.11.

Voor de voorvoegseloperator ++ wordt de waarde van unary-expression verhoogd met 1 van het juiste type. Het resultaat is de nieuwe waarde nadat er een verhoging heeft plaatsgevonden. De expressie ++E is gelijk aan E += 1 (7.11.2).

Voor de voorvoegseloperator -- wordt de waarde van unary-expression met 1 van het juiste type verwijderd. Het resultaat is de nieuwe waarde nadat de waarde is afgenomen. De expressie --E is gelijk aan E -= 1 (7.11.2).

Deze operators zijn juist associatief.

Voorbeelden:

$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 De unaire operator -join

Beschrijving:

De unaire -join operator produceert een tekenreeks die de samenvoeging is van de waarde van een of meer objecten die zijn aangewezen door unary-expression. (Er kan een scheidingsteken worden ingevoegd met behulp van de binaire versie van deze operator (7.8.4.4).)

unary-expression kan een scalaire waarde of een verzameling zijn.

Voorbeelden:

-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 De unaire split-operator

Beschrijving:

De unaire -split operator splitst een of meer tekenreeksen die zijn aangewezen door unary-expression, en retourneert hun subparts in een beperkte 1-dimensionale matrix van tekenreeks. Elke aaneengesloten groep witruimtetekens wordt behandeld als het scheidingsteken tussen opeenvolgende subdelen. (Een expliciete scheidingstekenreeks kan worden opgegeven met behulp van de binaire versie van deze operator (7.8.4.5).) Deze operator heeft twee varianten (7,8).

De tekst van het scheidingsteken is niet opgenomen in de resulterende tekenreeksen. Vooraanstaand en aaneenliggend witruimte in de invoerreeks wordt genegeerd. Een invoerreeks die leeg is of witruimte bevat, resulteert alleen in een matrix van 1 tekenreeks, die leeg is.

unary-expression kan een scalaire waarde of een matrix met tekenreeksen aanwijzen.

Voorbeelden:

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

Beschrijving:

Deze operator converteert expliciet (6) de waarde die is aangewezen door unary-expression naar het type dat is aangewezen door type-literal. Als type-literal anders is dan void, is het type van het resultaat het benoemde type en is de waarde de waarde na de conversie. Als type-literal void is, wordt er geen object naar de pijplijn geschreven en is er geen resultaat.

Wanneer een expressie van een type wordt gecast naar hetzelfde type, zijn het resulterende type en de resulterende waarde het type en de waarde van de unary-expression.

Deze operator is juist associatief.

Voorbeelden:

[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 Binaire komma-operator

Syntaxis:

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

Beschrijving:

De binaire komma-operator maakt een 1-dimensionale matrix waarvan de elementen de waarden zijn die worden aangeduid door de operanden, in lexicale volgorde. De matrix heeft een onbeperkt type.

Voorbeelden:

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

De toevoeging van haakjes groeperen aan bepaalde binaire komma-expressies documenteert niet de standaard prioriteit; In plaats daarvan wordt het resultaat gewijzigd.

Operator 7.4 Range

Syntaxis:

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

Beschrijving:

Een bereikexpressie maakt een onbeperkte 1-dimensionale matrix waarvan de elementen de waarden zijn van de int-reeks die is opgegeven door de bereikgrens. De waarden die door de operanden worden aangeduid, worden zo nodig geconverteerd naar int (6.4). De operand die de lagere waarde na de conversie aanmaak , is de ondergrens, terwijl de operand die de hogere waarde aanmaak na de conversie de bovengrens is. Beide grenzen kunnen hetzelfde zijn. In dat geval heeft de resulterende matrix lengte 1. Als de linkeropeen de ondergrens aanwijzen, is de volgorde in oplopende volgorde. Als de linkeropeenhoek de bovengrens aanwijzen, is de volgorde aflopend.

Conceptueel gezien is deze operator een snelkoppeling voor de bijbehorende binaire reeks komma's met komma's. Het bereik kan bijvoorbeeld ook 5..8 worden gegenereerd met behulp van 5,6,7,8. Als er echter een oplopende of aflopende reeks nodig is zonder een matrix, kan een implementatie voorkomen dat er een daadwerkelijke matrix wordt gegenereerd. In hoeft bijvoorbeeld geen foreach ($i in 1..5) { ... }matrix te worden gemaakt.

Een bereikexpressie kan worden gebruikt om een matrixsegment op te geven (9,9).

Voorbeelden:

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

Operator 7.5 Format

Syntaxis:

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)

Beschrijving:

Met een format-expression worden een of meer waarden opgemaakt die zijn aangewezen door range-expression volgens een notatiespecificatiereeks die is aangewezen door format-expression. De posities van de waarden die zijn aangewezen door range-expression , worden genummerd vanaf nul en nemen in lexicale volgorde toe. Het resultaat heeft het type string.

Een notatiespecificatiereeks kan nul of meer indelingsspecificaties bevatten die elk de volgende vorm hebben:

{N [ ,M ][ : FormatString ]}

N vertegenwoordigt de waardepositie van een (vereist) bereikexpressie , M de minimale weergavebreedte (optioneel) en FormatString geeft de (optionele) indeling aan. Als de breedte van een opgemaakte waarde groter is dan de opgegeven breedte, wordt de breedte dienovereenkomstig verhoogd. Waarden waarnaar niet wordt verwezen in FormatString worden genegeerd nadat ze zijn geëvalueerd op neveneffecten. Als N verwijst naar een niet-bestaande positie, wordt het gedrag implementatie gedefinieerd. De waarde van type $null en void worden opgemaakt als lege tekenreeksen. Matrices worden opgemaakt als voor subexpressie (7.1.6). Als u de tekens '{' en '}' wilt opnemen in een indelingsspecificatie zonder dat ze worden geïnterpreteerd als scheidingstekens, schrijft u ze respectievelijk als {{en '}}'.

Zie het type System.IFormattable in Ecma Technical Report TR/84 voor een volledige definitie van indelingsspecificaties.

Voorbeelden:

`$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<

Als N in een indelingsspecificatie naar een niet-bestaande positie verwijst, teert een FormatError.

7.6 Multiplicative Operators

Syntaxis:

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 Vermenigvuldiging

Beschrijving:

Het resultaat van * de vermenigvuldigingsoperator is het product van de waarden die zijn aangewezen door de twee operanden nadat de gebruikelijke rekenkundige conversies (6,15) zijn toegepast.

Deze operator is associatief.

Voorbeelden:

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 Tekenreeksreplicatie

Beschrijving:

Wanneer de linkerope operand * een tekenreeks aanwijzen, maakt de binaire operator een nieuwe tekenreeks die de tekenreeks bevat die is aangewezen door de linkerope operand, die het aantal keren heeft gerepliceerd dat is aangewezen door de waarde van de rechterope operand als geconverteerd naar het type geheel getal (6,4).

Deze operator is associatief.

Voorbeelden:

"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 Matrixreplicatie

Beschrijving:

Wanneer de linkerope operand * een matrix aanwijzen, maakt de binaire operator een nieuwe niet-getrainde 1-dimensionale matrix die de waarde bevat die is aangewezen door de linkeropeer, het aantal keren gerepliceerd dat wordt aangegeven door de waarde van de rechteropetrix als geconverteerd naar het type geheel getal (6,4). Een replicatie van nul resulteert in een matrix van lengte 1. Als de linkeropeen een multidimensionale matrix aanwijzen, wordt deze afgevlakt (9,12) voordat deze wordt gebruikt.

Deze operator is associatief.

Voorbeelden:

$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 Division

Beschrijving:

/ Het resultaat van de delingsoperator is het quotiënt wanneer de waarde die wordt aangeduid door de linkerope operand wordt gedeeld door de waarde die is opgegeven door de rechterope operand nadat de gebruikelijke rekenkundige conversies (6,15) zijn toegepast.

Als een poging wordt gedaan om een geheel getal of decimaal deling door nul uit te voeren, treedt er een door de implementatie gedefinieerde beëindigingsfout op.

Deze operator is associatief.

Voorbeelden:

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

Als een poging wordt gedaan om een geheel getal of decimaal deling door nul uit te voeren, treedt er een RuntimeException-uitzondering op.

7.6.5 Restant

Beschrijving:

Het resultaat van % de restoperator is de rest wanneer de waarde die wordt aangeduid door de linkerope operand wordt gedeeld door de waarde die is aangewezen door de rechteropeerator nadat de gebruikelijke rekenkundige conversies (6,15) zijn toegepast.

Als een poging wordt gedaan om een geheel getal of decimaal deling door nul uit te voeren, treedt er een door de implementatie gedefinieerde beëindigingsfout op.

Voorbeelden:

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

Als een poging wordt gedaan om een geheel getal of decimaal deling door nul uit te voeren, treedt er een RuntimeException-uitzondering op.

7.7 Additieve operators

Syntaxis:

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

7.7.1 Optelling

Beschrijving:

Het resultaat van de opteloperator + is de som van de waarden die zijn aangewezen door de twee operanden nadat de gebruikelijke rekenkundige conversies (6,15) zijn toegepast.

Deze operator is associatief.

Voorbeelden:

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 Tekenreeksen samenvoegen

Beschrijving:

Wanneer de linkerope operand + een tekenreeks aanwijzen, maakt de binaire operator een nieuwe tekenreeks die de waarde bevat die is aangewezen door de linkerope operand, gevolgd door de waarde(en) die zijn aangewezen door de rechterope operand als geconverteerd naar een tekenreeks (6.8).

Deze operator is associatief.

Voorbeelden:

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

7.7.3 Matrix-samenvoeging

Beschrijving:

+ Wanneer de linkeropetrix een matrix aanwijzen, maakt de binaire operator een nieuwe niet-getrainde 1-dimensionale matrix die de elementen bevat die zijn aangewezen door de linkeropeer, direct gevolgd door de waarde(s) die zijn aangewezen door de rechteropend. Multidimensionale matrices in beide operanden worden afgevlakt (9,12) voordat ze worden gebruikt.

Deze operator is associatief.

Voorbeelden:

$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 Hashtable concatenation

Beschrijving:

Wanneer beide operanden Hashtables + aanwijzen, maakt de binaire operator een nieuwe Hashtable die de elementen bevat die zijn aangewezen door de linkeropend, gevolgd door de elementen die zijn aangewezen door de rechterope operand.

Als de Hashtables dezelfde sleutel bevatten, t gegenereerd een implementatie gedefinieerde beëindigingsfout.

Deze operator is associatief.

Voorbeelden:

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

Als de Hashtables dezelfde sleutel bevatten, teert een uitzondering van het type BadOperatorArgument .

7.7.5 Aftrekken

Beschrijving:

- Het resultaat van de aftrekkingsoperator is het verschil wanneer de waarde die wordt aangeduid door de rechterope operand wordt afgetrokken van de waarde die is aangewezen door de linkeropeer nadat de gebruikelijke rekenkundige conversies (6,15) zijn toegepast.

Deze operator is associatief.

Voorbeelden:

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 Vergelijkingsoperators

Syntaxis:

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)

Beschrijving:

Het type van de waarde die is aangewezen door de linkeropeer, bepaalt hoe de waarde die is aangewezen door de rechterope operand wordt geconverteerd (6), indien nodig, voordat de vergelijking wordt uitgevoerd.

Sommige vergelijkingsoperatoren (hier geschreven als -op) hebben twee varianten, één die casegevoelig is (-cop) en een die niet (-iop) is. De -op-versie is gelijk aan -iop. De gevoeligheid van case's is alleen zinvol bij vergelijkingen van waarden van het type tekenreeks. In vergelijkingscontexten zonder tekenreeks gedragen de twee varianten zich hetzelfde.

Deze operators zijn associatief.

7.8.1 Gelijkheids- en relationele operators

Beschrijving:

Er zijn twee gelijkheidsoperators*: gelijkheid* (-eq) en ongelijkheid (-ne); en vier relationele operators: kleiner dan (-lt), kleiner dan of gelijk aan (-le), groter dan (-gt) en groter dan-of-gelijk aan (-ge). Elk van deze heeft twee varianten (7,8).

Als u wilt dat twee tekenreeksen gelijk zijn, moeten ze dezelfde lengte en inhoud en letter hebben, indien van toepassing.

Als de waarde die wordt aangeduid door de linkeropeer geen verzameling is, heeft het resultaat het type bool. Anders is het resultaat een mogelijk lege ongeconstrainde 1-dimensionale matrix met de elementen van de verzameling die True testen in vergelijking met de waarde die is aangewezen door de rechterope operand.

Voorbeelden:

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 Containment-operators

Beschrijving:

Er zijn vier containmentoperators: contains (-contains), does-not-contain (‑notcontains), in (-in) en not-in (-notin). Elk van deze heeft twee varianten (7,8).

De containmentoperators retourneren een resultaat van het type bool dat aangeeft of een waarde ten minste één keer voorkomt (of niet voorkomt) in de elementen van een matrix. Met -contains en ‑notcontainswordt de waarde aangeduid door de rechterope operand en wordt de matrix aangeduid door de linkerope operand. Met -in en -notinworden de operanden omgekeerd. De waarde wordt aangeduid door de linkerope operand en de matrix wordt aangeduid door de rechterope operand.

Als de matrixopeern voor deze operators een scalaire waarde heeft, wordt de scalaire waarde behandeld als een matrix van één element.

Voorbeelden:

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 Operators voor type testen en conversie

Beschrijving:

De typeoperator -is test of de waarde die is aangewezen door de linkeropeen is van het type of is afgeleid van een type dat het type heeft, dat is aangewezen door de rechterope operand. De rechterope operand moet een type of een waarde aanwijzen die kan worden geconverteerd naar een type (zoals een tekenreeks die een type een naam geeft). Het type van het resultaat is bool. De operator type -isnot retourneert de logische negatie van het bijbehorende -is formulier.

De typeoperator -as probeert de waarde die is aangewezen door de linkerope operand te converteren naar het type dat is aangewezen door de rechterope operand. De rechterope operand moet een type of een waarde aanwijzen die kan worden geconverteerd naar een type (zoals een tekenreeks die een type een naam geeft). Als de conversie mislukt, $null wordt geretourneerd. Anders wordt de geconverteerde waarde geretourneerd en is het retourtype van dat resultaat het runtimetype van de geconverteerde waarde.

Voorbeelden:

$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 Operators voor patroonmatching en tekstmanipulatie

7.8.4.1 De operators -like en -notlike

Beschrijving:

Als de linkeropeen de verzameling niet aanwijzen, heeft het resultaat het type bool. Anders is het resultaat een mogelijk lege ongeconstrainde 1-dimensionale matrix met de elementen van de verzameling die True testen in vergelijking met de waarde die is aangewezen door de rechterope operand. De rechterope operand kan een tekenreeks aanwijzen die expressies met jokertekens (3,15) bevat. Deze operators hebben twee varianten (7,8).

Voorbeelden:

"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 De operators -match en -notmatch

Beschrijving:

Als de linkeropeenvolger geen verzameling aanwijzen, heeft het resultaat het type bool en als dat resultaat is $true, worden de elementen van de hashtabel $matches ingesteld op de tekenreeksen die overeenkomen met (of niet overeenkomen) met de waarde die is aangegeven door de rechteropeer. Anders is het resultaat een mogelijk lege ongeconstrainde 1-dimensionale matrix met de elementen van de verzameling die True testen in vergelijking met de waarde die is aangewezen door de rechterope operand en $matches die niet is ingesteld. De rechterope operand kan een tekenreeks aanwijzen die reguliere expressies (3.16) bevat. In dat geval wordt dit een patroon genoemd. Deze operators hebben twee varianten (7,8).

Deze operators ondersteunen submatches (7.8.4.6).

Voorbeelden:

"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 De operator -replace

Beschrijving:

De -replace operator staat tekstvervanging toe in een of meer tekenreeksen die zijn aangewezen door de linkerope operand met behulp van de waarden die zijn aangegeven door de rechterope operand. Deze operator heeft twee varianten (7,8). De rechteropeer heeft een van de volgende vormen:

  • De tekenreeks die moet worden gevonden, die reguliere expressies kan bevatten (3,16). In dit geval is de vervangende tekenreeks impliciet ''.
  • Een matrix van 2 objecten met de tekenreeks die moet worden gevonden, gevolgd door de vervangende tekenreeks.

Als de linkerope operand een tekenreeks aanwijzen, heeft het resultaat type tekenreeks. Als de linkerope operand een 1-dimensionale matrix van tekenreeks aanwijzen, is het resultaat een onbeperkte 1-dimensionale matrix, waarvan de lengte hetzelfde is als voor de matrix van de linkeropeer, die de invoerreeksen bevat nadat de vervanging is voltooid.

Deze operator ondersteunt submatches (7.8.4.6).

Voorbeelden:

"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 De binaire operator -join

Beschrijving:

De binaire -join operator produceert een tekenreeks die de samenvoeging is van de waarde van een of meer objecten die zijn aangewezen door de linkerope operand nadat deze zijn geconverteerd naar tekenreeks (6.7), indien nodig. De tekenreeks die wordt aangeduid door de rechterope operand wordt gebruikt om de (mogelijk lege) waarden in de resulterende tekenreeks te scheiden.

De linkerope operand kan een scalaire waarde of een verzameling zijn.

Voorbeelden:

(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 De binaire splitsoperator

Beschrijving:

De binaire -split operator splitst een of meer tekenreeksen die zijn aangewezen door de linkeropeer, en retourneert de subparts in een beperkte 1-dimensionale matrix van tekenreeksen. Deze operator heeft twee varianten (7,8). De linkerope operand kan een scalaire waarde of een matrix met tekenreeksen aanwijzen. De rechteropeer heeft een van de volgende vormen:

  • Een scheidingstekenreeks
  • Een matrix van 2 objecten met een scheidingstekenreeks gevolgd door een numeriek aantal splitsingen
  • Een matrix van 3 objecten met een scheidingstekenreeks, een numeriek aantal splitsingen en een tekenreeks met opties
  • Een scriptblok
  • Een matrix van 2 objecten met een scriptblok gevolgd door een numeriek aantal splitsingen

De scheidingstekenreeks kan reguliere expressies (3.16) bevatten. Deze wordt gebruikt om subparts te zoeken met de invoerreeksen. Het scheidingsteken is niet opgenomen in de resulterende tekenreeksen. Als de linkeropeen een lege tekenreeks aanwijzen, resulteert dit in een leeg tekenreekselement. Als de scheidingstekenreeks een lege tekenreeks is, vindt u deze op elke tekenpositie in de invoertekenreeksen.

Standaard worden alle subonderdelen van de invoerreeksen als afzonderlijke elementen in het resultaat geplaatst; Het aantal splitsingen kan echter worden gebruikt om dit gedrag te wijzigen. Als dat aantal negatief, nul of groter is dan of gelijk is aan het aantal subparts in een invoerreeks, gaat elk subonderdeel naar een afzonderlijk element. Als dat aantal kleiner is dan het aantal subonderdelen in de invoerreeks, zijn er count-elementen in het resultaat, met het laatste element dat alle subonderdelen bevat die groter zijn dan het eerste aantal - 1 subonderdelen.

Een tekenreeks met opties bevat nul of meer optienamen met elk aangrenzend paar gescheiden door een komma. Vooraanstaand, aaneengesloten en ingesloten witruimte wordt genegeerd. Optienamen kunnen in elke volgorde staan en zijn casegevoelig.

Als een optiesreeks de optienaam SimpleMatch bevat, kan deze ook de optienaam IgnoreCase bevatten. Als een tekenreeks opties bevat de optienaam RegexMatch of deze bevat geen RegexMatch of SimpleMatch, kan deze een optienaam behalve SimpleMatch bevatten. Het mag echter niet zowel Multiline als Singleline bevatten.

Hier is de set met optienamen:

Optie Beschrijving
CultureInvariant Negeert culturele verschillen in taal bij het evalueren van het scheidingsteken.
ExplicitCapture Negeert niet-benoemde match-groepen, zodat alleen expliciete opnamegroepen worden geretourneerd in de lijst met resultaten.
IgnoreCase Forceer niet-casegevoelige matching, zelfs als -csplit wordt gebruikt.
IgnorePatternWhitespace Negeert niet-genegeerde witruimte en opmerkingen gemarkeerd met het nummerteken (#).
Multiline Deze modus herkent het begin en einde van regels en tekenreeksen. De standaardmodus is Singleline.
RegexMatch Gebruik reguliere expressiematching om het scheidingsteken te evalueren. Dit is de standaardinstelling.
SimpleMatch Gebruik eenvoudige tekenreeksvergelijking bij het evalueren van het scheidingsteken.
Eén lijn In deze modus worden alleen het begin en einde van tekenreeksen herkend. Dit is de standaardmodus.

Het scriptblok (7.1.8) specificeert de regels voor het bepalen van het scheidingsteken en moet evalueren om het type bool te typen.

Voorbeelden:

"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 Submatches

Het patroon dat wordt gematcht -matchdoor , -notmatchen -replace kan subparts ( submatches genoemd) bevatten, die worden scheidingstekens tussen haakjes. Kijk eens naar het volgende voorbeeld:

"red" -match "red"

Het resultaat is $true en sleutel 0 van $matches bevat 'rood', dat deel van de tekenreeks die is aangewezen door de linkeropend die exact overeen kwam met het patroon dat is aangegeven door de rechteropeennd.

In het volgende voorbeeld is het hele patroon submatch:

"red" -match "(red)"

Net als voorheen bevat sleutel 0 'rood'. Sleutel 1 bevat echter ook 'rood', dat wil zeggen dat deel van de tekenreeks die wordt aangeduid door de linkeropeener die exact overeenkomen met de submatch.

Houd rekening met het volgende, complexere patroon:

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

Dit patroon maakt submatches van 'r', 're', 'd' of 'rood' mogelijk.

Nogmaals, sleutel 0 bevat 'rood'. Sleutel 1 bevat 're', sleutel 2 bevat 'r' en sleutel 3 bevat 'd'. De sleutel-waardeparen staan in een overeenkomende volgorde van links naar rechts in het patroon, met langere tekenreeksparen vóór kortere reeksen.

In het geval van -replaceheeft de vervangende tekst toegang tot de submatches via $nnamen van het formulier , waarbij de eerste overeenkomst is $1, de tweede is $3, en meer. Bijvoorbeeld:

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

De resulterende tekenreeks is 'de ochtend van maandag'.

In plaats van sleutels in indexen $matches op basis van nul te hebben, kunnen submatches worden benoemd met behulp van het formulier ?<*name*>. Kan bijvoorbeeld "((r)e)(d)" worden geschreven met drie benoemde submatches, m1, m2 en m3, als volgt: "(?<m1>(?<m2>r)e)(?<m3>d)".

7.8.5 Shift-operators

Beschrijving:

De shift left(-shl) operator en shift right (-shr) operator converteert de waarde die is ontworpen door de linkeropend naar een geheel getaltype en de waarde die is aangewezen door de rechteropeerator naar int, indien nodig, met behulp van de gebruikelijke rekenkundige conversies (6,15).

De linkeroperator shift verschuift de linkeropeen na een aantal bits dat wordt berekend zoals hieronder wordt beschreven. De lege bitposities in lage volgorde zijn ingesteld op nul.

Met de shift-rechtsoperator wordt de linkerope operand naar rechts verplaatst met een aantal bits dat wordt berekend zoals hieronder wordt beschreven. De bits in lage volgorde van de linkeropeenpunt worden verwijderd, de resterende bits worden naar rechts verplaatst. Wanneer de linkeropeen een ondertekende waarde is, worden de positie van de lege bit in hoge volgorde ingesteld op nul als de linkeropeen is ingesteld op een niet-negatief en ingesteld op één als de linkeropeenpositie negatief is. Wanneer de linkeropeen een niet-ondertekende waarde is, worden de positie van lege bits in hoge volgorde ingesteld op nul.

Wanneer de linkeropeenpunt het type int heeft, wordt het aantal shiften bepaald door de vijf bits van de rechteropend in lage volgorde. Wanneer de rechteropeen een lang type heeft, wordt het aantal verschuivingen bepaald door de zes bits van de rechteropend in lage volgorde.

Voorbeelden:

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

7.9 Bitwise-operators

Syntaxis:

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

Beschrijving:

De bitwise AND-operator -band, de bitsgewijze OF-operator -boren de bitwise XOR-operator -bxor converteren de waarden die zijn aangewezen door hun operanden, indien nodig, met behulp van de gebruikelijke rekenkundige conversies (6,15). Als na de conversie beide waarden het type int hebben, is dat het type van het resultaat. Als beide waarden een type lang hebben, is dat het type van het resultaat. Als de ene waarde type int heeft en de andere een type lang heeft, is het resultaattype lang. Anders is de expressie niet goed gevormd. Het resultaat is respectievelijk de bitwise AND, bitwise OR of bitwise XOR van de mogelijk geconverteerde operandwaarden.

Deze operators zijn associatief. Ze zijn welwerkf als geen van beide operanden een neveneffect bevat.

Voorbeelden:

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 Logische operators

Syntaxis:

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

Beschrijving:

De logische AND-operator -and converteert de waarden die zijn toegewezen door de operanden boolnaar , indien nodig (#6.2). Het resultaat is de logische AND van de mogelijk geconverteerde operandwaarden en heeft het type bool. Als de linkeropeen wordt geëvalueerd als Onwaar, wordt de rechteropeen niet geëvalueerd.

De logische OR-operator -or converteert de waarden die zijn toegewezen door de operanden boolnaar , indien nodig (6.2). Het resultaat is de logische OR van de mogelijk geconverteerde operandwaarden en heeft het type bool. Als de linkeropeen wordt geëvalueerd als Waar, wordt de rechteropeen niet geëvalueerd.

De logische XOR-operator -xor converteert de waarden die zijn toegewezen door de operanden naar bool (#6.2). Het resultaat is de logische XOR van de mogelijk geconverteerde operandwaarden en heeft het type bool.

Deze operators zijn associatief.

Voorbeelden:

$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 Toewijzingsoperators

Syntaxis:

assignment-expression:
    expression assignment-operator statement

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

Beschrijving:

Een toewijzingsoperator slaat een waarde op in de beschrijfbare locatie die is aangewezen door de expressie . Zie voor een discussie over toewijzingsoperator = :7.11.1. Zie voor een bespreking van alle andere toewijzingsoperatoren ,7.11.2.

Een toewijzingsexpressie heeft de waarde die is toegewezen door de expressie nadat de toewijzing heeft plaatsgevonden; Deze toewijzingsexpressie wijst echter zelf geen beschrijfbare locatie aan. Als expressie beperkt is tot het type (5.3), is het type dat in die beperking wordt gebruikt het type van het resultaat; anders is het type van het resultaat het type nadat de gebruikelijke rekenkundige conversies (6,15) zijn toegepast.

Deze operator is juist associatief.

7.11.1 Eenvoudige toewijzing

Beschrijving:

In eenvoudige toewijzing (=) vervangt de waarde die is aangewezen door de instructie de waarde die is opgeslagen op de beschrijfbare locatie die is aangewezen door expressie. Als expressie echter een niet-bestaande sleutel in een hashtabel aanwijzen, wordt die sleutel toegevoegd aan de hashtabel met een gekoppelde waarde van de waarde die is aangewezen door de instructie .

Zoals wordt weergegeven in de grammatica, kan de expressie een door komma's gescheiden lijst met beschrijfbare locaties aanwijzen. Dit staat bekend als meerdere toewijzingen. met de instructie wordt een lijst met een of meer door komma's gescheiden waarden aangeduid. De komma's in beide operanden maken deel uit van de syntaxis voor meerdere toewijzingen en vertegenwoordigen niet de binaire kommaoperator. Waarden worden genomen uit de lijst die is aangewezen door de instructie , in lexicale volgorde, en opgeslagen in de bijbehorende beschrijfbare locatie die is aangewezen door expressie. Als de lijst die is aangewezen door de instructie minder waarden heeft dan er beschrijfbare locaties voor expressies zijn, nemen de overtollige locaties de waarde over$null. Als de lijst die is aangewezen door de instructie meer waarden bevat dan er beschrijfbare locaties voor expressies zijn, nemen alle behalve de meest rechtse expressielocatie de bijbehorende instructiewaarde aan en wordt de meest rechtse expressielocatie een niet-getrainde 1-dimensionale matrix met alle resterende instructiewaarden als elementen.

Voor instructies met waarden (8.1.2) kan de instructie een instructie zijn.

Voorbeelden:

$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 Samengestelde toewijzing

Beschrijving:

Een samengestelde toewijzing heeft de vorm E1 op= E2en is E1 = E1 op (E2) gelijk aan de eenvoudige toewijzingsexpressie, behalve dat in het geval van samengestelde toewijzing de expressie E1 slechts één keer wordt geëvalueerd. Als expressie beperkt is tot het type (5.3), is het type dat in die beperking wordt gebruikt het type van het resultaat; anders wordt het type van het resultaat bepaald door 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.

Notitie

Een operand die een niet-getrainde waarde van het numerieke type aanwijst, kan het type wijzigen door een toewijzingsoperator wanneer het resultaat wordt opgeslagen.

Voorbeelden:

$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 Omleidingsoperators

Syntaxis:

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

Beschrijving:

De omleidingsoperator > neemt de standaarduitvoer van de pijplijn en leidt deze om naar de locatie die is aangewezen door redirected-file-name, en overschrijft de huidige inhoud van die locatie.

De omleidingsoperator >> neemt de standaarduitvoer van de pijplijn en leidt deze om naar de locatie die is aangewezen door redirected-file-name, afhankelijk van de huidige inhoud van die locatie, indien aanwezig. Als deze locatie niet bestaat, wordt deze gemaakt.

De omleidingsoperator n> met het formulier neemt de uitvoer van stream n van de pijplijn en leidt deze om naar de locatie die is aangewezen door redirected-file-name, en overschrijft de huidige inhoud van die locatie.

De omleidingsoperator n>> met het formulier neemt de uitvoer van stream n van de pijplijn en leidt deze om naar de locatie die is aangewezen door redirected-file-name, afhankelijk van de huidige inhoud van die locatie, indien vandaan. Als deze locatie niet bestaat, wordt deze gemaakt.

De omleidingsoperator met het formulier m>&n schrijft uitvoer van stream m naar dezelfde locatie als stream n.

Hier volgen de geldige stromen:

Stream Beschrijving
1 Standaarduitvoerstroom
2 Foutuitvoerstroom
3 Waarschuwingsuitvoerstroom
4 Uitgebreide uitvoerstroom
5 Foutopsporingsuitvoerstroom
* Standaarduitvoer, foutuitvoer, waarschuwingsuitvoer, uitgebreide uitvoer en foutopsporingsuitvoerstromen

De omleidingsoperators 1>&2, 6>en 6>> < zijn gereserveerd voor toekomstig gebruik.

Als bij uitvoer de waarde van redirected-file-name is $null, wordt de uitvoer verwijderd.

Normaal gesproken wordt de waarde van een expressie met een neveneffect op het hoogste niveau niet naar de pijplijn geschreven, tenzij die expressie tussen haakjes staat. Als een dergelijke expressie echter de linkerope operand is van een operator die standaarduitvoer omleiden, wordt de waarde geschreven.

Voorbeelden:

$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