7. Expressies

Redactionele notitie

Belangrijk

De Windows PowerShell Language Specification 3.0 is gepubliceerd in december 2012 en is gebaseerd op Windows PowerShell 3.0. Deze specificatie geeft niet de huidige status van PowerShell weer. Er is geen plan om deze documentatie bij te werken om de huidige status weer te geven. Deze documentatie wordt hier gepresenteerd voor historische naslaginformatie.

Het specificatiedocument is beschikbaar als een Microsoft Word-document in het Microsoft Downloadcentrum op: https://www.microsoft.com/download/details.aspx?id=36389 Dat Word-document hier is geconverteerd voor presentatie in Microsoft Learn. Tijdens de conversie zijn enkele redactionele wijzigingen aangebracht om opmaak voor het Docs-platform mogelijk te maken. Sommige typfouten en kleine fouten zijn gecorrigeerd.

Syntaxis:

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

Beschrijving:

Een expressie is een reeks operatoren en operanden die een methode, een functie, een beschrijfbare locatie of een waarde aanwijzen; geeft de berekening van een waarde; produceert een of meer bijwerkingen; of voert een combinatie daarvan uit. Bijvoorbeeld

• De letterlijke waarde 123 is een expressie die de int-waarde 123 aangeeft.
• De expressie 1,2,3,4 het matrixobject met vier elementen aanwijst met de weergegeven waarden.
• De expressie 10.4 * $a geeft een berekening op.
• De expressie $a++ produceert een neveneffect.
• De expressie $a[$i--] = $b[++$j] voert een combinatie van deze dingen uit.

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

Een implementatie van PowerShell kan ondersteuning bieden voor door de gebruiker gedefinieerde typen en deze typen kunnen bewerkingen bevatten die erop zijn gedefinieerd. Alle details van dergelijke typen en bewerkingen worden gedefinieerd door de implementatie.

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 is het. Zie §7.1.1 voor een gedetailleerde bespreking hiervan.

Gewoonlijk wordt een expressie die een verzameling aanwijst ([§4§4]) geïnventariseerd 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 die de verzameling aangeeft de variabele $x, wat resulteert in drie int waarden, plus de int 99. In het derde geval is de expressie echter een directe aanroep naar een cmdlet, dus het resultaat wordt niet opgesomd en $a is een matrix van twee elementen, int[3] en int.

Als een bewerking niet is gedefinieerd door PowerShell, wordt het type waarde dat is aangewezen door de linkeroperand gecontroleerd om te zien of deze een bijbehorende op_<operation> methode 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 Groeperen van haakjes

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 geparentheseerde expressie is een primaire expressie waarvan het type en de waarde hetzelfde zijn als die van de expressie zonder haakjes. Als de expressie een variabele aanwijst, wijst de haakje-expressie diezelfde variabele aan. $x.m en ($x).m zijn bijvoorbeeld gelijkwaardig.

Het groeperen van haakjes kan worden gebruikt in een expressie om de standaardprioriteit en associativiteit binnen die expressie vast te leggen. Ze kunnen ook worden gebruikt om die standaardprioriteit 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 groeperen op het hoogste niveau redundant. Dat is echter niet altijd het geval. Bekijk het volgende voorbeeld:

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

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

Hier volgt 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 de eerste en derde gevallen wordt de waarde van het resultaat naar de pijplijn geschreven. Hoewel de expressie in het tweede geval wordt geëvalueerd, wordt het resultaat niet naar de pijplijn geschreven vanwege de aanwezigheid van de bijwerking-operator = op het hoogste niveau. (Door het $a = deel te verwijderen, kan de waarde worden geschreven, omdat * geen operator voor neveneffect is.)

Om te voorkomen dat een waarde van een expressie zonder neveneffecten op het hoogste niveau naar de pijplijn wordt geschreven, moet deze expliciet worden genegeerd, als volgt:

# 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, plaatst u de waarde van een expressie met bijwerkingen op het hoogste niveau als volgt tussen haakjes:

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

Daarom zijn de groeperende haakjes in dit geval niet overbodig.

In het volgende voorbeeld hebben we variabele vervanging (§2.3.5.2) die plaatsvindt in een letterlijke tekenreeks:

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

In het eerste geval vertegenwoordigen de haakjes de begrenzers van een subexpressieniet groeperingshaakjes en omdat de expressie op het hoogste niveau een operator voor neveneffect bevat, wordt de waarde van de expressie niet naar de pijplijn geschreven. Natuurlijk worden de > en < tekens nog geschreven.) Als er groeperingshaakjes worden toegevoegd (zoals weergegeven in het tweede geval), is schrijven ingeschakeld.

De volgende voorbeelden bevatten allemaal operators voor side-effect 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 haakjes groeperen rond een expressie die geen neveneffecten op het hoogste niveau bevat, maakt deze haakjes overbodig. Bijvoorbeeld;

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

Bekijk het volgende voorbeeld met twee bijwerkingen, waarvan geen van beide zich op het hoogste niveau bevindt:

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 Toegang tot leden

Syntaxis:

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

Houd er rekening mee dat er geen spaties zijn toegestaan na primaire-uitdrukking.

Beschrijving:

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

De rechteroperand wijst een toegankelijk exemplaarlid aan binnen het type object dat is aangewezen door de linkeroperand of, als de linkeroperand een matrix aanwijst, wijst de rechteroperand toegankelijke exemplaarleden aan binnen elk element van de matrix.

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

