7. výrazy

Syntaxe:

expression:
    logical-expression

Popis:

Výraz je sekvence operátorů a operandů, které určují metodu, funkci, zapisovatelné umístění nebo hodnotu. Určuje výpočet hodnoty; Vytvoří jeden nebo více vedlejších účinků; nebo provede několik kombinací. Třeba

• Literál 123 je výraz, který určuje hodnotu typu int 123.
• Výraz 1,2,3,4 určuje objekt pole se 4 prvky, který má zobrazené hodnoty.
• Výraz 10.4 * $a Určuje výpočet.
• Výraz $a++ vytvoří vedlejší efekt.
• Výraz $a[$i--] = $b[++$j] provádí kombinaci těchto věcí.

S výjimkou případů, kdy je určeno pro některé operátory, pořadí vyhodnocení podmínek ve výrazu a pořadí, ve kterém se nacházejí vedlejší účinky, není určeno. Příklady nespecifikovaného chování zahrnují následující: $i++ + $i , $i + --$i a $w[$j++] = $v[$j] .

Implementace PowerShellu může poskytovat podporu pro uživatelsky definované typy a tyto typy můžou mít definované operace. Všechny podrobnosti o těchto typech a operacích jsou definovány implementací.

Výraz nejvyšší úrovně je ten, který není součástí nějakého většího výrazu. Pokud výraz nejvyšší úrovně obsahuje operátor vedlejšího účinku, hodnota tohoto výrazu není zapsána do kanálu; v opačném případě je to. Podrobnou diskuzi o tom najdete v tématu § 7.1.1 .

Výraz, který určuje kolekci (§ 4), je obvykle uveden na prvky prvku, když je použita hodnota tohoto výrazu. Nejedná se však o případ, kdy je výraz vyvolání rutiny. Třeba

$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

V prvních dvou použití $(...) operátoru je výraz, který je určen pro kolekci, proměnná $x , která je vyhodnocena jako výsledek tří int hodnot a int 99. Ve třetím případě je však výraz přímým voláním rutiny, takže výsledek není vytvořen a $a je pole dvou prvků, int[3] a int .

Pokud operace není definována prostředím PowerShell, je zkontrolován typ hodnoty určené levým operandem, aby bylo možné zjistit, zda má odpovídající op_<operation> metodu.

7,1 primární výrazy

Syntaxe:

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 seskupení závorek

Syntaxe:

Tip

~opt~Zápis v definicích syntaxe označuje, že lexikální entita je v syntaxi nepovinná.

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

Popis:

Výraz v závorkách je primární výraz , jehož typ a hodnota jsou stejné jako hodnoty výrazu bez závorek. Pokud výraz určí proměnnou, výraz v závorkách určí stejnou proměnnou. Například $x.m a ($x).m jsou ekvivalentní.

Ve výrazu lze použít seskupovací závorky k dokumentování výchozí priority a asociativita v rámci tohoto výrazu. Lze je také použít k přepsání této výchozí priority a asociativita. Třeba

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

Seskupení závorek na nejvyšší úrovni je obvykle redundantní. Nejedná se však vždy o případ. Uvažujte následující příklad:

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

V druhém případě se v závorkách mění sémantika, což vede k poli, jejichž dva prvky jsou pole 2 čísla a skalární int 6.

Tady je další výjimka:

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

V prvním a třetím případě je hodnota výsledku zapsána do kanálu. Nicméně i když je vyhodnocen výraz ve druhém případě, výsledek není zapsán do kanálu z důvodu přítomnosti operátoru vedlejšího účinku = na nejvyšší úrovni. (Odebrání $a = části umožňuje zápis hodnoty, protože * není operátor vedlejšího efektu.)

Chcete-li zastavit hodnotu jakéhokoli výrazu, který neobsahuje vedlejší efekty na nejvyšší úrovni před zápisem do kanálu, vyřaďte jej explicitně následujícím způsobem:

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

Chcete-li zapisovat do kanálu hodnotu jakéhokoli výrazu obsahujícího vedlejší účinky na straně nejvyšší úrovně, vložte tento výraz do závorek následujícím způsobem:

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

V takovém případě nejsou závorky pro seskupení v tomto případě redundantní.

V následujícím příkladu máme proměnnou Substitution (§ 2.3.5.2), která probíhá v řetězcovém literálu:

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

V prvním případě kulaté závorky reprezentují oddělovače dílčího výrazu, které neseskupují závorky, a protože výraz nejvyšší úrovně obsahuje operátor vedlejšího efektu, hodnota výrazu není zapsána do kanálu. Samozřejmě > jsou stále zapsány znaky a < .) Pokud jsou přidány závorky seskupení – jak je znázorněno v druhém případě – zápis je povolen.

Následující příklady obsahují operátory vedlejších účinků nejvyšší úrovně:

$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

Použití skupinových závorek kolem výrazu obsahujícího žádné vedlejší efekty na nejvyšší úrovni způsobuje, že tyto závorky nejsou redundantní. Například;

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

Vezměte v úvahu následující příklad, který má dva vedlejší účinky, ani na nejvyšší úrovni:

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

Výsledek je zapsán do kanálu, protože výraz nejvyšší úrovně nemá žádné vedlejší účinky.

přístup ke členu 7.1.2

Syntaxe:

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

Popis:

Operátor . slouží k výběru člena instance z objektu nebo klíče z Hashtable . Levý operand musí určovat objekt a pravý operand musí označovat přístupného člena instance.

Buď pravý operand určuje přístupný člen instance v rámci typu objektu určeného levým operandem, nebo pokud levý operand určí pole, pravý operand určí přístupné členy instance v rámci každého prvku pole.

Před . operátorem není povolen prázdný znak.

Tento operátor je asociativní od sebe.

Operátor :: slouží k výběru statického člena z daného typu. Levý operand musí určovat typ a pravý operand musí v rámci daného typu určit přístupného statického člena.

Před :: operátorem není povolen prázdný znak.

Tento operátor je asociativní od sebe.

Pokud operand na pravé straně Určuje zapisovatelné umístění v rámci typu objektu určeného levým operandem, pak celý výraz určí zapisovatelné umístění.

