7. Uttryck

Syntax:

expression:
    logical-expression

Beskrivning:

Ett uttryck är en sekvens med operatorer och operander som anger en metod, en funktion, en skrivbar plats eller ett värde. anger beräkningen av ett värde. genererar en eller flera sidoeffekter, eller utför någon kombination av dessa. Exempel:

• Literalen 123 är ett uttryck som anger int-värdet 123.
• Uttrycket anger 1,2,3,4 matrisobjektet med 4 element som har de värden som visas.
• Uttrycket anger 10.4 * $a en beräkning.
• Uttrycket ger $a++ en sidoeffekt.
• Uttrycket utför $a[$i--] = $b[++$j] en kombination av dessa saker.

Förutom vad som anges för vissa operatorer är utvärderingsordningen för termer i ett uttryck och i vilken ordning sidoeffekter sker ospecificerade. Exempel på ospecificerade beteenden är: $i++ + $i, $i + --$ioch $w[$j++] = $v[$j].

En implementering av PowerShell kan ge stöd för användardefinierade typer och dessa typer kan ha åtgärder som definierats för dem. All information om sådana typer och åtgärder är implementeringsdefinierad.

Ett uttryck på den översta nivån är ett uttryck som inte ingår i ett större uttryck. Om ett uttryck på den översta nivån innehåller en bieffektsoperator skrivs inte värdet för uttrycket till pipelinen. annars är det det. Se 7.1.1 för en detaljerad beskrivning av detta.

Normalt räknas ett uttryck som anger en samling (4) upp i dess komponenter när värdet för uttrycket används. Detta är dock inte fallet när uttrycket är en cmdlet-anrop. Exempel:

$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

I de två första $(...) användningsområdena för operatorn $xär uttrycket som anger samlingen variabeln , som räknas int upp, vilket resulterar i tre värden plus int 99. Men i det tredje fallet är uttrycket ett direkt anrop till en cmdlet, så resultatet räknas inte upp och $a är en matris med två element, int[3] och int.

Om en åtgärd inte definieras av PowerShell kontrolleras den typ av värde som anges av den vänstra operanden för att se om den har en motsvarande op_<operation> metod.

7.1 Primära uttryck

Syntax:

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 Grupperingsparenteser

Syntax:

Tips

Notationen ~opt~ i syntaxdefinitionerna anger att den lexikala entiteten är valfri i syntaxen.

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

Beskrivning:

Ett parentesuttryck är ett primärt uttryck vars typ och värde är samma som uttryckets utan parenteser. Om uttrycket anger en variabel anger det parentesiserade uttrycket samma variabel. Till exempel är $x.m och ($x).m likvärdiga.

Gruppering av parenteser kan användas i ett uttryck för att dokumentera standardvärdet för prioritet och associativitet i uttrycket. De kan också användas för att åsidosätta standardinställningen och associativiteten. Exempel:

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

Normalt är gruppering av parenteser på den översta nivån redundant. Det är dock inte alltid fallet. Se följande exempel:

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

I det andra fallet ändrar parenteserna semantiken, vilket resulterar i en matris vars två element är en matris med 2 int och skalär int 6.

Här är ett annat undantag:

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

I det första och tredje fallen skrivs resultatets värde till pipelinen. Även om uttrycket i det andra fallet utvärderas skrivs inte resultatet till pipelinen på grund av förekomsten av sidoeffektsoperatorn = på den översta nivån. (Borttagning av delen $a = gör att värdet kan skrivas, eftersom det * inte är en bieffektsoperator.)

Om du vill stoppa ett värde för uttryck som inte innehåller sidoeffekter på den översta nivån från att skrivas till pipelinen tar du bort det explicit, enligt följande:

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

Om du vill skriva värdet för ett uttryck som innehåller sidoeffekter på den översta nivån till pipelinen omsluter du uttrycket inom parentes, enligt följande:

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

Därför är grupperingsparenteserna i det här fallet inte redundanta.

I följande exempel har vi variabelersättning (2.3.5.2) som sker i en stränglitteral:

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

I det första fallet representerar parenteserna ett underuttrycks avgränsare som inte grupperar parenteser, och eftersom uttrycket på den översta nivån innehåller en bieffektsoperator skrivs uttryckets värde inte till pipelinen. Naturligtvis är tecknen > och < fortfarande skrivna.) Om parenteser för gruppering läggs till, vilket visas i det andra fallet, aktiveras skrivning.

Följande exempel innehåller var och en av de översta operatorerna för sidoeffekt:

$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

Användningen av gruppering av parenteser runt ett uttryck som inte innehåller några sidoeffekter på den översta nivån gör dessa parenteser redundanta. Till exempel;

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

Titta på följande exempel som har två sidoeffekter, och ingen av dem är på den översta nivån:

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

Resultatet skrivs till pipelinen eftersom uttrycket på den översta nivån inte har några sidoeffekter.

7.1.2 Medlemsåtkomst

Syntax:

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

Beskrivning:

Operatorn . används för att välja en instansmedlem från ett -objekt eller en nyckel från en Hashtable. Den vänstra operanden måste ange ett -objekt, och den högra operanden måste ange en tillgänglig instansmedlem.

Antingen anger den högra operanden en tillgänglig instansmedlem inom den typ av objekt som anges av den vänstra operanden eller, om den vänstra operanden anger en matris, anger den högra operanden tillgängliga instansmedlemmar inom varje element i matrisen.

Blanksteg tillåts inte före operatorn . .

Operatorn lämnas associativ.

Operatorn :: används för att välja en statisk medlem från en viss typ. Den vänstra operanden måste ange en typ, och den högra operanden måste ange en tillgänglig statisk medlem inom den typen.