Deze operator blijft associatief.

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

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

Deze operator blijft associatief.

Als de rechteroperand een beschrijfbare locatie aanwijst binnen het type object dat is aangewezen door de linkeroperand, 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:
    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~ )

Houd er rekening mee dat er geen spaties zijn toegestaan na primaire-uitdrukking.

Beschrijving:

Een aanroepexpressie roept de methode aan die is aangewezen door primary-expression.member-name of primary-expression::member-name. De haakjes in argumentlijst een mogelijk lege, door komma's gescheiden lijst met expressies bevatten 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 overeen te komen met de typen die door de methode worden verwacht. De evaluatievolgorde van primary-expression.member-name, primary-expression::member-nameen de argumenten zijn niet opgegeven.

Deze operator blijft associatief.

Het type van het resultaat van een aanroepexpressie is een method-designator (§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 Elementtoegang

Syntaxis:

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

Beschrijving:

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

7.1.4.1 Een matrix subscripteren

Beschrijving:

Matrices worden uitgebreid besproken in §9. Als expressie een 1dimensionale matrix is, raadpleegt u §7.1.4.5.

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

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

Wanneer primaire expressie een matrix van drie of meer dimensies aanwijst, 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, wordt het resultaat $null. Het is een fout bij het schrijven naar een niet-bestaand element.

Voor een subscriptexpressie met multidimensionale matrices is de volgorde van evaluatie van de dimensiepositieexpressies niet opgegeven. Als u bijvoorbeeld een driedimensionale matrix $ahebt, is het gedrag van $a[$i++,$i,++$i] niet opgegeven.

Als expressie een matrix is, raadpleegt u §7.1.4.5.

Deze operator blijft 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 een schrijftoegang tot een niet-bestaand element wordt geprobeerd, wordt er een IndexOutOfRange uitzondering gegenereerd.

7.1.4.2 Een tekenreeks subscripteren

Beschrijving:

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

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 subscripteren

Beschrijving:

Wanneer primaire expressie een hashtabel aanwijst, retourneert de operator [] de waarde(s) die zijn gekoppeld aan de sleutel(en) die zijn aangewezen door expressie. Het type uitdrukking kent geen beperkingen.

Als expressie een enkele sleutelnaam is, is het resultaat de bijbehorende waarde en heeft dat type als resultaat, tenzij er geen dergelijke sleutel bestaat, in dat geval is het resultaat $null. Als $null wordt gebruikt als sleutel, wordt het gedrag door de implementatie bepaald. Als expressie een matrix met sleutelnamen is, raadpleegt u §7.1.4.5.

Als expressie een matrix is, raadpleegt u §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, wordt er een $null uitzondering gegenereerd als als enige waarde wordt gebruikt om een Hashtable te subscripteren.

7.1.4.4 Subscripting van een XML-document

Beschrijving:

Wanneer primaire expressie een object van het type XML aanwijst, wordt expressie indien nodig geconverteerd naar tekenreeks en retourneert de operator [] het eerste onderliggende element met de naam die is opgegeven door expressie. Het type expressie van moet een string zijn. Het type van het resultaat is afhankelijk van de implementatie gedefinieerd. Het resultaat kan worden aangesproken met een subscript om het eerste kindelement terug te geven. Als er geen kindelement bestaat met de naam die is opgegeven door expressie, wordt het resultaat $null. Het resultaat wijst geen schrijfbare 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 resultaat is System.Xml.XmlElement of System.String.

7.1.4.5 Matrixsegmenten genereren

Wanneer primaire expressie een object aanwijst van een type dat kan worden opgesomd (§4) of een hashtabel en expressie een 1dimensionale matrix is, is het resultaat een matrixsegment (§9,9) met de elementen van primaire expressie aangewezen door de elementen van expressie.

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

Voorbeelden:

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

7.1.5 Operatoren voor het verhogen en verlagen van het voorvoegsel

Syntaxis:

post-increment-expression:
    primary-expression ++

post-decrement-expression:
    primary-expression dashdash

Beschrijving:

De primaire expressie moet een schrijfbare locatie met een waarde van het numerieke type (§4) of de waarde $nullaanwijzen. Als de waarde die wordt aangewezen door de operand $nullis, wordt die waarde geconverteerd naar het type int en vervolgens naar de waarde nul voordat de operator wordt geëvalueerd. Het type van de waarde die is aangewezen door primaire expressie kan veranderen wanneer het resultaat wordt opgeslagen. Zie §7.11 voor een discussie over typewijziging via toewijzing.

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

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

Deze operatoren blijven 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 behavior

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

7.1.6 $(...) operator

Syntaxis:

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

Beschrijving:

Als verklaringenlijst wordt weggelaten, is het resultaat $null. Anders wordt verklaringslijst geëvalueerd. Objecten die als onderdeel van de evaluatie naar de pijplijn worden geschreven, worden verzameld in een ongeconstrainde 1-dimensionale matrix, in volgorde. Als de matrix met verzamelde objecten leeg is, wordt het resultaat $null. Als de matrix van verzamelde objecten één element bevat, is het resultaat dat element; anders is het resultaat de niet-getrainde 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 instructielijst wordt weggelaten, is het resultaat een onbegrensde 1-dimensionale array van lengte nul. Anders wordt instructielijst geëvalueerd en worden alle objecten die als onderdeel van de evaluatie naar de pijplijn worden geschreven, in een ongerestricte 1-dimensionale array verzameld, in volgorde. Het resultaat is de (mogelijk lege) ongeconstrainde 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 Scriptblok-uitdrukking

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:

paramblok wordt beschreven in §8.10.9. lijst met benoemde blokken wordt beschreven in §8.10.7.

Een scriptblok is een niet-benoemd blok met instructies die als één eenheid kunnen worden gebruikt. Scriptblokken kunnen worden gebruikt om een codeblok aan te roepen alsof het één opdracht was, of ze kunnen worden toegewezen aan variabelen die kunnen worden uitgevoerd.

De benoemde lijst met namen of instructielijst wordt uitgevoerd en het type en de waarde van het resultaat zijn het type en de waarde(s) van de resultaten van deze instructiesets.

Een scriptblokexpressie is van het type scriptblock (§4.3.7).

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

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

7.1.9 Letterlijke hash-expressie

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-letterlijke expressie wordt gebruikt om een hashtabel (§10) van nul of meer elementen te maken die elk een sleutel-waardepaar zijn.

De sleutel kan elk type hebben, behalve het null-type. De gekoppelde waarden kunnen elk type hebben, inclusief het null-type, en elk van deze waarden kan elke expressie zijn die de gewenste waarde aanwijst, inclusief $null.

De volgorde van de sleutel-waardeparen is niet significant.

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 }

