7. Wyrażenia

Notatka redakcyjna

Ważny

Specyfikacja języka Windows PowerShell 3.0 została opublikowana w grudniu 2012 r. i jest oparta na systemie Windows PowerShell 3.0. Ta specyfikacja nie odzwierciedla bieżącego stanu programu PowerShell. Nie ma planu aktualizacji tej dokumentacji w celu odzwierciedlenia bieżącego stanu. Ta dokumentacja jest przedstawiona tutaj w celu uzyskania informacji historycznych.

Dokument specyfikacji jest dostępny jako dokument programu Microsoft Word z Centrum pobierania Microsoft pod adresem: https://www.microsoft.com/download/details.aspx?id=36389 Dokument programu Word został przekonwertowany na prezentację tutaj w witrynie Microsoft Learn. Podczas konwersji wprowadzono pewne zmiany redakcyjne w celu dostosowania formatowania dla platformy Docs. Usunięto niektóre literówki i drobne błędy.

Składnia:

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

Opis:

Wyrażenie to sekwencja operatorów i operandów, która wyznacza metodę, funkcję, lokalizację zapisywalną lub wartość; określa obliczanie wartości; powoduje co najmniej jeden efekt uboczny; lub wykonuje niektóre kombinacje tych kombinacji. Na przykład

• Literał 123 to wyrażenie, które wyznacza wartość liczbową całkowitą 123.
• Wyrażenie 1,2,3,4 wyznacza obiekt tablicy 4-elementowej o pokazanych wartościach.
• Wyrażenie 10.4 * $a określa obliczenia.
• Wyrażenie $a++ daje efekt uboczny.
• Wyrażenie $a[$i--] = $b[++$j] wykonuje kombinację tych elementów.

Z wyjątkiem określonych przypadków dla niektórych operatorów, kolejność oceny wyrażeń w zdaniu oraz kolejność występowania skutków ubocznych są nieokreślone. Przykłady nieokreślonego zachowania obejmują następujące elementy: $i++ + $i, $i + --$ii $w[$j++] = $v[$j].

Implementacja programu PowerShell może zapewnić obsługę typów zdefiniowanych przez użytkownika, a te typy mogą mieć zdefiniowane operacje. Wszystkie szczegóły takich typów i operacji są zależne od implementacji.

wyrażenie najwyższego poziomu to wyrażenie, które nie jest częścią większego wyrażenia. Jeśli wyrażenie najwyższego poziomu zawiera operator efektu ubocznego, wartość tego wyrażenia nie jest zapisywana do potoku; w przeciwnym razie jest. Szczegółowe omówienie można znaleźć w §7.1.1.

Zazwyczaj wyrażenie, które wyznacza kolekcję ([§4§4]) jest wyliczane do elementów składowych, gdy jest używana wartość tego wyrażenia. Nie jest to jednak przypadek, gdy wyrażenie jest wywołaniem polecenia cmdlet. Na przykład

$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

W dwóch pierwszych zastosowaniach operatora $(...) wyrażenie wyznaczające kolekcję jest zmienną $x, która jest wyliczana, co powoduje trzy wartości int oraz int 99. Jednak w trzecim przypadku wyrażenie jest bezpośrednim wywołaniem polecenia cmdlet, więc wynik nie jest wyliczany, a $a jest tablicą dwóch elementów, int[3] i int.

Jeśli operacja nie jest zdefiniowana przez program PowerShell, typ wartości wyznaczonej przez lewy operand jest sprawdzany, aby sprawdzić, czy ma odpowiednią metodę op_<operation>.

7.1 Wyrażenia podstawowe

Składnia:

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 Nawiasy grupowania

Składnia:

Napiwek

Notacja ~opt~ w definicjach składni wskazuje, że jednostka leksykalna jest opcjonalna w składni.

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

Opis:

Wyrażenie nawiasowe to wyrażenie-podstawowe, którego typ i wartość są takie same jak w przypadku wyrażenia bez nawiasów. Jeśli wyrażenie wyznaczy zmienną, wyrażenie nawiasu wyznacza tę samą zmienną. Na przykład $x.m i ($x).m są równoważne.

Nawiasy grupowania mogą być używane w wyrażeniu w celu udokumentowania domyślnego pierwszeństwa i kojarzenia w tym wyrażeniu. Można ich również użyć do zastąpienia tego domyślnego pierwszeństwa i asocjacji. Na przykład

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

Zazwyczaj grupowanie nawiasów na najwyższym poziomie jest nadmiarowe. Jednak nie zawsze tak jest. Rozważmy następujący przykład:

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

W drugim przypadku nawiasy zmieniają semantykę, powodując tablicę, której dwa elementy są tablicą 2 liczb całkowitych i skalarną liczbą całkowitą 6.

Oto kolejny wyjątek:

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

W pierwszym i trzecim przypadku wartość wyniku jest zapisywana w potoku. Jednak mimo że wyrażenie w drugim przypadku jest ewaluowane, wynik nie jest zapisywany w potoku z powodu obecności operatora efektu ubocznego = na najwyższym poziomie. (Usunięcie części $a = umożliwia zapisanie wartości, ponieważ * nie jest operatorem ubocznym).

Aby zatrzymać wartość żadnego wyrażenia, które nie zawiera efektów ubocznych najwyższego poziomu, należy je jawnie odrzucić w następujący sposób:

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

Aby zapisać w potoku wartość dowolnego wyrażenia zawierającego efekty uboczne najwyższego poziomu, należy ująć to wyrażenie w nawiasy w następujący sposób:

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

W związku z tym nawiasy grupowania w tym przypadku nie są nadmiarowe.

W poniższym przykładzie mamy podstawianie zmiennych (§2.3.5.2) odbywa się w literału ciągu:

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

W pierwszym przypadku nawiasy reprezentują wyrażenie podrzędneograniczników, nie grupowania nawiasów, a wyrażenie najwyższego poziomu zawiera operator efektu bocznego, wartość wyrażenia nie jest zapisywana w potoku. Oczywiście znaki > i < są nadal zapisywane). Jeśli dodane są nawiasy grupujące — jak pokazano w drugim przypadku — możliwe jest zapisywanie.

W poniższych przykładach każdy zawiera operatory efektów ubocznych najwyższego poziomu:

$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

Użycie nawiasów wokół wyrażenia, które nie zawiera efektów ubocznych na najwyższym poziomie kodu, sprawia, że takie nawiasy są zbędne. Na przykład;

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

Rozważmy następujący przykład, który ma dwa skutki uboczne, z których żaden nie znajduje się na najwyższym poziomie:

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

Wynik jest zapisywany do potoku, ponieważ wyrażenie na najwyższym poziomie nie ma skutków ubocznych.

7.1.2 Dostęp do składowych

Składnia:

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

Należy pamiętać, że po wyrażeniu-podstawowymnie jest dozwolona żadna spacja.

Opis:

Operator . służy do wybierania członka instancji z obiektu lub klucza z Hashtable. Lewy operand musi wskazywać na obiekt, a prawy operand musi wskazywać na dostępny członek instancji.

Prawy operand wyznacza dostępny element instancji wewnątrz typu obiektu wskazanego przez lewy operand, lub jeśli lewy operand wskazuje tablicę, prawy operand odnosi się do dostępnych elementów instancji w każdym elemencie tablicy.

Odstęp nie jest dozwolony przed operatorem ..

Ten operator jest pozostawiony asocjacyjny.

Operator :: służy do wybierania statycznego członka z danego typu. Lewy operand musi określać typ, a prawy operand musi określać dostępny statyczny członek tego typu.

Odstęp nie jest dozwolony przed operatorem ::.

Ten operator jest pozostawiony asocjacyjny.

Jeśli operand po prawej stronie wyznacza zapisywalną lokalizację w typie obiektu wyznaczonego przez lewy operand, całe wyrażenie wyznacza zapisywalną lokalizację.

Przykłady:

$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 Wyrażenia wywołania

Składnia:

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

Należy pamiętać, że po wyrażeniu-podstawowymnie jest dozwolona żadna spacja.

Opis:

Wyrażenie-wywołania- wywołuje metodę wyznaczoną przez primary-expression.member-name lub primary-expression::member-name. Nawiasy na liście argumentów zawierają prawdopodobnie pustą, rozdzielaną przecinkami listę wyrażeń, które wyznaczają argumenty , których wartości są przekazywane do metody. Przed wywołaniem metody argumenty są obliczane i konwertowane zgodnie z regułami §6, w razie potrzeby, aby dopasować typy oczekiwane przez metodę. Kolejność oceny primary-expression.member-name, primary-expression::member-nameoraz argumentów jest nieokreślona.

Ten operator jest pozostawiony asocjacyjny.

Typ wyniku wyrażenie-wywołania jest projektowania metody (§4.5.24).

Przykłady:

[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 Dostęp do elementów

Składnia:

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

Opis:

Między wyrażeniem podstawowym a lewym nawiasem kwadratowym ([) nie powinno być białych znaków.

7.1.4.1 Indeksowanie tablicy

Opis:

Tablice zostały szczegółowo omówione w §9. Jeśli wyrażenie jest tablicą 1-wymiarową, zobacz §7.1.4.5.

Gdy wyrażenie-podstawowe wyznacza tablicę 1-wymiarową A, operator [] zwraca element znajdujący się w A[0 + expression] po przekonwertowaniu wartości wyrażenia na int. Wynik ma typ elementu tablicy, do którego odwołuje się poprzez indeks. Jeśli wyrażenie jest ujemne, A[expression] wyznaczy element znajdujący się w A[A.Length + expression].

Gdy wyrażenie-podstawowe wyznacza tablicę dwuwymiarową B, operator zwraca element znajdujący się w po wartości wiersza i kolumnie składników wyrażenia (które są określone jako lista rozdzielona przecinkami) zostały przekonwertowane na . Wynik ma typ elementu tablicy, do którego odwołuje się poprzez indeks. W przeciwieństwie do tablicy 1-wymiarowej, położenia ujemne nie mają specjalnego znaczenia.

Gdy wyrażenie-podstawowe wyznacza tablicę trzech lub więcej wymiarów, stosowane są reguły 2-wymiarowych tablic, a położenia wymiarów są określane jako rozdzielona przecinkami lista wartości.

Jeśli próba odczytu z nieistniejącego elementu zostanie podjęta, wynikiem jest $null. Błąd polega na zapisywaniu do nieistniejącego elementu.

W przypadku wyrażenia indeksowego tablicy wielowymiarowej kolejność obliczania wyrażeń położenia wymiaru jest nieokreślona. Na przykład w przypadku tablicy 3-wymiarowej $azachowanie $a[$i++,$i,++$i] jest nieokreślone.

Jeśli wyrażenie jest tablicą, zobacz §7.1.4.5.

Ten operator jest pozostawiony asocjacyjny.

Przykłady:

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

Gdy zostanie podjęta próba zapisu do nieistniejącego elementu, zostanie zgłoszony wyjątek IndexOutOfRange.

7.1.4.2 Indeksowanie ciągu

Opis:

Gdy wyrażenie-podstawowe oznacza ciąg znaków S, operator [] zwraca znak znajdujący się na pozycji określonej jako zerowa przez wyrażenie , jako typ char. Jeśli wyrażenie jest większe lub równe długości tego ciągu, wynik jest $null. Jeśli wyrażenie jest ujemne, S[expression] wyznaczy element znajdujący się w S[S.Length + expression].

Przykłady:

$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 Indeksowanie tabeli skrótu

Opis:

Kiedy wyrażenie podstawowe oznacza tabelę skrótu, operator [] zwraca wartość lub wartości powiązane z kluczem albo kluczami wskazanymi przez wyrażenie . Typ wyrażenia nie jest ograniczony.

Jeśli wyrażenie jest jedną nazwą klucza, wynikiem jest skojarzona wartość i ma ten typ, chyba że taki klucz nie istnieje, w takim przypadku wynik jest $null. Jeśli $null jest używany jako klucz, zachowanie jest zdefiniowane przez implementację. Jeśli wyrażenie jest tablicą nazw kluczy, zobacz §7.1.4.5.

Jeśli wyrażenie jest tablicą, zobacz §7.1.4.5.

Przykłady:

$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

Gdy wyrażenie jest pojedynczą nazwą klucza, a $null jest używana jako jedyna wartość do indeksowania tablicy mieszającej, zgłaszany jest wyjątek NullArrayIndex.

7.1.4.4 Indeksowanie dokumentu XML

Opis:

Gdy wyrażenie-podstawowe wyznacza obiekt typu XML, wyrażenie jest, w razie potrzeby, konwertowane na ciąg, a operator [] zwraca pierwszy element podrzędny o nazwie określonej przez wyrażenie . Typ wyrażenia musi być ciągiem. Typ wyniku jest zdefiniowany przez implementację. Wynik można opatrzyć indeksem dolnym, aby uzyskać jego pierwszy element podrzędny. Jeśli żaden element podrzędny nie istnieje o nazwie określonej przez wyrażenie , wynik jest $null. Wynik nie wyznacza lokalizacji możliwej do zapisu.

Przykłady:

$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 wyniku to System.Xml.XmlElement lub System.String.

7.1.4.5 Generowanie fragmentów tablicy

Gdy wyrażenie podstawowe określa obiekt typu wyliczalnego (§4) lub tablicę haszującą, a wyrażenie jest tablicą jednowymiarową, wynikiem jest wycinek tablicy (§9.9), zawierający elementy wyrażenia podstawowego określone przez elementy wyrażenia .

W przypadku tabeli skrótu wycinek tablicy zawiera skojarzone wartości z podanymi kluczami, chyba że taki klucz nie istnieje, w takim przypadku odpowiedni element jest $null. Jeśli $null jest użyty jako dowolna nazwa klucza, zachowanie zależy od implementacji.

Przykłady:

$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: Gdy wyrażenie jest kolekcją dwóch lub więcej nazw kluczy, jeśli $null jest używane jako nazwa klucza, jest ignorowane i nie ma odpowiedniego elementu w wynikowej tablicy.

7.1.5 Operatory przyrostku i dekrementacji

Składnia:

post-increment-expression:
    primary-expression ++

post-decrement-expression:
    primary-expression dashdash

Opis:

Wyrażenie podstawowe musi wyznaczać lokalizację, która jest zapisywalna, mającą wartość typu liczbowego (§4) lub o wartości $null. Jeśli wartość określona przez operand to $null, ta wartość jest konwertowana na typ int i wartość zero przed obliczeniem operatora. Typ wartości wyznaczonej przez wyrażenie podstawowe może ulec zmianie przy przechowywaniu wyniku. Zobacz §7.11 dla omówienia zmiany typu za pośrednictwem przypisania.

Wynik wygenerowany przez operator ++ postfix jest wartością wyznaczoną przez operand. Po uzyskaniu tego wyniku, wartość określona przez operand jest zwiększana o 1, zgodnie z odpowiednim typem. Typ wyniku wyrażenia E++ jest taki sam jak w przypadku wyniku wyrażenia E + 1 (§7.7).

Wynik wygenerowany przez operator -- postfix jest wartością wyznaczoną przez operand. Po otrzymaniu tego wyniku wartość wyznaczona przez operand jest zmniejszana o 1, zgodnie z odpowiednim typem. Typ wyniku wyrażenia E-- jest taki sam jak w przypadku wyniku wyrażenia E - 1 (§7.7).

Te operatory pozostają asocjacyjne.

Przykłady:

$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

Operator 7.1.6 $(...)

Składnia:

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

Opis:

Jeśli lista instrukcji zostanie pominięta, wynik to $null. W przeciwnym razie zostanie obliczona lista instrukcji. Wszystkie obiekty zapisywane w potoku w ramach oceny są zbierane w nieskrępowanej tablicy 1-wymiarowej w kolejności. Jeśli tablica zebranych obiektów jest pusta, wynik jest $null. Jeśli tablica zebranych obiektów zawiera jeden element, wynik jest tym elementem; w przeciwnym razie wynikiem jest niekonseksowana tablica 1-wymiarowa zebranych wyników.

Przykłady:

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

Składnia:

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

Opis:

Jeśli lista-instrukcji zostanie pominięta, wynikiem jest nieograniczona tablica 1-wymiarowa o zerowej długości. W przeciwnym razie listy instrukcji jest poddawana ocenie, a wszystkie obiekty zapisane w potoku podczas oceny są zbierane w nieograniczonej tablicy jednowymiarowej, w kolejności. Wynikiem jest (prawdopodobnie pusta) nieskrępowana tablica 1-wymiarowa.

Przykłady:

$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 Wyrażenie bloku skryptu

Składnia:

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

Opis:

blok parametrów jest opisany w §8.10.9. nazwana lista bloków jest opisana w §8.10.7.

Blok skryptu to nienazwany blok instrukcji, który może być używany jako pojedyncza jednostka. Bloki skryptów mogą służyć do wywoływania bloku kodu tak, jakby był to pojedyncze polecenie lub można je przypisać do zmiennych, które można wykonać.

lista bloków o nazwie lub lista instrukcji jest wykonywana, a typ i wartości wyniku odpowiadają typowi i wartościom wyników tych zestawów instrukcji.

Wyrażenie blokujące skrypt ma typ scriptblock (§4.3.7).

Jeśli pominięty zostanie blok parametrów , przekazywane do bloku skryptu argumenty będą dostępne za pośrednictwem $args (§8.10.1).

Podczas powiązywania parametrów blok skryptu może zostać przekazany jako obiekt bloku skryptu lub jako wynik po ewaluacji tego bloku. Aby uzyskać więcej informacji, zobacz §6.17.

7.1.9 Wyrażenie literału hasha

Składnia:

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

Opis:

wyrażenie-literału-skrótu służy do tworzenia tabeli skrótu (§10) z zera lub większej liczby elementów, z których każda jest parą klucz/wartość.

Klucz może mieć dowolny typ z wyjątkiem typu null. Skojarzone wartości mogą mieć dowolny typ, w tym typ null, a każda z tych wartości może być dowolnym wyrażeniem, które wyznacza żądaną wartość, w tym $null.

Kolejność par klucz/wartość nie jest znacząca.

Przykłady:

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

tworzy dwie tabele skrótów, $h1 i $h2, z których każda zawiera trzy pary klucz/wartość, a trzecia $h3, która jest pusta. $h4 tabela skrótów ma klucze różnych typów.

7.1.10 Wyrażenie literału typu

Składnia:

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 [

Opis:

literału typu jest reprezentowana w implementacji przez niektóre nieokreślone typu bazowego. W związku z tym nazwa typu jest synonimem jego typu bazowego.

Literały typu używane są w różnych kontekstach:

• Określanie jawnej konwersji (§6, §7.2.9)
• Tworzenie tablicy z ograniczeniem typu (§9.4)
• Uzyskiwanie dostępu do statycznych składowych obiektu (§7.1.2)
• Określanie ograniczenia typu dla zmiennej (§5.3) lub parametr funkcji (§8.10.2)

Przykłady:

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

Typ stosu ogólnego (§4.4) wyspecjalizowany do przechowywania ciągów może być zapisywany jako [Stack[string]], a ogólny typ słownika, który jest wyspecjalizowany do przechowywania kluczy int ze skojarzonymi wartościami ciągów, może być zapisywany jako [Dictionary[int,string]].

Typ literału typu , oznaczonego jako, to System.Type. Pełną nazwą typu sugerowanego powyżej Stack[string] jest System.Collections.Generic.Stack[int]. Pełną nazwą typu sugerowanego powyżej Dictionary[int,string] jest System.Collections.Generic.Dictionary[int,string].

7.2 Operatory jednoargumentowe

Składnia:

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

Opis:

Operator przecinka (,) tworzy nieokreśloną tablicę 1-wymiarową zawierającą jeden element, którego typ i wartość są takie same jak typu i wartości wyrażenia unarnego .

Ten operator jest prawostronnie łączny.

Przykłady:

$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 Logiczne NIE

Składnia:

logical-not-operator:
    dash not

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

Opis:

Operator -not konwertuje wartość wyznaczoną przez wyrażenie jednoargumentowe na typ bool (§6.2), w razie potrzeby i generuje wynik tego typu. Jeśli wartość jednoargumentowego wyrażenia to True, wynik to False i na odwrót. Operator ! jest alternatywną pisownią dla -not.

Ten operator jest prawostronnie łączny.

Przykłady:

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

7.2.3 Bitowa negacja

Składnia:

bitwise-not-operator:
    dash bnot

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

Opis:

Operator -bnot konwertuje wartość wyznaczoną przez wyrażenie jednoargumentowe na typ całkowity (§6.4), jeśli to konieczne. Jeśli przekonwertowana wartość może być reprezentowana w typie int to jest to typ wyniku. W przeciwnym razie, jeśli przekonwertowana wartość może być reprezentowana w typie długim to jest to typ wyniku. W przeciwnym razie wyrażenie jest źle sformułowane. Wynikowa wartość jest uzupełnieniem jedynki przekonwertowanej wartości.

Ten operator jest prawostronnie łączny.

Przykłady:

-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 Unarny plus

Opis:

Wyrażenie w formie + unary-expression jest traktowane tak, jakby zostało napisane jako 0 + unary-expression (§7.7). Literał liczby całkowitej 0 ma typ int.

Ten operator jest prawostronnie łączny.

Przykłady:

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

7.2.5 Jednoargumentowy minus

Opis:

Wyrażenie w formie - unary-expression jest traktowane tak, jakby zostało napisane jako 0 - unary-expression (§7.7). Literał całkowity 0 ma typ int. Operator minus może być jednym z znaków kreski wymienionych w §7.2.

Ten operator jest prawostronnie łączny.

Przykłady:

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

7.2.6 Operatory prefiksu przyrostu i dekrementacji

Opis:

Wyrażenie jednoargumentowe musi wyznaczyć zapisywalną lokalizację o typie liczbowym (§4) lub mieć wartość $null. Jeśli wartość wyznaczona przez jego jednoargumentowe wyrażenie jest $null, to wartość jednoargumentowego wyrażeniajest konwertowana na typ int i ustawiona na zero przed oceną operatora.

Notatka

Typ wartości określony przez wyrażenie jednoargumentowe może się zmienić po zapisaniu wyniku. Zobacz §7.11 dla omówienia zmiany typu za pośrednictwem przypisania.

Dla operatora inkrementacji prefiksu ++ wartość jednoargumentowego wyrażenia jest zwiększana przez 1 odpowiedniego typu. Wynik jest nową wartością po inkrementacji. Wyrażenie ++E jest równoważne E += 1 (§7.11.2).

Dla operatora dekrementacji prefiksu --, wartość jednoargumentowego wyrażenia jest zmniejszana o 1 odpowiedniego typu. Wynikiem jest nowa wartość po dekrementacji. Wyrażenie --E jest równoważne E -= 1 (§7.11.2). Operator dekrementacji prefiksu może być dowolnym wzorcem pasującym do wzorca dashdash w §7.2.

Te operatory są odpowiednie do asocjacji.

Przykłady:

$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 Jednoargumentowy operator -join

Składnia:

join-operator:
    dash join

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

Opis:

Operator jednoargumentowy -join tworzy ciąg znaków będący połączeniem wartości jednego lub więcej obiektów wyznaczonych przez jednoargumentowe wyrażenie . (Separator można wstawić przy użyciu wersji binarnej tego operatora (§7.8.4.4).)

jednoargumentowe wyrażenie może być wartością skalarną lub kolekcją.

Przykłady:

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

Składnia:

split-operator:
    dash split

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

Opis:

Jednoargumentowy operator -split dzieli jeden lub więcej ciągów określonych przez jednoargumentowe wyrażenie , zwracając ich podciągi w ograniczonej jednowymiarowej tablicy ciągów. Traktuje ona dowolny ciąg znaków białych jako ogranicznik między kolejnymi częściami. Można określić jawny ciąg ogranicznika przy użyciu wersji binarnej tego operatora (§7.8.4.5) lub jego dwóch wariantów (§7.8).

Tekst ogranicznika nie jest uwzględniany w wynikowych ciągach. Początkowe i końcowe znaki odstępu w ciągu wejściowym są ignorowane. Ciąg wejściowy, który jest pusty lub zawiera tylko białe znaki, skutkuje tablicą z jednym ciągiem, który jest pusty.

wyrażenie unarne może wyznaczyć wartość skalarną lub tablicę ciągów.

Przykłady:

-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 Operator rzutowania

Opis:

Ten operator konwertuje jawnie (§6) wartość wyznaczoną przez jednoargumentowe wyrażenie na typ wyznaczony przez literał typu (§7.1.10). Jeśli literał typu jest różny od void, typ wyniku to nazwany typ, a wartość to wartość po konwersji. Jeśli literał typu jest pusty, żaden obiekt nie jest zapisywany w potoku i nie ma żadnego wyniku.

Kiedy wyrażenie dowolnego typu jest rzutowane na ten sam typ, wynikowy typ i wartość to typ i wartość jednoargumentowego wyrażenia .

Ten operator jest prawostronnie łączny.

Przykłady:

[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.

Operator przecinka binarnego 7.3

Składnia:

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

Opis:

Operator przecinka binarnego tworzy tablicę 1-wymiarową, której elementy są wartościami wyznaczonymi przez operandy w kolejności leksykalnej. Tablica ma nieokreślony typ.

Przykłady:

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

Dodanie nawiasów grupujących do niektórych wyrażeń binarnych z przecinkami nie dokumentuje domyślnego priorytetu; zamiast tego zmienia wynik.

Operator zakresu 7.4

Składnia:

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

Opis:

wyrażenie-zakres tworzy nieograniczoną jednowymiarową tablicę, której elementami są wartości zdefiniowanej przez granice zakresu sekwencji int. Wartości wyznaczone przez operandy są konwertowane na int, w razie potrzeby (§6.4). Operand określający niższą wartość po konwersji to dolna granica, podczas gdy operand określający wyższą wartość po konwersji to górna granica. Obie granice mogą być takie same, w takim przypadku wynikowa tablica ma długość 1. Jeśli lewy operand wyznacza dolną granicę, sekwencja jest w kolejności rosnącej. Jeśli lewy operand wyznacza górną granicę, sekwencja jest w kolejności malejącej.

Koncepcyjnie ten operator jest skrótem dla odpowiedniej sekwencji operatorów przecinka binarnego. Na przykład zakres 5..8 można również wygenerować przy użyciu 5,6,7,8. Jeśli jednak wymagana jest sekwencja rosnąca lub malejąca bez posiadania tablicy, implementacja może uniknąć generowania rzeczywistej tablicy. Na przykład w foreach ($i in 1..5) { ... }nie trzeba tworzyć tablicy.

wyrażenie zakresu może być używane do wskazania wycinka tablicy (§9.9).

Przykłady:

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

Operator formatu 7.5

Składnia:

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)

Opis:

Wyrażenie formatu formatuje jedną lub więcej wartości wyznaczonych przez wyrażenie zakresu zgodnie z ciągiem specyfikacji formatu wyznaczonym przez wyrażenie formatu . Pozycje wartości wyznaczonych przez wyrażenie zakresu są numerowane zaczynając od zera i zwiększają się w porządku leksykalnym. Wynik ma typ string.

Ciąg specyfikacji formatu może zawierać zero lub więcej specyfikacji formatu, z których każdy ma następujący formularz:

{N [ ,M ][ : FormatString ]}

N reprezentuje (wymaganą) pozycji wartości wyrażenia zakresu, M reprezentuje (opcjonalną) minimalną szerokość ekranu, a FormatString wskazuje (opcjonalny) format. Jeśli szerokość sformatowanej wartości przekracza określoną szerokość, szerokość zostanie odpowiednio zwiększona. Wartości, których pozycje nie są przywoływane w FormatString są ignorowane po ocenie pod kątem wszelkich skutków ubocznych. Jeśli N odnosi się do nieistniejącej pozycji, zachowanie jest zdefiniowane przez implementację. Wartość typu $null i void są formatowane jako puste ciągi. Tablice są formatowane dla wyrażenia podrzędnego (§7.1.6). Aby uwzględnić znaki { i } w specyfikacji formatu bez ich interpretowania jako ograniczników formatu, zapisz je odpowiednio jako {{ i }}.

Aby uzyskać pełną definicję specyfikacji formatu, zobacz typ System.IFormattable w Ecma Technical Report TR/84.

Przykłady:

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

W specyfikacji formatu, jeśli N odnosi się do pozycji nieistniejącej, zostanie zgłoszony FormatError.

7.6 Operatory mnożenia

Składnia:

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 mnożenie

Opis:

Wynikiem operatora mnożenia * jest produkt wartości wyznaczonych przez dwa operandy, gdy zwykłe konwersje arytmetyczne (§6.15) zostały zastosowane.

Ten operator jest pozostawiony asocjacyjny.

Przykłady:

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 Replikacja ciągów

Opis:

Gdy lewy operand oznacza ciąg znaków, operator * tworzy nowy ciąg, który zawiera ciąg oznaczony przez lewy operand, powielony tyle razy, ile wskazuje wartość prawego operandu przekonwertowanego na typ całkowity (§6.4).

Ten operator jest pozostawiony asocjacyjny.

Przykłady:

"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 Replikacja tablic

Opis:

Gdy lewy operand wyznacza tablicę, operator binarny * tworzy nową nieograniczoną jednowymiarową tablicę zawierającą wartość wyznaczoną przez lewy operand, powtórzoną tyle razy, ile wynosi wartość prawego operandu w postaci przekonwertowanej na typ całkowity (§6.4). Jeśli liczba powtórzeń wynosi zero, skutkuje to tablicą o długości 1. Jeśli lewy operand wyznacza tablicę wielowymiarową, jest spłaszczona (§9.12) przed użyciem.

Ten operator jest pozostawiony asocjacyjny.

Przykłady:

$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 Podział

Opis:

Wynik działania operatora dzielenia / to iloraz otrzymany, gdy wartość wyznaczona przez lewy operand zostanie podzielona przez wartość wyznaczoną przez prawy operand, po zastosowaniu zwykłych konwersji arytmetycznych (§6.15).

Jeśli podjęto próbę wykonania dzielenia całkowitego lub dziesiętnego przez zero, zostanie zgłoszony błąd zakończenia zdefiniowany przez implementację.

Ten operator jest pozostawiony asocjacyjny.

Przykłady:

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 podjęto próbę wykonania dzielenia całkowitego lub dziesiętnego przez zero, zostanie zgłoszony wyjątek RuntimeException.

7.6.5 Pozostała część

Opis:

Wynik operatora reszty % jest resztą, gdy wartość wyznaczona przez lewy operand jest podzielona przez wartość wyznaczoną przez prawy operand, po tym jak zwykłe konwersje arytmetyczne (§6.15) zostały zastosowane.

Jeśli podjęto próbę wykonania dzielenia całkowitego lub dziesiętnego przez zero, zostanie zgłoszony błąd zakończenia zdefiniowany przez implementację.

Przykłady:

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

Jeśli podjęto próbę wykonania dzielenia całkowitego lub dziesiętnego przez zero, zostanie zgłoszony wyjątek RuntimeException.

7.7 Operatory dodawania

Składnia:

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 Dodawanie

Opis:

Wynikiem operatora dodawania + jest suma wartości wyznaczonych przez dwa operandy po zastosowaniu zwykłych konwersji arytmetycznych (§6.15).

Ten operator jest pozostawiony asocjacyjny.

Przykłady:

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 Łączenie ciągów

Opis:

Gdy lewy operand oznacza ciąg, operator binarny + tworzy nowy ciąg zawierający wartość oznaczoną przez lewy operand, natychmiast po której następują wartości oznaczone przez prawy operand po przekonwertowaniu na typ ciągu (§6.8).

Ten operator jest pozostawiony asocjacyjny.

Przykłady:

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

7.7.3 Łączenie tablic

Opis:

Gdy lewy operand wyznacza tablicę, operator binarny + tworzy nową niezakresowaną tablicę 1-wymiarową, która zawiera elementy wyznaczone przez lewy operand, a następnie natychmiast po nich wartości wyznaczone przez prawy operand. Tablice wielowymiarowe obecne w którymkolwiek z operandów są spłaszczone (§9.12) przed użyciem.

Ten operator jest pozostawiony asocjacyjny.

Przykłady:

$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 Łączenie tabeli skrótów

Opis:

Gdy oba operandy oznaczają tabele skrótów, operator binarny + tworzy nową tabelę skrótów, zawierającą elementy oznaczone przez lewy operand, a następnie elementy oznaczone przez prawy operand.

Jeśli tabele skrótów zawierają ten sam klucz, zostanie zgłoszony błąd zakończenia zdefiniowany przez implementację.

Ten operator jest pozostawiony asocjacyjny.

Przykłady:

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

Jeśli tabele skrótów zawierają ten sam klucz, zostanie zgłoszony wyjątek typu BadOperatorArgument.

Odejmowanie 7.7.5

Opis:

Wynikiem operatora odejmowania - jest różnica, gdy wartość wyznaczona przez prawy operand jest odejmowana od wartości wyznaczonej przez lewy operand po zastosowaniu zwykłych konwersji arytmetycznych (§6.15). Operator odejmowania może być jednym z znaków kreski wymienionych w §7.7.

Ten operator jest pozostawiony asocjacyjny.

Przykłady:

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 Operatory porównania

Składnia:

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

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

Opis:

Typ wartości wyznaczonej przez lewy operand określa, w jaki sposób wartość wyznaczona przez prawy operand jest konwertowana (§6), w razie potrzeby przed wykonaniem porównania.

Niektóre operatory porównania mają dwa warianty: jeden uwzględniający wielkość liter (-c<operator>), i jeden, który tej wielkości nie uwzględnia (-i<operator>). Wersja -<operator> jest równoważna -i<operator>. Rozróżnianie wielkości liter ma znaczenie tylko w przypadku porównań wartości typu ciąg znaków. W kontekstach porównania innych niż ciąg dwa warianty zachowują się tak samo.

Te operatory pozostają asocjacyjne.

7.8.1 Operatory relacyjne i równości

Składnia:

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

Opis:

Istnieją dwa operatory równości: równość (-eq) i nierówność (-ne); oraz cztery operatory relacyjne: mniejszości (-lt), mniejszości lub równości (-le), większości (-gt) i większości lub równości (-ge). Każdy z nich ma dwa warianty (§7.8).

Aby dwa ciągi były uznane za równe, muszą mieć taką samą długość i zawartość oraz wielkość liter, jeśli ma to zastosowanie.

Jeśli wartość wyznaczona przez lewy operand nie jest kolekcją, wynik ma typ bool. W przeciwnym razie wynikiem jest prawdopodobnie pusta tablica 1-wymiarowa zawierająca elementy kolekcji, które testuje wartość True w porównaniu z wartością wyznaczoną przez prawy operand.

Przykłady:

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 Operatory zawierania

Składnia:

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)

Opis:

Istnieją cztery operatory zawierania: zawiera (-contains), nie zawiera (-notcontains), znajduje się w (-in) i nie znajduje się w (-notin). Każdy z nich ma dwa warianty (§7.8).

Operatory zawierania zwracają wynik typu bool, który wskazuje, czy wartość występuje (lub nie występuje) co najmniej raz w elementach tablicy. W przypadku -contains i -notcontainswartość jest wyznaczana przez prawy operand, a tablica jest wyznaczana przez lewy operand. W przypadku -in i -notinoperandy są odwrócone. Wartość jest wyznaczona przez lewy argument, a tablica przez prawy argument.

Dla celów tych operatorów, jeśli operand tablicy ma wartość skalarną, wartość skalarna jest traktowana jako tablica jednego elementu.

Przykłady:

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 Operatory testowania typów i konwersji

Składnia:

type-operator: one of
    dash is
    dash as

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

Opis:

Operator typu -is sprawdza, czy wartość określona przez lewy operand ma typ lub jest pochodną typu określonego przez prawy operand. Prawy operand musi wyznaczyć typ lub wartość, którą można przekonwertować na typ (na przykład ciąg, który nazywa typ). Typ wyniku to bool. Operator typu -isnot zwraca logiczne zaprzeczenie odpowiadającej -is postaci.

Operator typu -as próbuje przekonwertować wartość wyznaczoną przez lewy operand na typ wyznaczony przez prawy operand. Prawy operand musi wyznaczyć typ lub wartość, którą można przekonwertować na typ (na przykład ciąg, który nazywa typ). Jeśli konwersja nie powiedzie się, zostanie zwrócona $null; W przeciwnym razie zwracana jest przekonwertowana wartość, a zwracany typ tego wyniku jest typem środowiska uruchomieniowego przekonwertowanej wartości.

Przykłady:

$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 Dopasowywanie wzorca i operatory manipulowania tekstem

7.8.4.1 Operatory -like i -notlike

Składnia:

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)

Opis:

Jeśli lewy operand nie wyznaczy kolekcji, wynik ma typ bool. W przeciwnym razie wynikiem jest prawdopodobnie pusta tablica 1-wymiarowa zawierająca elementy kolekcji, które testuje wartość True w porównaniu z wartością wyznaczoną przez prawy operand. Prawy operand może oznaczać ciąg zawierający wyrażenia wieloznaczne (§3.15). Te operatory mają dwa warianty (§7.8).

Przykłady:

"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 Operatory -match i -notmatch

Składnia:

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)