Příklady:

$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

výrazy vyvolání 7.1.3

Syntaxe:

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

Popis:

Výraz vyvolání volá metodu určenou primárním výrazem. název členu nebo primární výraz::Member-Name. Kulaté závorky v seznamu argumentů obsahují možné prázdné čárkami oddělený seznam výrazů, které určují argumenty , jejichž hodnoty jsou předány metodě. Před voláním metody jsou argumenty vyhodnocovány a převedeny podle pravidel § 6, pokud je to nutné, aby odpovídaly typům, které očekává metoda. Pořadí vyhodnocení primárního výrazu. název členu, primární výraz::Member-Name a argumenty nejsou určeny.

Tento operátor je asociativní od sebe.

Typ výsledku vyvolání výrazu je označení metody (§ 4.5.24).

Příklady:

[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

přístup k elementu 7.1.4

Syntaxe:

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

Popis:

Mezi primárním výrazem a levou hranatou závorkou ( [ ) nesmí být mezera.

7.1.4.1í podscriptu pole

Popis:

Pole jsou podrobněji popsána v § 9. Pokud je výraz jednorozměrné pole, viz § 7.1.4.5.

Když primární výraz označí jednorozměrné pole a, operátor [] vrátí prvek umístěný A[0 + expression] po po převedení hodnoty výrazu na int . Výsledek má typ prvku pole, které je v dolním indexu. Pokud je výraz záporný, A[expression] označuje element umístěný na A[A.Length + expression] .

Když primární výraz označí dvojrozměrné pole B, vrátí operátor [] element umístěný B[0 + row,0 + column] po po hodnotě výrazu ( který je zadaný jako seznam oddělený čárkami), na int který se převede. Výsledek má typ prvku pole, které je v dolním indexu. Na rozdíl od pro jednorozměrné pole nemají záporné pozice žádný zvláštní význam.

Když primární výraz určí pole o třech nebo více dimenzích, použijí se pravidla pro dvojrozměrné pole a pozice dimenzí se určí jako seznam hodnot oddělených čárkami.

Je-li proveden pokus o přístup pro čtení u neexistujícího prvku, je $null výsledkem. Je-li zapsána do neexistujícího prvku, jedná se o chybu.

Pro výraz dolního indexu multidimenzionálního pole není pořadí vyhodnocování výrazů pozice dimenze určeno. Například vzhledem k trojrozměrnému poli $a není chování $a[$i++,$i,++$i] určeno.

Pokud je výraz pole, viz § 7.1.4.5.

Tento operátor je asociativní od sebe.

Příklady:

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

Pokud dojde k pokusu o přístup pro zápis k neexistujícímu prvku, je vyvolána výjimka IndexOutOfRange .

7.1.4.2í indexu řetězce

Popis:

Pokud primární výraz označuje řetězec S, operátor [] vrátí znak umístěný v pozici s hodnotou nula, která je označena výrazem, jako znak. Pokud je výraz větší než nebo roven délce tohoto řetězce, je $null výsledkem. Pokud je výraz záporný, S[expression] označuje element umístěný na S[S.Length + expression] .

Příklady:

$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 podscripting zatřiďovací tabulky

Popis:

Když primární výraz určí zatřiďovací tabulku, vrátí operátor [] hodnoty přidružené k klíčům určeným výrazem. Typ výrazu není omezen.

Pokud je výrazem jeden název klíče, je výsledkem přidružená hodnota a má tento typ, pokud žádný takový klíč neexistuje, v takovém případě je $null výsledkem. Je-li $null použit jako klíč, je chování definováno implementací. Výraz IF je pole názvů klíčů, viz § 7.1.4.5.

Pokud je výraz pole, viz § 7.1.4.5.

Příklady:

$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

Pokud je výrazem jeden název klíče, pokud $null se používá jako jediná hodnota pro dolní index zatřiďovací tabulky, je vyvolána výjimka NullArrayIndex .

7.1.4.4 dokument XML

Popis:

Když primární výraz určí objekt typu XML, je výraz převeden na řetězec, pokud je to nutné, a operátor [] vrátí první podřízený prvek s názvem určeným výrazem. Typ výrazu musí být řetězec. Typ výsledku je definován implementací. Výsledek může být dolním prvkem pro vrácení prvního podřízeného prvku. Pokud neexistuje žádný podřízený element s názvem určeným výrazem, je $null výsledkem. Výsledek neurčuje umístění s možností zápisu.

Příklady:

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

Typ výsledku je System.Xml.XmlElement nebo System.String .

7.1.4.5 generování řezů Array

Když primární výraz určí objekt typu, který je vyčíslitelné (§ 4) nebo zatřiďovací tabulka, a výraz je jednorozměrné pole, výsledkem je řez pole (§ 9,9) obsahující prvky primárního výrazu určeného prvky výrazu.

V případě zatřiďovací tabulky obsahuje řez pole přidružené hodnoty k poskytnutým klíčům, pokud žádný takový klíč neexistuje, v takovém případě odpovídající prvek $null . Pokud $null se používá jako jakýkoli název klíče, který je chování definováno implementací.

Příklady:

$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: pokud je výraz kolekcí dvou nebo více názvů klíčů, je-li $null použit jako jakýkoli název klíče, který klíč je ignorován a nemá žádný odpovídající prvek ve výsledném poli.

operátory přírůstku a snížení přípony 7.1.5

Syntaxe:

post-increment-expression:
    primary-expression ++

post-decrement-expression:
    primary-expression dashdash

dashdash:
    --

Popis:

Primární výraz musí označovat zapisovatelné umístění s hodnotou číselného typu (§ 4) nebo hodnotou $null . Pokud je $null hodnota určená operandem, je tato hodnota převedena na typ int a hodnota nula před vyhodnocením operátoru. Typ hodnoty určené primárním výrazem se může při uložení výsledku změnit. Diskuzi o změně typu prostřednictvím přiřazení naleznete v tématu § 7,11 .

Výsledek vytvořený operátorem přípony ++ je hodnota určená operandem. Po získání tohoto výsledku je hodnota určená operandem zvýšena o 1 z příslušného typu. Typ výsledku výrazu E++ je stejný jako výsledek výrazu E + 1 (§ 7,7).

Výsledek vytvořený operátorem přípony -- je hodnota určená operandem. Po získání tohoto výsledku je hodnota určená operandem snížena o 1 z příslušného typu. Typ výsledku výrazu E-- je stejný jako výsledek výrazu E - 1 (§ 7,7).

Tyto operátory jsou asociativní zleva.

Příklady:

$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

7.1.6 $ (...) – operátor

Syntaxe:

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

Popis:

Je-li vynechán Výpis – seznam , výsledek je $null . V opačném případě se vyhodnotí Výpis – seznam . Všechny objekty zapsané do kanálu v rámci vyhodnocení jsou shromažďovány v neomezeném jednorozměrném poli, a to v pořadí. Pokud je pole shromážděných objektů prázdné, výsledek je $null . Pokud pole shromážděných objektů obsahuje jeden prvek, výsledkem je element; v opačném případě je výsledkem neomezené jednorozměrné pole shromážděných výsledků.

Příklady:

$j = 20
$($i = 10) # pipeline gets nothing
$(($i = 10)) # pipeline gets int 10
$($i = 10; $j) # pipeline gets int 20
$(($i = 10); $j) # pipeline gets [object[]](10,20)
$(($i = 10); ++$j) # pipeline gets int 10
$(($i = 10); (++$j)) # pipeline gets [object[]](10,22)
$($i = 10; ++$j) # pipeline gets nothing
$(2,4,6) # pipeline gets [object[]](2,4,6)

7.1.7 @ (...) – operátor

Syntaxe:

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

Popis:

Je-li vynechán Výpis-list , je výsledkem neomezení jednorozměrného pole s nulovou délkou. V opačném případě je vyhodnocen příkaz-list a všechny objekty zapsané do kanálu v rámci vyhodnocení jsou shromažďovány v neomezeném jednorozměrném poli v daném pořadí. Výsledkem je (možná prázdné) neomezeně jednorozměrné pole.

Příklady:

$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

výraz bloku skriptu 7.1.8

Syntaxe:

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

Popis:

parametr-Block je popsán v § 8.10.9. seznam pojmenovaných bloků je popsán v § 8.10.7.

Blok skriptu je nepojmenovaný blok příkazů, který lze použít jako jednu jednotku. Bloky skriptu lze použít k vyvolání bloku kódu, jako by byl jediný příkaz, nebo mohou být přiřazeny k proměnným, které mohou být provedeny.

Seznam pojmenované-Block-list nebo Statement-list je proveden a typ a hodnoty výsledku jsou typy a hodnoty výsledků těchto sad příkazů.

Výraz Script-Block-Expression je typu ScriptBlock (§ 4.3.7).

Je-li parametr para-Block vynechán, jsou všechny argumenty předané do bloku skriptu k dispozici prostřednictvím $args (§ 8.10.1).

Během vazby parametrů lze blok skriptu předat buď jako objekt bloku skriptu, nebo jako výsledek po vyhodnocení bloku skriptu. Další informace naleznete v tématu § 6,17 .

výraz literálu 7.1.9 hash

Syntaxe:

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

Popis:

Výraz hash-Literal se používá k vytvoření zatřiďovací tabulky (§ 10) nula nebo více elementů, z nichž každý je pár klíč/hodnota.

Klíč může být libovolného typu s výjimkou typu s hodnotou null. Přidružené hodnoty mohou mít libovolný typ, včetně typu null a každá z těchto hodnot může být libovolný výraz, který určuje požadovanou hodnotu, včetně $null .

Řazení párů klíč/hodnota není významné.

Příklady:

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

Vytvoří dvě Zatřiďovacími tabulkami, $h1 a $h2 každý obsahující tři páry klíč/hodnota a třetí, $h3 , který je prázdný. $h4Zatřiďovací tabulka má klíče různých typů.

výraz literálu typu 7.1.10

Syntaxe:

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 [

Popis:

Literál typu je reprezentován v implementaci nespecifikovaným základním typem. V důsledku toho je název typu synonymum pro svůj základní typ.

Literály typu jsou používány v několika kontextech:

• Určení explicitního převodu (§ 6, § 7.2.9)
• Vytvoření pole s omezením typu (§ 9,4)
• Přístup ke statickým členům objektu (§ 7.1.2)
• Určení omezení typu pro proměnnou (§ 5,3) nebo parametr funkce (§ 8.10.2)

Příklady:

Příklady literálů typu jsou [int] , [object[] a [int[,,]] . Obecný typ zásobníku (4.4), [Stack[string]]který se specializuje na udržování řetězců, může být napsán jako a int obecný typ slovníku, který se specializuje na držení klíčů s přidruženými řetězcovou hodnotou, může být zapsán jako [Dictionary[int,string]].

Typ literálu typu je System.Type. Úplný název výše navrhovaného Stack[string] typu je System.Collections.Generic.Stack[int]. Úplný název výše navrhovaného Dictionary[int,string] typu je System.Collections.Generic.Dictionary[int,string].

7.2 Unární operátory

Syntaxe:

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 Operátor unární čárky

Popis:

Tento operátor vytvoří jednorozměrné pole bez omezení s jedním prvkem, jehož typ a hodnota jsou typu unary-expression.

Tento operátor je asociativní zprava.

Příklady:

$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 Logické NOT

Popis:

Operátor -not převede hodnotu určenou výrazem unary-expression na typ bool (\6.2), pokud je to potřeba, a vytvoří výsledek tohoto typu. Pokud má hodnota unary-expression hodnotu True, je výsledkem Hodnota False a naopak. Operátor ! je alternativní pravopis pro -not.

Tento operátor je asociativní zprava.

Příklady:

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

7.2.3 Bitový OPERÁTOR NOT

Popis:

Operátor -bnot v případě potřeby převede hodnotu určenou výrazem unary-expression na celočíselný typ (6,4). Pokud lze převedenou hodnotu reprezentovat v typu int, pak je to typ výsledku. Jinak, pokud lze převedenou hodnotu reprezentovat v typu long, pak je to typ výsledku. V opačném případě je výraz špatně formátovaný. Výsledná hodnota je doplňkem 1 převedené hodnoty.

Tento operátor je asociativní zprava.

Příklady:

-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 Unární plus

Popis:

Výraz ve tvaru +unární-výraz se bude považovat za napsaný jako 0 + unary-expression (7,7). Celočíselný literál 0 má typ int.

Tento operátor je asociativní zprava.

Příklady:

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

7,2,5 Unární minus

Popis:

Výraz ve tvaru -unary-expression se bude považovat za napsaný jako 0 - unary-expression (7,7). Celočíselný literál 0 má typ int.

Tento operátor je asociativní zprava.

Příklady:

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

7.2.6 Operátory inkrementování a dekrementování předpony

Popis:

Unary-expression musí určit zapisovatelné umístění s hodnotou číselného typu (\4) nebo hodnotou $null. Pokud je hodnota určená svým unárním $nullvýrazem , převede se hodnota unary-expression na typ int a hodnota nula před vyhodnocením operátoru.

Poznámka

Typ hodnoty určené výrazem unary-expression se může při uložení výsledku změnit. Diskuzi o změně typu prostřednictvím přiřazení najdete v tématu 7.11 .

U operátoru předpony ++ je hodnota unary-expression zvýšena o 1 příslušného typu. Výsledkem je nová hodnota po zvýšení. Výraz je ++E ekvivalentní výrazu E += 1 (%)7.11.2.

U operátoru prefix -- je hodnota unary-expression snížena o 1 příslušného typu. Výsledkem je nová hodnota po dekrementování. Výraz je --E ekvivalentní výrazu E -= 1 (%)7.11.2.

Tyto operátory jsou asociativní zprava.

Příklady:

$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 Unární operátor -join

Popis:

Unární operátor -join vytvoří řetězec, který je zřetězením hodnoty jednoho nebo více objektů určených výrazem unary-expression. (Oddělovač lze vložit pomocí binární verze tohoto operátoru (%)7.8.4.4).)

unary-expression může být skalární hodnota nebo kolekce.

Příklady:

-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 Unární operátor -split

Popis:

Unární operátor -split rozdělí jeden nebo více řetězců určených unárním výrazem a vrátí jejich dílčí části v omezeném jednorozměrném poli řetězce. Považuje všechny souvislé skupiny mezer jako oddělovač mezi po sobě jdoucími dílčími částmi. (Explicitní řetězec oddělovače lze zadat pomocí binární verze tohoto operátoru (%)7.8.4.5).) Tento operátor má dvě varianty (7,8).

Text oddělovače není součástí výsledných řetězců. Počáteční a koncové prázdné znaky ve vstupním řetězci se ignorují. Vstupní řetězec, který je prázdný nebo obsahuje prázdné znaky, má za výsledek pouze pole s 1 řetězcem, které je prázdné.

Unary-expression může určit skalární hodnotu nebo pole řetězců.

Příklady:

-split " red\`tblue\`ngreen " # 3 strings: "red", "blue", "green"
-split ("yes no", "up down") # 4 strings: "yes", "no", "up", "down"
-split " " # 1 (empty) string

Operátor přetypování 7.2.9

Popis:

Tento operátor explicitně převede hodnotu určenou výrazem unary-expression na typ určený type-literal. Pokud je typ literál jiný než void, typ výsledku je pojmenovaný typ a hodnota je hodnota po převodu. Pokud je type-literal void, do kanálu se zapisovat žádný objekt a žádný výsledek neexistuje.

Pokud je výraz libovolného typu přetypován na stejný typ, výsledný typ a hodnota jsou typem a hodnotou unary-expression.

Tento operátor je asociativní zprava.

Příklady:

[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ární operátor čárky

Syntaxe:

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

Popis:

Operátor binární čárky vytvoří jednorozměrné pole, jehož prvky jsou hodnoty určené jeho operandy v lexikálním pořadí. Pole má typ bez omezení.

Příklady:

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

Přidání závorek do určitých binárních výrazů čárky nezdokumentuje výchozí prioritu. místo toho se změní výsledek.

7.4 Operátor rozsahu

Syntaxe:

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

Popis:

Výraz range-expression vytvoří jednorozměrné pole bez omezení, jehož prvky jsou hodnoty sekvence int určené hranicemi rozsahu. Hodnoty určené operandy jsou v případě potřeby převedeny na typ int (%)6.4. Operand označující nižší hodnotu po převodu je dolní mez, zatímco operand určující vyšší hodnotu po převodu je horní mez. Obě meze mohou být stejné, v takovém případě má výsledné pole délku 1. Pokud levý operand určuje dolní mez, je sekvence ve vzestupném pořadí. Pokud levý operand určuje horní mez, je sekvence v sestupném pořadí.

Koncepčně je tento operátor zkratkou pro odpovídající sekvenci operátoru binární čárky. Například rozsah lze také 5..8 vygenerovat pomocí 5,6,7,8. Pokud je však potřeba vzestupná nebo sestupná posloupnost bez pole, implementace se může vyhnout generování skutečného pole. Například v souboru foreach ($i in 1..5) { ... }není potřeba vytvářet žádné pole.

Výraz range-expression lze použít k určení řezu pole (9,9).

Příklady:

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 – operátor formátu

Syntaxe:

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)

Popis:

Výraz Format formátuje jednu nebo více hodnot, které jsou určeny výrazem Range podle formátu řetězce určeného formátovacím výrazem. Pozice hodnot určených výrazem Range jsou číslovány od nuly a zvyšují v lexikálním pořadí. Výsledek je typu string .

Řetězec specifikace formátu může obsahovat nula nebo více specifikací formátu, z nichž každá má následující tvar:

{N [ ,M ][ : FormatString ]}

N představuje (povinný) Rozsah hodnoty výrazu- pozice, M představuje (volitelnou) minimální šířku zobrazení a vlastnost formatString označuje formát (volitelné). Pokud šířka formátované hodnoty překročí zadanou šířku, Šířka se odpovídajícím způsobem zvýší. Hodnoty, jejichž pozice nejsou odkazovány v formatString , jsou po vyhodnocení pro jakékoli vedlejší účinky ignorovány. Pokud N odkazuje na neexistující pozici, chování je definováno implementací. Hodnota typu a typ $null void jsou formátovány jako prázdné řetězce. Pole jsou formátována jako dílčí výrazy (§ 7.1.6). Chcete-li zahrnout znaky "{" a "}" ve specifikaci formátu bez jejich interpretace jako oddělovače formátu, zapište je jako "{{" a "}}" v uvedeném pořadí.

Úplnou definici specifikací formátu naleznete v tématu typ System.IFormattable v technické sestavě ECMA TR/84.

Příklady:

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

Ve specifikaci formátu Pokud N odkazuje na neexistující pozici, je vyvolána výjimka FormatError .

7,6 multiplikativní operátory

Syntaxe:

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 násobení

Popis:

Výsledek operátoru * násobení je součin hodnot určených dvěma operandy po použití běžných aritmetických převodů (§ 6,15).

Tento operátor je asociativní od sebe.

Příklady:

12 * -10L      # long result -120
-10.300D * 12  # decimal result -123.600
10.6 * 12      # double result 127.2
12 * "0xabc"   # int result 32976

replikace řetězců 7.6.2

Popis:

Když levý operand určí řetězec, binární * operátor vytvoří nový řetězec, který obsahuje hodnotu určenou levým operandem replikovanou, kolikrát je určena hodnotou pravého operandu, jak je převedena na celočíselný typ (§ 6,4).

Tento operátor je asociativní od sebe.

Příklady:

"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

replikace pole 7.6.3

Popis:

Když levý operand určí pole, binární * operátor vytvoří nové nešifrované jednorozměrné pole, které obsahuje hodnotu určenou levým operandem replikovanou, která je určená hodnotou levého operandu, která byla určena hodnotou pravého operandu, jak je převedena na celočíselný typ (§ 6,4). Počet replikací s nulovým výsledkem v poli o délce 1. Pokud levý operand určí multidimenzionální pole, je před použitím shrnut (§ 9,12).

Tento operátor je asociativní od sebe.

Příklady:

$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 rozdělení

Popis:

Výsledek operátoru / dělení je podíl, pokud je hodnota určená levým operandem dělena hodnotou určenou pravým operandem po použití běžných aritmetických převodů (§ 6,15).

Je-li proveden pokus o provedení celého čísla nebo desítkového dělení nulou, je vyvolána koncová Chyba definovaná implementací.

Tento operátor je asociativní od sebe.

Příklady:

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

Je-li proveden pokus o provedení celého čísla nebo desítkového dělení nulou, je vyvolána výjimka RuntimeException – .

7.6.5 zbytek

Popis:

Výsledek zbývajícího operátoru % je zbytek, pokud je hodnota určená levým operandem dělena hodnotou určenou pravým operandem po použití běžných aritmetických převodů (§ 6,15).

Je-li proveden pokus o provedení celého čísla nebo desítkového dělení nulou, je vyvolána koncová Chyba definovaná implementací.

Příklady:

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

Je-li proveden pokus o provedení celého čísla nebo desítkového dělení nulou, je vyvolána výjimka RuntimeException – .

operátory sčítání 7,7

Syntaxe:

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

7.7.1 sčítání

Popis:

Výsledek operátoru + sčítání je součet hodnot určených dvěma operandy po použití běžných aritmetických převodů (§ 6,15).

Tento operátor je asociativní od sebe.

Příklady:

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 řetězce concatentaion

Popis:

Když levý operand určí řetězec, binární + operátor vytvoří nový řetězec, který obsahuje hodnotu určenou levým operandem následovaný bezprostředně hodnotou, která je určena pravým operandem, který následuje za převodem na typ String (§ 6,8).

Tento operátor je asociativní od sebe.

Příklady:

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

zřetězení pole 7.7.3

Popis:

Když levý operand určí pole, binární + operátor vytvoří nové neomezeně jednorozměrné pole, které obsahuje prvky určené levým operandem následovaným bezprostředně hodnotou, která je určena pravým operandem. Multidimenzionální pole přítomná v obou operandech jsou shrnuta (§ 9,12) před použitím.

Tento operátor je asociativní od sebe.

Příklady:

$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 zřetězení zatřiďovací tabulky

Popis:

Pokud oba operandy označují Zatřiďovacími tabulkami binární + operátor, vytvoří novou zatřiďovací tabulku, která obsahuje prvky určené levým operandem následovanými bezprostředně prvky určené pravým operandem.

Pokud Zatřiďovacími tabulkami obsahuje stejný klíč, je vyvolána koncová Chyba definovaná implementací.

Tento operátor je asociativní od sebe.

Příklady:

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

Pokud Zatřiďovacími tabulkami obsahuje stejný klíč, je vyvolána výjimka typu BadOperatorArgument .

odčítání 7.7.5

Popis:

Výsledek operátoru - odčítání je rozdíl, pokud je hodnota určená pravým operandem odečtena od hodnoty určené levým operandem po použití běžných aritmetických převodů (§ 6,15).

Tento operátor je asociativní od sebe.

Příklady:

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 operátory porovnání

Syntaxe:

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)

Popis:

Typ hodnoty určené levým operandem určuje, jak je hodnota určená pravým operandem převedena (§ 6), je-li to nutné, před provedením porovnání.

Některé porovnání – operátor, který je napsán jako-op, má dvě varianty, jeden, který rozlišuje velká a malá písmena (-c op), a druhý, který není (-i op). Verze op je ekvivalentem op. Rozlišování velkých a malých písmen je smysluplné jenom s porovnáním hodnot typu String. V kontextech porovnání bez řetězce se tyto dvě varianty chovají stejně.

Tyto operátory jsou asociativní zleva.

7.8.1 operátory rovnosti a relačních operátorů

Popis:

Existují dva operátory rovnosti : rovnost ( -eq ) a nerovnost ( -ne ); a čtyři relační operátory: menší než ( -lt ), menší než nebo rovno ( -le ), větší než ( -gt ), a větší než nebo rovno ( -ge ). Každé z nich má dvě varianty (§ 7,8).

Aby dva řetězce mohly porovnat stejné délky, musí mít v případě potřeby stejnou délku a obsah a velká písmena.

Pokud hodnota určená levým operandem není kolekce, výsledek je typu bool . V opačném případě je výsledkem pravděpodobně prázdné neomezená hodnota jednorozměrného pole obsahujícího prvky kolekce, která testuje hodnotu true, pokud je porovnána s hodnotou určenou pravý operandem.

Příklady:

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 operátory zahrnutí

Popis:

Existují čtyři operátory zahrnutí : Contains ( -contains ), obsahuje ( ‑notcontains ), in ( -in ) a Not-in ( -notin ). Každé z nich má dvě varianty (§ 7,8).

Operátory omezení vracejí výsledek typu bool, který označuje, zda se hodnota vyskytuje (nebo k ní nedochází) alespoň jednou v prvcích pole. S -contains a ‑notcontains je hodnota určena pravým operandem a pole je určeno levým operandem. S-in a -notin jsou operandy obráceny. Hodnota je určena levým operandem a pole je určeno pravým operandem.

Pro účely těchto operátorů, pokud operand pole má skalární hodnotu, je skalární hodnota považována za pole jednoho prvku.

Příklady:

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

testování typu 7.8.3 a operátory převodu

Popis:

Operátor -is typu testuje, zda hodnota určená levým operandem má typ, nebo je odvozena z typu, který má typ, určený pravý operandem. Pravý operand musí určovat typ nebo hodnotu, která může být převedena na typ (například řetězec, který název typu). Typ výsledku je bool . Operátor -isnot Type vrátí logickou negaci odpovídajícího -is formuláře.

Operátor -as typu se pokusí převést hodnotu určenou levým operandem na typ určený pravý operandem. Pravý operand musí určovat typ nebo hodnotu, která může být převedena na typ (například řetězec, který název typu). Pokud převod selže, $null je vrácena. jinak je vrácena převedená hodnota a návratový typ tohoto výsledku je typ modulu runtime převedené hodnoty.

Příklady:

$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 porovnávání vzorů a operátory manipulace s textem

7.8.4.1 operátory LIKE a-notlike

Popis:

Pokud levý operand neurčuje kolekci, výsledek je typu bool . V opačném případě je výsledkem pravděpodobně prázdné neomezená hodnota jednorozměrného pole obsahujícího prvky kolekce, která testuje hodnotu true, pokud je porovnána s hodnotou určenou pravý operandem. Pravý operand může označovat řetězec, který obsahuje zástupné výrazy (§ 3,15). Tyto operátory mají dvě varianty (§ 7,8).

Příklady:

"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 operátory-Match a-notmatch

Popis:

Pokud levý operand neurčuje kolekci, výsledek má typ bool a pokud je $true to výsledek, prvky zatřiďovací tabulky $matches jsou nastaveny na řetězce, které odpovídají (nebo neshodují) hodnotu určenou pravým operandem. V opačném případě je výsledkem pravděpodobně prázdné neomezená jednorozměrná pole obsahující prvky kolekce, které testuje hodnotu true, pokud je porovnána s hodnotou určenou pravý operandem a $matches není nastavena. Pravý operand může označovat řetězec, který obsahuje regulární výrazy (§ 3,16), v takovém případě je označován jako vzor. Tyto operátory mají dvě varianty (§ 7,8).

Tyto operátory podporují podshody (§ 7.8.4.6).

Příklady:

"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 operátor-Replace

Popis:

-replaceOperátor umožňuje nahrazení textu v jednom nebo více řetězcích určených levým operandem pomocí hodnot určených pravým operandem. Tento operátor má dvě varianty (§ 7,8). Pravý operand má jednu z následujících forem:

• Řetězec, který se má umístit, který může obsahovat regulární výrazy (§ 3,16). V tomto případě je náhradní řetězec implicitně "".
• Pole 2 objekty obsahující řetězec, který má být umístěn, následovaný náhradním řetězcem.

Pokud levý operand určí řetězec, výsledek má typ String. Pokud levý operand označuje jednorozměrné pole řetězce, výsledkem je neomezená jednorozměrná pole, jehož délka je stejná jako u pole levého operandu, které obsahuje vstupní řetězce po nahrazení.

Tento operátor podporuje podshody (§ 7.8.4.6).

Příklady:

"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 operátor binárního spojení

Popis:

Binární -join operátor vytvoří řetězec, který je zřetězením hodnoty jednoho nebo více objektů určeného levým operandem po převodu na řetězec (§ 6,7), v případě potřeby. Řetězec určený pomocí pravého operandu se používá k oddělení (případně prázdných) hodnot ve výsledném řetězci.

Levý operand může být skalární hodnota nebo kolekce.

Příklady:

(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 operátor binárního rozdělení

Popis:

Binární -split operátor rozdělí jeden nebo více řetězců určených levým operandem a vrátí jejich dílčí části do omezeného jednorozměrného pole řetězce. Tento operátor má dvě varianty (§ 7,8). Levý operand může určit skalární hodnotu nebo pole řetězců. Pravý operand má jednu z následujících forem:

• Řetězec oddělovače
• Pole 2 objekty obsahující řetězec oddělovače následovaný číselným počtem rozdělení
• Pole 3 objekty obsahující řetězec oddělovače, počet číselných rozdělení a řetězec možností
• Blok skriptu
• Pole 2 objekty obsahující blok skriptu následovaný počtem číselných rozdělení

Řetězec oddělovače může obsahovat regulární výrazy (§ 3,16). Slouží k vyhledání dílčích částí se vstupními řetězci. Oddělovač není zahrnutý ve výsledných řetězcích. Pokud levý operand určí prázdný řetězec, který má za následek prázdný prvek řetězce. Pokud je řetězec oddělovače prázdným řetězcem, nachází se v každé pozici znaku ve vstupních řetězcích.

Ve výchozím nastavení jsou všechny dílčí části vstupních řetězců umístěny do výsledku jako samostatné prvky. počet rozdělení lze však použít k úpravě tohoto chování. Pokud je tento počet záporný, nula nebo větší nebo roven počtu dílčích částí ve vstupním řetězci, každý subpart přejde do samostatného prvku. Je-li tento počet menší než počet dílčích částí ve vstupním řetězci, existují prvky ve výsledku s koncovým elementem obsahujícím všechny dílčí části nad rámec první počet-1 dílčí části.

Řetězec možností obsahuje nula nebo více názvů možností s každou sousední dvojicí oddělenou čárkou. Úvodní, koncové a vložené prázdné znaky jsou ignorovány. Názvy možností můžou být v libovolném pořadí a rozlišují se malá a velká písmena.

Pokud řetězec Options obsahuje možnost název SimpleMatch, může obsahovat také název možnosti IgnoreCase. Pokud řetězec Options obsahuje název možnosti RegexMatch nebo neobsahuje buď RegexMatch nebo SimpleMatch, může obsahovat libovolný název možnosti kromě SimpleMatch. Nesmí ale obsahovat víceřádkové i režimu Singleline.

Tady je sada názvů možností:

Možnost	Popis
CultureInvariant	Při vyhodnocování oddělovače ignoruje kulturní rozdíly v jazyce.
Popisu	Ignoruje nepojmenované skupiny shody, takže se v seznamu výsledků vrátí jenom explicitní skupiny zachycení.
IgnoreCase	Vynutí porovnávání bez ohledu na velikost písmen, i -csplit když se používá.
IgnorePatternWhitespace	Ignoruje neřídicí mezeru a komentáře označené znaménkem čísla (#).
Multiline	Tento režim rozpoznává začátek a konec řádků a řetězců. Výchozí režim je režimu Singleline.
RegexMatch	Pro vyhodnocení oddělovače použijte odpovídající regulární výraz. Tato možnost je výchozí.
SimpleMatch	Při vyhodnocování oddělovače použijte jednoduché porovnání řetězců.
Režimu Singleline	Tento režim rozpoznává pouze začátek a konec řetězce. Je to výchozí režim.

Blok skriptu (§ 7.1.8) určuje pravidla pro určení oddělovače a musí se vyhodnotit jako typ bool.

Příklady:

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

Vzor, který odpovídá -match , -notmatch a -replace může obsahovat dílčí části (označované jako dílčí shody) oddělenými závorkami. Uvažujte následující příklad:

"red" -match "red"

Výsledek je a klíč 0 z $matches obsahuje "Red", který je $true součástí řetězce určeného levým operandem, který přesně odpovídá vzoru určenému pravým operandem.

V následujícím příkladu je celý vzor shodný s:

"red" -match "(red)"

Stejně jako dřív obsahuje klíč 0 "Red"; Nicméně klíč 1 obsahuje také "Red", který je součástí řetězce určeného levým operandem, který přesně odpovídá dílčí shodě.

Vezměte v úvahu následující složitější vzor:

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

Tento model umožňuje pododpovídat "r", "znovu", "d" nebo "Red".

Opět klíč 0 obsahuje "Red". Klíč 1 obsahuje "" znovu ", klíč 2 obsahuje" r "a klíč 3 obsahuje" d ". Páry klíč/hodnota jsou v odpovídajícím pořadí od zleva doprava ve vzoru s delšími shodami řetězců před kratšími.

V případě -replace může nahrazující text získat přístup k podshodám prostřednictvím názvů formuláře $n , kde první shoda je $1 , druhá je $3 a tak dále. Třeba

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

Výsledný řetězec je "ráno v pondělí".

Místo toho, aby měly klíče v $matches indexech založených na nule, mohou být dílčí shody pojmenovány pomocí formuláře ?<*name*> . Například "((r)e)(d)" lze zapsat se třemi pojmenovanými shodami, M1, m2 a M3 následujícím způsobem: "(?<m1>(?<m2>r)e)(?<m3>d)" .

7.8.5 Shift – operátory

Popis:

Operátor Shift Left ( -shl ) a Shift Right ( -shr ) převedou hodnotu navrženou levým operandem na celočíselný typ a hodnotu určenou pravý operandem int, pokud je to nutné, pomocí obvyklých aritmetických převodů (§ 6,15).

Operátor posunutí doleva posune levý operand doleva o několik bitů vypočítaných podle popisu níže. Prázdné bitové pozice v dolním pořadí jsou nastaveny na hodnotu nula.

Operátor posunu vpravo posune levý operand vpravo počtem bitů vypočítaných podle popisu níže. Dolní pořadí bitů levého operandu se zahodí, zbývající bity se posunou doprava. Je-li levý operand znaménkem, je horní hodnota prázdné bitové pozice nastavena na hodnotu nula, pokud je levý operand nezáporný a je-li levý operand záporný, nastavte na hodnotu jedna. Když je levý operand hodnota bez znaménka, je horní pořadí prázdných pozic nastaveno na hodnotu nula.

Je-li levý operand typu int, je počet posunut podle pěti bitů pravého operandu v dolním pořadí. Je-li pravý operand typu Long, je počet posunu dán dolním šesti bity pravého operandu.

Příklady:

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

7,9 bitových operátorů

Syntaxe:

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

Popis:

Bitový operátor AND -band , bitový operátor OR -bor a BITOVÝ operátor XOR – bxor převede hodnoty určené jejich operandy na typy integer, pokud je to nutné, pomocí obvyklých aritmetických převodů (§ 6,15). V případě převodu, pokud obě hodnoty mají typ int, který je typem výsledku. V opačném případě, pokud obě hodnoty mají typ Long, což je typ výsledku. Pokud je jedna hodnota typu int a druhá má typ Long, je typ výsledku dlouhý. V opačném případě je výraz nesprávně vytvořen. Výsledkem je bitový operátor AND, bitový operátor OR, nebo bitový operátor XOR, v uvedeném pořadí, případně převedených hodnot operandu.

Tyto operátory jsou asociativní zleva. Jsou komutativníy, pokud žádný operand neobsahuje vedlejší efekt.

Příklady:

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

logické operátory 7,10

Syntaxe:

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

Popis:

Logický operátor -and and převede hodnoty určené jeho operandy na bool , pokud je to nutné (§ 6,2). Výsledkem je logický operátor a případně převedené hodnoty operandu a má typ bool . Pokud je levý operand vyhodnocen jako false, není vyhodnocen pravý operand.

Logický operátor -or or převede hodnoty určené jeho operandy na bool , pokud je to nutné (§ 6,2). Výsledkem je logický nebo případně převedené hodnoty operandu a má typ bool . Pokud je levý operand vyhodnocen jako true, není vyhodnocen pravý operand.

Logický operátor -xor XOR převede hodnoty určené jeho operandy na bool (§ 6,2). Výsledkem je logická XOR pro případné převedené hodnoty operandu a má typ bool .

Tyto operátory jsou asociativní zleva.

Příklady:

$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

operátory přiřazení 7,11

Syntaxe:

assignment-expression:
    expression assignment-operator statement

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

Popis:

Operátor přiřazení ukládá hodnotu do zapisovatelného umístění označeného výrazem. Diskuzi operátoru = přiřazení viz § 7.11.1. Pro diskuzi o všech ostatních operátorech přiřazení, viz § 7.11.2.

Výraz přiřazení má hodnotu určenou výrazem poté, co bylo přiřazení provedeno. Nicméně tento výraz přiřazení sám neurčuje zapisovatelné umístění. Pokud je výraz typu s omezením (§ 5,3), typ použitý v tomto omezení je typ výsledku; v opačném případě typ výsledku je typ po použití obvyklých aritmetických převodů (§ 6,15).

Tento operátor je asociativní zprava.

jednoduché přiřazení 7.11.1

Popis:

V jednoduchém přiřazení ( = ) hodnota určená příkazem nahrazuje hodnotu uloženou v zapisovatelném umístění označeném výrazem. Nicméně pokud výraz označuje neexistující klíč v zatřiďovací tabulce, tento klíč se přidá do tabulky hash s přidruženou hodnotou Value určenou příkazem.

Jak je znázorněné gramatikou, výraz může označovat čárkami oddělený seznam umístění s možností zápisu. Toto je známé jako více přiřazení. příkaz určuje seznam jedné nebo více hodnot oddělených čárkami. Čárky v obou seznamech operandů jsou součástí syntaxe vícenásobného přiřazení a nepředstavují binární operátor čárky. Hodnoty jsou přijímány ze seznamu určeného příkazem, v lexikálním pořadí a uloženy v odpovídajícím umístění, které je označeno výrazem. Pokud seznam označený příkazem má méně hodnot, než kolik existuje pro $null zapisovatelné umístění výrazů , převezmou tato přebytečná umístění. Pokud je v seznamu určeném příkazem více hodnot, než je umístění s možností zápisu pro výrazy , všechna kromě toho, že umístění výrazu v pravém krajním případě trvá na odpovídající hodnotě příkazu a umístění výrazu , které je nejvíce vpravo, se bude neomezeně jednorozměrné pole se všemi zbývajícími hodnotami příkazu jako prvky.

Pro příkazy, které mají hodnoty (§ 8.1.2), může být příkazem příkaz.

Příklady:

$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

složené přiřazení 7.11.2

Popis:

Složené přiřazení má formulář E1 op= E2 a je ekvivalentní k jednoduchému výrazu E1 = E1 op (E2) přiřazení s tím rozdílem, že v případě složeného přiřazení je výraz E1 vyhodnocen pouze jednou. Pokud je výraz typu s omezením (§ 5,3), typ použitý v tomto omezení je typ výsledku; v opačném případě typ výsledku Určuje op. Pro *= naleznete v tématu § 7.6.1, § 7.6.2, § 7.6.3; pro /= , viz § 7.6.4; pro %= , viz § 7.6.5; pro += , viz § 7.7.1, § 7.7.2, §7.7.3; pro -= , viz § 7.7.5.

Poznámka

Operand označující neomezenou hodnotu číselného typu může být jeho typ změněn operátorem přiřazení při uložení výsledku.

Příklady:

$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 – operátory přesměrování

Syntaxe:

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

Popis:

Operátor > přesměrování převezme standardní výstup z kanálu a přesměruje ho do umístění určeného přesměrovaným souborem-File-Name a přepíše aktuální obsah tohoto umístění.

Operátor >> přesměrování převezme standardní výstup z kanálu a přesměruje ho do umístění určeného přesměrovaným souborem-File-Name a připojuje se k aktuálnímu obsahu daného umístění, pokud existuje. Pokud toto umístění neexistuje, vytvoří se.

Operátor přesměrování s formulářem n> přebírá výstup proudu n z kanálu a přesměruje ho do umístění určeného přesměrovaným souborem-File-Name a přepíše aktuální obsah tohoto umístění.

Operátor přesměrování s formulářem n>> přebírá výstup datového proudu n z kanálu a přesměruje ho do umístění určeného přesměrovaným souborem-File-Name a připojuje se k aktuálnímu obsahu daného umístění, pokud existuje. Pokud toto umístění neexistuje, vytvoří se.

Operátor přesměrování pomocí formuláře m>&n zapisuje výstup ze streamu m do stejného umístění jako datový proud n.

Platnými datovými proudy jsou následující:

Stream	Description
1	Standardní výstupní datový proud
2	Chybový stream výstupu
3	Výstupní datový proud upozornění
4	Podrobný výstupní datový proud
5	Ladění výstupního streamu
*	Standardní výstup, chybový výstup, výstup upozornění, podrobný výstup a výstupní streamy ladění

Operátory přesměrování 1>&2, 6>a 6>> jsou < vyhrazené pro budoucí použití.

Pokud je ve výstupu hodnota redirected-file-name $null, výstup se zahodí.

Obvykle se hodnota výrazu obsahujícího vedlejší efekt nejvyšší úrovně nezapisuje do kanálu, pokud není tento výraz uzavřený v páru závorek. Pokud je však takový výraz levým operandem operátoru, který přesměruje standardní výstup, hodnota je zapsána.

Příklady:

$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