waarmee twee hashtabellen worden gemaakt, $h1 en $h2, die elk drie sleutel-/waardeparen bevatten, en een derde, $h3, die leeg is. Hashtable $h4 heeft sleutels van verschillende typen.

7.1.10 Letterlijke expressie van type

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 typeliteratuur wordt in een implementatie weergegeven door een niet-gespecificeerd onderliggend type. Als gevolg hiervan is een typenaam een synoniem voor het onderliggende type.

Type-literals worden gebruikt in verschillende contexten:

• Een expliciete conversie opgeven (§6, §7.2.9)
• Een typebeperkingsmatrix 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:

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

Een algemeen stacktype (§4.4) dat speciaal is voor het opslaan van tekenreeksen, kan worden geschreven als [Stack[string]]en een algemeen woordenlijsttype dat is gespecialiseerd voor het opslaan van int sleutels met bijbehorende tekenreekswaarden, kan worden geschreven als [Dictionary[int,string]].

Het type van een type-literal 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 operatoren

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

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

Beschrijving:

De komma-operator (,) maakt een niet-gekoppelde 1-dimensionale matrix met één element, waarvan het type en de waarde dat zijn van unaire expressie.

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

Syntaxis:

logical-not-operator:
    dash not

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

Beschrijving:

De operator -not de waarde die is aangewezen door unary-expression converteert naar het type bool (§6.2), en produceert indien nodig een resultaat van dat type. Als de waarde van unaire-expressieWaar is, dan is het resultaat Onwaar, 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 Bitsgewijze NOT

Syntaxis:

bitwise-not-operator:
    dash bnot

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

Beschrijving:

De operator -bnot de waarde die door unaire expressie is aangewezen, converteert naar een geheel getal (§6,4), indien nodig. Als de geconverteerde waarde kan worden weergegeven in het type int is dat het resultaattype. Als de geconverteerde waarde in type long kan worden weergegeven, dan is dat het resultaattype. Anders is de uitdrukking ongeldig gevormd. De resulterende waarde is de aanvulling op 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 het is geschreven als 0 + unary-expression (§7,7). Het letterlijke 0 geheel getal 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 Unary min

Beschrijving:

Een expressie van het formulier - unary-expression wordt behandeld alsof het is geschreven als 0 - unary-expression (§7,7). De letterlijke waarde van het gehele getal 0 heeft het type int. De mintekenoperator kan een van de streepjes tekens zijn die worden vermeld in §7,2.

Deze operator is juist associatief.

Voorbeelden:

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

7.2.6 Voorvoegsel verhogen en verlagen operators

Beschrijving:

De unaire expressie moet een schrijfbare locatie met een waarde van het numerieke type (§4) of de waarde $nullaanwijzen. Als de waarde die is aangewezen door de unaire expressie$nullis, wordt unaire expressie geconverteerdde waarde wordt geconverteerd naar het type int en de waarde nul voordat de operator wordt geëvalueerd.

Notitie

Het type van de waarde die is aangewezen door unaire expressie kan veranderen wanneer het resultaat wordt opgeslagen. Zie §7.11 voor een discussie over typewijziging via toewijzing.

De prefix-incrementoperator ++ verhoogt de waarde van de unaire expressie met 1 van het geschikte type. Het resultaat is de nieuwe waarde nadat het verhogen heeft plaatsgevonden. De expressie ++E is gelijk aan E += 1 (§7.11.2).

Voor de prefix-decrementoperator -- wordt de waarde van de unitaire expressie verlaagd met 1 van het juiste type. Het resultaat is de nieuwe waarde nadat het verlagen heeft plaatsgevonden. De expressie --E is gelijk aan E -= 1 (§7.11.2). De operator voor het verlagen van voorvoegsels kan een van de patronen zijn die overeenkomen met het patroon dashdash in §7.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 becomes -1

7.2.7 De unaire -join operator

