7. Expressões

Sintaxe:

expression:
    logical-expression

Descrição:

Uma expressão é uma sequência de operadores e operands que designa um método, uma função, um local estadizável, ou um valor; especifica a cálculo de um valor; produz um ou mais efeitos secundários; ou executa alguma combinação da mesma. Por exemplo,

• O literal 123 é uma expressão que designa o valor int 123.
• A expressão 1,2,3,4 designa o objeto de matriz de 4 elementos tendo os valores apresentados.
• A expressão 10.4 * $a especifica uma computação.
• A expressão $a++ produz um efeito colateral.
• A expressão $a[$i--] = $b[++$j] executa uma combinação destas coisas.

Salvo especificação para alguns operadores, a ordem de avaliação dos termos numa expressão e a ordem em que os efeitos secundários ocorrem não são ambas não especificadas. Exemplos de comportamento não especificado incluem: $i++ + $i, $i + --$ie $w[$j++] = $v[$j].

Uma implementação do PowerShell pode fornecer suporte para tipos definidos pelo utilizador, e esses tipos podem ter operações definidas neles. Todos os detalhes deste tipo e operações são definidos.

Uma expressão de alto nível é uma expressão que não faz parte de uma expressão maior. Se uma expressão de nível superior contiver um operador de efeito colateral, o valor dessa expressão não está escrito no gasoduto; caso contrário, é. Consulte §7.1.1 para uma discussão detalhada sobre isto.

Normalmente, uma expressão que designa uma coleção (§4) é enumerada nos seus elementos constituintes quando o valor dessa expressão é usado. No entanto, este não é o caso quando a expressão é uma invocação de cmdlet. Por exemplo,

$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

Nas duas primeiras utilizações do $(...) operador, a expressão que designa a coleção é a variável $x, que é enumerada resultando em três int valores, mais os int 99. No entanto, no terceiro caso, a expressão é uma chamada direta para um cmdlet, pelo que o resultado não é enumerado, e $a é um conjunto de dois elementos, int[3] e int.

Se uma operação não for definida pela PowerShell, o tipo de valor designado pela ópera esquerda é inspecionado para ver se tem um método correspondente op_<operation> .

7.1 Expressões primárias

Sintaxe:

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 Parênteses de agrupamento

Sintaxe:

Dica

A ~opt~ notação nas definições de sintaxe indica que a entidade lexical é opcional na sintaxe.

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

Descrição:

Uma expressão parêntesa é uma expressão primária cujo tipo e valor são os mesmos da expressão sem os parênteses. Se a expressão designar uma variável, então a expressão parênteses designa essa mesma variável. Por exemplo, $x.m e ($x).m são equivalentes.

Os parênteses agrupantes podem ser utilizados numa expressão para documentar a precedência e a associatividade predefinidas dentro dessa expressão. Também podem ser usados para anular essa precedência padrão e associatividade. Por exemplo,

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

Normalmente, os parênteses agrupados no nível mais alto são redundantes. No entanto, nem sempre é assim. Considere o exemplo seguinte:

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

No segundo caso, os parênteses mudam a semântica, resultando numa matriz cujos dois elementos são uma matriz de 2 ints e o scalar int 6.

Aqui está outra exceção:

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

No primeiro e terceiro casos, o valor do resultado é escrito ao oleoduto. No entanto, embora a expressão no segundo caso seja avaliada, o resultado não é escrito para o gasoduto devido à presença do operador de efeito secundário = ao nível superior. (A remoção da $a = peça permite que o valor seja escrito, tal como * não é um operador de efeito colateral.)

Para impedir que um valor de qualquer expressão que não contenha efeitos secundários de nível superior seja escrito no gasoduto, deite-o explicitamente como se segue:

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

Para escrever ao oleoduto o valor de qualquer expressão que contenha efeitos colaterais de nível superior, encerra essa expressão nos parênteses, da seguinte forma:

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

Como tal, os parênteses do agrupamento neste caso não são redundantes.

No exemplo seguinte, temos a substituição variável (§2.3.5.2) a decorrer numa sequência literal:

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

No primeiro caso, os parênteses representam os delimiters de uma subexexposição que não agrupam parênteses, e como a expressão de nível superior contém um operador de efeito colateral, o valor da expressão não é escrito para o oleoduto. Claro, os > personagens e < os personagens ainda estão escritos.) Se forem adicionados parênteses de agrupamento , como mostrado no segundo caso, a escrita está ativada.

Os seguintes exemplos contêm operadores de efeito colateral de alto nível:

$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 utilização de parênteses em agrupamento em torno de uma expressão que não contém efeitos colaterais de alto nível torna esses parênteses redundantes. Por exemplo;

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

Considere o seguinte exemplo que tem dois efeitos colaterais, nenhum dos quais está no nível superior:

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

O resultado é escrito para o oleoduto, uma vez que a expressão de nível superior não tem efeitos colaterais.

7.1.2 Acesso dos membros

Sintaxe:

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

Descrição:

O operador . é utilizado para selecionar um membro de um objeto ou uma chave de um Hashtable. A ópera esquerda deve designar um objeto, e a ópera direita deve designar um membro de instância acessível.

Ou a ópera direita designa um membro de instância acessível dentro do tipo do objeto designado pela ópera esquerda ou, se a ópera esquerda designar uma matriz, a ópera direita designa membros de instância acessíveis dentro de cada elemento da matriz.

O espaço branco não é permitido perante o . operador.

Este operador é deixado associativo.

O operador :: é utilizado para selecionar um membro estático de um determinado tipo. A ópera esquerda deve designar um tipo, e o operand da direita deve designar um membro estático acessível dentro desse tipo.

O espaço branco não é permitido perante o :: operador.

Este operador é deixado associativo.

Se a ópera da direita designar uma localização writável dentro do tipo do objeto designado pela ópera esquerda, então toda a expressão designa um local writable.

Exemplos:

$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 Expressões de invocação

Sintaxe:

invocation-expression: Note no whitespace is allowed after primary-expression. 
    primary-expression . member-name argument-list
    primary-expression :: member-name argument-list

argument-list:
    ( argument-expression-list~opt~ new-lines~opt~ )

Descrição:

Uma expressão de invocação chama o método designado pela expressão primária. nome do membro ou expressão primária::nome do membro. Os parênteses na lista de argumentos contêm uma lista de expressões possivelmente vazias e separadas por vírgulas, que designam os argumentos cujos valores são passados ao método. Antes de o método ser chamado, os argumentos são avaliados e convertidos de acordo com as regras do §6, se necessário, para corresponder aos tipos esperados pelo método. A ordem de avaliação da expressão primária. nome do membro, expressão primária::nome de membro, e os argumentos não são especificados.

