7. Выражения
Редакционная заметка
Важный
спецификация языка Windows PowerShell 3.0 была опубликована в декабре 2012 года и основана на Windows PowerShell 3.0. Эта спецификация не отражает текущее состояние PowerShell. Нет плана обновить эту документацию, чтобы отразить текущее состояние. Эта документация представлена здесь для получения исторической справки.
Документ спецификации доступен в виде файла Microsoft Word в Центре загрузки Майкрософт: https://www.microsoft.com/download/details.aspx?id=36389. Этот документ Word был преобразован для показа здесь, на платформе Microsoft Learn. Во время преобразования некоторые редакционные изменения были внесены в соответствии с форматированием платформы Docs. Исправлены некоторые опечатки и незначительные ошибки.
Синтаксис:
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
Описание:
Выражение — это последовательность операторов и операндов, которые определяют метод, функцию, доступное для записи расположение или значение; указывает вычисление значения; создает один или несколько побочных эффектов; или выполняет их сочетание. Например
- Литерал 123 является выражением, обозначающим целочисленное значение 123.
- Выражение
1,2,3,4обозначает объект массива 4 элементов, имеющий отображаемые значения. - Выражение
10.4 * $aуказывает вычисление. - Выражение
$a++создает побочный эффект. - Выражение
$a[$i--] = $b[++$j]выполняет сочетание этих вещей.
Кроме того, как указано для некоторых операторов, порядок оценки терминов в выражении и порядок, в котором происходят побочные эффекты, не указаны. Ниже приведены примеры неопределенного поведения: $i++ + $i, $i + --$iи $w[$j++] = $v[$j].
Реализация PowerShell может обеспечить поддержку определяемых пользователем типов, и эти типы могут иметь определенные операции. Все подробности таких типов и операций определяются реализацией.
Выражение верхнего уровня — это выражение, которое не является частью какого-то большего выражения. Если выражение верхнего уровня содержит оператор побочных эффектов, значение этого выражения не записывается в конвейер; в противном случае оно записывается. Подробные сведения об этом см. в §7.1.1.
Обычно выражение, указывающее коллекцию ([§4§4]) перечисляется в составные элементы при использовании значения этого выражения. Однако это не так, если выражение является вызовом командлета. Например
$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
В первых двух случаях использования оператора $(...), выражение, обозначающее коллекцию, это переменная $x, которая перечисляется, приводя к трем значениям int, плюс int 99. Однако в третьем случае выражение является прямым вызовом командлета, поэтому результат не перечисляется, а $a представляет собой массив двух элементов, int[3] и int.
Если операция не определена PowerShell, то проверяется тип значения, указанного левым операндом, чтобы узнать, имеет ли он соответствующий метод op_<operation>.
7.1 Первичные выражения
Синтаксис:
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 Группирование круглых скобок
Синтаксис:
Подсказка
Нотация ~opt~ в определениях синтаксиса указывает, что лексическая сущность является необязательной в синтаксисе.
parenthesized-expression:
( new-lines~opt~ pipeline new-lines~opt~ )
Описание:
Выражение в скобках — это первичное выражение, тип и значение которого совпадают с типом и значением выражения без скобок. Если выражение обозначает переменную, то скобка обозначает ту же переменную. Например, $x.m и ($x).m эквивалентны.
Группирование скобок может использоваться в выражении для документирования приоритета по умолчанию и ассоциативности в этом выражении. Их также можно использовать для переопределения приоритета по умолчанию и ассоциативности. Например
4 + 6 * 2 # 16
4 + (6 * 2) # 16 document default precedence
(4 + 6) * 2 # 20 override default precedence
Обычно группирование круглых скобок на самом высоком уровне является избыточным. Однако это не всегда так. Рассмотрим следующий пример:
2,4,6 # Length 3; values 2,4,6
(2,4),6 # Length 2; values [object[]],int
Во втором случае круглые скобки изменяют семантику, что приводит к массиву, два элемента которого являются массивом из 2 инт и скалярным интом 6.
Вот еще одно исключение:
23.5/2.4 # pipeline gets 9.79166666666667
$a = 1234 * 3.5 # value not written to pipeline
$a # pipeline gets 4319
В первых и третьих случаях значение результата записывается в конвейер. Однако, хотя выражение во втором случае вычисляется, результат не записывается в конвейер из-за наличия оператора побочных эффектов = на верхнем уровне. (Удаление части $a = позволяет записывать значение, так как * не является оператором с побочными эффектами.)
Чтобы предотвратить запись в конвейер значения любого выражения, не содержащего побочных эффектов верхнего уровня, явно отбросьте это значение, как показано ниже.
# None of these value are written to pipeline
[void](23.5/2.4)
[void]$a
$null = $a
$a > $null
Чтобы записать в конвейер значение любого выражения, содержащего побочные эффекты верхнего уровня, заключите это выражение в скобки следующим образом:
($a = 1234 * 3.5) # pipeline gets 4319
Таким образом, скобки в этом случае не являются лишними.
В следующем примере мы имеем подстановку переменных (§2.3.5.2) в строковом литерале:
">$($a = -23)<" # value not written to pipeline, get ><
">$(($a = -23))<" # pipeline gets >-23<
В первом случае скобки представляют собой ограничители для подвыражения , а не круглые скобки для группировки . Так как выражение верхнего уровня содержит оператор побочных эффектов, его значение не записывается в конвейер. Конечно, > и < символы по-прежнему написаны.) Если добавляются скобки группировки, как показано во втором случае, возможность записи включена.
В следующих примерах каждый из них содержит операторы побочных эффектов верхнего уровня:
$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
Использование группирующих скобок вокруг выражения, не содержащего побочных эффектов верхнего уровня, делает эти скобки избыточными. Например;
$a # pipeline gets 0
($a) # no side effect, so () redundant
Рассмотрим следующий пример, который имеет два побочных эффекта, ни из которых не находится на верхнем уровне:
12.6 + ($a = 10 - ++$b) # pipeline gets 21.6.
Результат записывается в конвейер, так как выражение верхнего уровня не имеет побочных эффектов.
7.1.2 Доступ к члену
Синтаксис:
member-access:
primary-expression . new-line~opt~ member-name
primary-expression :: new-line~opt~ member-name
Обратите внимание, что пробелы не разрешены после первичных выражений.
Описание:
Оператор . используется для выбора элемента экземпляра из объекта или ключа из Hashtable.
Левый операнд должен обозначать объект, а правый операнд должен обозначать доступный член экземпляра.
Либо правый операнд назначает элемент доступного экземпляра в типе объекта, заданного левым операндом, либо, если левый операнд обозначает массив, правый операнд назначает элементы доступного экземпляра в каждом элементе массива.
Пробелы не разрешены перед оператором ..
Этот оператор остается ассоциативным.
Оператор :: используется для выбора статического элемента из заданного типа. Левый операнд должен назначить тип, а правый операнд должен назначить доступный статический элемент в этом типе.
Пробелы не разрешены перед оператором ::.
Этот оператор остается ассоциативным.
Если правый операнд назначает записываемое расположение в типе объекта, указанного левым операндом, то целое выражение обозначает записываемое расположение.
Примеры:
$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
Синтаксис:
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~ )
Обратите внимание, что пробелы не разрешены после первичного выражения.
Описание:
Выражение вызова вызывает метод, указанный primary-expression.member-name или primary-expression::member-name. Круглые скобки в списке аргументов содержат, возможно, пустой, разделенный запятыми список выражений, которые указывают аргументы чьи значения передаются методу. Перед вызовом метода аргументы вычисляются и преобразуются в соответствии с правилами §6при необходимости, чтобы соответствовать типам, ожидаемым методом. Порядок оценки primary-expression.member-name, primary-expression::member-nameи аргументов не указан.
Этот оператор остается ассоциативным.
Тип результата выражения вызова
Примеры:
[math]::Sqrt(2.0) # call method with argument 2.0
[char]::IsUpper("a") # call method
$b = "abc#$%XYZabc"
$b.ToUpper() # call instance method
[math]::Sqrt(2) # convert 2 to 2.0 and call method
[math]::Sqrt(2D) # convert 2D to 2.0 and call method
[math]::Sqrt($true) # convert $true to 1.0 and call method
[math]::Sqrt("20") # convert "20" to 20 and call method
$a = [math]::Sqrt # get method descriptor for Sqrt
$a.Invoke(2.0) # call Sqrt via the descriptor
$a = [math]::("Sq"+"rt") # get method descriptor for Sqrt
$a.Invoke(2.0) # call Sqrt via the descriptor
$a = [char]::ToLower # get method descriptor for ToLower
$a.Invoke("X") # call ToLower via the descriptor
Доступ к элементу 7.1.4
Синтаксис:
element-access:
primary-expression [ new-lines~opt~ expression new-lines~opt~ ]
Описание:
Между первичным выражением и левой квадратной скобкой ([) не должно быть пробелов.
7.1.4.1 Подстрока массива
Описание:
Массивы подробно рассматриваются в §9. Если выражение является 1-мерным массивом, см. §7.1.4.5.
Когда первичное выражение назначает 1-мерный массив A, оператор [] возвращает элемент, расположенный по A[0 + expression] после преобразования значения выражения в int.
Результат имеет тип элемента подстрочного массива. Если выражение отрицательное, A[expression] обозначает элемент, расположенный в A[A.Length + expression].
Если
Если первичное выражение обозначает массив из трех или более измерений, правила для 2-мерных массивов применяются, а позиции измерения задаются как разделенный запятыми список значений.
Если выполняется попытка доступа для чтения к не существующему элементу, результат будет $null. Это ошибка попытки записи в несуществующий элемент.
Для многомерного выражения подстрочного массива порядок вычисления выражений позиции измерения не определен. Например, для данного трехмерного массива $aповедение $a[$i++,$i,++$i] не определено.
Если выражение является массивом, см. §7.1.4.5.
Этот оператор остается ассоциативным.
Примеры:
$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]
При попытке доступа на запись к не существующему элементу возникает исключение IndexOutOfRange.
7.1.4.2 подстрока строки
Описание:
Если первичное выражение обозначает строку S, оператор [] возвращает символ в позиции, определенной выражением , начиная с нуля, в виде символа (char). Если выражение больше или равно длине этой строки, результат — $null. Если выражение отрицательное, S[expression] обозначает элемент, расположенный в S[S.Length + expression].
Примеры:
$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 Подстрока хэш-файла
Описание:
Если первичное выражение обозначает хэш-таблицу, оператор [] возвращает значения, связанные с ключами, указанными выражением . Тип выражения
Если выражение является одним именем ключа, результатом является ассоциированное значение, обладающее соответствующим типом, если только такой ключ не существует, иначе результат будет $null. Если $null используется в качестве ключа, то поведение определяется реализацией. Если выражение является массивом имен ключей, см. §7.1.4.5.
Если выражение является массивом, см. §7.1.4.5.
Примеры:
$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
Если выражение является единичным именем ключа, и если $null используется в качестве единственного значения для индексации хэш-таблицы, возникает исключение NullArrayIndex.
7.1.4.4 Подстрока XML-документа
Описание:
Если первичное выражение обозначает объект типа xml, выражение преобразуется в строку, при необходимости, и оператор [] возвращает первый дочерний элемент с именем, указанным выражением . Тип выражения должен быть строкой. Тип результата определяется реализацией. Результат можно индексировать, чтобы вернуть первый дочерний элемент. Если дочерний элемент с именем, указанным выражением , не существует, результат — $null. Результат не указывает на доступное для записи место.
Примеры:
$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
Тип результата — System.Xml.XmlElement или System.String.
7.1.4.5 Создание срезов массива
Если первичное выражение обозначает объект типа, который является перечисляемым (§4) или хэш-таблицей, и выражение является 1-мерным массивом, результатом является срез массива (§9.9), содержащий элементы первичного выражения, указанные элементами выражения.
В случае хэш-таблицы срез массива содержит значения, связанные с указанными ключами, если такой ключ не существует, соответствующий элемент становится $null. Если $null используется в качестве любого имени ключа, поведение определяется реализацией.
Примеры:
$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: Когда выражение является коллекцией из двух или более имен ключей, если $null используется в качестве имени ключа, этот ключ игнорируется и не имеет соответствующего элемента в результирующем массиве.
7.1.5 Постфиксные операторы инкремента и декремента
Синтаксис:
post-increment-expression:
primary-expression ++
post-decrement-expression:
primary-expression dashdash
Описание:
основное выражение должно указывать на записываемое место с числовым значением (§4) или значением $null. Если значение, указанное операндом, равно $null, это значение сначала преобразуется в тип int и в значение ноль перед тем, как оператор будет вычислен. Тип значения, который указан как в первичном выражении, может измениться при сохранении результата. См. §7.11 для обсуждения изменения типа через присваивание.
Результат, полученный оператором postfix ++, является значением, указанным операндом. После получения этого результата значение, указанное операндом, увеличивается на 1 соответствующего типа.
Тип результата выражения E++ совпадает с типом результата выражения E + 1 (§7.7).
Результат, полученный оператором postfix --, является значением, указанным операндом. После получения этого результата значение, указанное операндом, уменьшается на 1 соответствующего типа.
Тип результата выражения E-- совпадает с результатом выражения E - 1 (§7.7).
Эти операторы остаются ассоциативными.
Примеры:
$i = 0 # $i = 0
$i++ # $i is incremented by 1
$j = $i-- # $j takes on the value of $i before the decrement
$a = 1,2,3
$b = 9,8,7
$i = 0
$j = 1
$b[$j--] = $a[$i++] # $b[1] takes on the value of $a[0], then $j is
# decremented, $i incremented
$i = 2147483647 # $i holds a value of type int
$i++ # $i now holds a value of type double because
# 2147483648 is too big to fit in type int
[int]$k = 0 # $k is constrained to int
$k = [int]::MaxValue # $k is set to 2147483647
$k++ # 2147483648 is too big to fit, imp-def behavior
$x = $null # target is unconstrained, $null goes to [int]0
$x++ # value treated as int, 0->1
Оператор $(...) 7.1.6
Синтаксис:
sub-expression:
$( new-lines~opt~ statement-list~opt~ new-lines~opt~ )
Описание:
Если список инструкций опущен, результат $null. В противном случае вычисляется список выражений. Все объекты, записанные в конвейер во время оценки, собираются в неограниченном одномерном массиве в указанном порядке. Если массив собранных объектов пуст, результат будет $null. Если массив собранных объектов содержит один элемент, результатом является этот элемент; в противном случае результатом является неограниченный 1-мерный массив собранных результатов.
Примеры:
$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 оператор @(...)
Синтаксис:
array-expression:
@( new-lines~opt~ statement-list~opt~ new-lines~opt~ )
Описание:
Если список инструкций опущен, результатом является неограниченный 1-мерный массив нулевой длины.
В противном случае вычисляется
Примеры:
$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 Выражение блока скрипта
Синтаксис:
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
Описание:
парам-блок описан в §8.10.9. именованного списка описаны в §8.10.7.
Блок скрипта — это неименованный блок инструкций, которые можно использовать в качестве одной единицы. Блоки скриптов можно использовать для вызова блока кода, как если бы это была одна команда, или они могут быть назначены переменным, которые можно выполнить.
Выполняется список именованных блоков или список инструкций , и тип и значение результата соответствуют типу и значению результатов этих наборов инструкций.
Если парам-блок опущен, все аргументы, передаваемые блоку скрипта, доступны через $args (§8.10.1).
Во время привязки параметров блок скрипта можно передать как объект блока скрипта, так и как результат после оценки блока скрипта. Дополнительные сведения см. в §6.17.
Литеральное выражение хэша
Синтаксис:
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
Описание:
Из хэш-литерального выражения создается хэш-таблица (§10) из нуля или более элементов, каждый из которых представляет собой пару "ключ-значение".
Ключ может иметь любой тип, кроме типа NULL. Связанные значения могут иметь любой тип, включая тип NULL, и каждое из этих значений может быть любым выражением, которое обозначает требуемое значение, включая $null.
Порядок пар "ключ-значение" не является значительным.
Примеры:
$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 }
который создает два хэш-файла, $h1 и $h2, каждая из которых содержит три пары "ключ-значение" и третью, $h3, то есть пустую. Хэш-таблица $h4 имеет ключи различных типов.
Литеральное выражение типа 7.1.10
Синтаксис:
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 [
Описание:
типа
Литералы типов используются в ряде контекстов:
- Указание явного преобразования (§6, §7.2.9)
- Создание ограниченного типа массива (§9.4)
- Доступ к статическим элементам объекта (§7.1.2)
- Указание ограничения типа для переменной (§5.3) или параметра функции (§8.10.2)
Примеры:
[int].IsPrimitive # $true
[Object[]].FullName # "System.Object[]"
[int[,,]].GetArrayRank() # 3
Универсальный тип стека (§4.4), который специально предназначен для хранения строк, может быть записан как [Stack[string]], а универсальный тип словаря, специализированный для хранения int ключей со связанными строковыми значениями, может быть записан как [Dictionary[int,string]].
Тип типа-литерала есть System.Type. Полное имя указанного выше типа Stack[string] равно System.Collections.Generic.Stack[int]. Полное название предложенного выше типа Dictionary[int,string] является System.Collections.Generic.Dictionary[int,string].
7.2 Унарные операторы
Синтаксис:
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
Описание:
Оператор запятых (,) создает неограниченный 1-мерный массив с одним элементом, типом и значением которого является унарное выражение.
Этот оператор является правоассоциативным.
Примеры:
$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 Логическое НЕ
Синтаксис:
logical-not-operator:
dash not
dash: one of
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Описание:
Оператор -not преобразует значение, указанное унарным выражением в тип bool (§6.2), при необходимости и создает результат этого типа. Если значение унарного выражения равно True, то результатом будет False, и наоборот. Оператор ! — это альтернативная орфография для -not.
Этот оператор является правоассоциативным.
Примеры:
-not $true # False
-not -not $false # False
-not 0 # True
-not 1.23 # False
!"xyz" # False
7.2.3 Побитовые НЕ
Синтаксис:
bitwise-not-operator:
dash bnot
dash: one of
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Описание:
Оператор -bnot преобразует значение, указанное унарным выражением в целочисленный тип (§6.4), при необходимости. Если преобразованное значение может быть представлено в типе int то это тип результата. Кроме того, если преобразованное значение может быть представлено в типе long, то это тип результата. В противном случае выражение является плохо сформированным. Результирующее значение — это единичное дополнение преобразованного значения.
Этот оператор является правоассоциативным.
Примеры:
-bnot $true # int with value 0xFFFFFFFE
-bnot 10 # int with value 0xFFFFFFF5
-bnot 2147483648.1 # long with value 0xFFFFFFFF7FFFFFFF
-bnot $null # int with value 0xFFFFFFFF
-bnot "0xabc" # int with value 0xFFFFF543
7.2.4 Унарий плюс
Описание:
Выражение формы + unary-expression рассматривается так, как если бы оно было записано как 0 + unary-expression (§7,7). Целый литерал 0 имеет тип int.
Этот оператор является правоассоциативным.
Примеры:
+123L # type long, value 123
+0.12340D # type decimal, value 0.12340
+"0xabc" # type int, value 2748
7.2.5 Унарный минус
Описание:
Выражение формы - unary-expression рассматривается так, как если бы оно было записано как 0 - unary-expression (§7,7). Целочисленный литерал 0 имеет тип int. Оператор минуса может быть одним из тире символов, перечисленных в §7.2.
Этот оператор является правоассоциативным.
Примеры:
-$true # type int, value -1
-123L # type long, value -123
-0.12340D # type decimal, value -0.12340
Операторы префиксного увеличения и уменьшения 7.2.6
Описание:
унарное выражение должно назначить записываемое расположение, имеющее значение числового типа (§4) или значение $null. Если значение, указанное его унарным выражением,$null, значение унарного выраженияпреобразуется в тип int и значение ноль перед вычислением оператора.
Заметка
Тип значения, указанного унарного выражения может измениться при хранении результата. См. §7.11 для обсуждения изменения типа через присваивание.
Для оператора префиксного инкремента ++ значение унарного выражения увеличивается на 1 соответствующего типа. Результатом является новое значение после увеличения. Выражение ++E эквивалентно E += 1 (§7.11.2).
Для префиксного декрементного оператора -- значение унарного выражения уменьшается на 1 соответствующего типа. Результатом является новое значение после уменьшения. Выражение --E эквивалентно E -= 1 (§7.11.2). Оператор декремента префикса может быть любым из шаблонов, соответствующих шаблону dashdash в §7.2.
Эти операторы являются правоассоциативными.
Примеры:
$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 Унарный оператор -join
Синтаксис:
join-operator:
dash join
dash: one of
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Описание:
Унарный оператор -join создает строку, которая является объединением значения одного или нескольких объектов, назначенных унарным выражением. (Разделитель можно вставить с помощью двоичной версии этого оператора (§7.8.4.4).)
унарное выражение может быть скалярным значением или коллекцией.
Примеры:
-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 Унарный оператор -split
Синтаксис:
split-operator:
dash split
dash: one of
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Описание:
Унарный оператор -split разбивает одну или несколько строк, заданных унарным выражением , возвращая их подстроки в ограниченном по размеру 1-мерном массиве строк. Она обрабатывает любую плотную группу символов пробелов как разделитель между последовательными подчастями. Строку явного разделителя можно указать с помощью двоичной версии этого оператора (§7.8.4.5) или двух вариантов (§7.8).
Текст разделителя не включается в результирующий текст. Начальные и конечные пробелы во входной строке игнорируются. Входная строка, пустая или содержащая пробелы, приводит только к массиву одной строки, которая пуста.
унарное выражение может назначить скалярное значение или массив строк.
Примеры:
-split " red`tblue`ngreen " # 3 strings: "red", "blue", "green"
-split ("yes no", "up down") # 4 strings: "yes", "no", "up", "down"
-split " " # 1 (empty) string
Оператор приведения типа 7.2.9 Cast
Описание:
Этот оператор явно преобразует (§6) значение, указанное унарным выражением в тип, назначенный типом-литеральным (§7.1.10). Если тип-литерал отличается от void, то тип результата — именованный тип, а значение — это значение после преобразования. Если буквальный тип является пустым, объект не записывается в конвейер, и результата не будет.
Когда выражение любого типа приводится к тому же типу, результирующий тип и значение соответствуют типу и значению унарного выражения .
Этот оператор является правоассоциативным.
Примеры:
[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
Синтаксис:
array-literal-expression:
unary-expression , new-lines~opt~ array-literal-expression
Описание:
Оператор двоичной запятой создает 1-мерный массив, элементы которого являются значениями, назначенными операндами, в лексическом порядке. Массив имеет неограниченный тип.
Примеры:
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
Добавление скобок для группировки к некоторым бинарным запятым выражениям не документирует приоритет по умолчанию; вместо этого изменяет результат.
Оператор диапазона 7.4
Синтаксис:
range-expression:
unary-expression .. new-lines~opt~ unary-expression
Описание:
выражение диапазона создает неограниченный одномерный массив, элементы которого представляют собой значения целочисленной последовательности, определяемой границами диапазона. Значения, назначенные операндами, преобразуются в int, при необходимости (§6,4). Операнд, указывающий меньшее значение после преобразования, является нижней границы, а операнд, указывающий более высокое значение после преобразования, является верхней границы. Обе границы могут быть одинаковыми, в этом случае результирующий массив имеет длину 1.
Если левая операнда обозначает нижнюю границу, последовательность находится в порядке возрастания. Если левый операнд обозначает верхнюю границу, последовательность находится в порядке убывания.
Концептуально этот оператор является сокращением для соответствующей последовательности операторов запятой. Например, диапазон 5..8 также можно создать с помощью 5,6,7,8. Однако, если требуется последовательность по возрастанию или убыванию без использования массива, можно избежать создания фактического массива при реализации. Например, в foreach ($i in 1..5) { ... }не требуется создавать массив.
Можно использовать
Примеры:
1..10 # ascending range 1..10
-495..-500 # descending range -495..-500
16..16 # sequence of 1
$x = 1.5
$x..5.40D # ascending range 2..5
$true..3 # ascending range 1..3
-2..$null # ascending range -2..0
0xf..0xa # descending range 15..10
Оператор формата 7.5
Синтаксис:
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)
Описание:
выражение формата форматирует одно или несколько значений, определенных выражением диапазона , в соответствии со строкой спецификации формата , указанной выражением формата . Позиции значений, указанных выражением диапазона , нумеруются, начиная с нуля и увеличиваются в лексикографическом порядке. Результат имеет тип string.
Строка спецификации формата может содержать ноль или больше спецификаций формата, каждая из которых имеет следующую форму:
{N [ ,M ][ : FormatString ]}
N представляет обязательную позицию значения выражения диапазона, M представляет собой (необязательную) минимальную ширину отображения, а FormatString указывает (необязательный) формат. Если ширина отформатированного значения превышает указанную ширину, ширина увеличивается соответствующим образом. Значения, позиции которых не ссылаются в FormatString, игнорируются после проверки на предмет побочных эффектов. Если N относится к несуществующей позиции, поведение зависит от реализации. Значение типа $null и void форматируются как пустые строки. Массивы форматируются как в случае подвыражения (§7.1.6). Чтобы включить символы { и } в спецификацию формата без их интерпретации как разделителей формата, напишите их как {{ и }}соответственно.
Полное определение спецификаций формата см. в
Примеры:
"__{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__
В спецификации формата, если N относится к несуществующей позиции, вызывается FormatError.
7.6 Множительные операторы
Синтаксис:
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 Умножение
Описание:
Результатом оператора умножения * является произведение значений, назначенных двумя операндами после применения обычных арифметических преобразований (§6.15).
Этот оператор остается ассоциативным.
Примеры:
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
Описание:
Когда левый операнд обозначает строку, двоичный оператор * создает новую строку, содержащую ту же строку, обозначенную левым операндом, реплицированную столько раз, сколько указано значением правого операнда, преобразованного в целочисленный тип (§6.4).
Этот оператор остается ассоциативным.
Примеры:
"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
Описание:
Когда левый операнд обозначает массив, двоичный оператор * создает новый неограниченный 1-мерный массив, содержащий значение, указанное левым операндом, реплицированное количество раз, указанное значением правого операнда, преобразованным в целый тип (§6.4). Число репликаций, равное нулю, приводит к массиву длиной 1. Если левый операнд обозначает многомерный массив, он плоский (§9.12) перед использованием.
Этот оператор остается ассоциативным.
Примеры:
$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 Деление
Описание:
Результатом оператора деления / является частное, если значение, указанное левым операндом, делится на значение, указанное правым операндом, после того как были применены стандартные арифметические преобразования (§6.15).
Если предпринята попытка выполнить целочисленное или десятичное деление по нулю, возникает определяемая реализацией ошибка завершения.
Этот оператор остается ассоциативным.
Примеры:
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
Если предпринята попытка выполнить целочисленное или десятичное деление по нулю, возникает исключение RuntimeException.
7.6.5 Оставшаяся часть
Описание:
Результатом оставшегося оператора % является оставшаяся часть, когда значение, указанное левым операндом, делится на значение, указанное правым операндом после обычных арифметических преобразований (§6.15) .
Если предпринята попытка выполнить целочисленное или десятичное деление по нулю, возникает определяемая реализацией ошибка завершения.
Примеры:
10 % 3 # int result 1
10.0 % 0.3 # double result 0.1
10.00D % "0x4" # decimal result 2.00
Если предпринята попытка выполнить целочисленное или десятичное деление по нулю, возникает исключение RuntimeException.
7.7 Аддитивные операторы
Синтаксис:
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
Описание:
Результатом оператора добавления + является сумма значений, назначенных двумя операндами после применения обычных арифметических преобразований (§6.15).
Этот оператор остается ассоциативным.
Примеры:
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 Объединение строк
Описание:
Когда левый операнд является строкой, двоичный оператор + создаёт новую строку, содержащую значение, указанное левым операндом, а затем значение, указанное правым операндом и преобразованное в тип строка (§6.8).
Этот оператор остается ассоциативным.
Примеры:
"red" + "blue" # "redblue"
"red" + "123" # "red123"
"red" + 123 # "red123"
"red" + 123.456e+5 # "red12345600"
"red" + (20,30,40) # "red20 30 40"
7.7.3 Объединение массивов
Описание:
Когда левый операнд обозначает массив, двоичный оператор + создает новый неограниченный одномерный массив, который содержит элементы, обозначенные левым операндом, сразу после которых следуют значения, обозначенные правым операндом. Многомерные массивы, присутствующие в любом из операндов, преобразованы в одномерные (§9.12) перед использованием.
Этот оператор остается ассоциативным.
Примеры:
$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 Объединение хеш-таблиц
Описание:
Когда оба операнда представляют собой хеш-таблицы, двоичный оператор + создает новую хеш-таблицу, содержащую элементы, обозначенные левым операндом, а затем элементы, обозначенные правым операндом.
Если хеш-таблицы содержат один и тот же ключ, возникает определяемая реализацией ошибка завершения.
Этот оператор остается ассоциативным.
Примеры:
$h1 = @{ FirstName = "James"; LastName = "Anderson" }
$h2 = @{ Dept = "Personnel" }
$h3 = $h1 + $h2 # new Hashtable, Count = 3
Если хеш-таблицы содержат тот же ключ, возникает исключение типа BadOperatorArgument.
7.7.5 Вычитание
Описание:
Результатом оператора вычитания - является разница, когда значение, указанное правым операндом, вычитается из значения, указанного левым операндом после обычных арифметических преобразований (§6.15) . Оператор вычитания может быть одним из тире символов, перечисленных в §7.7.
Этот оператор остается ассоциативным.
Примеры:
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
Синтаксис:
comparison-expression:
primary-expression comparison-operator new-lines~opt~ expression
comparison-operator:
equality-operator
relational-operator
containment-operator
type-operator
like-operator
match-operator
Описание:
Тип значения, указанного левым операндом, определяет, как преобразуется значение, указанное правым операндом (§6), при необходимости, до завершения сравнения.
Некоторые операторы сравнения имеют два варианта, один из которых учитывает регистр (-c<operator>), и тот, который не учитывает регистр (-i<operator>). Версия -<operator> эквивалентна -i<operator>. Чувствительность к регистру имеет смысл только при сравнении значений типа string. В контекстах сравнения, отличных от строк, два варианта ведут себя одинаково.
Эти операторы остаются ассоциативными.
7.8.1 Операторы равенства и реляционные операторы
Синтаксис:
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
Описание:
Существует два оператора равенства: равенство (-eq) и неравенство (-ne); и четыре реляционных оператора: меньше (-lt), меньше или равно (-le), больше (-gt) и больше или равно (-ge). Каждый из этих вариантов имеет два варианта (§7,8).
Чтобы две строки считались равными, они должны иметь одинаковую длину, содержимое и регистр букв.
Если значение, указанное левым операндом, не является коллекцией, результат имеет тип bool.
В противном случае результатом может быть пустой 1-мерный массив, содержащий элементы коллекции, которые тестируют True при сравнении со значением, указанным правым операндом.
Примеры:
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
Синтаксис:
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)
Описание:
Существует четыре оператора хранения: содержит (-contains), не содержит (-notcontains), в (-in) и не в (-notin). Каждый из этих вариантов имеет два варианта (§7,8).
Операторы проверки содержимого возвращают результат типа bool, определяющий, встречается ли значение (или не встречается) по крайней мере один раз в элементах массива. При использовании -contains и -notcontainsзначение назначается правым операндом, а массив обозначается левым операндом. При -in и -notinоперанды возвращаются обратно. Значение назначается левым операндом, а массив обозначается правым операндом.
В целях этих операторов, если операнд массива имеет скалярное значение, скалярное значение рассматривается как массив одного элемента.
Примеры:
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 Операторы тестирования и преобразования типов
Синтаксис:
type-operator: one of
dash is
dash as
dash:
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Описание:
Оператор типа -is проверяет, имеет ли значение, указанное левым операндом, тип или производно от типа, указанного правым операндом. Правый операнд должен назначить тип или значение, которое можно преобразовать в тип (например, строку, которая называет тип).
Тип результата — bool. Оператор типа -isnot возвращает логическое отрицание соответствующей формы -is.
Оператор типа -as пытается преобразовать значение, указанное левым операндом, в тип, назначенный правым операндом. Правый операнд должен назначить тип или значение, которое можно преобразовать в тип (например, строку, которая называет тип). Если преобразование завершается ошибкой, возвращается $null; в противном случае преобразованное значение возвращается, а возвращаемый тип этого результата — это тип среды выполнения преобразованного значения.
Примеры:
$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 Операторы сопоставления шаблонов и текстовых манипуляций
7.8.4.1 Операторы -like и -notlike
Синтаксис:
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)
Описание:
Если левый операнд не обозначает коллекцию, результат имеет тип bool. В противном случае результатом может быть пустой 1-мерный массив, содержащий элементы коллекции, которые тестируют True при сравнении со значением, указанным правым операндом. Правый операнд может обозначать строку, содержащую подстановочные знаки (§3.15). Эти операторы имеют два варианта (§7.8).
Примеры:
"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 Операторы -match и -notmatch
Синтаксис:
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)
Описание:
Если левый операнд не обозначает коллекцию, результат имеет тип bool и если результат $true, элементы хэш-таблицы $matches задаются в строках, которые соответствуют (или не совпадают) значению, указанному правым операндом. В противном случае результатом является, возможно, пустой неограниченный 1-мерный массив, содержащий элементы коллекции, которые выдают True при сравнении со значением, указанным правым операндом, и $matches не установлен. Правый операнд может назначить строку, содержащую регулярные выражения (§3.16), в этом случае она называется шаблоном . Эти операторы имеют два варианта (§7.8).
Эти операторы поддерживают подсовпадения (§7.8.4.6).
Примеры:
"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 Оператор -replace
Синтаксис:
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)
Описание:
Оператор -replace разрешает замену текста в одной или нескольких строках, назначенных левым операндом, используя значения, указанные правым операндом. Этот оператор имеет два варианта (§7.8). Правый операнд имеет одну из следующих форм:
- Строка, которую нужно найти и которая может содержать регулярные выражения (§3.16). В этом случае строка замены по умолчанию является пустой («»).
- Массив из 2 объектов, содержащих искомую строку, за которой следует строка замены.
Если левый операнд обозначает строку, результат имеет строку типа. Если левый операнд обозначает 1-мерный массив строк, результатом является неограниченный 1-мерный массив, длина которого совпадает с массивом левого операнда, содержащего входные строки после завершения замены.
Этот оператор поддерживает подсовпадения (§7.8.4.6).
Примеры:
"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 Оператор бинарного -join
Синтаксис:
binary-join-operator: one of
dash join
dash:
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Описание:
Двоичный -join оператор создает строку, которая является объединением значения одного или нескольких объектов, назначенных левым операндом после преобразования в строку (при необходимости§6.7). Строка, определяемая правым операндом, используется для разделения значений (возможно, пустых) в результирующей строке.
Левая операнда может быть скалярным значением или коллекцией.
Примеры:
(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 Двоичный оператор -split
Синтаксис:
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)
Описание:
Двоичный -split оператор разбивает одну или несколько строк, назначенных левым операндом, возвращая их подпартии в ограниченном 1-мерном массиве строк. Этот оператор имеет два варианта (§7.8). Левый операнд может назначить скалярное значение или массив строк. Правый операнд имеет одну из следующих форм:
- Строка-разделитель
- Массив из 2 объектов, содержащих строку разделителя, за которой следует числовое значение количества разделений
- Массив из 3 объектов, содержащих строку разделителя, числовое число разбиения и строку параметров
- Блок скрипта
- Массив из 2 объектов, содержащих блок скрипта, за которым следует числовое число разбиения
Строка разделителя может содержать регулярные выражения (§3.16). Он используется для поиска подразделов с входными строками. Разделитель не включается в результирующий список строк. Если левый операнд обозначает пустую строку, это приводит к пустому элементу строки. Если строка разделителя является пустой строкой, она обнаруживается в каждой позиции символов во входных строках.
По умолчанию все подчасти входных строк помещаются в результат в виде отдельных элементов; однако для изменения этого поведения можно использовать параметр разбиения. Если это число отрицательно, равно нуля или больше или равно числу подчастей во входной строке, каждая подчасть помещается в отдельный элемент. Если это число меньше количества подпартий во входной строке, в результате имеются элементы счетчика, а конечный элемент, содержащий все подпартии за пределами первого счетчика, — 1 подпартий.
Строка параметров содержит ноль или более имен параметров, причем каждая соседняя пара разделяется запятой. Начальные, конечные и вложенные пробелы игнорируются. Названия параметров могут быть в любом порядке и чувствительны к регистру.
Если строка параметров содержит имя параметра SimpleMatch, оно также может содержать имя параметра IgnoreCase. Если строка параметров содержит имя параметра RegexMatch или не содержит либо RegexMatch, либо SimpleMatch, он может содержать любое имя параметра, кроме SimpleMatch. Однако он не должен содержать и Multiline и Singleline.
Ниже приведен набор имен параметров:
| параметр | описание |
|---|---|
| Культурно-неизменяемый | Игнорирует культурные различия в языке при оценке разделителя. |
| Явный захват | Игнорирует неназванные группы совпадений, чтобы в списке результатов возвращались только явные группы записи. |
| IgnoreCase | Принудительное сопоставление без учета регистра, даже если используется -csplit. |
| IgnorePatternWhitespace | Игнорирует неискаченное пробелы и примечания, помеченные знаком номера (#). |
| Многостроочное | Этот режим распознает начало и конец строк и текстовых строк. Режим по умолчанию — однострочный. |
| RegexMatch | Используйте сопоставление регулярных выражений для оценки разделителя. Это значение по умолчанию. |
| SimpleMatch | При оценке разделителя используйте простое сравнение строк. |
| Сингллайн | Этот режим распознает только начало и конец строк. Это режим по умолчанию. |
Блок скрипта (§7.1.8) задает правила для определения разделителя и должен оцениваться в тип bool.
Примеры:
"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 Подматчи
Шаблон, соответствующий -match, -notmatchи -replace, может содержать составные части (называемые подсовпадениями ), разграниченные скобками. Рассмотрим следующий пример:
"red" -match "red"
Результатом является $true, и ключ 0 из $matches содержит "красный", это часть строки, которая непосредственно соответствует шаблону, заданному правым операндом.
В следующем примере весь шаблон представляет собой подмножную диаграмму:
"red" -match "(red)"
Как и раньше, ключ 0 содержит "красный"; однако, ключ 1 также содержит "красный", и это та часть строки, указанная левым операндом, которая точно совпадает с подвыражением.
Рассмотрим следующий, более сложный шаблон:
"red" -match "((r)e)(d)"
Этот шаблон позволяет находить совпадения для "re", "r", "d" или "red".
Опять же, ключ 0 содержит "красный". Ключ 1 содержит "re", ключ 2 содержит "r", а ключ 3 содержит "d". Пары "ключ-значение" расположены в соответствующем порядке слева направо в шаблоне, где более длинные строки совпадений предшествуют более коротким.
В случае -replaceзамещающий текст может получить доступ к сопоставлениям с помощью имен формы $n, где первое совпадение $1, второе совпадение — $3и т. д. Например
"Monday morning" -replace '(Monday|Tuesday) (morning|afternoon|evening)','the $2 of $1'
Результирующая строка — "утро понедельника".
Вместо того чтобы ключи в $matches отсчитывались от нуля, подсовпадения можно назвать с помощью формы ?<*name*>. Например, "((r)e)(d)" можно записать с тремя именованными подсовпадениями, m1, m2и m3следующим образом: "(?<m1>(?<m2>r)e)(?<m3>d)".
Операторы сдвига 7.8.5
Синтаксис:
shift-operator: one of
dash shl
dash shr
dash:
- (U+002D)
EnDash character (U+2013)
EmDash character (U+2014)
Horizontal bar character (U+2015)
Описание:
Операторы shift влево (-shl) и shift вправо (-shr) преобразовывают значение, определенное левым операндом, в целочисленный тип, и значение, указанное правым операндом, в int при необходимости, с помощью обычных арифметических преобразований (§6.15).
Оператор сдвига влево сдвигает левый операнд на количество битов, вычисляемое, как описано ниже. Для пустых позиций бита низкого порядка задано значение нулю.
Оператор сдвига вправо сдвигает левый операнд вправо на число битов, вычисляемое, как описано ниже. Биты нижнего порядка левого операнда удаляются, оставшиеся биты смещены вправо. Когда левый операнд является подписанным значением, пустые битовые позиции старшего порядка устанавливаются в ноль, если левый операнд не отрицательный, и в единицу, если левый операнд отрицательный. Когда левый операнд является беззнаковым значением, старшие разряды пустых позиций устанавливаются в ноль.
Если левый операнд имеет тип int, количество сдвигов определяется пятью младшими битами правого операнда. Если правый операнд имеет тип long, количество сдвигов задается младшими шестью битами правого операнда.
Примеры:
0x0408 -shl 1 # int with value 0x0810
0x0408 -shr 3 # int with value 0x0081
0x100000000 -shr 0xfff81 # long with value 0x80000000
7.9 Битовые операторы
Синтаксис:
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
Описание:
Побитовый оператор AND -band, побитовый оператор OR -bor, а также побитовый оператор XOR -bxor преобразуют значения, указываемые их операндами, в целые типы при необходимости, с использованием обычных арифметических преобразований (§6.15). После преобразования оба значения имеют тип int, который является типом результата. В противном случае, если оба значения имеют тип long, то это тип результата.
Если одно значение имеет тип int и другое имеет тип long, тип результата - long.
В противном случае выражение неправильно сформировано. Результатом является побитовое И, побитовое ИЛИ или побитовое исключающее ИЛИ соответственно преобразованных значений операндов.
Эти операторы остаются ассоциативными. Они коммутативны, если ни один из операндов не содержит побочных эффектов.
Примеры:
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 Логические операторы
Синтаксис:
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
Описание:
Логический оператор И -and преобразует значения, определяемые его операндами в bool, при необходимости (§6.2). Результатом является логическое И значений операндов, которые, возможно, были преобразованы, и результат имеет тип bool. Если левый операнд оценивается как False, правый операнд не вычисляется.
Логический оператор ИЛИ -or преобразует значения, назначенные их операндами, в bool, при необходимости (§6.2). Результатом является логическая операция ИЛИ над, возможно, преобразованными значениями операнда, и он имеет тип bool. Если левый операнд оценивается как True, правый операнд не вычисляется.
Логический оператор XOR -xor преобразует значения, назначенные операндами в bool (§6.2). Результатом является логическая операция XOR над, возможно, преобразованными значениями операндов и имеет тип bool.
Эти операторы остаются ассоциативными.
Примеры:
$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
Синтаксис:
assignment-expression:
expression assignment-operator statement
assignment-operator: *one of
= dash = += *= /= %=
Описание:
Оператор присваивания сохраняет значение в записываемом месте, указанном выражением . Для обсуждения оператор назначения= см. §7.11.1. Обсуждение всех других операторов назначения см. в разделе §7.11.2.
Выражение назначения имеет значение, указанное выражением после назначения; однако это выражение назначения не указывает на записываемое расположение. Если выражение ограничено типом (§5.3), тип, используемый в этом ограничении, является типом результата; В противном случае тип результата является типом после применения обычных арифметических преобразований (§6.15) .
Этот оператор является правоассоциативным.
7.11.1 Простое назначение
Описание:
В
Как показано в грамматике, выражение может обозначать список адресов для записи, разделенных запятыми.
Это называется множественным назначением.
оператор обозначает список одного или нескольких значений, разделенных запятой. Запятые в любом списке операндов являются частью синтаксиса с несколькими назначениями и не представляют двоичный оператор запятой. Значения берутся из списка, указанного оператором , в лексическом порядке и помещаются в соответствующее место для записи, определенное выражением . Если список, назначенный оператором , имеет меньше значений, чем выражений записываемых расположений, избыточные расположения принимают значение $null. Если список, указанный оператором , имеет больше значений, чем записываемых расположений выражений, все, кроме правого расположения, принимают соответствующие значения, заданные оператором , а правое расположение выражений становится неограниченным одномерным массивом со всеми остальными значениями, заданными оператором , в виде элементов.
Для выражений, имеющих значения (§8.1.2), выражение может быть другим выражением.
Примеры:
$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 Составное назначение
Описание:
составное назначение имеет форму E1 op= E2и эквивалентно простому выражению присваивания E1 = E1 op (E2) за исключением того, что в составном случае выражение E1 вычисляется только один раз. Если выражение ограничено типом (§5.3), тип, используемый в этом ограничении, является типом результата; в противном случае тип результата определяется op. Сведения о *=см. в разделе §7.6.1, §7.6.2, §7.6.3; для /=см. §7.6.4; для %=см. §7.6.5; для +=см. §7.7.1, §7.7.2, §7.7.3; для -=см. §7.7.5.
Заметка
Операнд, указывающий неограниченное значение числового типа, может изменить его тип оператором назначения при хранении результата.
Примеры:
$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
Синтаксис:
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
Описание:
Оператор перенаправления > принимает стандартные выходные данные из конвейера и перенаправляет их в расположение, указанное перенаправленным именем файла, перезаписывая текущее содержимое данного расположения.
Оператор перенаправления >> принимает стандартные выходные данные из конвейера и перенаправляет их в расположение, указанное перенаправленным именем файла, добавляя к текущему содержимому этого файла, если таковые есть. Если это место не существует, оно создается.
Оператор перенаправления с формой n> принимает выходные данные потоков n из конвейера и перенаправляет их в место, указанное перенаправленным именем файла , перезаписывая текущее содержимое этого местоположения.
Оператор перенаправления формата n>> принимает выходные данные потоков и из конвейера и перенаправляет их в место, указанное по перенаправленному имени файла , добавляя к текущему содержимому этого места, если оно имеется. Если это местоположение не существует, оно создается.
Оператор перенаправления с формой m>&n записывает выходные данные из потока m в то же расположение, что и поток n.
Ниже приведены допустимые потоки:
| Поток | Описание |
|---|---|
| 1 | Стандартный выходной поток |
| 2 | Поток вывода ошибок |
| 3 | Предупреждающий выходной поток |
| 4 | Подробный выходной поток |
| 5 | Отладка выходного потока |
| * | Стандартный вывод, вывод ошибок, предупреждающий вывод, подробный вывод и потоки отладочного вывода |
Операторы перенаправления 1>&2, 6>, 6>> и < зарезервированы для дальнейшего использования.
Если в выходных данных значение перенаправленного имени файла равно $null, то выходные данные отклоняются.
Как правило, значение выражения, содержащего побочный эффект верхнего уровня, не записывается в конвейер, если это выражение не заключено в пару скобок. Однако если такое выражение является левым операндом оператора, который перенаправляет стандартные выходные данные, то значение записывается.
Примеры:
$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
PowerShell