Syntaxis:

join-operator:
    dash join

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

Beschrijving:

De unaire -join-operator levert een tekenreeks die de samenvoeging is van de waarde van een of meer objecten aangewezen door de -unaire-expressie. (Een scheidingsteken kan worden ingevoegd met behulp van de binaire versie van deze operator (§7.8.4.4).)

unaire expressie 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

Syntaxis:

split-operator:
    dash split

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

Beschrijving:

De unaire -split-operator splitst een of meer tekenreeksen die zijn aangewezen door de unaire expressie en retourneert hun subonderdelen in een beperkte 1-dimensionale array van tekenreeksen. Het behandelt elke aaneengesloten groep witruimtetekens als het scheidingsteken tussen opeenvolgende subonderdelen. Een expliciete scheidingstekenreeks kan worden opgegeven met behulp van de binaire versie van deze operator (§7.8.4.5) of de twee varianten (§7.8).

De tekst van het scheidingsteken wordt niet opgenomen in de resulterende tekenreeksen. Voorloop- en volgspaties in de invoertekenreeks worden genegeerd. Een invoertekenreeks die leeg is of witruimte bevat, resulteert alleen in een matrix van één tekenreeks, die leeg is.

unaire expressie 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 unaire expressie naar het type dat is aangewezen door type-letterlijke (§7.1.10). Als type-letterlijke anders is dan nietig, is het type van het resultaat het benoemde type en de waarde de waarde na de conversie. Als type-litteraal leeg is, wordt er geen object naar de pijplijn geschreven en is er geen resultaat.

Wanneer een expressie van een willekeurig type naar hetzelfde type wordt gecast, zijn het resulterende type en de waarde die van de eenplaatsige expressie.

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 , new-lines~opt~ array-literal-expression

Beschrijving:

De binaire komma-operator maakt een 1dimensionale matrix waarvan de elementen de waarden zijn die zijn aangewezen door de operanden, in lexicale volgorde. De array 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 groeperingshaakjes aan bepaalde binaire komma-expressies documenteert niet de standaardprioriteit; in plaats daarvan verandert het resultaat.

7.4 Bereikoperator

Syntaxis:

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

Beschrijving:

Een bereikexpressie maakt een niet-gekoppelde 1dimensionale matrix waarvan de elementen de waarden zijn van de int reeks die is opgegeven door de bereikgrenzen. De waarden die door de operanden worden aangewezen, worden indien nodig geconverteerd naar int(§6.4). De operand die de lagere waarde na conversie aangeeft, is de ondergrens, terwijl de operand die de hogere waarde na conversie aangeeft, de bovengrensis. Beide grenzen kunnen hetzelfde zijn, in dat geval heeft de resulterende matrix de lengte 1. Als de linkeroperand de ondergrens aanwijst, bevindt de reeks zich in oplopende volgorde. Als de linkeroperand de bovengrens aanwijst, bevindt de reeks zich in aflopende volgorde.

In essentie is deze operator een vereenvoudiging van de overeenkomstige reeks van binaire kommaoperatoren. Het bereik 5..8 kan bijvoorbeeld ook worden gegenereerd met behulp van 5,6,7,8. Als echter een oplopende of aflopende reeks nodig is zonder een matrix te hebben, kan een implementatie het genereren van een werkelijke matrix voorkomen. In foreach ($i in 1..5) { ... }hoeft u bijvoorbeeld geen matrix te maken.

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

Voorbeelden:

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 Formaatoperator

Syntaxis:

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)

Beschrijving:

Een formaat-expressie formatteert een of meer waarden die zijn aangewezen door bereik-expressie volgens een formaat-specificatie-reeks aangewezen door formaat-expressie. De posities van de waarden die zijn bepaald door bereik-expressie worden genummerd vanaf nul en in oplopende lexicale volgorde. Het type van het resultaat is string.

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

{N [ ,M ][ : FormatString ]}

N- vertegenwoordigt een (vereiste) bereikexpressie waardepositie, geeft M- de minimale weergavebreedte aan en FormatString 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 voor bijwerkingen. Als N verwijst naar een niet-bestaande positie, is het gedrag afhankelijk van de implementatie. Waarden van het type $null en void worden als lege tekenreeksen opgemaakt. 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 opmaakscheidingstekens, schrijft u ze respectievelijk als {{ en }}.

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

Voorbeelden:

"__{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__

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

7.6 Vermenigvuldigende operatoren

Syntaxis:

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 Vermenigvuldiging

Beschrijving:

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

Deze operator blijft 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 linkeroperand een tekenreeks aanwijst, maakt de binaire * operator een nieuwe tekenreeks die de tekenreeks bevat die door de linkeroperand is aangewezen, herhaald zoveel keer als is aangegeven door de waarde van de rechteroperand, geconverteerd naar het geheel getal type (§6.4).

Deze operator blijft 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 linkeroperand een array aanwijst, maakt de binaire operator * een nieuwe onbegrensde 1-dimensionale array die de waarde bevat die door de linkeroperand is aangewezen, gerepliceerd het aantal keer dat wordt bepaald door de waarde van de rechteroperand, omgezet naar een geheel getal (§6.4). Een replicatieaantal van nul resulteert in een matrix van lengte 1. Als de linkeroperand een multidimensionale matrix aanwijst, wordt deze afgevlakt (§9,12) voordat deze wordt gebruikt.