Este operador é deixado associativo.

O tipo de resultado de uma invocação-expressão é um designador de método (§4.5.24).

Exemplos:

[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 Acesso de elemento

Sintaxe:

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

Descrição:

Não deve haver espaço em branco entre a expressão primária e o suporte quadrado esquerdo ([).

7.1.4.1 Subescrição de uma matriz

Descrição:

As matrizes são discutidas em detalhe em §9. Se a expressão for uma matriz 1-dimensional, consulte §7.1.4.5.

Quando a expressão primária designa uma matriz 1-dimensional A, o operador [] devolve o elemento localizado A[0 + expression] após a conversão do valor da expressão para int. O resultado tem o tipo de elemento da matriz sendo subscrito. Se a expressão for negativa, A[expression] designa o elemento localizado em A[A.Length + expression].

Quando a expressão primária designa uma matriz B bidimensional, o operador [] devolve o elemento localizado B[0 + row,0 + column] após o valor da linha e os componentes da coluna de expressão (que são especificados como uma lista separada de vírgula) terem sido convertidos para int. O resultado tem o tipo de elemento da matriz sendo subscrito. Ao contrário de uma matriz unidimensional, as posições negativas não têm um significado especial.

Quando a expressão primária designa um conjunto de três ou mais dimensões, as regras para matrizes bidimensionais aplicam-se e as posições de dimensão são especificadas como uma lista de valores separadas por vírgula.

Se se tentar um acesso de leitura a um elemento não existente, o resultado é $null. É um erro escrever a um elemento não existente.

Para uma expressão subscrita multidimensional, a ordem de avaliação das expressões de posição de dimensão não é especificada. Por exemplo, dada uma matriz $atridimensional, o comportamento não $a[$i++,$i,++$i] é especificado.

Se a expressão for uma matriz, consulte §7.1.4.5.

Este operador é deixado associativo.

Exemplos:

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

Se for tentado um acesso por escrito a um elemento não existente, é levantada uma exceção IndexOutOfRange .

7.1.4.2 Subescrição de uma cadeia

Descrição:

Quando a expressão primária designa uma corda S, o operador [] devolve o carácter localizado na posição de base zero indicada por expressão, como um char. Se a expressão for maior ou igual ao comprimento da corda, o resultado é $null. Se a expressão for negativa, S[expression] designa o elemento localizado em S[S.Length + expression].

Exemplos:

$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 Subscrito de um Hashtable

Descrição:

Quando a expressão primária designa um Hashtable, o operador [] devolve os valores associados à ou as teclas designadas por expressão. O tipo de expressão não é restrito.

Quando a expressão é um único nome-chave, o resultado é o valor associado e tem esse tipo, a menos que não exista tal chave, nesse caso, o resultado é $null. Se $null for usado como a chave, o comportamento é definido. Se a expressão for uma variedade de nomes-chave, consulte §7.1.4.5.

Se a expressão for uma matriz, consulte §7.1.4.5.

Exemplos:

$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

Quando a expressão é um único nome chave, se $null for usado como o único valor para subscrito um Hashtable, é levantada uma exceção NullArrayIndex .

7.1.4.4 Subescrição de um documento XML

Descrição:

Quando a expressão primária designa um objeto de tipo xml, a expressão é convertida em corda, se necessário, e o operador [] devolve o primeiro elemento da criança com o nome especificado por expressão. O tipo de expressão deve ser corda. O tipo de resultado é definido. O resultado pode ser subscrito para devolver o seu primeiro elemento de criança. Se não existir nenhum elemento infantil com o nome especificado por expressão, o resultado é $null. O resultado não designa um local de localização exequível.

Exemplos:

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

O tipo de resultado é System.Xml.XmlElement ou System.String.

7.1.4.5 Geração de fatias de matriz

Quando a expressão primária designa um objeto de um tipo que é enumerado (§4) ou um Hashtable, e a expressão é uma matriz unidimensional, o resultado é uma fatia de matriz (§9.9) contendo os elementos de expressão primária designados pelos elementos de expressão.

No caso de um Hashtable, a fatia de matriz contém os valores associados às teclas fornecidas, a menos que não exista tal chave, nesse caso, o elemento correspondente é $null. Se $null for usado como qualquer nome chave, o comportamento é definido.

Exemplos:

$a = [int[]](30,40,50,60,70,80,90)
$a[1,3,5]                 # slice has Length 3, value 40,60,80
++$a[1,3,5][1]            # preincrement 60 in array 40,60,80
$a[,5]                    # slice with Length 1
$a[@()]                   # slice with Length 0
$a[-1..-3]                # slice with Length 0, value 90,80,70
$a = New-Object 'int[,]' 3,2
$a[0,0] = 10; $a[0,1] = 20; $a[1,0] = 30
$a[1,1] = 40; $a[2,0] = 50; $a[2,1] = 60
$a[(0,1),(1,0)]           # slice with Length 2, value 20,30, parens needed
$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1['FirstName']          # the value associated with key FirstName
$h1['BirthDate']          # no such key, returns $null
$h1['FirstName','IDNum']  # returns [object[]], Length 2 (James/123)
$h1['FirstName','xxx']    # returns [object[]], Length 2 (James/$null)
$h1[$null,'IDNum']        # returns [object[]], Length 1 (123)

Windows PowerShell: Quando a expressão é uma coleção de dois ou mais nomes-chave, se $null for usada como qualquer nome chave essa chave é ignorada e não tem nenhum elemento correspondente na matriz resultante.

7.1.5 Operadores de pós-fixação e decrementos

Sintaxe:

post-increment-expression:
    primary-expression ++

post-decrement-expression:
    primary-expression dashdash

dashdash:
    --

Descrição:

A expressão primária deve designar um local writable com um valor do tipo numérico (§4) ou o valor $null. Se o valor designado pela ópera for $null, esse valor é convertido para digitar int e valor zero antes de o operador ser avaliado. O tipo de valor designado por expressão primária pode mudar quando o resultado é armazenado. Consulte §7.11 para uma discussão de mudança de tipo por atribuição.

O resultado produzido pelo operador de pós-estarfixo ++ é o valor designado pela ópera. Após a obtenção deste resultado, o valor designado pela ópera é aumentado por 1 do tipo apropriado. O tipo de resultado da expressão E++ é o mesmo que para o resultado da expressão E + 1 (§7.7).

O resultado produzido pelo operador de pós-estarfixo -- é o valor designado pela ópera. Após a obtenção desse resultado, o valor designado pela ópera é decrementedo por 1 do tipo apropriado. O tipo de resultado da expressão E-- é o mesmo que para o resultado da expressão E - 1 (§7.7).

Estes operadores são deixados associativos.

Exemplos:

$i = 0                # $i = 0
$i++                  # $i is incremented by 1
$j = $i--             # $j takes on the value of $i before the decrement

$a = 1,2,3
$b = 9,8,7
$i = 0
$j = 1
$b[$j--] = $a[$i++]   # $b[1] takes on the value of $a[0], then $j is
                      # decremented, $i incremented

$i = 2147483647       # $i holds a value of type int
$i++                  # $i now holds a value of type double because
                      # 2147483648 is too big to fit in type int

[int]$k = 0           # $k is constrained to int
$k = [int]::MaxValue  # $k is set to 2147483647
$k++                  # 2147483648 is too big to fit, imp-def bahavior

$x = $null            # target is unconstrained, $null goes to [int]0
$x++                  # value treated as int, 0->1

7.1.6 $(...) operador

Sintaxe:

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

Descrição:

Se a lista de declarações for omitida, o resultado é $null. Caso contrário, a lista de declarações é avaliada. Quaisquer objetos escritos ao oleoduto como parte da avaliação são recolhidos numa matriz unidimensional não constrangida, por ordem. Se a matriz de objetos recolhidos estiver vazia, o resultado é $null. Se a matriz de objetos recolhidos contiver um único elemento, o resultado é esse elemento; caso contrário, o resultado é a matriz unidimensional não-constrangida de resultados recolhidos.

Exemplos:

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

Sintaxe:

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

Descrição:

Se a lista de declarações for omitida, o resultado é uma matriz de 1 dimensão não constrangida de comprimento zero. Caso contrário, a lista de declarações é avaliada, e quaisquer objetos escritos no oleoduto como parte da avaliação são recolhidos numa matriz unidimensional não condicionada, por ordem. O resultado é a (possivelmente vazia) matriz de 1 dimensão não constrangida.

Exemplos:

$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 Expressão do bloco de script

Sintaxe:

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

Descrição:

param-block é descrito em §8.10.9. lista de blocos nomeados é descrito em §8.10.7.

Um bloco de scripts é um bloco sem nome de declarações que pode ser usado como uma única unidade. Os blocos de script podem ser usados para invocar um bloco de código como se fosse um único comando, ou podem ser atribuídos a variáveis que podem ser executadas.

A lista de blocos ou de declaração-lista é executada e os tipos e valores do resultado são o tipo e o valor dos resultados desses conjuntos de declaração.

Uma expressão de bloco de script tem bloco de scripts tipo (§4.3.7).

Se o bloco de param for omitido, quaisquer argumentos passados para o bloco de scripts estão disponíveis através $args (§8.10.1).

Durante a ligação dos parâmetros, um bloco de script pode ser passado como um objeto de bloqueio de script ou como resultado após o bloco de scripts ter sido avaliado. Consulte §6.17 para mais informações.

7.1.9 Expressão literal de hash

Sintaxe:

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

Descrição:

Uma expressão hash-literal é usada para criar um Hashtable (§10) de zero ou mais elementos cada um dos quais é um par chave/valor.

A chave pode ter qualquer tipo, exceto o tipo nulo. Os valores associados podem ter qualquer tipo, incluindo o tipo nulo, e cada um desses valores pode ser qualquer expressão que designe o valor pretendido, incluindo $null.

A encomenda dos pares chave/valor não é significativa.

Exemplos:

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

que cria dois Hashtables, $h1 e $h2cada um contendo três pares de chaves/valor, e um terceiro, $h3que está vazio. Hashtable $h4 tem chaves de vários tipos.

7.1.10 Expressão literal do tipo

Sintaxe:

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 [

Descrição:

Um tipo-literal é representado numa implementação por algum tipo subjacente não especificado. Como resultado, um nome tipo é um sinónimo para o seu tipo subjacente.

Os tipos literais são utilizados em vários contextos:

• Especificando uma conversão explícita (§6, §7.2.9)
• Criação de uma matriz de tipo-restrição (§9.4)
• Aceder aos membros estáticos de um objeto (§7.1.2)
• Especificando uma restrição de tipo numa variável (§5.3) ou num parâmetro de função (§8.10.2)

Exemplos:

Exemplos de tipos literais são [int], [object[]e [int[,,]]. Um tipo de pilha genérica (§4.4) especializado para segurar cordas pode ser escrito como [Stack[string]], e um tipo de dicionário genérico que é especializado para segurar int as teclas com valores de cordas associados pode ser escrito como [Dictionary[int,string]].

O tipo de tipo literal é System.Type. O nome completo para o tipo Stack[string] acima sugerido é System.Collections.Generic.Stack[int]. O nome completo para o tipo Dictionary[int,string] acima sugerido é System.Collections.Generic.Dictionary[int,string].

7.2 Operadores não-americanos

Sintaxe:

unary-expression:
    primary-expression
    expression-with-unary-operator

expression-with-unary-operator:
    , new-lines~opt~ unary-expression
    -not new-lines~opt~ unary-expression
    ! new-lines~opt~ unary-expression
    -bnot new-lines~opt~ unary-expression
    + new-lines~opt~ unary-expression
    dash new-lines~opt~ unary-expression
    pre-increment-expression
    pre-decrement-expression
    cast-expression
    -split new-lines~opt~ unary-expression
    -join new-lines~opt~ unary-expression

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

pre-increment-expression:
    ++ new-lines~opt~ unary-expression

pre-decrement-expression:
    dashdash new-lines~opt~ unary-expression

cast-expression:
    type-literal unary-expression

dashdash:
    dash dash

7.2.1 Operador de vírgula unary

Descrição:

Este operador cria uma matriz unidimensional não condicionada com um elemento, cujo tipo e valor são os de expressão não-ary.

Este operador tem razão associativo.

Exemplos:

$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 Lógico NÃO

Descrição:

O operador -não converte o valor designado por expressão unary para o tipo bool (§6.2), se necessário, e produz um resultado desse tipo. Se o valor da expressão não-real é verdadeiro, o resultado é falso, e vice-versa. O operador! é uma ortografia alternativa para -não.

Este operador tem razão associativo.

Exemplos:

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

7.2.3 Bitwise NÃO

Descrição:

O operador -bnot converte o valor designado por expressão não-suficiente para um tipo inteiro (§6.4), se necessário. Se o valor convertido pode ser representado no tipo int, então este é o tipo de resultado. Caso contrário, se o valor convertido pode ser representado no tipo longo, então este é o tipo de resultado. Caso contrário, a expressão está mal formada. O valor resultante é o complemento dos valores convertidos.

Este operador tem razão associativo.

Exemplos:

-bnot $true         # int with value 0xFFFFFFFE
-bnot 10            # int with value 0xFFFFFFF5
-bnot 2147483648.1  # long with value 0xFFFFFFFF7FFFFFFF
-bnot $null         # int with value 0xFFFFFFFF
-bnot "0xabc"       # int with value 0xFFFFF543

7.2.4 Unary plus

Descrição:

Uma expressão da forma +expressão não-ary é tratada como se estivesse escrita como 0 + unary-expression (§7.7). O inteiro literal 0 tem o tipo int.

Este operador tem razão associativo.

Exemplos:

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

7.2.5 Unary menos

Descrição:

Uma expressão da forma -unary-expression é tratada como se estivesse escrita como 0 - unary-expression (§7.7). O inteiro literal 0 tem o tipo int.

Este operador tem razão associativo.

Exemplos:

-$true # tipo int, valor -1 -123L # tipo longo, valor -123 -0.12340D # tipo decimal, valor -0,12340

7.2.6 Operadores de incremento de prefixos e decrementos

Descrição:

A expressão não-ary deve designar um local writable com um valor do tipo numérico (§4) ou o valor $null. Se o valor designado pela sua expressão $nullnão é , o valor da expressão unary é convertido para digitar int e valor zero antes de o operador ser avaliado.

Nota

O tipo de valor designado por expressão unary pode mudar quando o resultado é armazenado. Consulte §7.11 para uma discussão de mudança de tipo por atribuição.

Para o operador de prefixo ++ , o valor da expressão unary é aumentado por 1 do tipo apropriado. O resultado é o novo valor após a incremento. A expressão ++E é equivalente a E += 1 (§7.11.2).

Para o operador prefixo -- , o valor da expressão não-ary é decrementedo por 1 do tipo adequado. O resultado é o novo valor após a decrementação. A expressão --E é equivalente a E -= 1 (§7.11.2).

Estes operadores têm razão associativo.

Exemplos:

$i = 0                # $i = 0
$++i                  # $i is incremented by 1
$j = --$i             # $i is decremented then $j takes on the value of $i

$a = 1,2,3
$b = 9,8,7
$i = 0;
$j = 1
$b[--$j] = $a[++$i]   # $j is # decremented, $i incremented, then $b[0]
                      # takes on the value of $a[1]

$i = 2147483647       # $i holds a value of type int
++$i                  # $i now holds a value of type double because
                      # 2147483648 is too big to fit in type int

[int]$k = 0           # $k is constrained to int
$k = [int]::MinValue  # $k is set to -2147483648
$--k                  # -2147483649 is too small to fit, imp-def behavior

$x = $null            # target is unconstrained, $null goes to [int]0
$--x                  # value treated as int, 0->-1

7.2.7 O operador unary -join

Descrição:

O operador unary -join produz uma corda que é a concatenação do valor de um ou mais objetos designados por expressão unary. (Um separador pode ser inserido utilizando a versão binária deste operador (§7.8.4.4).)

expressão unary pode ser um valor escalar ou uma coleção.

Exemplos:

-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 O operador não-dividido

Descrição:

O operador unary -split divide uma ou mais cordas designadas por expressão unary, devolvendo as suas subpartes numa matriz de corda unidimensional restrita. Trata qualquer grupo contíguo de personagens do espaço branco como o delimiter entre subpartes sucessivas. (Uma cadeia delimiter explícito pode ser especificada utilizando a versão binária deste operador (§7.8.4.5).) Este operador tem duas variantes (§7.8).

O texto delimiter não está incluído nas cordas resultantes. Liderar e seguir o espaço branco na cadeia de entrada é ignorado. Uma cadeia de entrada que está vazia ou contém espaço branco só resulta numa matriz de 1 corda, que está vazia.

expressão unary pode designar um valor escalar ou uma matriz de cordas.

Exemplos:

-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 Operador de elenco

Descrição:

Este operador converte explicitamente (§6) o valor designado por expressão nãoary para o tipo designado por tipo literal. Se o tipo-literal for diferente do vazio, o tipo de resultado é o tipo nomeado, e o valor é o valor após a conversão. Se o tipo-literal for nulo, nenhum objeto é escrito para o oleoduto e não há resultado.

Quando uma expressão de qualquer tipo é lançada para o mesmo tipo, o tipo e valor resultantes é o tipo e o valor da expressão unary.

Este operador tem razão associativo.

Exemplos:

[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 Operador binário de vírgula

Sintaxe:

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

Descrição:

O operador binário de vírgula cria uma matriz unidimensional cujos elementos são os valores designados pelos seus operands, em ordem lexical. A matriz tem um tipo desconvertido.

Exemplos:

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

A adição de parênteses agrupantes a determinadas expressões binárias de vírgula não documenta a precedência predefinida; em vez disso, altera o resultado.

7.4 Operador de gama

Sintaxe:

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

Descrição:

Uma expressão de alcance cria uma matriz unidimensional não limitada cujos elementos são os valores da sequência int especificada pelos limites de alcance. Os valores designados pelos operands são convertidos para int, se necessário (§6.4). O operand que designa o valor mais baixo após a conversão é o limite inferior, enquanto o operand que designa o valor mais alto após a conversão é o limite superior. Ambos os limites podem ser os mesmos, caso em que a matriz resultante tem comprimento 1. Se a ópera esquerda designar o limite inferior, a sequência está em ordem ascendente. Se a ópera esquerda designar o limite superior, a sequência está em ordem descendente.

Conceptualmente, este operador é um atalho para a correspondente sequência binária do operador do vírgula. Por exemplo, a gama 5..8 também pode ser gerada utilizando 5,6,7,8. No entanto, se uma sequência ascendente ou descendente for necessária sem ter uma matriz, uma implementação pode evitar gerar uma matriz real. Por exemplo, em foreach ($i in 1..5) { ... }, não é necessário criar matriz.

Uma expressão de alcance pode ser usada para especificar uma fatia de matriz (§9.9).

Exemplos:

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

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

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

7.5 Operador de formato

Sintaxe:

format-expression:
    range-expression
    format-expression format-operator new-lines~opt~ range-expression

format-operator:
    dash f

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

Descrição:

Um formato de expressão de formato um ou mais valores designados por expressão de gama de acordo com uma cadeia de especificações de formato designada por expressão de formato. As posições dos valores designados por expressão de alcance são numeradas a partir de zero e aumentando em ordem lexical. O resultado tem o tipo string.

Uma cadeia de especificações de formato pode conter especificações de formato zero ou mais, cada uma com o seguinte formulário:

{N [ ,M ][ : FormatString ]}

N representa uma posição de valor de expressão de gama (necessária), M representa a largura mínima de exibição (opcional) e o FormatString indica o formato (opcional). Se a largura de um valor formatado exceder a largura especificada, a largura é aumentada em conformidade. Os valores cujas posições não são referenciadas no FormatString são ignorados após serem avaliados para quaisquer efeitos secundários. Se N se refere a uma posição inexistente, o comportamento é definido. O valor do tipo $null e do vazio são formatados como cordas vazias. As matrizes são formatadas como para sub-expressão (§7.1.6). Para incluir os caracteres "{" e "}" numa especificação de formato sem que sejam interpretados como delimiters de formato, escreva-os como "{{" e "}}", respectivamente.

Para obter uma definição completa das especificações do formato, consulte o tipo System.IFormattable no Relatório Técnico TR/84 da Ecma.

Exemplos:

`$i` = 10; $j = 12
"{2} <= {0} + {1}\`n" -f $i,$j,($i+$j)  # 22 <= 10 + 12
">{0,3}<" -f 5                          # > 5<
">{0,-3}<" -f 5                         # >5 <
">{0,3:000}<" -f 5                      # >005<
">{0,5:0.00}<" -f 5.0                   # > 5.00<
">{0:C}<" -f 1234567.888                # >$1,234,567.89<
">{0:C}<" -f -1234.56                   # >($1,234.56)<
">{0,12:e2}<" -f 123.456e2              # > 1.23e+004<
">{0,-12:p}<" -f -0.252                 # >-25.20 % <
$format = ">{0:x8}<"
$format -f 123455                       # >0001e23f<

Numa especificação de formato se N se refere a uma posição inexistente, é levantado um FormatError .

7.6 Operadores multiplicadores

Sintaxe:

multiplicative-expression:
    format-expression
    multiplicative-expression * new-lines~opt~ format-expression
    multiplicative-expression / new-lines~opt~ format-expression
    multiplicative-expression % new-lines~opt~ format-expression

7.6.1 Multiplicação

Descrição:

O resultado do operador * de multiplicação é o produto dos valores designados pelos dois operáticos após a aplicação das habituais conversões aritméticas (§6.15).

Este operador é deixado associativo.

Exemplos:

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 Replicação de cordas

Descrição:

Quando a ópera esquerda designa uma corda, o operador binário * cria uma nova corda que contém a designada pela ópera esquerda, replicando o número de vezes designada pelo valor da ópera direita como convertida para o tipo inteiro (§6.4).

Este operador é deixado associativo.

Exemplos:

"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 Replicação da matriz

Descrição:

Quando a ópera esquerda designa uma matriz, o operador binário * cria uma nova matriz unidimensional não constrangida que contém o valor designado pela ópera esquerda replicado o número de vezes designada pelo valor da ópera direita como convertida para o tipo inteiro (§6.4). Uma contagem de replicação de zero resulta numa matriz de comprimento 1. Se a ópera esquerda designar uma matriz multidimensional, é achatada (§9.12) antes de ser utilizada.

Este operador é deixado associativo.

Exemplos:

$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 Divisão

Descrição:

O resultado do operador / de divisão é o quociente quando o valor designado pela ópera esquerda é dividido pelo valor designado pela ópera direita após a aplicação das habituais conversões aritméticas (§6.15).

Se for feita uma tentativa de executar a divisão detetamento ou decimal por zero, é levantado um erro de terminação definido pela implementação.

Este operador é deixado associativo.

Exemplos:

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

Se for feita uma tentativa de realizar uma divisão detetamento ou decimal por zero, é levantada uma exceção RuntimeException .

7.6.5 Restante

Descrição:

O resultado do operador % remanescente é o restante quando o valor designado pela ópera esquerda é dividido pelo valor designado pela ópera direita após a aplicação das habituais conversões aritméticas (§6.15).

Se for feita uma tentativa de executar a divisão detetamento ou decimal por zero, é levantado um erro de terminação definido pela implementação.

Exemplos:

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

Se for feita uma tentativa de realizar uma divisão detetamento ou decimal por zero, é levantada uma exceção RuntimeException .

7.7 Operadores aditivos

Sintaxe:

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

7.7.1 Adição

Descrição:

O resultado do operador + de adição é a soma dos valores designados pelos dois operands após a aplicação das habituais conversões aritméticas (§6.15).

Este operador é deixado associativo.

Exemplos:

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 Concatentação de cordas

Descrição:

Quando a ópera esquerda designa uma corda, o operador binário + cria uma nova corda que contém o valor designado pela ópera esquerda seguida imediatamente pelo valor(s) designado pela ópera direita como convertido em cadeia de tipo (§6.8).

Este operador é deixado associativo.

Exemplos:

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

7.7.3 Concatenação array

Descrição:

Quando a ópera esquerda designa uma matriz, o operador binário + cria uma nova matriz unidimensional não constrangida que contém os elementos designados pela ópera esquerda seguida imediatamente pelo valor(s) designado pela ópera direita. As matrizes multidimensionais presentes em qualquer ópera são achatadas (§9.12) antes de serem utilizadas.

Este operador é deixado associativo.

Exemplos:

$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 Concatenação hashtable

Descrição:

Quando ambos os óperas designam Hashtables, o operador binário + cria um novo Hashtable que contém os elementos designados pela ópera esquerda seguidos imediatamente pelos elementos designados pela ópera direita.

Se os Hashtables contiverem a mesma chave, é levantado um erro de terminação definido pela implementação.

Este operador é deixado associativo.

Exemplos:

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

Se os Hashtables contiverem a mesma chave, é levantada uma exceção do tipo BadOperatorArgument .

7.7.5 Subtração

Descrição:

O resultado do operador - de subtração é a diferença quando o valor designado pela ópera direita é subtraído do valor designado pela ópera esquerda após a aplicação das habituais conversões aritméticas (§6.15).

Este operador é deixado associativo.

Exemplos:

12 - -10L      # long result 2c
-10.300D - 12  # decimal result -22.300
10.6 - 12      # double result -1.4
12 - "0xabc"   # int result -2736

7.8 Operadores de comparação

Sintaxe:

comparison-operator: one of
    dash as           dash ccontains     dash ceq
    dash cge          dash cgt           dash cle
    dash clike        dash clt           dash cmatch
    dash cne          dash cnotcontains  dash cnotlike
    dash cnotmatch    dash contains      dash creplace
    dash csplit       dash eq            dash ge
    dash gt           dash icontains     dash ieq
    dash ige          dash igt           dash ile
    dash ilike        dash ilt           dash imatch
    dash in           dash ine           dash inotcontains
    dash inotlike     dash inotmatch     dash ireplace
    dash is           dash isnot         dash isplit
    dash join         dash le            dash like
    dash lt           dash match         dash ne
    dash notcontains  dash notin         dash notlike
    dash notmatch     dash replace       dash shl
    dash shr          dash split

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

Descrição:

O tipo de valor designado pela ópera esquerda determina como o valor designado pela ópera direita é convertido (§6), se necessário, antes da comparação ser feita.

Alguns operadores de comparação (escritos aqui como -op) têm duas variantes, uma que é sensível ao caso (-cop), e outra que não é (-iop). A versão -op é equivalente a -iop. A sensibilidade ao caso só tem significado com comparações de valores de tipo de cadeia. Em contextos de comparação não-cordas, as duas variantes comportam-se da mesma forma.

Estes operadores são deixados associativos.

7.8.1 Os operadores da igualdade e das relacionais

Descrição:

Existem dois operadores para a igualdade: igualdade (-eq) e desigualdade (-ne); e quatro operadores relacionais: menos do que (-lt), menos ou igual a (-le), maior do que (-gt) e maior do que ou igual a (-ge). Cada uma delas tem duas variantes (§7.8).

Para que duas cordas comparem iguais, devem ter o mesmo comprimento e conteúdo, e a caixa da carta, se for caso disso.

Se o valor designado pela ópera esquerda não for uma coleção, o resultado tem o tipo bool. Caso contrário, o resultado é uma matriz dimensional possivelmente vazia e descontável contendo os elementos da coleção que testam True quando comparado com o valor designado pela ópera certa.

Exemplos:

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 Operadores de contenção

Descrição:

Existem quatro operadores de contenção: contém (-contains), não contém (‑notcontains), em (-in) e não-in (-notin). Cada uma delas tem duas variantes (§7.8).

Os operadores de contenção devolvem um resultado do tipo bool que indica se ocorre um valor (ou não ocorre) pelo menos uma vez nos elementos de uma matriz. Com -contains e ‑notcontains, o valor é designado pela ópera direita e a matriz é designada pela ópera esquerda. Com -in e -notin, os óperas são invertidos. O valor é designado pela ópera esquerda e a matriz é designada pela ópera direita.

Para efeitos destes operadores, se o opero de matriz tem um valor escalar, o valor escalar é tratado como uma matriz de um elemento.

Exemplos:

10,20,30,20,10 -contains 20     # True
10,20,30,20,10 -contains 42.9   # False
10,20,30 -contains "10"         # True
"010",20,30 -contains 10        # False
10,20,30,20,10 -notcontains 15  # True
"Red",20,30 -ccontains "RED"    # False

7.8.3 Operadores de teste e conversão de tipo

Descrição:

O operador -is de tipo testa se o valor designado pela ópera esquerda tem o tipo, ou é derivado de um tipo que tem o tipo, designado pela ópera direita. A ópera certa deve designar um tipo ou um valor que possa ser convertido para um tipo (como uma corda que nomeia um tipo). O tipo de resultado é bool. O operador -isnot de tipo devolve a negação lógica do formulário correspondente -is .

O operador -as do tipo tenta converter o valor designado pela ópera esquerda para o tipo designado pela ópera direita. A ópera certa deve designar um tipo ou um valor que possa ser convertido para um tipo (como uma corda que nomeia um tipo). Se a conversão falhar, $null é devolvida; caso contrário, o valor convertido é devolvido e o tipo de retorno desse resultado é o tipo de tempo de execução do valor convertido.

Exemplos:

$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 Operadores de correspondência de padrões e manipulação de texto

7.8.4.1 Os operadores -like e -não-similares

Descrição:

Se a ópera esquerda não designar uma coleção, o resultado tem o tipo bool. Caso contrário, o resultado é uma matriz dimensional possivelmente vazia e descontável contendo os elementos da coleção que testam True quando comparado com o valor designado pela ópera certa. A ópera direita pode designar uma cadeia que contenha expressões wildcard (§3.15). Estes operadores têm duas variantes (§7.8).

Exemplos:

"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 Os operadores -match e -notmatch

Descrição:

Se a ópera esquerda não designar uma coleção, o resultado tem o tipo bool e, se esse resultado for $true, os elementos do Hashtable $matches são definidos para as cordas que combinam (ou não correspondem) o valor designado pela ópera direita. Caso contrário, o resultado é uma matriz dimensional possivelmente vazia e descontável contendo os elementos da coleção que testam True quando comparado com o valor designado pela ópera certa, e $matches não está definido. A ópera direita pode designar uma corda que contenha expressões regulares (§3.16), neste caso, é referida como um padrão. Estes operadores têm duas variantes (§7.8).

Estes operadores suportam submatches (§7.8.4.6).

Exemplos:

"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 O operador de substituição

Descrição:

O -replace operador permite a substituição de texto em uma ou mais cordas designadas pela ópera esquerda usando os valores designados pela ópera direita. Este operador tem duas variantes (§7.8). A ópera direita tem uma das seguintes formas:

• A cadeia a ser localizada, que pode conter expressões regulares (§3.16). Neste caso, a cadeia de substituição é implicitamente "".
• Uma matriz de 2 objetos contendo a corda a localizar, seguida da corda de substituição.

Se a ópera esquerda designar uma corda, o resultado tem a corda do tipo. Se a ópera esquerda designar uma matriz de corda 1-dimensional, o resultado é uma matriz unidimensional não constrangida, cujo comprimento é o mesmo que para a matriz de operand esquerda, contendo as cordas de entrada após a substituição ter terminado.

Este operador suporta subamachos (§7.8.4.6).

Exemplos:

"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 O operador binário de junção

Descrição:

O operador binário -join produz uma corda que é a concatenação do valor de um ou mais objetos designados pela ópera esquerda depois de ter sido convertido em corda (§6.7), se necessário. A corda designada pela ópera direita é usada para separar os valores (possivelmente vazios) na corda resultante.

A ópera à esquerda pode ser um valor escalar ou uma coleção.

Exemplos:

(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 O operador binário dividido

Descrição:

O operador binário -split divide uma ou mais cordas designadas pela ópera esquerda, devolvendo as suas subpartes numa matriz de corda unidimensional restrita. Este operador tem duas variantes (§7.8). A ópera esquerda pode designar um valor escalar ou uma variedade de cordas. A ópera direita tem uma das seguintes formas:

• Uma corda delimiter
• Uma matriz de 2 objetos contendo uma corda delimiter seguido de uma contagem de divisão numérica
• Uma matriz de 3 objetos contendo uma corda delimiter, uma contagem de divisão numérica, e uma cadeia de opções
• Um bloco de scripts
• Uma matriz de 2 objetos contendo um bloco de script seguido de uma contagem de divisão numérica

A corda delimiter pode conter expressões regulares (§3.16). É utilizado para localizar subpartes com as cordas de entrada. O delimiter não está incluído nas cordas resultantes. Se a ópera esquerda designar uma corda vazia, isso resulta num elemento de corda vazio. Se a corda delimiter for uma corda vazia, encontra-se em todas as posições de caracteres nas cordas de entrada.

Por predefinição, todas as subpartes das cordas de entrada são colocadas no resultado como elementos separados; no entanto, a contagem de divisão pode ser usada para modificar este comportamento. Se essa contagem for negativa, zero ou superior ou igual ao número de subpartes numa cadeia de entrada, cada subparte vai para um elemento separado. Se essa contagem for inferior ao número de subpartes na cadeia de entrada, existem elementos de contagem no resultado, com o elemento final contendo todas as subpartes para além da primeira contagem - 1 subpartes.

Uma cadeia de opções contém nomes de opções zero ou mais com cada par adjacente separado por uma vírgula. Liderar, seguir e incorporar o espaço branco é ignorado. Os nomes de opções podem estar em qualquer ordem e são sensíveis a casos.

Se uma cadeia de opções contiver o nome de opção SimpleMatch, também pode conter o nome de opção IgnoreCase. Se uma cadeia de opções contiver o nome de opção RegexMatch ou não contiver RegexMatch ou SimpleMatch, pode conter qualquer nome de opção, exceto SimpleMatch. No entanto, não deve conter tanto a Multiline como a Singleline.

Aqui está o conjunto de nomes de opções:

Opção	Descrição
CulturaInvariante	Ignora as diferenças culturais na linguagem ao avaliar o delimiter.
ExplicitCapture	Ignora grupos de correspondência não nomeados para que apenas grupos de captura explícitos sejam devolvidos na lista de resultados.
IgnoreCase	Forçar casos insensíveis, mesmo que -csplit seja usado.
IgnorePatternWhitespace	Ignora o espaço branco semscaped e comentários marcados com o sinal de número (#).
Multiline	Este modo reconhece o início e o fim das linhas e cordas. O modo predefinido é Singleline.
RegexMatch	Utilize uma combinação de expressão regular para avaliar o delimiter. Esta é a predefinição.
SimpleMatch	Utilize uma simples comparação de cordas ao avaliar o delimiter.
Linha única	Este modo reconhece apenas o início e o fim das cordas. É o modo predefinido.

O bloco de scripts (§7.1.8) especifica as regras para determinar olimiter, e deve avaliar para escrever bool.

Exemplos:

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

O padrão que está a ser acompanhado por -match, -notmatche -replace pode conter subpartes (chamadas submatches) delimitadas por parênteses. Considere o exemplo seguinte:

"red" -match "red"

O resultado é $true e a chave 0 contém $matches "vermelho", essa parte da corda designada pela ópera esquerda que exatamente correspondia ao padrão designado pela ópera direita.

No seguinte exemplo, todo o padrão é um sub-jogo:

"red" -match "(red)"

Como antes, a chave 0 contém "vermelho"; no entanto, a chave 1 também contém "vermelho", que é a parte da corda designada pela ópera esquerda que exatamente correspondeu ao sub-jogo.

Considere o seguinte, mais complexo, padrão:

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

Este padrão permite subammas de "r", "re", "d" ou "vermelho".

Mais uma vez, a chave 0 contém "vermelho". A chave 1 contém "re", a tecla 2 contém "r", e a chave 3 contém "d". Os pares chave/valor estão em ordem correspondente da esquerda para a direita no padrão, com combinações de cordas mais longas anteriores às mais curtas.

No caso de, o texto de -replacesubstituição pode aceder aos submatches através de nomes do formulário $n, onde é $1o primeiro jogo , o segundo é $3, e assim por diante. Por exemplo,

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

A corda resultante é "a manhã de segunda-feira".

Em vez de ter chaves em $matches índices de base zero, os submumatos podem ser nomeados usando o formulário ?<*name*>. Por exemplo, "((r)e)(d)" pode ser escrito com três submumatches nomeados, m1, m2 e m3, da seguinte forma: "(?<m1>(?<m2>r)e)(?<m3>d)".

7.8.5 Operadores de turno

Descrição:

O operador de turno à esquerda (-shl) e o operador de turno à direita (-shr) convertem o valor desenhado pela ópera esquerda para um tipo inteiro e o valor designado pela ópera direita para int, se necessário, utilizando as habituais conversões aritméticas (§6.15).

O operador de turno à esquerda desloca a ópera esquerda por uma série de bits calculados como descrito abaixo. As posições vazias de baixa ordem estão definidas para zero.

O operador de turno da direita desloca a ópera esquerda para a direita por uma série de bits calculados como descrito abaixo. As partes de baixa ordem da ópera esquerda são descartadas, as partes restantes deslocadas para a direita. Quando a ópera esquerda é um valor assinado, as posições vazias de alta ordem são definidas para zero se a ópera esquerda não for negativa e definida para uma se a ópera esquerda for negativa. Quando a ópera esquerda é um valor não assinado, as posições vazias de alta ordem estão definidas para zero.

Quando a ópera esquerda tem o tipo int, a contagem de turnos é dada pela baixa ordem cinco partes da ópera direita. Quando a ópera certa tem um tipo longo, a contagem de turnos é dada pela baixa ordem seis pedaços da ópera certa.

Exemplos:

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

7.9 Operadores bitwise

Sintaxe:

bitwise-expression:
    comparison-expression
    bitwise-expression -band new-lines~opt~ comparison-expression
    bitwise-expression -bor new-lines~opt~ comparison-expression
    bitwise-expression -bxor new-lines~opt~ comparison-expression

Descrição:

O operador -bandbitwise E , o operador -borbitwise OR , e o bitwise XOR operador -bxor convertem os valores designados pelos seus operands para tipos inteiros, se necessário, utilizando as conversões aritméticas habituais (§6.15). Após a conversão, se ambos os valores tiverem tipo int este é o tipo de resultado. Caso contrário, se ambos os valores tiverem tipo longo, este é o tipo de resultado. Se um valor tiver tipo int e o outro tiver tipo longo, o tipo de resultado é longo. Caso contrário, a expressão está mal formada. O resultado é o bitwise E, bitwise OR, ou bitwise XOR, respectivamente, dos valores opernd possivelmente convertidos.

Estes operadores são deixados associativos. São comutativas se nenhum dos óperas contiver um efeito colateral.

Exemplos:

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 Operadores lógicos

Sintaxe:

logical-expression:
    bitwise-expression
    logical-expression -and new-lines~opt~ bitwise-expression
    logical-expression -or new-lines~opt~ bitwise-expression
    logical-expression -xor new-lines~opt~ bitwise-expression

Descrição:

O operador -and lógico E converte os valores designados pelos seus operáticos para bool, se necessário (§6.2). O resultado é o lógico e dos valores operáticos possivelmente convertidos, e tem tipo bool. Se a ópera esquerda avaliar a False a ópera direita não é avaliada.

O operador -or lógico de OR converte os valores designados pelos seus operands para bool, se necessário (§6.2). O resultado é o OR lógico dos valores operáticos possivelmente convertidos, e tem tipo bool. Se a ópera esquerda avaliar true the right operand is not assessed.

O operador -xor lógico XOR converte os valores designados pelos seus operands para bool (§6.2). O resultado é o XOR lógico dos valores operáticos possivelmente convertidos, e tem tipo bool.

Estes operadores são deixados associativos.

Exemplos:

$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 Operadores de atribuição

Sintaxe:

assignment-expression:
    expression assignment-operator statement

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

Descrição:

Um operador de atribuição armazena um valor no local dedesempreitável designado por expressão. Para uma discussão sobre o operador = de atribuição consulte §7.11.1. Para uma discussão de todos os outros operadores de atribuição consulte §7.11.2.

Uma expressão de atribuição tem o valor designado por expressão após a atribuição; no entanto, esta expressão de atribuição não designa por si só um local dedificável. Se a expressão for limitada por tipo (§5.3), o tipo utilizado nesse constrangimento é o tipo de resultado; caso contrário, o tipo de resultado é o tipo após a aplicação das conversões aritméticas habituais (§6.15).

Este operador tem razão associativo.

7.11.1 Atribuição simples

Descrição:

Na simples atribuição (=), o valor designado por declaração substitui o valor armazenado no local de instrução designado por expressão. No entanto, se a expressão designar uma chave inexistente numa Hashtable, essa chave é adicionada ao Hashtable com um valor associado do valor designado por declaração.

Como mostrado pela gramática, a expressão pode designar uma lista separada de vírgula de locais writáveis. Isto é conhecido como missão múltipla. a declaração designa uma lista de um ou mais valores separados por vírgula. As vírgulas em qualquer uma das listas de ópera fazem parte da sintaxe de atribuição múltipla e não representam o operador binário de vírgula. Os valores são retirados da lista designada por declaração, por ordem lexical, e armazenados no local de instrução correspondente designado por expressão. Se a lista designada por declaração tiver menos valores do que existem locais de expressão , os locais excedentários assumem o valor $null. Se a lista designada por declaração tiver mais valores do que existem locais de expressão , todos, menos a localização de expressão mais correta, assumem o valor de declaração correspondente e o local de expressão mais à direita torna-se uma matriz de 1 dimensão não constrangida com todos os valores de afirmação restantes como elementos.

Para declarações que tenham valores (§8.1.2), a declaração pode ser uma declaração.

Exemplos:

$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 Atribuição composta

Descrição:

Uma atribuição composta tem o formulário E1 op= E2, e é equivalente à expressão E1 = E1 op (E2) de atribuição simples, exceto que no caso de atribuição composta a expressão E1 é avaliada apenas uma vez. Se a expressão for limitada por tipo (§5.3), o tipo utilizado nesse constrangimento é o tipo de resultado; caso contrário, o tipo de resultado é determinado por op. Para *=, ver §7.6.1, §7.6.2, §7.6.3; para /=, ver §7.6.4; para %=, ver §7.6.5; para +=, ver §7.7.1, §7.7.2, §7.7.3; para -=, ver §7.7.5.

Nota

Um operand que designe um valor não constrangido do tipo numérico pode ter o seu tipo alterado por um operador de atribuição quando o resultado é armazenado.

Exemplos:

$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 Operadores de reorientação

Sintaxe:

pipeline:
    assignment-expression
    expression redirections~opt~ pipeline-tail~opt~
    command verbatim-command-argument~opt~ pipeline-tail~opt~

redirections:
    redirection
    redirections redirection

redirection:
    merging-redirection-operator
    file-redirection-operator redirected-file-name

redirected-file-name:
    command-argument
    primary-expression

file-redirection-operator: one of
    >   >>   2>   2>>   3>   3>>   4>   4>>
    5>  5>>  6>   6>>   >    >>    <

merging-redirection-operator: one of
    >&1   2>&1   3>&1   4>&1   5>&1   6>&1
    >&2   1>&2   3>&2   4>&2   5>&2   6>&2

Descrição:

O operador > de reorientação retira a saída padrão do oleoduto e redireciona-a para o local designado por nome de ficheiro redirecionado, sobreescrita do conteúdo atual dessa localização.

O operador >> de reorientação retira a saída padrão do gasoduto e redireciona-a para o local designado por nome de ficheiro redirecionado, apenuando-se ao conteúdo atual dessa localização, se houver. Se essa localização não existir, é criada.

O operador de reorientação com o formulário n> retira a saída do stream n do pipeline e redireciona-o para o local designado por nome de ficheiro redirecionado, sobreescrita do conteúdo atual dessa localização.

O operador de reorientação com o formulário n>> retira a saída do stream n do pipeline e redireciona-o para o local designado por nome de ficheiro redirecionado, anexando ao conteúdo atual dessa localização, se houver. Se essa localização não existir, é criada.

O operador de reorientação com o formulário m>&n escreve a saída do stream m para o mesmo local que o stream n.

Seguem-se os fluxos válidos:

Fluxo	Descrição
1	Fluxo de saída padrão
2	Fluxo de saída de erro
3	Fluxo de saída de aviso
4	Fluxo de saída verboso
5	Fluxo de saída de depurar
*	Saída padrão, saída de erro, saída de aviso, saída verbosa e fluxos de saída de depurante

Os operadores 1>&2de redirecionamento , 6>``6>> e estão < reservados para uso futuro.

Se na saída o valor do nome de ficheiro redirecionado for $null, a saída é descartada.

Normalmente, o valor de uma expressão que contenha um efeito colateral de nível superior não é escrito ao oleoduto a menos que essa expressão seja incluída num par de parênteses. No entanto, se tal expressão for a ópera esquerda de um operador que redireciona a produção padrão, o valor é escrito.

Exemplos:

$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