Blanksteg tillåts inte före operatorn :: .

Operatorn lämnas associativ.

Om den högra operanden anger en skrivbar plats inom den typ av objekt som anges av den vänstra operanden, anger hela uttrycket en skrivbar plats.

Exempel:

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

Syntax:

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

Beskrivning:

Ett anropsuttryck anropar metoden som anges av primary-expression. member-name or primary-expression::member-name. Parenteserna i argument-list innehåller en eventuellt tom, kommaavgränsad lista över uttryck, som anger de argument vars värden skickas till metoden. Innan metoden anropas utvärderas argumenten och konverteras enligt reglerna för -6, om det behövs, för att matcha de typer som förväntas av metoden. Utvärderingsordningen för primary-expression. member-name, primary-expression::member-name och argumenten är ospecificerade.

Operatorn lämnas associativ.

Typen av resultat av ett anropsuttryck är en metoddesignerare (4.5.24).

Exempel:

[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åtkomst

Syntax:

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

Beskrivning:

Det får inte finnas något tomt utrymme mellan primary-expression och vänster hakparentes ([).

7.1.4.1 Nedsänka en matris

Beskrivning:

Matriser beskrivs i detalj i -9. Om uttrycket är en 1-dimensionell matris, se 7.1.4.5.

När primary-expression anger en 1-dimensionell matris A returnerar operatorn [] elementet A[0 + expression] som finns på efter att värdet för uttrycket har konverterats till int. Resultatet har elementtypen för matrisen som är nedsänkt. Om uttrycket är negativt anger A[expression] elementet som finns på A[A.Length + expression].

När primary-expression anger en 2-dimensionell matris B returnerar [] B[0 + row,0 + column] operatorn elementet som finns på efter att värdet för rad- och kolumnkomponenterna i uttrycket (som anges som en kommaavgränsad lista) har konverterats till int. Resultatet har elementtypen för matrisen som är nedsänkt. Till skillnad från en 1-dimensionell matris har negativa positioner ingen särskild betydelse.

När primary-expression anger en matris med tre eller flera dimensioner tillämpas reglerna för tvådimensionella matriser och dimensionspositionerna anges som en kommaavgränsad lista med värden.

Om du försöker få läsbehörighet för ett icke-befintligt element blir resultatet $null. Det är ett fel att skriva till ett element som inte finns.

För ett flerdimensionellt subscript-uttryck med matris är utvärderingsordningen för dimensionspositionsuttrycken ospecificerad. Om du till exempel har en 3-dimensionell matris $aär beteendet $a[$i++,$i,++$i] för ospecificerat.

Om uttrycket är en matris, se 7.1.4.5.

Den här operatorn lämnas associativ.

Exempel:

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

Om ett försök görs att skriva åtkomst till ett icke-befintligt element utlöses ett IndexOutOfRange-undantag .

7.1.4.2 Nedsänka en sträng

Beskrivning:

När primary-expression anger en sträng S returnerar operatorn [] tecknet som finns i den nollbaserade positionen som anges av uttryck som ett tecken. Om uttrycket är större än eller lika med strängens längd blir resultatet $null. Om uttrycket är negativt anger S[expression] elementet som finns på S[S.Length + expression].

Exempel:

$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 Nedsänka en hash-tabell

Beskrivning:

När primary-expression anger en Hashtable returnerar operatorn [] de värden som är associerade med de nycklar som anges av uttrycket. Typen av uttryck är inte begränsad.

När uttrycket är ett enskilt nyckelnamn är resultatet det associerade värdet och har den typen, såvida inte det inte finns någon sådan nyckel, i vilket fall resultatet är $null. Om $null används som nyckel är implementeringen definierad. Om uttrycket är en matris med nyckelnamn kan du se .7.1.4.5.

Om uttrycket är en matris kan du se .7.1.4.5.

Exempel:

$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

När uttrycket är ett enskilt nyckelnamn, $null och om det används som det enda värdet för att skapa en hashtabell, utlöses ett NullArrayIndex-undantag .

7.1.4.4 Uppsänka ett XML-dokument

Beskrivning:

När primary-expression anger ett objekt av typen xml konverteras uttrycket till sträng, om det behövs, och operatorn [] returnerar det första underordnade elementet som har det namn som anges av uttrycket. Typen av uttryck måste vara sträng. Resultatets typ är implementeringen som definierats. Resultatet kan nedsänkas för att returnera dess första underordnade element. Om det inte finns något undergivet element med det namn som anges av uttrycket blir resultatet $null. Resultatet anger inte en skrivbar plats.

Exempel:

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

Typen av resultat är System.Xml.XmlElement eller System.String.

7.1.4.5 Generera matrissegment

När primary-expression anger ett objekt av en typ som är uppräkningsbar (·4) eller en hash-tabell, och uttrycket är en 1-dimensionell matris, är resultatet en matrissegment (·9.9) som innehåller elementen i primary-expression som anges av elementen i uttrycket.

När det gäller en hash-tabell innehåller matrissegmentet de associerade värdena för de angivna nycklarna, såvida inte det inte finns någon sådan nyckel, i vilket fall motsvarande element är $null. Om $null används som ett nyckelnamn är beteendet implementeringsdefinierat.

Exempel:

$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 : När uttrycket är en samling med två eller flera nyckelnamn, $null om används som ett nyckelnamn ignoreras den nyckeln och inte har något motsvarande element i den resulterande matrisen.

7.1.5 Operatorer för ökning och ökning av postkorrigeringar

Syntax:

post-increment-expression:
    primary-expression ++

post-decrement-expression:
    primary-expression dashdash

dashdash:
    --

Beskrivning:

Det primära uttrycket måste ange en skrivbar plats som har ett värde av numerisk typ (·4) eller värdet $null. Om värdet som operanden anger $nullär konverteras det värdet till typen int och värdet noll innan operatorn utvärderas. Typen av värde som anges av primary-expression kan ändras när resultatet lagras. En diskussion om typändring via tilldelning finns i mer information om ändring av typ i .7.11.

Resultatet som skapas av postfixoperatorn ++ är det värde som operanden anger. När resultatet har erhållits ökas värdet som anges av operanden med 1 av lämplig typ. Typen av resultatet av uttrycket är E++ samma som för resultatet av uttrycket E + 1 (7,7).

Resultatet som skapas av postfixoperatorn -- är det värde som operanden anger. När resultatet har erhållits minskar värdet som operanden anger med 1 av lämplig typ. Typen av resultatet av uttrycket är E-- samma som för resultatet av uttrycket E - 1 (7,7).

Dessa operatorer lämnas associativa.

Exempel:

$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

Operatorn 7.1.6 $(...)

Syntax:

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

Beskrivning:

Om statement-list utelämnas blir resultatet $null. Annars utvärderas instruktionslistan . Alla objekt som skrivs till pipelinen som en del av utvärderingen samlas in i en ej tränad 1-dimensionell matris i ordning. Om matrisen med insamlade objekt är tom blir resultatet $null. Om matrisen med insamlade objekt innehåller ett enda element blir resultatet det elementet. Annars är resultatet den ohämmad 1-dimensionella matrisen med insamlade resultat.

Exempel:

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

Operatorn 7.1.7 @(...)

Syntax:

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

Beskrivning:

Om statement-list utelämnas är resultatet en ej tränad 1-dimensionell matris med längden noll. Annars utvärderas instruktionslistan och alla objekt som skrivs till pipelinen som en del av utvärderingen samlas in i en ej tränad 1-dimensionell matris i ordning. Resultatet är den (eventuellt tomma) ej tränade 1-dimensionella matrisen.

Exempel:

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

Syntax:

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

Beskrivning:

param-block beskrivs i .8.10.9. named-block-list beskrivs i .8.10.7.

Ett skriptblock är ett namnlöst block med instruktioner som kan användas som en enda enhet. Skriptblock kan användas för att anropa ett kodblock som om det vore ett enda kommando, eller så kan de tilldelas till variabler som kan köras.

Den namngivna blocklistan eller instruktionslistan körs och resultatets typ och värde är typen och värdet för resultatet av dessa instruktionsuppsättningar.

Ett skriptblockuttryck har typen scriptblock (–4.3.7).

Om parameterblock utelämnas är argument som skickas till skriptblocket tillgängliga via $args (8.10.1).

Under parameterbindningen kan ett skriptblock skickas antingen som ett skriptblockobjekt eller som resultat när skriptblocket har utvärderats. Mer information finns i 6.17 .

7.1.9 Hash-literaluttryck

Syntax:

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

Beskrivning:

Ett hash-literal-uttryck används för att skapa en hash-tabell (–10) med noll eller flera element som vart och ett är ett nyckel/värde-par.

Nyckeln kan ha vilken typ som helst förutom null-typen. De associerade värdena kan ha vilken typ som helst, inklusive null-typen, och vart och ett av dessa värden kan vara ett uttryck som anger önskat värde, inklusive $null.

Ordningen på nyckel/värde-paren är inte viktig.

Exempel:

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

som skapar två hashtabeller, och $h1 $h2, som var och en innehåller tre nyckel/värde-par, och en tredje, $h3, som är tom. Hash-tabellen $h4 har nycklar av olika typer.

7.1.10 Typlitteraluttryck

Syntax:

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 [

Beskrivning:

En typ-literal representeras i en implementering av någon ospecificerad underliggande typ. Därför är ett typnamn en synonym för dess underliggande typ.

Typlitteraler används i ett antal kontexter:

• Ange en explicit konvertering (·6, ·7.2.9)
• Skapa en typbegränsad matris (·9.4)
• Åtkomst till statiska medlemmar i ett objekt (7.1.2)
• Ange en typbegränsning för en variabel (5.3) eller en funktionsparameter (8.10.2)

Exempel:

Exempel på typlitteraler är [int], [object[]och [int[,,]]. En generisk stacktyp (4.4) som är specialiserad för att innehålla strängar kan skrivas som , int och en allmän ordlistetyp som är specialiserad för att innehålla nycklar med associerade strängvärden kan skrivas [Stack[string]]som [Dictionary[int,string]].

Typen av en type-literal är System.Type. Det fullständiga namnet för den typ som Stack[string] föreslås ovan är System.Collections.Generic.Stack[int]. Det fullständiga namnet för den typ som Dictionary[int,string] föreslås ovan är System.Collections.Generic.Dictionary[int,string].

7.2 Unary-operatorer

Syntax:

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 En enära kommateckenoperator

Beskrivning:

Den här operatorn skapar en icke-tränad 1-dimensionell matris med ett element vars typ och värde är det för ett endimensionellt uttryck.

Den här operatorn är rätt associativ.

Exempel:

$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 Logiskt INTE

Beskrivning:

Operatorn -not konverterar det värde som anges av unary-expression till typen bool (6.2), om det behövs, och genererar ett resultat av den typen. Om ett unary-expression-värde är True blir resultatet False och vice versa. Operatorn ! är en alternativ stavning för -not.

Den här operatorn är rätt associativ.

Exempel:

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

7.2.3 Bitwise NOT

Beskrivning:

Operatorn -bnot konverterar det värde som anges av unary-expression till en heltalstyp (medietyp (6.4), om det behövs. Om det konverterade värdet kan representeras av typen int är det resultattypen. Om det konverterade värdet kan representeras av typen long är det annars resultattypen. Annars är uttrycket dåligt format. Det resulterande värdet är ett komplement till det konverterade värdet.

Den här operatorn är rätt associativ.

Exempel:

-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

Beskrivning:

Ett uttryck av formuläret +unary-expression behandlas som om det skrevs som 0 + unary-expression (-7.7). Heltalslitteralen 0 har typen int.

Den här operatorn är rätt associativ.

Exempel:

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

7.2.5 Unary minus

Beskrivning:

Ett uttryck av formuläret -unary-expression behandlas som om det skrevs som 0 - unary-expression (-7.7). Heltalslitteralen 0 har typen int.

Den här operatorn är rätt associativ.

Exempel:

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

7.2.6 Operatorer för ökning och ökning av prefix

Beskrivning:

Unary-expression måste ange en skrivbar plats som har ett värde av numerisk typ (#4) eller värdet $null. Om värdet som anges av dess unary-expression $nullär konverteras värdet för ett unary-expression till type int och value zero innan operatorn utvärderas.

Anteckning

Typen av värde som anges av unary-expression kan ändras när resultatet lagras. Se 7.11 för en diskussion om typändring via tilldelning.

För prefixoperatorn ++ ökas värdet för ett unary-expression med 1 av lämplig typ. Resultatet är det nya värdet när inkrement har skett. Uttrycket motsvarar ++E E += 1 (–7.11.2).

För prefixoperatorn -- minskar värdet för unary-expression med 1 av lämplig typ. Resultatet är det nya värdet efter att minskande har skett. Uttrycket motsvarar --E E -= 1 (–7.11.2).

Dessa operatorer är rätt associativa.

Exempel:

$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 Operatorn unary -join

Beskrivning:

Den enära -join operatorn genererar en sträng som är sammanfogningen av värdet för ett eller flera objekt som anges av ett unary-expression. (En avgränsare kan infogas med hjälp av den binära versionen av operatorn (7.8.4.4).)

unary-expression kan vara ett skalärt värde eller en samling.

Exempel:

-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 Operatorn unary -split

Beskrivning:

Den enära -split operatorn delar upp en eller flera strängar som anges av ett unary-expression och returnerar sina underdelar i en begränsad 1-dimensionell strängmatris. Den behandlar alla sammanhängande grupper med blankstegstecken som avgränsare mellan efterföljande underdelar. (En explicit avgränsarsträng kan anges med hjälp av den binära versionen av operatorn (·7.8.4.5).) Den här operatorn har två varianter (7,8).

Avgränsartexten ingår inte i de resulterande strängarna. Inledande och avslutande blanksteg i indatasträngen ignoreras. En indatasträng som är tom eller som innehåller blanksteg resulterar endast i en matris med 1 sträng, som är tom.

unary-expression kan ange ett skalärt värde eller en matris med strängar.

Exempel:

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

Beskrivning:

Den här operatorn konverterar explicit (·6) värdet som anges av unary-expression till den typ som anges av type-literal. Om type-literal är annat än void är resultatets typ den namngivna typen och värdet är värdet efter konverteringen. Om type-literal är void skrivs inget objekt till pipelinen och det finns inget resultat.

När ett uttryck av någon typ typ, är den resulterande typen och värdet det enära-uttryckets typ och värde.

Den här operatorn är rätt associativ.

Exempel:

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

7.3 Binär kommateckenoperator

Syntax:

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

Beskrivning:

Den binära kommateckenoperatorn skapar en 1-dimensionell matris vars element är de värden som anges av operanderna, i lexikal ordning. Matrisen har en ej tränad typ.

Exempel:

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

Tillägget av grupperingsparenteser till vissa binära kommateckenuttryck dokumenterar inte standardvärdet. I stället ändras resultatet.

7.4 Intervalloperator

Syntax:

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

Beskrivning:

Ett intervalluttryck skapar en icke-tränad 1-dimensionell matris vars element är värdena för den int-sekvens som anges av intervallbunden. De värden som operanderna anger konverteras till int, om det behövs (6.4). Operanden som anger det lägre värdet efter konverteringen är den nedre gränsen, medan operanden som anger det högre värdet efter konverteringen är den övre gränsen. Båda gränserna kan vara samma, vilket innebär att den resulterande matrisen har längden 1. Om den vänstra operanden anger den nedre gränsen är sekvensen i stigande ordning. Om den vänstra operanden anger den övre gränsen är sekvensen i fallande ordning.

Konceptuellt är den här operatorn en genväg för motsvarande binärt kommateckenoperatorsekvens. Intervallet kan till exempel 5..8 också genereras med hjälp av 5,6,7,8. Men om en stigande eller fallande sekvens behövs utan att ha en matris kan en implementering undvika att generera en faktisk matris. I behöver till foreach ($i in 1..5) { ... }exempel ingen matris skapas.

Ett intervalluttryck kan användas för att ange ett matrissegment (9,9).

Exempel:

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

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

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

7.5-formatoperator

Syntax:

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)

Beskrivning:

Ett formatuttryck formaterar ett eller flera värden som anges av range-expression enligt en formatsträng för specifikation som anges av format-expression. Positionerna för de värden som anges av range-expression numreras med början vid noll och ökar i lexikal ordning. Resultatet har typen string.

En formatsträng kan innehålla noll eller flera formatspecifikationer som vart och ett har följande format:

{N [ ,M ][ : FormatString ]}

N representerar en (obligatorisk) värdeposition för intervalluttryck , M representerar den (valfria) minsta visningsbredden och FormatString anger formatet (valfritt). Om bredden för ett formaterat värde överskrider den angivna bredden ökas bredden i enlighet med detta. Värden vars positioner inte refereras till i FormatString ignoreras efter att ha utvärderats för eventuella sidoeffekter. Om N refererar till en obefintlig position är beteendet implementeringsdefinierat. Värdet av typen $null och void formateras som tomma strängar. Matriser formateras som underuttryck (7.1.6). Om du vill inkludera tecknen "{" och "}" i en formatspecifikation utan att de tolkas som formatavgränsare skriver du dem som "{{" respektive "}}".

En fullständig definition av formatspecifikationer finns i typen System.IFormattable i Ecma Technical Report TR/84.

Exempel:

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

Om N refererar till en obefintlig position i en formatspecifikation utlöses ett FormatError .

7.6 Multiplikativa operatorer

Syntax:

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 Multiplikation

Beskrivning:

Resultatet av multiplikationsoperatorn * är produkten av de värden som anges av de två operanderna efter att de vanliga aritmetiska konverteringarna (â 6,15) har tillämpats.

Operatorn lämnas associativ.

Exempel:

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 Strängreplikering

Beskrivning:

När den vänstra operanden anger en sträng skapar den binära operatorn en ny sträng som innehåller den som angetts * av den vänstra operanden och replikerar antalet gånger som anges av värdet för den högra operanden som konverterad till heltalstyp (6.4).

Operatorn lämnas associativ.

Exempel:

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

Beskrivning:

När den vänstra operanden * anger en matris skapar den binära operatorn en ny ej tränad 1-dimensionell matris som innehåller det värde som anges av den vänstra operanden och replikerar antalet gånger som anges av värdet för den högra operanden som konverterat till heltalstyp (6.4). Replikeringsantalet noll resulterar i en matris med längden 1. Om den vänstra operanden anger en flerdimensionell matris, plattas den ut (·9.12) innan den används.

Operatorn lämnas associativ.

Exempel:

$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

Beskrivning:

Resultatet av divisionsoperatorn / är kvoten när värdet som anges av den vänstra operanden divideras med värdet som anges av den högra operanden efter att de vanliga aritmetiska konverteringarna (·6.15) har tillämpats.

Om ett försök görs att utföra heltal eller decimaldivision med noll utlöses ett implementeringsdefinierat avslutande fel.

Operatorn lämnas associativ.

Exempel:

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

Om ett försök görs att utföra heltal eller decimaldivision med noll utlöses ett RuntimeException-undantag .

7.6.5 Rest

Beskrivning:

Resultatet av % restoperatorn är resten när värdet som anges av den vänstra operanden divideras med värdet som anges av den högra operanden efter att de vanliga aritmetiska konverteringarna (6,15) har tillämpats.

Om ett försök görs att utföra heltal eller decimaldivision med noll utlöses ett implementeringsdefinierat avslutande fel.

Exempel:

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

Om ett försök görs att utföra heltal eller decimaldivision med noll utlöses ett RuntimeException-undantag .

7.7 Additiva operatorer

Syntax:

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

7.7.1 Tillägg

Beskrivning:

Resultatet av additionsoperatorn + är summan av de värden som anges av de två operanderna efter att de vanliga aritmetiska konverteringarna (6,15) har tillämpats.

Operatorn lämnas associativ.

Exempel:

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 Sträng concatentaion

Beskrivning:

När den vänstra operanden + anger en sträng skapar den binära operatorn en ny sträng som innehåller det värde som anges av den vänstra operanden följt av de värden som anges av den högra operanden som konverteras till type string (·6.8).

Operatorn lämnas associativ.

Exempel:

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

7.7.3 Sammanfogning av matris

Beskrivning:

När den vänstra operanden + anger en matris skapar den binära operatorn en ny, ej tränad 1-dimensionell matris som innehåller elementen som anges av den vänstra operanden följt av de värden som anges av den högra operanden. Flerdimensionella matriser som finns i någon av operanderna plattas ut (·9.12) innan de används.

Operatorn lämnas associativ.

Exempel:

$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

Beskrivning:

När båda operanderna anger Hashtables + skapar den binära operatorn en ny hash-tabell som innehåller elementen som anges av den vänstra operanden följt av de element som anges av den högra operanden.

Om hashtabellerna innehåller samma nyckel utlöses ett implementeringsdefinierat avslutande fel.

Operatorn lämnas associativ.

Exempel:

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

Om hashtabellerna innehåller samma nyckel utlöses ett undantag av typen BadOperatorArgument .

7.7.5 Subtraktion

Beskrivning:

Subtraktionsoperatorns - resultat är skillnaden när värdet som anges av den högra operanden subtraheras från det värde som anges av den vänstra operanden efter att de vanliga aritmetiska konverteringarna (·6.15) har tillämpats.

Operatorn lämnas associativ.

Exempel:

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 Jämförelseoperatorer

Syntax:

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)

Beskrivning:

Typen av värde som anges av den vänstra operanden avgör hur värdet som anges av den högra operanden konverteras (â 6), om det behövs, innan jämförelsen görs.

Vissa jämförelseoperatorer (skrivna här som -op) har två varianter, en som är fallkänslig (-cop) och en som inte är (-iop). -op-versionen motsvarar -iop. Fallkänsligheten är bara meningsfull med jämförelser av värden av typen sträng. I jämförelsekontexter som inte är strängar fungerar de två varianterna på samma sätt.

Dessa operatorer lämnas associativa.

7.8.1 Likhets- och relationsoperatorer

Beskrivning:

Det finns två likhetsoperatorer: likhet (-eq) och olikhet (-ne), och fyra relationsoperatorer: mindre än (-lt), mindre än eller lika med (-le), större än (-gt) och större än eller lika med (-ge). Var och en av dessa har två varianter (–7,8).

För att två strängar ska kunna jämföras med måste de ha samma längd och innehåll, och bokstavsfall om det behövs.

Om värdet som anges av den vänstra operanden inte är en samling har resultatet typen bool. Annars är resultatet en eventuellt tom 1-dimensionell matris som innehåller elementen i samlingen som testar True jämfört med värdet som anges av den högra operanden.

Exempel:

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 Inneslutningsoperatorer

Beskrivning:

Det finns fyra inneslutningsoperatorer: contains (-contains), does-not-contain (‑notcontains), in (-in) och not-in ().-notin Var och en av dessa har två varianter (–7,8).

Inneslutningsoperatorer returnerar ett resultat av typen bool som anger om ett värde inträffar (eller inte inträffar) minst en gång i elementen i en matris. Med -contains och ‑notcontainsanges värdet av den högra operanden och matrisen anges av den vänstra operanden. Med -in -notinoch är operanderna omvända. Värdet anges av den vänstra operanden och matrisen anges av den högra operanden.

För dessa operatorer behandlas skalära värden som en matris med ett element om matrisopernden har ett skalära värde.

Exempel:

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 Typtestnings- och konverteringsoperatorer

Beskrivning:

Typoperatorn -is testar om värdet som anges av den vänstra operanden har typen eller härleds från en typ som har typen , som anges av den högra operanden. Den högra operanden måste ange en typ eller ett värde som kan konverteras till en typ (till exempel en sträng som namnger en typ). Resultatets typ är bool. Typoperatorn -isnot returnerar den logiska negationen för motsvarande -is formulär.

Typoperatorn -as försöker konvertera värdet som anges av den vänstra operanden till den typ som anges av den högra operanden. Den högra operanden måste ange en typ eller ett värde som kan konverteras till en typ (till exempel en sträng som namnger en typ). Om konverteringen misslyckas returneras $null . Annars returneras det konverterade värdet och returtypen för resultatet är körningstypen för det konverterade värdet.

Exempel:

$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 Operatorer för mönstermatchning och textmanipulering

7.8.4.1 Operatorerna -like och -notlike

Beskrivning:

Om den vänstra operanden inte anger någon samling har resultatet typen bool. Annars är resultatet en eventuellt tom 1-dimensionell matris som innehåller elementen i samlingen som testar True jämfört med värdet som anges av den högra operanden. Den högra operanden kan ange en sträng som innehåller uttryck med jokertecken (3.15). Dessa operatorer har två varianter (7,8).

Exempel:

"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 Operatorerna -match och -notmatch

Beskrivning:

Om den vänstra operanden bool $trueinte anger någon samling har resultatet typen och om resultatet är , anges elementen i hash-tabellen $matches till de strängar som matchar (eller matchar inte) värdet som anges av den högra operanden. Annars är resultatet en eventuellt tom, 1-dimensionell matris som innehåller elementen i samlingen som testar True jämfört med värdet som anges av den högra operanden och $matches som inte har angetts. Den högra operanden kan ange en sträng som innehåller reguljära uttryck (3.16), i vilket fall det kallas ett mönster. Dessa operatorer har två varianter (7,8).

Dessa operatorer stöder delmatchningar (7.8.4.6).

Exempel:

"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 Operatorn -replace

Beskrivning:

Operatorn -replace tillåter textersättning i en eller flera strängar som anges av den vänstra operanden med hjälp av de värden som anges av den högra operanden. Den här operatorn har två varianter (7,8). Den högra operanden har något av följande former:

• Strängen som ska finnas, som kan innehålla reguljära uttryck (3.16). I det här fallet är ersättningssträngen implicit "".
• En matris med 2 objekt som innehåller strängen som ska finnas, följt av ersättningssträngen.

Om den vänstra operanden anger en sträng har resultatet en typsträng. Om den vänstra operanden anger en 1-dimensionell matris med sträng är resultatet en icke-tränad 1-dimensionell matris vars längd är samma som för den vänstra operandens matris, som innehåller indatasträngarna efter att ersättningen har slutförts.

Den här operatorn stöder delmatchningar (7.8.4.6).

Exempel:

"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 Operatorn binary -join

Beskrivning:

Den binära -join operatorn genererar en sträng som är sammanfogningen av värdet för ett eller flera objekt som angetts av den vänstra operanden efter att ha konverterats till sträng (6,7), om det behövs. Strängen som anges av den högra operanden används för att separera (eventuellt tomma) värden i den resulterande strängen.

Den vänstra operanden kan vara ett skalära värde eller en samling.

Exempel:

(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 Operatorn binary -split

Beskrivning:

Den binära -split operatorn delar upp en eller flera strängar som anges av den vänstra operanden och returnerar sina underdelar i en begränsad 1-dimensionell strängmatris. Den här operatorn har två varianter (7,8). Den vänstra operanden kan ange ett skalära värde eller en matris med strängar. Den högra operanden har något av följande former:

• En avgränsarsträng
• En matris med 2 objekt som innehåller en avgränsarsträng följt av ett numeriskt antal delningar
• En matris med 3 objekt som innehåller en avgränsarsträng, ett numeriskt antal delningar och en alternativsträng
• Ett skriptblock
• En matris med 2 objekt som innehåller ett skriptblock följt av ett numeriskt antal delningar

Avgränsarsträngen kan innehålla reguljära uttryck (3.16). Den används för att hitta underdelar med indatasträngarna. Avgränsaren ingår inte i de resulterande strängarna. Om den vänstra operanden anger en tom sträng resulterar det i ett tomt strängelement. Om avgränsarsträngen är en tom sträng finns den vid varje teckenposition i indatasträngarna.

Som standard placeras alla underdelar i indatasträngarna i resultatet som separata element. Antalet delningar kan dock användas för att ändra det här beteendet. Om antalet är negativt, noll eller större än eller lika med antalet underdelar i en indatasträng hamnar varje underdel i ett separat element. Om antalet är mindre än antalet underdelar i indatasträngen finns det count-element i resultatet, där det sista elementet innehåller alla underdelar utöver det första antalet – 1 underdelar.

En alternativsträng innehåller noll eller flera alternativnamn där varje angränsande par avgränsas med ett kommatecken. Inledande, avslutande och inbäddat tomt utrymme ignoreras. Alternativnamn kan vara i valfri ordning och är fallkänsliga.

Om en alternativsträng innehåller alternativnamnet SimpleMatch kan den också innehålla alternativnamnet IgnoreCase. Om en alternativsträng innehåller alternativnamnet RegexMatch eller om den inte innehåller RegexMatch eller SimpleMatch, kan den innehålla val annat alternativnamn än SimpleMatch. Den får dock inte innehålla både Multiline och Singleline.

Här är uppsättningen alternativnamn:

Alternativ	Beskrivning
CultureInvariant	Ignorerar kulturella skillnader i språk vid utvärdering av avgränsaren.
ExplicitCapture	Ignorerar icke-namngivna matchningsgrupper så att endast explicita insamlingsgrupper returneras i resultatlistan.
IgnoreCase	Framtring av icke-känslig matchning, även om -csplit används.
IgnorePatternWhitespace	Ignorerar tomt utrymme som inte är över och kommentarer som markerats med nummertecknet (#).
Multiline	Det här läget identifierar början och slutet av rader och strängar. Standardläget är Enkelrad.
RegexMatch	Använd matchning av reguljära uttryck för att utvärdera avgränsaren. Det här är standardinställningen.
SimpleMatch	Använd enkel strängjämförelse när du utvärderar avgränsaren.
Enkelrad	Det här läget identifierar endast början och slutet av strängar. Det är standardläget.

Skriptblocket (·7.1.8) anger reglerna för att fastställa avgränsaren och måste utvärderas till typen bool.

Exempel:

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

Mönstret som matchas av -match, -notmatchoch -replace kan innehålla underdelar (kallas undermatchningar) avgränsade med parenteser. Se följande exempel:

"red" -match "red"

Resultatet är och $true nyckel 0 $matches i innehåller "röd", den del av strängen som anges av den vänstra operanden som exakt matchade mönstret som angetts av den högra operanden.

I följande exempel är hela mönstret ett undermatchning:

"red" -match "(red)"

Precis som tidigare innehåller nyckel 0 "röd"; Nyckel 1 innehåller dock även "röd", vilket är den del av strängen som anges av den vänstra operanden som exakt matchade undermatchning.

Tänk på följande, mer komplexa mönster:

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

Det här mönstret tillåter delmatchningar av "r", "re", "d" eller "red".

Nyckel 0 innehåller återigen "röd". Nyckel 1 innehåller "re", nyckel 2 innehåller "r" och nyckel 3 innehåller "d". Nyckel/värde-paren är i matchande ordning från vänster till höger i mönstret, med längre strängmatchningar före kortare.

När det gäller -replacekan ersättningstexten komma åt undermatchningar via $nnamnen på formuläret , där den första $1matchningen är , den andra är $3och så vidare. Exempel:

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

Den resulterande strängen är "måndagens morgon".

I stället för att ha nycklar $matches i nollbaserade index kan undermatchningar namnges med hjälp av formuläret ?<*name*>. Kan till exempel "((r)e)(d)" skrivas med tre namngivna undermatchningar, m1, m2 och m3, enligt följande: "(?<m1>(?<m2>r)e)(?<m3>d)".

7.8.5 Skiftoperatorer

Beskrivning:

Skift-vänsteroperatorn (-shl) och skift högeroperatorn (-shr) konverterar värdet som utformats av den vänstra operanden till en heltalstyp och värdet som anges av den högra operanden till int, vid behov, med hjälp av de vanliga aritmetiska konverteringarna (·6.15).

Skift-vänsteroperatorn flyttar den vänstra operanden åt vänster med ett antal bitar som beräknas enligt beskrivningen nedan. De tomma bitpositionerna med låg ordning är inställda på noll.

Operatorn skift höger flyttar den vänstra operanden till höger med ett antal bitar som beräknas enligt beskrivningen nedan. Den vänstra operandens lågordnings bitar tas bort, och de återstående bitarna flyttas åt höger. När den vänstra operanden är ett signerat värde anges de tomma bitpositionerna med hög ordning till noll om den vänstra operanden är icke-negativ och inställd på ett om den vänstra operanden är negativ. När den vänstra operanden är ett osignerat värde anges de tomma bitpositionerna med hög ordning till noll.

När den vänstra operanden har typen int anges skiftantalet av de fem bitarna med låg ordning i den högra operanden. När den högra operanden har typen long anges skiftantalet av den låga ordningen sex bitar av den högra operanden.

Exempel:

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

7.9 Bitvisa operatorer

Syntax:

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

Beskrivning:

Den bitvisa AND-operatorn -band, den bitvisa OR-operatorn -boroch den bitvisa XOR-operatorn -bxor konverterar de värden som operanderna anger till heltalstyper, om det behövs, med hjälp av de vanliga aritmetiska konverteringarna (6,15). Om båda värdena har typen int efter konverteringen är det resultatets typ. Om båda värdena har typen long är det annars typen av resultat. Om ett värde har typen int och det andra har typen long är resultatet lång. Annars är uttrycket dåligt format. Resultatet är den bitvisa AND-, bitvisa ELLER- eller bitvisa XOR-delen av de eventuellt konverterade operandvärdena.

Dessa operatorer lämnas associativa. De är kommutativa om ingen operand innehåller en sidoeffekt.

Exempel:

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 Logiska operatorer

Syntax:

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

Beskrivning:

Den logiska operatorn AND -and konverterar de värden som anges av operanderna booltill , om det behövs (6.2). Resultatet är det logiska AND för de eventuellt konverterade operandvärdena och har typen bool. Om den vänstra operanden utvärderas till Falskt utvärderas inte den högra operanden.

Den logiska OR-operatorn -or konverterar de värden som anges av operanderna booltill , om det behövs (6.2). Resultatet är det logiska ELLER för de eventuellt konverterade operandvärdena och har typen bool. Om den vänstra operanden utvärderas till Sant utvärderas inte den högra operanden.

Den logiska XOR-operatorn -xor konverterar de värden som anges av operanderna till bool (6.2). Resultatet är den logiska XOR för de eventuellt konverterade operandvärdena och har typen bool.

Dessa operatorer lämnas associativa.

Exempel:

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

Syntax:

assignment-expression:
    expression assignment-operator statement

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

Beskrivning:

En tilldelningsoperator lagrar ett värde på den skrivbara plats som anges av uttrycket . En diskussion om assignment-operator finns = i .7.11.1. En diskussion av alla andra tilldelningsoperatorer finns i .7.11.2.

Ett tilldelningsuttryck har värdet som anges av uttrycket när tilldelningen har ägt rum. Tilldelningsuttrycket anger dock inte själv en skrivbar plats. Om uttrycket är typbegränsat (–5,3) är den typ som används i begränsningen typen av resultat. Annars är typen av resultat typen efter att de vanliga aritmetiska konverteringarna (6,15) har tillämpats.

Den här operatorn är rätt associativ.

7.11.1 Enkel tilldelning

Beskrivning:

I enkel tilldelning (=) ersätter värdet som anges av - instruktionen det värde som lagras på den skrivbara plats som anges av uttrycket. Men om uttrycket anger en nyckel som inte finns i en hash-tabell läggs nyckeln till i hash-tabellen med ett associerat värde för värdet som anges av - instruktionen.

Enligt grammatiken kan uttryck ange en kommaavgränsad lista över skrivbara platser. Detta kallas för flera tilldelningar. - instruktionen anger en lista med ett eller flera kommaavgränsade värden. Kommatecken i endera operandlistan är en del av syntaxen för flera tilldelningar och representerar inte den binära kommateckenoperatorn. Värden tas från listan som anges av -instruktionen , i lexikal ordning, och lagras på motsvarande skrivbara plats som anges av uttrycket. Om listan som anges av -instruktionen har färre värden än det finns skrivbara platser för uttryck tar de överflödiga platserna värdet $null. Om listan som anges av -instruktionen har fler värden än det finns skrivbara platser för uttryck, tar alla utom den plats för uttrycket som är mest till höger på motsvarande instruktionsvärde, och platsen för uttrycket right-most blir en ej tränad 1-dimensionell matris med alla återstående instruktionsvärden som element.

För -instruktioner som har värden (8.1.2) kan -instruktionen vara en -instruktion.

Exempel:

$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 Sammansatt tilldelning

Beskrivning:

En sammansatt tilldelning har formen E1 op= E2och E1 = E1 op (E2) motsvarar det enkla tilldelningsuttrycket, förutom att uttrycket E1 i det sammansatta tilldelningsfallet endast utvärderas en gång. Om uttrycket är typbegränsat (–5,3) är den typ som används i begränsningen typen av resultat. Annars bestäms resultatets typ av 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.

Anteckning

En operand som anger ett ej tränat värde av numerisk typ kan få sin typ ändrad av en tilldelningsoperator när resultatet lagras.

Exempel:

$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 Operatorer för omdirigering

Syntax:

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

Beskrivning:

Omdirigeringsoperatorn > tar standardutdata från pipelinen och omdirigerar den till den plats som anges av redirected-file-name och skriver över platsens aktuella innehåll.

Omdirigeringsoperatorn >> tar standardutdata från pipelinen och omdirigerar den till den plats som anges av redirected-file-name, och i så fall till den platsens aktuella innehåll. Om den platsen inte finns skapas den.

Omdirigeringsoperatorn n> med formuläret tar utdata från dataströmmen n från pipelinen och omdirigerar den till den plats som anges av redirected-file-name och skriver över platsens aktuella innehåll.

Omdirigeringsoperatorn n>> med formuläret tar utdata från dataströmmen n från pipelinen och omdirigerar den till den plats som anges av redirected-file-name, och i så fall till den platsens aktuella innehåll. Om den platsen inte finns skapas den.

Omdirigeringsoperatorn med formuläret skriver m>&n utdata från stream m till samma plats som stream n.

Följande är giltiga strömmar:

Stream	Beskrivning
1	Standardutdataström
2	Felutdataström
3	Varningsutdataström
4	Utförlig utdataström
5	Felsöka utdataström
*	Standardutdata, felutdata, varningsutdata, utförliga utdata och felsökning av utdataströmmar

Omdirigeringsoperatorer 1>&2, 6>och 6>> är < reserverade för framtida användning.

Om värdet för redirected-file-name är på $nullmatas ut ignoreras utdata.

Normalt skrivs värdet för ett uttryck som innehåller en sidoeffekt på den översta nivån inte till pipelinen såvida inte uttrycket omges av ett par parenteser. Men om ett sådant uttryck är den vänstra operanden för en operator som omdirigerar standardutdata skrivs värdet.

Exempel:

$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