Deze operator blijft 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 Divisie

Beschrijving:

Het resultaat van de operator voor delen / is het quotiënt wanneer de door de linkeroperand aangewezen waarde wordt gedeeld door de door de rechteroperand aangewezen waarde na de gebruikelijke rekenkundige conversies (§6,15) zijn toegepast.

Als er een poging wordt gedaan om gehele getallen of decimaal te delen door nul, wordt er een door de implementatie gedefinieerde afsluitfout gegenereerd.

Deze operator blijft 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 er een poging wordt gedaan om gehele getallen of decimalen te delen door nul, wordt een RuntimeException uitzondering gegenereerd.

7.6.5 Rest

Beschrijving:

Het resultaat van de restoperator % is de rest wanneer de waarde die door de linkeroperand is aangewezen, wordt gedeeld door de waarde die is aangewezen door de rechteroperand nadat de gebruikelijke rekenkundige conversies (§6,15) zijn toegepast.

Als er een poging wordt gedaan om gehele getallen of decimaal te delen door nul, wordt er een door de implementatie gedefinieerde afsluitfout gegenereerd.

Voorbeelden:

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

Als er een poging wordt gedaan om gehele getallen of decimalen te delen door nul, wordt een RuntimeException uitzondering gegenereerd.

7.7 Additieve operatoren

Syntaxis:

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 Optellen

Beschrijving:

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

Deze operator blijft 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 Tekenreekssamenvoeging

Beschrijving:

Wanneer de linkeroperand een tekenreeks aanwijst, maakt de operator binaire + een nieuwe tekenreeks die de waarde bevat die is aangewezen door de linkeroperand, gevolgd door de door de rechteroperand aangewezen waarde(s) die zijn geconverteerd naar een tekenreeks (§6.8).

Deze operator blijft 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 Matrixsamenvoeging

Beschrijving:

Wanneer de linkeroperand een matrix aanwijst, maakt de operator binaire + een nieuwe ongeconstrainde 1dimensionale matrix die de elementen bevat die zijn aangewezen door de linkeroperand, gevolgd door de waarde(s) die door de rechteroperand zijn aangewezen. Multidimensionale matrices die aanwezig zijn in beide operanden worden afgevlakt (§9,12) voordat ze worden gebruikt.

Deze operator blijft 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-samenvoeging

Beschrijving:

Wanneer beide operanden Hashtables aanwijzen, maakt de operator binaire + een nieuwe Hash-tabel die de elementen bevat die zijn aangewezen door de linkeroperand, gevolgd door de elementen die door de rechteroperand zijn aangewezen.

Als de hashtabellen dezelfde sleutel bevatten, wordt een implementatiegedefinieerde afsluitfout opgetreden.

Deze operator blijft associatief.

Voorbeelden:

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

Als de hashtabellen dezelfde sleutel bevatten, wordt een uitzondering van het type BadOperatorArgument- gegenereerd.

7.7.5 Aftrekken

Beschrijving:

Het resultaat van de aftrekkingsoperator - is het verschil wanneer de door de rechteroperand aangewezen waarde wordt afgetrokken van de waarde die is aangewezen door de linkeroperand nadat de gebruikelijke rekenkundige conversies (§6,15) zijn toegepast. De aftrekkingsoperator kan een van de koppelteken tekens zijn die worden vermeld in §7.7.

Deze operator blijft associatief.

Voorbeelden:

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 Vergelijkingsoperatoren

Syntaxis:

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

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

Beschrijving:

Het type van de waarde die door de linkeroperand is aangewezen, bepaalt hoe de waarde die door de rechteroperand wordt aangewezen (§6), indien nodig, wordt geconverteerd voordat de vergelijking wordt uitgevoerd.

Sommige vergelijkingsoperatoren hebben twee varianten, een die hoofdlettergevoelig (-c<operator>) is en een die niet hoofdlettergevoelig is (-i<operator>). De -<operator> versie is gelijk aan -i<operator>. Hoofdlettergevoeligheid is alleen zinvol bij vergelijkingen van waarden van het type string. In vergelijkingscontexten met niet-tekenreeksen gedragen de twee varianten zich hetzelfde.

Deze operatoren blijven associatief.

7.8.1 Gelijkheids- en relationele operatoren

Syntaxis:

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

Beschrijving:

Er zijn twee gelijkheidsoperators: gelijkheid (-eq) en ongelijkheid (-ne); en vier relationele operatoren: 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).

Opdat twee tekenreeksen als gelijk kunnen worden beschouwd, moeten ze dezelfde lengte, inhoud en, indien van toepassing, hoofdletters hebben.

Als de waarde die is aangewezen door de linkeroperand geen verzameling is, heeft het resultaat het type bool. Anders is het resultaat een mogelijk lege niet-gekoppelde 1-dimensionale matrix die de elementen van de verzameling bevat die Waar testen in vergelijking met de waarde die is aangewezen door de rechteroperand.

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 Insluitingsoperatoren

Syntaxis:

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)

Beschrijving:

Er zijn vier insluitingsoperatoren: bevat (-contains), bevat niet (-notcontains), in (-in) en not-in (-notin). Elk van deze heeft twee varianten (§7,8).

