Kommentar
Åtkomst till den här sidan kräver auktorisering. Du kan prova att logga in eller ändra kataloger.
Åtkomst till den här sidan kräver auktorisering. Du kan prova att ändra kataloger.
Redaktionell anteckning
Viktig
Windows PowerShell Language Specification 3.0 publicerades i december 2012 och baseras på Windows PowerShell 3.0. Den här specifikationen återspeglar inte det aktuella tillståndet för PowerShell. Det finns ingen plan för att uppdatera den här dokumentationen för att återspegla det aktuella tillståndet. Den här dokumentationen presenteras här för historisk referens.
Specifikationsdokumentet är tillgängligt som ett Microsoft Word-dokument från Microsoft Download Center på: https://www.microsoft.com/download/details.aspx?id=36389 Att Word-dokumentet har konverterats för presentation här på Microsoft Learn. Under konverteringen har vissa redaktionella ändringar gjorts för att anpassa formateringen för Docs-plattformen. Vissa stavfel och mindre fel har korrigerats.
Syntax:
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
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. ger en eller flera biverkningar; eller utför någon kombination av detta. Till exempel
- Den bokstavliga representationen 123 är en term som anger int-värdet 123.
- Uttrycket
1,2,3,4anger det 4-elementsmatrisobjekt som har de värden som visas. - Uttrycket
10.4 * $aanger en beräkning. - Uttrycket
$a++ger en bieffekt. - Uttrycket
$a[$i--] = $b[++$j]utför en kombination av dessa saker.
Förutom vad som anges för vissa operatorer är ordningen för utvärdering av termer i ett uttryck och ordningen i vilken biverkningar äger rum ospecificerade. Exempel på ospecificerat beteende är följande: $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 definierade för dem. All information om sådana typer och åtgärder definieras i implementeringen.
Ett uttryck på den översta nivån är ett uttryck som inte ingår i något större uttryck. Om ett uttryck på den översta nivån innehåller en bieffektoperator skrivs inte värdet för det uttrycket till pipelinen; i annat fall skrivs det. Se §7.1.1 för en detaljerad diskussion om detta.
Normalt bryts ett uttryck som betecknar en samling ([§4§4]) ned till sina beståndsdelar när värdet av det uttrycket används. Detta är dock inte fallet när uttrycket är en cmdlet-anrop. Till 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 $(...) är uttrycket som anger samlingen variabeln $x, som räknas upp, vilket resulterar i tre int 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 typen av det 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 Gruppering av parenteser
Syntax:
Tips
Den ~opt~ notationen i syntaxdefinitionerna anger att den lexikala entiteten är valfri i syntaxen.
parenthesized-expression:
( new-lines~opt~ pipeline new-lines~opt~ )
Beskrivning:
Ett parentesiserat uttryck är ett primärt uttryck vars typ och värde är samma som för uttrycket utan parenteser. Om uttrycket anger en variabel anger det parentesiserade uttrycket samma variabel. Till exempel är $x.m och ($x).m likvärdiga.
Grupperingsparenteser kan användas i ett uttryck för att dokumentera standardprioritet och associativitet i uttrycket. De kan också användas för att åsidosätta standardprioritet och associativitet. Till exempel
4 + 6 * 2 # 16
4 + (6 * 2) # 16 document default precedence
(4 + 6) * 2 # 20 override default precedence
Vanligtvis är gruppering av parenteser på den översta nivån redundanta. Men så är inte alltid fallet. Tänk på 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 ints och den skalära 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 fallet skrivs resultatets värde till pipelinen. Men även om uttrycket i det andra fallet utvärderas skrivs inte resultatet till pipelinen på grund av förekomsten av bieffektoperatorn = på den översta nivån. (Om $a = delen tas bort kan värdet skrivas eftersom * inte är en bieffektoperator.)
Om du vill stoppa ett värde för ett uttryck som inte innehåller biverkningar 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 till pipelinen värdet för alla uttryck som innehåller biverkningar på den översta nivån omger du uttrycket i parenteser 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 äger rum i en strängliteral:
">$($a = -23)<" # value not written to pipeline, get ><
">$(($a = -23))<" # pipeline gets >-23<
I det första fallet representerar parenteserna ett underuttryck's avgränsare och inte grupperingsparenteser. Eftersom toppnivåuttrycket innehåller en bieffektoperator 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, är skrivande aktiverat.
Följande exempel innehåller operatörer med sidoeffekt på högsta nivån.
$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 grupperingsparenteser runt ett uttryck som inte innehåller några biverkningar på den översta nivån gör dessa parenteser redundanta. Till exempel;
$a # pipeline gets 0
($a) # no side effect, so () redundant
Tänk på följande exempel som har två biverkningar, ingen av dem är på den översta nivån:
12.6 + ($a = 10 - ++$b) # pipeline gets 21.6.
Resultatet skrivs till pipelinen eftersom det översta uttrycket inte har några biverkningar.
7.1.2 Medlemsåtkomst
Syntax:
member-access:
primary-expression . new-line~opt~ member-name
primary-expression :: new-line~opt~ member-name
Observera att inget mellanslag tillåts efter primäruttryck.
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.
Tomt utrymme tillåts inte före . operatorn.
Den här 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.
Tomt utrymme tillåts inte före :: operatorn.
Den här operatorn lämnas associativ.
Om den högra operanden anger en skrivbar plats inom den typ av objekt som har utsetts 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:
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~ )
Observera att inget mellanslag tillåts efter primäruttryck.
Beskrivning:
Ett anropsuttryck anropar den metod som anges av primary-expression.member-name eller primary-expression::member-name. Parenteserna i argumentlista innehåller en lista med uttryck, som kan vara tom, komma-avgränsad, som specificerar argument vars värden skickas till metoden. Innan metoden anropas utvärderas och konverteras argumenten enligt reglerna i §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-nameoch argumenten är ospecificerade.
Den här operatorn lämnas associativ.
Typen av resultat av ett anropsuttryck är en metoddesignare (§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:
primary-expression [ new-lines~opt~ expression new-lines~opt~ ]
Beskrivning:
Det får inte finnas något blanksteg mellan primäruttryck och den vänstra hakparentesen ([).
7.1.4.1 Indexering av en array
Beskrivning:
Matriser beskrivs i detalj i §9. Om uttryck är en 1-dimensionell matris, se §7.1.4.5.
När primäruttryck anger en 1-dimensionell matris Areturnerar operatorn [] elementet som finns vid A[0 + expression] när värdet för uttryck har konverterats till int.
Resultatet har elementtypen för den array som indexerats. Om uttryck är negativt anger A[expression] elementet som finns på A[A.Length + expression].
När primäruttryck anger en 2-dimensionell matris Breturnerar operatorn [] elementet som finns på B[0 + row,0 + column] efter värdet för rad och kolumn komponenter i uttryck (som anges som en kommaavgränsad lista) har konverterats till int. Resultatet har elementtypen för den array som indexerats. Till skillnad från en 1-dimensionell matris har negativa positioner ingen särskild betydelse.
När primäruttryck anger en matris med tre eller fler dimensioner gäller reglerna för tvådimensionella matriser och dimensionspositionerna anges som en kommaavgränsad lista med värden.
Om ett läsbehörighetsförsök görs 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 matrisuttryck är utvärderingsordningen för dimensionspositionsuttrycken ospecificerad. Med en tredimensionell matris $aär beteendet för $a[$i++,$i,++$i] till exempel ospecificerat.
Om uttryck ä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 en skrivåtkomst till ett icke-befintligt element görs utlöses ett IndexOutOfRange- undantag.
7.1.4.2 Indexering av en sträng
Beskrivning:
När primäruttryck anger en sträng Sreturnerar operatorn [] tecknet i den nollbaserade position som anges av uttryck, som ett tecken. Om uttryck är större än eller lika med strängens längd blir resultatet $null. Om uttryck ä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 Indexering av en hashtabell
Beskrivning:
När primäruttryck anger en Hashtable returnerar operatorn [] de värden som är associerade med de nycklar som anges av uttryck. Typen av uttryck är inte begränsad.
När uttryck är ett enda nyckelnamn är resultatet det associerade värdet och har den typen, såvida inte någon sådan nyckel finns, i vilket fall resultatet är $null. Om $null används som nyckel definieras beteendet i implementeringen. Om uttryck är en matris med nyckelnamn, se §7.1.4.5.
Om uttryck är en matris, 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
Om uttryck är ett enda nyckelnamn utlöses ett $null undantag om används som det enda värdet för att underordna en Hashtable.
7.1.4.4 Indeksering av ett XML-dokument
Beskrivning:
När primäruttryck anger ett xml-objekt konverteras uttryck till sträng om det behövs, och operatorn [] returnerar det första underordnade elementet med namnet som anges av uttryck. Typen av uttryck måste vara sträng. Typen av resultat definieras i implementeringen. Resultatet kan subskriptas för att returnera sitt första barn element. Om det inte finns något underordnat element med det namn som anges av uttryckblir 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 matrissektorer
När primäruttryck anger ett objekt av en typ som är uppräkningsbar (§4) eller en Hashtable och uttryck är en 1-dimensionell matris, är resultatet en matrissektor (§9.9) som innehåller elementen i primära uttrycket som anges av elementen i uttryck.
När det gäller en Hashtable innehåller matrissegmentet de associerade värdena för de angivna nycklarna, såvida ingen sådan nyckel finns, i vilket fall motsvarande element är $null. Om $null används som ett nyckelnamn är beteendet implementeringsspecifikt.
Exempel:
$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: När uttryck är en samling med två eller flera nyckelnamn, om $null används som ett nyckelnamn ignoreras nyckeln och inte har något motsvarande element i den resulterande matrisen.
7.1.5 Postfix-inkrements- och minskningsoperatorer
Syntax:
post-increment-expression:
primary-expression ++
post-decrement-expression:
primary-expression dashdash
Beskrivning:
Det primära uttrycket måste ange en skrivbar plats med ett värde av numerisk typ (§4) eller värdet $null. Om värdet som anges av operand är $nullkonverteras det värdet till int och värdet noll innan operatorn utvärderas. Typen av värde som anges av primäruttryck kan ändras när resultatet lagras. Se §7.11 för en diskussion om typändring via tilldelning.
Resultatet som genereras av postfix-++-operatorn är det värde som anges av operanden. När resultatet har erhållits ökas värdet som anges av operanden med 1 av lämplig typ.
Typen av uttrycksresultat E++ är densamma som för resultatet av uttrycket E + 1 (§7.7).
Resultatet som genereras av postfix----operatorn är det värde som anges av operanden. När resultatet har erhållits minskas värdet som anges av operanden med 1 av lämplig typ.
Typen av uttrycksresultat E-- är densamma 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 behavior
$x = $null # target is unconstrained, $null goes to [int]0
$x++ # value treated as int, 0->1
7.1.6 $(...) operatör
Syntax:
sub-expression:
$( new-lines~opt~ statement-list~opt~ new-lines~opt~ )
Beskrivning:
Om saknas i uttalande-lista blir resultatet $null. Annars utvärderas instruktionslista. Alla objekt som skrivs till pipelinen som en del av utvärderingen samlas in i en obegränsad 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 obehindrade 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)
7.1.7 @(...) operator
Syntax:
array-expression:
@( new-lines~opt~ statement-list~opt~ new-lines~opt~ )
Beskrivning:
Om instruktionslista utelämnas är resultatet en obegränsad 1-dimensionell matris med längd noll. Annars utvärderas -instruktionslista och alla objekt som skrivs till pipelinen som en del av utvärderingen samlas in i en obegränsad 1-dimensionell matris i ordning. Resultatet är den (eventuellt tomma) obegränsade 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.
av den namngivna blocklistan eller -satslistan körs, och typen och värdena för resultatet är samma som typen och värdena för resultaten av dessa satsuppsättningar.
Ett skriptblock-uttryck har typen skriptblock (§4.3.7).
Om param-block utelämnas, är alla argument som skickas till skriptblocket tillgängliga via $args (§8.10.1).
Under parameterbindningen kan ett skriptblock skickas antingen som ett skriptblockobjekt eller som ett resultat efter att 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:
En hash-literal-expression används för att skapa en Hashtable (§10) med noll eller fler element som var och en är ett nyckel/värde-par.
Nyckeln kan ha valfri typ förutom null-typen. De associerade värdena kan ha valfri typ, 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 betydande.
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å Hashtables, $h1 och $h2, som var och en innehåller tre nyckel/värde-par och en tredje, $h3, som är tom. Hashtable $h4 har nycklar av olika typer.
7.1.10 Typliteralt uttryck
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 typliteral representeras i en implementering av någon ospecificerad underliggande typ. Därför är ett typnamn en synonym för dess underliggande typ.
Typliteraler 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:
[int].IsPrimitive # $true
[Object[]].FullName # "System.Object[]"
[int[,,]].GetArrayRank() # 3
En allmän stacktyp (§4.4) som är specialiserad på att innehålla strängar kan skrivas som [Stack[string]]och en allmän ordlistetyp som är specialiserad på att innehålla int nycklar med associerade strängvärden kan skrivas som [Dictionary[int,string]].
Typen av en -typliteral är System.Type. Det fullständiga namnet på typen Stack[string] som föreslås ovan är System.Collections.Generic.Stack[int]. Det fullständiga namnet på typen Dictionary[int,string] som 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
pre-increment-expression:
++ new-lines~opt~ unary-expression
pre-decrement-expression:
dashdash new-lines~opt~ unary-expression
dash: one of
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
cast-expression:
type-literal unary-expression
dashdash:
dash dash
7.2.1 Unary kommaoperator
Beskrivning:
Kommaoperatorn (,) skapar en obegränsad 1-dimensionell matris med ett element, vars typ och värde är unary-expression.
Den här operatorn är högerassociativ.
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
Syntax:
logical-not-operator:
dash not
dash: one of
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Beskrivning:
Operatorn -not konverterar vid behov värdet som anges av unärt uttryck till typen bool (§6.2) och producerar ett resultat av den typen. Om unary-expressionvärdet är Sant, är resultatet Falskt och vice versa. Operatorn ! är en alternativ stavning för -not.
Den här operatorn är högerassociativ.
Exempel:
-not $true # False
-not -not $false # False
-not 0 # True
-not 1.23 # False
!"xyz" # False
7.2.3 Bitvis INTE
Syntax:
bitwise-not-operator:
dash bnot
dash: one of
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Beskrivning:
Operatorn -bnot konverterar värdet som anges av unary-expression till en heltalstyp (§6.4), om det behövs. Om det konverterade värdet kan representeras i typ int är det resultattypen. Annars, om det konverterade värdet kan representeras i typ lång så är det resultattypen. Annars är uttrycket dåligt format. Det resulterande värdet är ettkomplementet för det konverterade värdet.
Den här operatorn är högerassociativ.
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 för formuläret + unary-expression behandlas som om det hade skrivits som 0 + unary-expression (§7.7). Heltalsliteralen 0 har typen int.
Den här operatorn är högerassociativ.
Exempel:
+123L # type long, value 123
+0.12340D # type decimal, value 0.12340
+"0xabc" # type int, value 2748
7.2.5 Monärt minus
Beskrivning:
Ett uttryck för formuläret - unary-expression behandlas som om det hade skrivits som 0 - unary-expression (§7.7). Heltalsliteral 0 har typen int. Minusoperatorn kan vara vilket som helst av de bindestreckstecken som anges i §7.2.
Den här operatorn är högerassociativ.
Exempel:
-$true # type int, value -1
-123L # type long, value -123
-0.12340D # type decimal, value -0.12340
7.2.6 Inkrements- och minskningsoperatorer för prefix
Beskrivning:
unary-expression måste ange en plats som är skrivbar och har ett värde av numerisk typ (§4) eller värdet $null. Om värdet som anges av dess unary-expression är $nullkonverteras unary-expressionvärde till typ int och värde noll innan operatorn utvärderas.
Notera
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 prefix-inkrementoperatorn ++ ökas värdet av den unära uttrycket med 1 av lämplig typ. Resultatet är det nya värdet när inkrementeringen har skett. Uttrycket ++E motsvarar E += 1 (§7.11.2).
För prefix-dekrementoperatorn -- minskas värdet av den unära uttrycket med 1 i en lämplig typ. Resultatet är det nya värdet efter att minskning har skett. Uttrycket --E motsvarar E -= 1 (§7.11.2). Prefixets dekrementoperator kan vara vilket som helst av de mönster som matchar dashdash-mönstret i §7.2.
Dessa operatorer är högerassociativa.
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 becomes -1
7.2.7 Den unära -join-operatorn
Syntax:
join-operator:
dash join
dash: one of
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Beskrivning:
Operatorn unary -join skapar en sträng som är sammanlänkningen av värdet för ett eller flera objekt som anges av unary-expression. (En avgränsare kan infogas med hjälp av den binära versionen av denna operator (§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 Det unära -split-operatorn
Syntax:
split-operator:
dash split
dash: one of
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Beskrivning:
Operatorn unary -split delar upp en eller flera strängar som anges av unary-expressionoch returnerar deras 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änsare-sträng kan anges med hjälp av den binära versionen av denna operator (§7.8.4.5) eller dess två varianter (§7.8).
Avgränsarens text ingår inte i de resulterande strängarna. Inledande och avslutande blanksteg i indatasträngen ignoreras. En indatasträng som är tom eller innehåller blanksteg resulterar endast i en matris med en 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 Type-omvandlingsoperatör
Beskrivning:
Denna operator konverterar uttryckligen (§6) värdet som anges av unary-expression till den typ som anges av type-literal (§7.1.10). Om type-literal är något annat än void, är resultatets typ den namngivna typen, och värdet är det efter konverteringen. Om typliteral är ogiltigt skrivs inget objekt till pipelinen och det finns inget resultat.
När ett uttryck av någon typ konverteras till samma typ, är den resulterande typen och värdet samma som unary-expression:s typ och värde.
Den här operatorn är högerassociativ.
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 kommaoperator
Syntax:
array-literal-expression:
unary-expression , new-lines~opt~ array-literal-expression
Beskrivning:
Den binära kommaoperatorn skapar en 1-dimensionell matris vars element är de värden som anges av dess operander, i lexikal ordning. Fältet har en obestämd 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 kommauttryck dokumenterar inte standardprioriteten. i stället ändras resultatet.
7.4 Intervalloperator
Syntax:
range-expression:
unary-expression .. new-lines~opt~ unary-expression
Beskrivning:
Ett intervalluttryck skapar en obegränsad 1-dimensionell matris vars element är värdena för int sekvens som anges av intervallgränsarna. Värdena som anges av operanderna konverteras till int, om det behövs (§6.4). Operanden som anger det lägre värdet efter konverteringen är lägre gräns, medan operanden som anger det högre värdet efter konverteringen är övre gräns. Båda gränserna kan vara desamma, i så fall har den resulterande matrisen längd 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ära kommaoperatorsekvens. Till exempel kan intervallet 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 foreach ($i in 1..5) { ... }behöver till exempel ingen matris skapas.
Ett range-expression kan användas för att ange en matrisdel (§9.9).
Exempel:
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 Formatoperator
Syntax:
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)
Beskrivning:
Ett formatuttryck formaterar ett eller flera värden som anges av range-expression enligt en format-specification-string som anges av formatuttryck. Positionerna för de värden som anges av range-expression numreras med början på noll och ökar i lexikal ordning. Resultatet har typen string.
En formatspecifikationssträng kan innehålla noll eller fler formatspecifikationer som var och en har följande formulär:
{N [ ,M ][ : FormatString ]}
N- representerar en (obligatorisk) värdeposition, M representerar den (valfria) minsta visningsbredden och FormatString- anger formatet (valfritt). Om bredden på ett formaterat värde överskrider den angivna bredden ökas bredden i enlighet med detta. Värden vars positioner inte refereras i FormatString ignoreras efter att ha utvärderats för eventuella biverkningar. Om N refererar till en obefintlig position är beteendet definitionsmässigt beroende av implementeringen. Värdet av typen $null och void formateras som tomma strängar. Matriser formateras som för 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:
"__{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__
Om N- i en formatspecifikation refererar till en obefintlig position utlöses en FormatError-.
7.6 Multiplicativa operatorer
Syntax:
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 Multiplikation
Beskrivning:
Resultatet av multiplikationsoperatorn * är produkten av de värden som anges av de två operanderna efter de vanliga aritmetiska konverteringarna (§6.15) har tillämpats.
Den här 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 anges av den vänstra operanden, replikerad det antal gånger som anges av värdet av den högra operanden omvandlad till heltalstyp (§6.4).
Den här 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 obegränsad 1-dimensionell matris som innehåller det värde som anges av den vänstra operanden replikerat antalet gånger som anges av värdet för den högra operanden som konverterat till heltalstyp (§6.4). Ett replikeringsantal på noll resulterar i en matris med längd 1. Om den vänstra operanden anger en flerdimensionell matris plattas den ut (§9.12) innan den används.
Den här 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 det värde som anges av den högra operanden efter de vanliga aritmetiska konverteringarna (§6.15) har tillämpats.
Om ett försök görs att utföra heltal eller decimaldelning med noll utlöses ett implementeringsdefinierat avslutande fel.
Den här 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 decimaldelning 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 det värde som anges av den högra operanden efter de vanliga aritmetiska konverteringarna (§6.15) har tillämpats.
Om ett försök görs att utföra heltal eller decimaldelning 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 decimaldelning med noll utlöses ett RuntimeException undantag.
Additionsoperatorer
Syntax:
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 Tillägg
Beskrivning:
Resultatet av tilläggsoperatorn + är summan av de värden som anges av de två operanderna efter de vanliga aritmetiska konverteringarna (§6.15) har tillämpats.
Den här 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ängsammanfogning
Beskrivning:
När den vänstra operanden anger en sträng skapar den binära + operatorn en ny sträng som innehåller värdet som anges av den vänstra operanden följt omedelbart av de värden som anges av den högra operanden som konverterade till typsträngen (§6.8).
Den här 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 Array-sammanfogning
Beskrivning:
När den vänstra operanden anger en matris skapar den binära + operatorn en ny obegränsad 1-dimensionell matris som innehåller de element som anges av den vänstra operanden följt omedelbart 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.
Den här 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 Hashtabellsammanfogning
Beskrivning:
När båda operanderna anger Hashtables skapar den binära + operatorn en ny Hashtable som innehåller de element som anges av den vänstra operanden följt omedelbart av de element som anges av den högra operanden.
Om Hashtables innehåller samma nyckel utlöses ett implementeringsdefinierat avslutande fel.
Den här operatorn lämnas associativ.
Exempel:
$h1 = @{ FirstName = "James"; LastName = "Anderson" }
$h2 = @{ Dept = "Personnel" }
$h3 = $h1 + $h2 # new Hashtable, Count = 3
Om Hashtables innehåller samma nyckel utlöses ett undantag av typen BadOperatorArgument.
7.7.5 Subtraktion
Beskrivning:
Resultatet av subtraktionsoperatorn - ä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. Subtraktionsoperatorn kan vara något av strecktecken som anges i §7.7.
Den här operatorn lämnas associativ.
Exempel:
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 Jämförelseoperatorer
Syntax:
comparison-expression:
primary-expression comparison-operator new-lines~opt~ expression
comparison-operator:
equality-operator
relational-operator
containment-operator
type-operator
like-operator
match-operator
Beskrivning:
Typen av det värde som anges av den vänstra operanden bestämmer hur värdet som utses av den högra operanden konverteras (§6), om det behövs, innan jämförelsen görs.
Vissa jämförelseoperatorer har två varianter, en som är skiftlägeskänslig (-c<operator>) och en som inte är skiftlägeskänslig (-i<operator>). Den -<operator> versionen motsvarar -i<operator>. Skiftlägeskänslighet är endast meningsfullt vid jämförelser av värden i datatypen 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
Syntax:
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
Beskrivning:
Det finns två likhetsoperatorer: likhet (-eq) och ojämlikhet (-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 lika måste de ha samma längd och innehåll och bokstavsfall, om det är lämpligt.
Om värdet som anges av den vänstra operanden inte är en samling, har resultatet typ bool.
Annars är resultatet en möjligen tom obehindrat 1-dimensionell matris som innehåller elementen i samlingen som testar Sant jämfört med värdet som anges av rätt operand.
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
Syntax:
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)
Beskrivning:
Det finns fyra kontrolloperatorer: innehåller (-contains), innehåller inte (-notcontains), i (-in) och inte i (-notin). Var och en av dessa har två varianter (§7.8).
Inneslutningsoperatorerna 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 utses av den vänstra operanden. Med -in och -notinär operanderna omvända. Värdet anges av den vänstra operanden och matrisen utses av den högra operanden.
För dessa operatorer behandlas skalärvärdet som en matris med ett element om matrisoperänden har ett skalärt 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
"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
Syntax:
type-operator: one of
dash is
dash as
dash:
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
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. Rätt operand måste ange en typ eller ett värde som kan konverteras till en typ (till exempel en sträng som namnger en typ).
Typen av resultat ä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. Rätt operand 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 det 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 Mönstermatchnings- och textmanipuleringsoperatorer
7.8.4.1 Operatorerna -like och -notlike
Syntax:
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)
Beskrivning:
Om den vänstra operanden inte anger en samling har resultatet typen bool. Annars är resultatet en möjligen tom obehindrat 1-dimensionell matris som innehåller elementen i samlingen som testar Sant jämfört med värdet som anges av rätt operand. Den högra operanden kan ange en sträng som innehåller jokerteckenuttryck (§3.15). Dessa operatörer 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
Syntax:
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)
Beskrivning:
Om den vänstra operanden inte anger en samling har resultatet typen bool och om resultatet är $trueanges elementen i Hashtable-$Matches till de strängar som matchar (eller matchar inte) värdet som anges av den högra operanden. Annars är resultatet en möjligen tom obegränsad 1-dimensionell matris som innehåller elementen i samlingen som testar Sant jämfört med värdet som anges av rätt operand och $Matches 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 operatörer har två varianter (§7.8).
Dessa operatörer stöder delmatchning (§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
Syntax:
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)
Beskrivning:
Operatorn -replace tillåter textbyte 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. Denna operator har två varianter (§7.8). Den högra operanden har något av följande formulär:
- Strängen som ska placeras, 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 placeras, följt av ersättningssträngen.
Om den vänstra operanden anger en sträng har resultatet typsträng. Om den vänstra operanden anger en 1-dimensionell strängmatris är resultatet en obegränsad 1-dimensionell matris, vars längd är densamma som för den vänstra operandens matris, som innehåller indatasträngarna efter att ersättningen har slutförts.
Denna operatör stöder delmatchning (§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 Den binära -join-operatorn
Syntax:
binary-join-operator: one of
dash join
dash:
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Beskrivning:
Den binära -join-operatorn skapar en sträng som är sammanlänkningen av värdet för ett eller flera objekt som anges 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 avgränsa (eventuellt tomma) värden i den resulterande strängen.
Den vänstra operanden kan vara ett skalärt 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 Den binära -split operatorn
Syntax:
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)
Beskrivning:
Den binära -split-operatorn delar upp en eller flera strängar som anges av den vänstra operanden och returnerar deras underdelar i en begränsad 1-dimensionell strängmatris. Denna operator har två varianter (§7.8). Den vänstra operanden kan ange ett skalärt värde eller en matris med strängar. Den högra operanden har något av följande formulär:
- En avgränsarsträng
- En matris med 2 objekt som innehåller en avgränsarsträng följt av ett numeriskt delat antal
- En matris med 3 objekt som innehåller en avgränsarsträng, ett numeriskt antal delade objekt och en alternativsträng
- Ett skriptblock
- En matris med 2 objekt som innehåller ett skriptblock följt av ett numeriskt delat antal
Avgränsarsträngen kan innehålla reguljära uttryck (§3.16). Den används för att lokalisera delar med hjälp av 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, hittas den vid varje teckenposition i indatasträngarna.
Som standard placeras alla underdelar av indatasträngarna i resultatet som separata element. Det delade antalet kan dock användas för att ändra det här beteendet. Om det 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 det antalet är mindre än antalet underdelar i indatasträngen finns det antal element i resultatet, där det sista elementet innehåller alla underdelar utöver det första antal – 1 underdelar.
En alternativsträng innehåller noll eller fler alternativnamn med varje intilliggande par avgränsat med kommatecken. Inledande, avslutande och inbäddade blanksteg ignoreras. Alternativnamn kan vara i valfri ordning och skiftlägeskänsliga.
Om en alternativsträng innehåller alternativnamnet SimpleMatchkan den även innehålla alternativnamnet IgnoreCase. Om en alternativsträng innehåller alternativnamnet RegexMatch eller om den inte innehåller antingen RegexMatch eller SimpleMatchkan den innehålla valfritt alternativnamn förutom SimpleMatch. Den får dock inte innehålla både Multiline och Singleline.
Här är uppsättningen med alternativnamn:
| alternativ | Beskrivning |
|---|---|
| CultureInvariant | Ignorerar kulturella skillnader i språk vid utvärdering av avgränsare. |
| ExplicitCapture | Ignorerar icke-namngivna matchningsgrupper så att endast explicita fångstgrupper returneras i resultatlistan. |
| IgnoreCase | Tvinga fram skiftlägesokänslig matchning, även om -csplit används. |
| IgnorePatternWhitespace | Ignorerar oskyddade blanksteg och kommentarer markerade med nummertecknet (#). |
| Flera ledningar | Det här läget identifierar början och slutet av rader och strängar. Standardläget är Singleline. |
| RegexMatch | Använd matchning av reguljära uttryck för att utvärdera avgränsare. 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änsare och måste utvärderas för att skriva 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 Delmatchning
Mönstret som matchas av -match, -notmatchoch -replace kan innehålla underdelar (kallas delmatchningar) avgränsade av parenteser. Tänk på följande exempel:
"red" -match "red"
Resultatet är $true och nyckel 0 i $Matches innehåller "röd", den del av strängen som anges av den vänstra operanden som exakt matchade det mönster som anges av den högra operanden.
I följande exempel är hela mönstret en delmatchning:
"red" -match "(red)"
Precis som tidigare innehåller nyckel 0 "röd"; men nyckel 1 innehåller också "röd", vilket är den del av strängen som anges av den vänstra operanden som exakt matchade delmatchningen.
Tänk på följande, mer komplexa mönster:
"red" -match "((r)e)(d)"
Det här mönstret tillåter delmatchning av "re", "r", "d" eller "red".
Återigen innehåller nyckeln 0 "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 namn i formatet $n, där den första matchen är $1, den andra är $3och så vidare. Till exempel
"Monday morning" -replace '(Monday|Tuesday) (morning|afternoon|evening)','the $2 of $1'
Den resulterande strängen är "morgonen på måndag".
I stället för att ha nycklar i $Matches vara nollbaserade index kan undermatchningar namnges med hjälp av formen ?<*name*>. Till exempel kan "((r)e)(d)" skrivas med tre namngivna delmatchningar, m1, m2och m3, enligt följande: "(?<m1>(?<m2>r)e)(?<m3>d)".
7.8.5 Skiftoperatorer
Syntax:
shift-operator: one of
dash shl
dash shr
dash:
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Beskrivning:
Skift vänster (-shl) operatorn och skift höger (-shr) operatorn konverterar värdet som anges av den vänstra operanden till en heltalstyp och värdet som anges av den högra operanden till int, om så behövs, med hjälp av de vanliga aritmetiska konverteringarna (§6.15).
Skift-vänsteroperatorn flyttar den vänstra operanden till vänster med ett antal bitar som beräknas enligt beskrivningen nedan. De tomma bitpositionerna i låg ordning är inställda på noll.
Skift-högeroperatorn flyttar den vänstra operanden åt höger med ett antal bitar som beräknas enligt beskrivningen nedan. Den vänstra operandens lågordningsbitar ignoreras, de återstående bitarna flyttas åt höger. När den vänstra operanden är ett signerat värde anges de tomma bitpositionerna i hög ordning till noll om den vänstra operanden inte är negativ och inställd på en om den vänstra operanden är negativ. När den vänstra operanden är ett osignerat värde anges de tomma bitpositionerna i hög ordning till noll.
När den vänstra operanden har typen int bestäms skiftantalet av de fem lägsta bitarna i den högra operanden. När den högra operanden har typen long, ges skiftantalet av de lägre sex bitarna 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 Bitvis-operatorer
Syntax:
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
Beskrivning:
Bitvis AND-operatorn -band, bitvis ELLER-operatorn -boroch bitvis XOR-operatorn -bxor konverterar de värden som anges av deras operander till heltalstyper, om det behövs, med hjälp av de vanliga aritmetiska konverteringarna (§6.15). Om båda värdena har typ int efter konverteringen är det resultatets typ. Annars, om båda värdena har typen lång, är det typen av resultat.
Om ett värde har typen int och det andra har typen long är resultatets typ lång.
Annars är uttrycket dåligt format. Resultatet är bitvis OCH, bitvis ELLER eller bitvis XOR för de eventuellt konverterade operandvärdena.
Dessa operatorer lämnas associativa. De är kommutativa om ingen av operanderna innehåller en bieffekt.
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:
unary-expression -and new-lines~opt~ unary-expression
unary-expression -or new-lines~opt~ unary-expression
unary-expression -xor new-lines~opt~ unary-expression
Beskrivning:
Den logiska AND-operatorn -and konverterar de värden som anges av dess operander till bool, om det behövs (§6.2). Resultatet är det logiska OCH för de eventuellt konverterade operandvärdena och har typen bool. Om den vänstra operanden utvärderas till False utvärderas inte den högra operanden.
Den logiska OR-operatorn -or konverterar de värden som anges av dess operander till bool, 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 dess operander till bool (§6.2). Resultatet är det logiska XOR:et 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 betecknas av uttryck. För en diskussion om tilldelningsoperatorn=, se §7.11.1. En diskussion om alla andra tilldelningsoperatörer finns i §7.11.2.
Ett tilldelningsuttryck har värdet som anges av uttryck efter att tilldelningen har ägt rum. Tilldelningsuttrycket anger dock inte själv en skrivbar plats. Om uttryck är typbegränsad (§5.3) är resultatets typ den begränsande typen; annars är det resultatets typ efter att de vanliga aritmetiska konverteringarna (§6.15) har tillämpats.
Den här operatorn är högerassociativ.
7.11.1 Enkel tilldelning
Beskrivning:
I enkel tilldelning (=) ersätter värdet som anges av -instruktionen värdet som lagras på den skrivbara plats som anges av uttryck. Men om uttryck anger en obefintlig nyckel i en Hashtable läggs den nyckeln till i Hashtable med ett associerat värde för värdet som anges av -instruktionen.
Som grammatiken visar kan uttryck ange en kommaavgränsad lista över skrivbara platser.
Detta kallas multipel tilldelning.
-instruktionen anger en lista över ett eller flera kommaavgränsade värden. Kommatecken i någon av operandlistan är en del av syntaxen för flera tilldelningar och inte representera den binära kommaoperatorn. Värden hämtas från listan som anges av -instruktionen, i lexikal ordning och lagras på motsvarande skrivbara plats som anges av uttryck. Om listan som anges av -instruktionen har färre värden än det finns uttryck skrivbara platser, får de överskjutande platserna värdet $null. Om listan som anges av -instruktionen har fler värden än det finns skrivbara platser för -uttryck, får alla utom det mest högra -uttryckets plats motsvarande -instruktionens värde, och den mest högra -uttryckets plats blir en obegränsad 1-dimensionell matris med alla återstående värden från -instruktionen som element.
För instruktioner som har värden (§8.1.2), kan -instruktion 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 formuläret E1 op= E2och motsvarar det enkla tilldelningsuttrycket E1 = E1 op (E2) förutom att uttrycket E1 bara utvärderas en gång i det sammansatta tilldelningsfallet. Om uttryck är typbegränsat (§5.3), är typen som används i den begränsningen resultatets typ. Annars bestäms resultatets typ av op. För *=, se §7.6.1, §7.6.2, §7.6.3; för /=, se §7.6.4; för %=, se §7.6.5; för +=, se §7.7.1, §7.7.2, §7.7.3; för -=, se §7.7.5.
Notera
En operande som anger ett icke-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 Omdirigeringsoperatorer
Syntax:
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
Beskrivning:
Omdirigeringsoperatorn > tar standardutdata från pipelinen och omdirigerar den till den plats som anges av redirected-file-nameoch skriver över platsens aktuella innehåll.
Omdirigeringsoperatorn >> tar standardutdata från pipelinen och omdirigerar den till den plats som anges av redirected-file-nameoch lägger till det i platsens befintliga innehåll, om sådant finns. Om den platsen inte finns skapas den.
Omdirigeringsoperatorn med formuläret n> tar utdata från strömmen n från pipelinen och omdirigerar den till den plats som anges av redirected-file-nameoch skriver över platsens aktuella innehåll.
Omdirigeringsoperatorn med formen n>> tar utdata från dataströmmen n i pipeline och omdirigerar den till platsen som anges av redirected-file-name, och lägger till det nuvarande innehållet på den platsen, om det finns. Om den platsen inte finns skapas den.
Omdirigeringsoperatorn med formuläret m>&n skriver utdata från strömmen m till samma plats som strömmen n.
Följande är giltiga strömmar:
| Ström | Beskrivning |
|---|---|
| 1 | Standard-utdataström |
| 2 | Fel på utdataströ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 |
Omdirigeringsoperatorerna 1>&2, 6>, 6>> och < är reserverade för framtida användning.
Om värdet för redirected-file-name är $nullignoreras utdata.
Normalt skrivs inte värdet för ett uttryck som innehåller en sidoeffekt på den översta nivån till pipelinen om 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
Samarbeta med oss på GitHub
Källan för det här innehållet finns på GitHub, där du även kan skapa och granska ärenden och pull-begäranden. Se vår deltagarguide för mer information.