Opis:

Jeśli lewy operand nie wyznacza kolekcji, wynik otrzymuje typ bool, a jeśli wynik jest $true, elementy tabeli skrótu $Matches zostają ustawione na ciągi, które pasują (lub nie pasują) do wartości wyznaczonej przez prawy operand. W przeciwnym razie wynikiem jest możliwie pusta, nieograniczona tablica 1-wymiarowa zawierająca elementy kolekcji, które testują się jako True w porównaniu z wartością wyznaczoną przez prawy operand, a $Matches nie jest ustawiony. Prawy operand może wyznaczyć ciąg zawierający wyrażenia regularne (§3.16), w takim przypadku jest określany jako wzorzec . Te operatory mają dwa warianty (§7.8).

Te operatory obsługują podpasie (§7.8.4.6).

Przykłady:

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

Składnia:

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)

Opis:

Operator -replace umożliwia zamianę tekstu w co najmniej jednym ciągu wyznaczonym przez lewy operand przy użyciu wartości wyznaczonych przez prawy operand. Ten operator ma dwa warianty (§7.8). Prawy operand ma jedną z następujących form:

• Ciąg, który ma być zlokalizowany, może zawierać wyrażenia regularne (§3.16). W takim przypadku ciąg zastępczy jest domyślnie "".
• Tablica z 2 obiektami zawierającymi najpierw ciąg do zlokalizowania, a następnie ciąg, który go zastąpi.