De insluitingsoperatoren retourneren een resultaat van het type bool dat aangeeft of een waarde ten minste één keer voorkomt in de elementen van een matrix. Met -contains en -notcontainswordt de waarde aangewezen door de rechteroperand en wordt de matrix aangewezen door de linkeroperand. Met -in en -notinworden de operanden omgekeerd. De waarde wordt aangewezen door de linkeroperand en de matrix wordt aangewezen door de rechteroperand.

Als de matrixoperand 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
"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 Typetests en conversie-operators

Syntaxis:

type-operator: one of
    dash is
    dash as

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

Beschrijving:

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

De typeoperator -as probeert de waarde die door de linkeroperand is aangewezen, te converteren naar het type dat is aangewezen door de rechteroperand. De rechteroperand moet een type of een waarde aanwijzen die kan worden geconverteerd naar een type (zoals een tekenreeks die een type noemt). Als de conversie mislukt, wordt $null geretourneerd; anders wordt de geconverteerde waarde geretourneerd en het retourtype van dat resultaat is 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 Patroonvergelijking en tekstmanipulatieoperators

7.8.4.1 De operators -like en -notlike

Syntaxis:

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)

Beschrijving:

Als de linkeroperand geen verzameling aanwijst, heeft het resultaat het type bool. Anders is het resultaat een mogelijk lege niet-gekoppelde 1-dimensionale matrix die de elementen van de verzameling bevat die Waar testen in vergelijking met de waarde die is aangewezen door de rechteroperand. De rechteroperand kan een tekenreeks aanwijzen die jokertekenexpressies bevat (§3.15). Deze operatoren 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

Syntaxis:

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)

Beschrijving:

Als de linkeroperand geen verzameling aanwijst, heeft het resultaat het type bool en als dat resultaat $trueis, worden de elementen van de hashtabel $Matches ingesteld op de tekenreeksen die overeenkomen met (of niet-overeenkomend) de waarde die is aangewezen door de rechteroperand. Anders is het resultaat een mogelijk lege niet-gekoppelde 1dimensionale matrix die de elementen van de verzameling bevat die Waar testen in vergelijking met de waarde die is aangewezen door de rechteroperand en $Matches niet is ingesteld. De rechteroperand kan een tekenreeks aanwijzen die reguliere expressies bevat (§3.16), in dat geval wordt het een patroongenoemd. Deze operatoren 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

Syntaxis:

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)

Beschrijving:

De operator -replace staat tekstvervanging toe in een of meer tekenreeksen die zijn aangewezen door de linkeroperand met behulp van de waarden die zijn aangewezen door de rechteroperand. Deze operator heeft twee varianten (§7,8). De rechteroperand 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 standaard "".
• Een matrix van 2 objecten met de tekenreeks die moet worden gevonden, gevolgd door de vervangende tekenreeks.

Als de linkeroperand een tekenreeks aanwijst, heeft het resultaat het type tekenreeks. Als de linkeroperand een 1-dimensionale array van tekenreeksen aanwijst, is het resultaat een ongedefinieerde 1-dimensionale array, waarvan de lengte gelijk is aan die van de array van de linkeroperand, die de invoertekenreeksen 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 operator binaire -join

Syntaxis:

binary-join-operator: one of
    dash join

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

Beschrijving:

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

De linkeroperand 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 operator binaire -split

Syntaxis:

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)

Beschrijving:

De binaire -split-operator splitst een of meer tekenreeksen die zijn aangewezen door de linkeroperand en retourneert hun subonderdelen in een beperkte 1-dimensionale matrix van tekenreeks. Deze operator heeft twee varianten (§7,8). De linkeroperand kan een scalaire waarde of een matrix met tekenreeksen aanwijzen. De rechteroperand heeft een van de volgende vormen:

• Een scheidingstekenreeks
• Een reeks van 2 objecten die een scheidingstekenreeks bevatten, gevolgd door een numerieke splitsaantal
• Een matrix van drie objecten met een tekenreeks met scheidingstekens, een aantal numerieke splitsingen en een optiesreeks
• Een scriptblok
• Een matrix van 2 objecten die een scriptblok bevatten, gevolgd door een aantal numerieke splitsingen

De tekenreeks voor scheidingstekens kan reguliere expressies bevatten (§3.16). Het wordt gebruikt om subonderdelen te zoeken met de invoertekenreeksen. Het scheidingsteken is niet opgenomen in de resulterende tekenreeksen. Als de linkeroperand een lege tekenreeks aanwijst, resulteert dit in een leeg tekenreekselement. Als de scheidingsreeks leeg is, wordt deze gevonden op elke tekenpositie in de invoertekst.

Standaard worden alle subonderdelen van de invoertekenreeksen 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 subonderdelen in een invoertekenreeks, wordt elk subonderdeel in een afzonderlijk element geplaatst. Als dat aantal kleiner is dan het aantal subonderdelen in de invoertekenreeks, zijn er [aantal] elementen in het resultaat, waarbij het laatste element alle subonderdelen bevat die verder gaan dan de eerste - 1 subonderdelen.

Een optiestekenreeks bevat nul of meer optienamen met elk aangrenzend paar gescheiden door een komma. Voorloop-, volg- en ingesloten witruimte wordt genegeerd. Optienamen kunnen in elke volgorde staan en hoofdlettergevoelig zijn.

Als een tekenreeks met opties de optienaam SimpleMatch-bevat, bevat deze mogelijk ook de naam van de optie IgnoreCase. Als een optietekenreeks de optienaam RegexMatch- bevat of niet RegexMatch- of SimpleMatch-bevat, kan deze een optienaam bevatten behalve SimpleMatch-. Het mag echter niet zowel Multiline als Singlelinebevatten.

Hier is de set van optienamen

Optie	Beschrijving
Cultuurinvariant	Negeert taalgerelateerde culturele verschillen bij het evalueren van het scheidingsteken.
ExplicitCapture	Negeert niet-benoemde matchgroepen, zodat alleen expliciete capture groepen worden geretourneerd in de resultaatlijst.
IgnoreCase	Hoofdletterongevoelige overeenkomsten afdwingen, zelfs als -csplit wordt gebruikt.
IgnorePatternWhitespace	Negeert niet-gescaped witruimte en opmerkingen die zijn gemarkeerd met het nummerteken (#).
Meerdere regels	Deze modus herkent het begin en einde van regels en tekenreeksen. De standaardmodus is Singleline-.
RegexMatch	Gebruik reguliere expressiekoppeling om het scheidingsteken te evalueren. Dit is de standaardwaarde.
SimpleMatch	Gebruik eenvoudige tekenreeksvergelijking bij het evalueren van het scheidingsteken.
Enkelelijn	Deze modus herkent alleen het begin en einde van tekenreeksen. Dit is de standaardmodus.

In het scriptblok (§7.1.8) worden de regels opgegeven voor het bepalen van het scheidingsteken, en moet tot het booleaanse type geëvalueerd worden.

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 Submatchen

Het patroon dat wordt vergeleken door -match, -notmatchen -replace kan subonderdelen (submatchesgenoemd) bevatten die zijn gescheiden door haakjes. Bekijk 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 linkeroperand die exact overeenkomt met het patroon dat is aangewezen door de rechteroperand.

In het volgende voorbeeld is het hele patroon een submatch:

"red" -match "(red)"

Net als voorheen bevat sleutel 0 'rood'; sleutel 1 bevat echter ook 'rood', dat is dat deel van de tekenreeks die is aangewezen door de linkeroperand die exact overeenkomt met de submatch.

Houd rekening met het volgende, complexere patroon:

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

Dit patroon staat submatches toe van 're', 'r', 'd' of 'rood'.

Sleutel 0 bevat opnieuw 'rood'. Sleutel 1 bevat 're', sleutel 2 bevat 'r' en sleutel 3 bevat 'd'. De sleutel-/waardeparen zijn in overeenkomende volgorde van links naar rechts in het patroon, waarbij langere tekenreeksen overeenkomen met voorgaande kortere.

In het geval van -replaceheeft de vervangende tekst toegang tot de subovereenkomsten via namen in de vorm van $n, waarbij de eerste overeenkomst $1is, de tweede $3, enzovoort. Bijvoorbeeld

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

De resulterende zin is 'de ochtend van maandag'.

In plaats van dat sleutels in $Matches nul-gebaseerde indexen zijn, kunnen submatches worden benoemd met behulp van de notatie ?<*name*>. "((r)e)(d)" kan bijvoorbeeld worden geschreven met drie benoemde submatchen, m1, m2en m3, als volgt: "(?<m1>(?<m2>r)e)(?<m3>d)".

7.8.5 Shift-operators

Syntaxis:

shift-operator: one of
    dash shl
    dash shr

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

Beschrijving:

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

De left shift-operator verschuift de linkeroperand naar links met een aantal bits zoals hieronder beschreven. De lege bitposities met lage volgorde worden ingesteld op nul.

De operator shift right verschuift de linkeroperand naar rechts door een aantal bits berekend zoals hieronder wordt beschreven. De bits met lage volgorde van de linkeroperand worden verwijderd, de resterende bits zijn naar rechts verschoven. Wanneer de linkeroperand een ondertekende waarde is, worden de lege bitposities in hoge volgorde ingesteld op nul als de linkeroperand niet-negatief is en wordt ingesteld op één als de linkeroperand negatief is. Wanneer de linkeroperand een niet-ondertekende waarde is, worden de lege bitposities in hoge volgorde ingesteld op nul.

Wanneer de linkeroperand van het type int is, wordt het shift-aantal bepaald door de vijf laagste bits van de rechteroperand. Wanneer de rechteroperand van het type long is, wordt de verschuivingswaarde bepaald door de zes laagste bits van de rechteroperand.

Voorbeelden:

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

7.9 Bitsgewijze operators

Syntaxis:

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

Beschrijving:

De bitwise AND-operator -band, de bitwise OR-operator -boren de operator bitwise XOR -bxor de waarden die door hun operanden zijn aangewezen, converteren naar gehele getallen, indien nodig met behulp van de gebruikelijke rekenkundige conversies (§6,15). Na de conversie, als beide waarden van het type int zijn, is dat ook het type van het resultaat. Anders, indien beide waarden van het type long zijn, is dat het type van het resultaat. Als de ene waarde het type int heeft en de andere het type long heeft, is het type van het resultaat long. Anders is de uitdrukking onjuist gevormd. Het resultaat is respectievelijk de bitgewijze AND, de bitgewijze OR of de bitgewijze XOR van de mogelijk geconverteerde operandwaarden.

Deze operatoren blijven associatief. Ze zijn commutatief 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:
    unary-expression -and new-lines~opt~ unary-expression
    unary-expression -or new-lines~opt~ unary-expression
    unary-expression -xor new-lines~opt~ unary-expression

Beschrijving:

De logische AND-operator -and converteert, indien nodig, de waarde die door zijn operand is aangewezen naar bool(§6.2). Het resultaat is de logische EN van de mogelijk geconverteerde operandwaarden en heeft het type bool. Als de linkeroperand onwaar evalueert, wordt de rechteroperand niet geëvalueerd.

De logische OR-operator -or converteert de waarden die door de operanden zijn aangewezen naar bool, indien nodig (§6.2). Het resultaat is de logische OR van de mogelijk geconverteerde operandwaarden en heeft het type bool. Als de linkeroperand waar is, wordt de rechteroperand niet geëvalueerd.

De logische XOR-operator -xor converteert de waarden die zijn aangewezen door de operanden naar bool (§6,2). Het resultaat is de logische XOR van de mogelijk geconverteerde operandwaarden en heeft het type bool.

Deze operatoren blijven 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 Toewijzingsoperatoren

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 expressie. Zie §7.11.1voor de bespreking van =. Zie §7.11.2voor een bespreking van alle andere toewijzingsoperatoren.

Een toewijzingsexpressie heeft de waarde die is aangewezen door expressie nadat de toewijzing is uitgevoerd; Deze toewijzingsexpressie wijst echter zelf geen schrijfbare locatie aan. Als expressie een typebeperking is (§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 na de gebruikelijke rekenkundige conversies (§6,15) toegepast.

Deze operator is juist associatief.

7.11.1 Eenvoudige opdracht

Beschrijving:

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

Zoals wordt weergegeven in de grammatica, kan expressie een door komma's gescheiden lijst met schrijfbare locaties aanwijzen. Dit staat bekend als meervoudige toewijzing. verklaring wijst een lijst met een of meer komma-gescheiden waarden aan. De komma's in beide operandenlijst maken deel uit van de syntaxis van meerdere toewijzingen en niet de binaire kommaoperator vertegenwoordigen. Waarden worden opgehaald uit de lijst die is aangewezen door instructie, in lexicale volgorde en opgeslagen op de bijbehorende beschrijfbare locatie die is aangewezen door expressie. Als de lijst die is toegewezen door instructie minder waarden heeft dan er uitdrukkingslocaties zijn die beschrijfbaar zijn, krijgen de overtollige locaties de waarde $null. Als de lijst die is aangewezen door instructie meer waarden heeft dan er expressie schrijfbare locaties zijn, nemen alle locaties behalve de meest rechtse expressie locatie de overeenkomstige instructie waarde aan, en wordt de meest rechtse expressie locatie een onbegrensde 1-dimensionale array met alle resterende instructie waarden als elementen.

Voor instructies met waarden (§8.1.2), kan 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 gelijk aan de eenvoudige toewijzingsexpressie E1 = E1 op (E2), behalve dat in het samengestelde toewijzingsscenario de expressie E1 slechts één keer wordt geëvalueerd. Als expressie een typebeperking is (§5,3), is het type dat in die beperking wordt gebruikt het type van het resultaat; anders wordt het type resultaat bepaald door op. Zie *=, §7.6.2, §7.6.3voor ; zie /=voor ; zie %=voor ; voor +=, zie §7.7.1, §7.7.2, §7.7.3; zie -=voor .

Notitie

Een operand die een niet-beperkte waarde van het numerieke type aangeeft, kan van type worden gewijzigd door een toewijzingsoperator bij het opslaan van het resultaat.

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:
    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 stuurt deze om naar de locatie die is aangewezen door omgeleide-bestandsnaam, waarbij de huidige inhoud van die locatie wordt overschreven.

De omleidingsoperator >> neemt de standaarduitvoer van de pijplijn en leidt deze om naar de locatie die is opgegeven door bestandsnaam van omleiding, waarbij deze wordt toegevoegd aan de huidige inhoud van die locatie, indien aanwezig. Als deze locatie niet bestaat, wordt deze gemaakt.

De omleidingsoperator met het formulier n> neemt de uitvoer van stream n van de pijplijn en leidt deze om naar de locatie die is aangewezen door omgeleide bestandsnaam, waarbij de huidige inhoud van die locatie wordt overschreven.

De omleidingsoperator met de vorm n>> neemt de uitvoer van stroom en van de pijplijn en leidt deze om naar de locatie die is aangewezen door omgeleide-bestandsnaam, waarbij het wordt toegevoegd aan de huidige inhoud van die locatie, indien van toepassing. Als deze locatie niet bestaat, wordt deze gemaakt.

De omleidingsoperator in de vorm m>&n schrijft uitvoer van stream m naar dezelfde locatie als stream n.

Hier volgen de geldige streams:

Stroom	Beschrijving
1	Standaarduitvoerstroom
2	Foutuitvoerstroom
3	Uitvoerstroom voor waarschuwingen
4	Uitgebreide uitvoerstroom
5	Uitvoerstroom voor foutopsporing
*	Standaarduitvoer, foutuitvoer, waarschuwingsuitvoer, uitgebreide uitvoer en foutopsporingsuitvoerstromen

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

Als de waarde van omgeleide bestandsnaam bij uitvoer $nullis, wordt de uitvoer genegeerd.

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 linkeroperand is van een operator die standaarduitvoer omleidt, 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