Jeśli lewy operand wyznacza ciąg, wynik ma typ string. Jeśli lewy operand wyznacza 1-wymiarową tablicę ciągów, wynikiem jest nieograniczona 1-wymiarowa tablica o tej samej długości co tablica lewego operandu, zawierająca ciągi wejściowe po zakończeniu zamiany.

Ten operator obsługuje podpasowania (§7.8.4.6).

Przykłady:

"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 Operator -join binarny

Składnia:

binary-join-operator: one of
    dash join

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

Opis:

Operator -join binarny tworzy ciąg, który jest łączeniem wartości co najmniej jednego obiektu wyznaczonego przez lewy operand po przekonwertowaniu na ciąg (§6.7), jeśli jest to konieczne. Ciąg wyznaczony przez prawy operand jest używany do oddzielania (prawdopodobnie pustych) wartości w wynikowym ciągu.

Lewy operand może być wartością skalarną lub kolekcją.

Przykłady:

(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 Operator -split binarny

Składnia:

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)

Opis:

Operator -split binarny dzieli jeden lub więcej ciągów wyznaczonych przez lewy operand, zwracając ich części podrzędne w ograniczonej 1-wymiarowej tablicy ciągu. Ten operator ma dwa warianty (§7.8). Lewy operand może wyznaczyć wartość skalarną lub tablicę ciągów. Prawy operand ma jedną z następujących form:

• Ciąg znaków ogranicznika
• Tablica 2 obiektów zawierająca ciąg ogranicznika, po którym następuje licznik podziału
• Tablica składająca się z 3 obiektów, która zawiera ciąg ogranicznika, liczbową liczbę podziałów oraz ciąg opcji
• Blok skryptu
• Tablica zawierająca 2 obiekty z blokiem skryptu, po którym następuje liczba podziałów

Ciąg ogranicznika może zawierać wyrażenia regularne (§3.16). Służy do lokalizowania podzespołów z użyciem ciągów wejściowych. Ogranicznik nie jest uwzględniany w wynikowych ciągach. Jeśli lewy operand wyznacza pusty ciąg, spowoduje to pusty element ciągu. Jeśli ciąg ogranicznika jest pustym ciągiem, znajduje się w każdej pozycji znaku w ciągach wejściowych.

Domyślnie wszystkie części podrzędne ciągów wejściowych są umieszczane w wyniku jako oddzielne elementy; można jednak użyć liczby podziałów w celu zmodyfikowania tego zachowania. Jeśli ta liczba jest ujemna, zero lub większa lub równa liczbie części podrzędnych w ciągu wejściowym, każda część podrzędna przechodzi do oddzielnego elementu. Jeśli ta liczba jest mniejsza niż liczba części podrzędnych w ciągu wejściowym, w wyniku znajdują się elementy zliczania, a ostatni element zawierający wszystkie części podrzędne wykraczające poza pierwszą liczbę — 1 części podrzędnych.

Ciąg opcji zawiera zero lub więcej nazw opcji , gdzie każda sąsiadująca para jest oddzielona przecinkiem. Wiodące, końcowe i osadzone znaki odstępu są ignorowane. Nazwy opcji mogą być w dowolnej kolejności i uwzględniana jest wielkość liter.

Jeśli ciąg opcji zawiera nazwę opcji SimpleMatch, może również zawierać nazwę opcji IgnoreCase. Jeśli ciąg opcji zawiera nazwę opcji regexMatch lub nie zawiera RegexMatch lub SimpleMatch, może zawierać dowolną nazwę opcji z wyjątkiem SimpleMatch. Nie może jednak zawierać zarówno w postaci wielowierszowej, jak i w postaci jednowierszowej.

Oto zestaw nazw opcji:

opcja	opis
Niezależny od kultury	Ignoruje różnice kulturowe w języku podczas oceniania separatora.
Jawne przechwytywanie	Ignoruje nienazwane grupy dopasowania, tak aby tylko jawne grupy przechwytywania zostały zwrócone na liście wyników.
Ignoruj litery	Wymuś dopasowywanie bez uwzględniania wielkości liter, nawet jeśli używany jest parametr -csplit.
IgnorePatternWhitespace	Ignoruje niewyobrażalne odstępy i komentarze oznaczone znakiem numeru (#).
Wielowierszowy	Ten tryb rozpoznaje początek i koniec wierszy i ciągów. Domyślnym trybem jest Singleline.
RegexMatch	Użyj dopasowania wyrażenia regularnego, aby ocenić ogranicznik. Jest to wartość domyślna.
SimpleMatch	Użyj prostego porównania ciągów podczas obliczania ogranicznika.
Pojedyncza linia	Ten tryb rozpoznaje tylko początek i koniec ciągów. Jest to tryb domyślny.

Blok skryptu (§7.1.8) określa reguły określania ogranicznika i musi zostać obliczony, aby wpisać wartość logiczną.

Przykłady:

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

Wzorzec dopasowywany przez -match, -notmatchi -replace może zawierać części podrzędne (nazywane podmatami ) rozdzielane nawiasami. Rozważmy następujący przykład:

"red" -match "red"

Rezultatem jest $true, a klucz 0 z $Matches zawiera "czerwony", co stanowi tę część ciągu określoną przez lewy operand, która dokładnie pasuje do wzorca określonego przez prawy operand.

W poniższym przykładzie cały wzorzec jest podpasmem:

"red" -match "(red)"

Tak jak poprzednio, klucz 0 zawiera "czerwony"; jednak klucz 1 zawiera również "czerwony", który jest częścią ciągu wyznaczonego przez lewy operand, który dokładnie pasuje do podpasowania.

Rozważmy następujący, bardziej złożony wzorzec:

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

Ten wzorzec umożliwia podpasowania "re", "r", "d" lub "red".

Ponownie klucz 0 zawiera "czerwony". Klucz 1 zawiera "re", klucz 2 zawiera "r", a klucz 3 zawiera "d". Pary klucz/wartość są uporządkowane od lewej do prawej we wzorcu, z dłuższymi dopasowaniami tekstowymi poprzedzającymi krótsze.

W przypadku -replacetekst zastępczy może uzyskać dostęp do poddopasowań za pomocą nazwy w formacie $n, gdzie pierwsze to $1, drugie to $3i tak dalej. Na przykład

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

Wynikowy ciąg to "poniedziałkowy poranek".

Zamiast kluczy w $Matches będących indeksami zaczynającymi się od zera, podciągi można nazwać przy użyciu formatu ?<*name*>. Na przykład można napisać "((r)e)(d)" z trzema nazwanymi podmatami, m1, m2i m3w następujący sposób: "(?<m1>(?<m2>r)e)(?<m3>d)".

7.8.5 Operatory przesunięcia

Składnia:

shift-operator: one of
    dash shl
    dash shr

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

Opis:

Operator przesunięcia w lewo (-shl) i przesunięcia w prawo (-shr) konwertuje wartość określoną przez lewy operand do typu całkowitego oraz wartość określoną przez prawy operand do int, jeśli to konieczne, przy użyciu zwykłych konwersji arytmetycznych (§6.15).

Operator przesunięcia w lewo przesuwa lewy operand w lewo o liczbę bitów obliczoną zgodnie z poniższym opisem. Puste pozycje bitów o niskiej kolejności są ustawione na zero.

Operator przesunięcia w prawo przesuwa lewy operand w prawo o liczbę bitów, obliczoną zgodnie z opisem poniżej. Bity o niskim znaczeniu lewego operandu są odrzucane, a pozostałe bity przesuwane w prawo. Gdy lewy operand jest wartością ze znakiem, puste pozycje bitów o wysokiej kolejności są ustawione na zero, jeśli lewy operand nie jest ujemny i ustawione na jeden, jeśli lewy operand jest ujemny. Gdy lewy operand jest wartością niepodpisaną, puste pozycje bitów o wysokiej kolejności są ustawione na zero.

Gdy lewy operand ma typ int, liczba przesunięć jest określana przez pięć najmłodszych bitów prawego operandu. Gdy prawy operand ma typ long, liczba przesunięć jest określana przez sześć najmniej znaczących bitów prawego operandu.

Przykłady:

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

7.9 Operatory bitowe

Składnia:

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

Opis:

Operator bitowy AND -band, operator bitowy OR -bori operator bitowy XOR -bxor przekształcają wartości określone przez ich operandy na typy całkowite, jeśli to konieczne, przy użyciu zwykłych konwersji arytmetycznych (§6.15). Po konwersji, jeśli obie wartości mają typ int, jest to typ wyniku. W przeciwnym razie, jeśli obie wartości mają typ long, jest to typ wyniku. Jeśli jedna wartość ma typ int, a drugi ma typ długi, typ wyniku jest długi. W przeciwnym razie wyrażenie jest źle sformułowane. Wynikiem jest operacja bitowa AND, OR lub XOR wartości operandu, które mogły zostać przekonwertowane.

Te operatory pozostają asocjacyjne. Są przemienne, jeśli żaden operand nie zawiera efektu ubocznego.

Przykłady:

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 Operatory logiczne

Składnia:

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

Opis:

Operator logiczny AND -and konwertuje wartości wyznaczone przez operandy na bool, w razie potrzeby (§6.2). Wynikiem jest operator logiczny AND z przekonwertowanymi wartościami operandów, jeśli to konieczne, i ma typ bool. Jeśli lewy operand zwróci wartość False, prawy operand nie zostanie oceniony.

Operator logiczny OR -or konwertuje wartości wyznaczone przez operandy na bool, w razie potrzeby (§6.2). Wynikiem jest logiczny OR prawdopodobnie przekonwertowanych wartości operandu i ma typ bool. Jeśli lewy operand zwraca wartość True, prawy operand nie jest oceniany.

Logiczny operator XOR -xor konwertuje wartości wyznaczone przez operandy na bool (§6.2). Wynikiem jest logiczny XOR możliwie przekonwertowanych wartości operandów i ma typ bool.

Te operatory pozostają asocjacyjne.

Przykłady:

$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 Operatory przypisania

Składnia:

assignment-expression:
    expression assignment-operator statement

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

Opis:

Operator przypisania przechowuje wartość w zapisywalnej lokalizacji wyznaczonej przez wyrażenie . Aby zapoznać się z omówieniem operatora przypisania = zobacz §7.11.1. Aby zapoznać się z omówieniem wszystkich innych operatorów przypisania, zobacz §7.11.2.

Wyrażenie przypisania ma wartość wyznaczoną przez wyrażenie po przypisaniu; jednak to wyrażenie przypisania nie wyznacza samej lokalizacji zapisywalnej. Jeśli wyrażenie jest ograniczone przez typ (§5.3), typ użyty w tym ograniczeniu stanowi typ wyniku; w przeciwnym razie typ wyniku stanowi typ po zastosowaniu zwykłych konwersji arytmetycznych (§6.15).

Ten operator jest prawostronnie łączny.

7.11.1 Proste przypisanie

Opis:

W prostym przypisaniu (=) wartość wskazana przez instrukcję zastępuje wartość przechowywaną w lokalizacji zapisywalnej wskazanej przez wyrażenie . Jeśli jednak wyrażenie wyznaczy nieistniejący klucz w tabeli skrótu, ten klucz zostanie dodany do tabeli skrótu ze skojarzoną wartością wyznaczoną przez instrukcję .

Jak pokazano w gramatyce, wyrażenie może wyznaczyć rozdzielaną przecinkami listę lokalizacji zapisywalnych. Jest to nazywane wielokrotnym przypisaniem. stwierdzenie wyznacza listę jednej lub większej liczby wartości oddzielonych przecinkami. Przecinki na obu listach operand są częścią składni wielokrotnego przypisania i nie , reprezentują operator przecinka binarnego. Wartości są pobierane z listy wyznaczonej przez instrukcję , w porządku leksykalnym i przechowywane w odpowiedniej lokalizacji zapisywalnej wyznaczonej przez wyrażenie . Jeśli lista wyznaczona przez instrukcję ma mniej wartości niż istnieje lokalizacji zapisywalnych określonych przez wyrażenie , nadmiarowe lokalizacje przyjmują wartość $null. Jeśli lista wyznaczona przez instrukcję ma więcej wartości niż istnieją zapisywalne lokalizacje wyrażeń , wszystkie poza najbardziej wysuniętą w prawo lokalizacją wyrażenia przyjmują odpowiadającą wartość instrukcji , a najbardziej wysunięta w prawo lokalizacja wyrażenia staje się nieograniczoną tablicą jednowymiarową ze wszystkimi pozostałymi wartościami instrukcji jako elementami.

W przypadku instrukcji, które mają wartości (§8.1.2), instrukcja może być instrukcją.

Przykłady:

$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 Przypisanie złożone

Opis:

przypisanie złożone ma postać E1 op= E2i jest równoważne prostemu wyrażeniu przypisania E1 = E1 op (E2) z tą różnicą, że w przypadku przypisania złożonego wyrażenie E1 jest ewaluowane tylko raz. Jeśli wyrażenie jest ograniczone co do typu (§5.3), typ zastosowany w tym ograniczeniu jest typem wyniku; w przeciwnym razie typ wyniku jest określany przez op. W przypadku *=zobacz §7.6.1, §7.6.2, §7.6.3; /=, zobacz §7.6.4; %=, zobacz §7.6.5; +=, zobacz §7.7.1, §7.7.2, §7.7.3; -=, zobacz §7.7.5.

Notatka

Operand wyznaczający nieograniczoną wartość typu liczbowego może mieć zmieniony typ przez operator przypisania, gdy wynik jest przechowywany.

Przykłady:

$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 Operatory przekierowania

Składnia:

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

Opis:

Operator przekierowania > pobiera standardowe dane wyjściowe z potoku i przekierowuje je do lokalizacji wyznaczonej przez przekierowanie nazwy pliku, zastępując bieżącą zawartość tej lokalizacji.

Operator przekierowania pobiera standardowe dane wyjściowe z potoku i przekierowuje je do lokalizacji wyznaczonej przez redirected-file-name, dołączając do bieżącej zawartości tej lokalizacji, jeśli istnieje. Jeśli ta lokalizacja nie istnieje, zostanie utworzona.

Operator przekierowania w formie n> pobiera dane wyjściowe strumienia n z potoku i przekierowuje je do lokalizacji wyznaczonej przez plik o nazwie, zastępując bieżącą zawartość tej lokalizacji.

Operator przekierowania w formie n>> pobiera dane wyjściowe strumienia n z potoku i przekierowuje je do lokalizacji wyznaczonej przez przekierowana-nazwa-pliku, dołączając do obecnej zawartości tej lokalizacji, jeśli istnieje. Jeśli ta lokalizacja nie istnieje, zostanie utworzona.

Operator przekierowania z formularzem m>&n zapisuje dane wyjściowe ze strumienia m do tej samej lokalizacji co strumień n.

Poniżej przedstawiono prawidłowe strumienie:

Stream	Opis
1	Standardowy strumień wyjściowy
2	Strumień wyjściowy błędu
3	Ostrzeżeniowy strumień wyjściowy
4	Szczegółowy strumień wyjściowy
5	Debugowanie strumienia wyjściowego
*	Standardowe strumienie wyjściowe, strumienie wyjściowe błędów, strumienie wyjściowe ostrzeżeń, szczegółowe strumienie wyjściowe i strumienie debugowania

Operatory przekierowania 1>&2, 6>, 6>> i < są zarezerwowane do użytku w przyszłości.

Jeśli w danych wyjściowych wartość redirected-file-name jest $null, dane wyjściowe zostaną odrzucone.

Zazwyczaj wartość wyrażenia zawierającego efekt uboczny najwyższego poziomu nie jest zapisywana w potoku, chyba że to wyrażenie jest ujęte w parę nawiasów. Jeśli jednak takie wyrażenie jest lewym operandem operatora, który przekierowuje standardowe dane wyjściowe, wartość jest zapisywana.

Przykłady:

$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