about_Operators

Descrição breve

Descreve os operadores compatíveis com o PowerShell.

Descrição longa

Um operador é um elemento de linguagem que você pode usar em um comando ou expressão. O PowerShell dá suporte a vários tipos de operadores para ajudá-lo a manipular valores.

Operadores aritméticos

Use operadores aritméticos (+, -, *, /, , %) para calcular valores em um comando ou expressão. Com esses operadores, você pode adicionar, subtrair, multiplicar ou dividir valores e calcular o restante (módulo) de uma operação de divisão.

O operador de adição concatena elementos. O operador de multiplicação retorna o número especificado de cópias de cada elemento. Você pode usar operadores aritméticos em qualquer tipo .NET que os implemente, como: Int, String, DateTime, Hashtable, e Arrays.

Operadores bit a bit (-band, -bor, -bxor, -bnot, -shl, -shr) manipulam os padrões de bits em valores.

Para obter mais informações, consulte about_Arithmetic_Operators.

Operadores de Atribuição

Use operadores de atribuição (=, +=, -=, *=, /=, ) %=para atribuir, alterar ou acrescentar valores a variáveis. Você pode combinar operadores aritméticos com atribuição para atribuir o resultado da operação aritmética a uma variável.

Para obter mais informações, consulte about_Assignment_Operators.

Operadores de comparação

Use operadores de comparação (-eq, -ne, -gt, -lt, -le, , ) -gepara comparar valores e condições de teste. Por exemplo, você pode comparar dois valores de cadeia de caracteres para determinar se eles são iguais.

Os operadores de comparação também incluem operadores que localizam ou substituem padrões no texto. Os operadores (, , ) usam expressões regulares e (-like, -notlike) usam curingas*. -replace-notmatch-match

Os operadores de comparação de contenção determinam se um valor de teste aparece em um conjunto de referência (-in, -notin, -contains, -notcontains).

Os operadores de comparação de tipo (-is, -isnot) determinam se um objeto é de um determinado tipo.

Para obter mais informações, consulte about_Comparison_Operators.

Operadores lógicos:

Use operadores lógicos (-and, -or, -xor, -not, !) para conectar instruções condicionais em uma única condicional complexa. Por exemplo, você pode usar um operador lógico -and para criar um filtro de objeto com duas condições diferentes.

Para obter mais informações, consulte about_Logical_Operators.

Operadores de redirecionamento

Use operadores de redirecionamento (>, >>, 2>, 2>>, e 2>&1) para enviar a saída de um comando ou expressão para um arquivo de texto. Os operadores de redirecionamento funcionam como o cmdlet (sem parâmetros), mas também permitem redirecionar a Out-File saída de erro para arquivos especificados. Você também pode usar o cmdlet para redirecionar a Tee-Object saída.

Para obter mais informações, consulte about_Redirection

Dividir e unir operadores

Os -split operadores and -join dividem e combinam substrings. O -split operador divide uma cadeia de caracteres em subcadeias de caracteres. O -join operador concatena várias cadeias de caracteres em uma única cadeia de caracteres.

Para obter mais informações, consulte about_Split e about_Join.

Operadores de tipo

Use os operadores de tipo (-is, -isnot, -as) para localizar ou alterar o tipo .NET de um objeto.

Para obter mais informações, consulte about_Type_Operators.

Operadores unários

Use os operadores unário ++ e -- para aumentar ou diminuir valores e - para negação. Por exemplo, para incrementar a variável $a de 9 para 10, digite $a++.

Para obter mais informações, consulte about_Arithmetic_Operators.

Operadores Especiais

Os operadores especiais têm casos de uso específicos que não se encaixam em nenhum outro grupo de operadores. Por exemplo, operadores especiais permitem que você execute comandos, altere o tipo de dados de um valor ou recupere elementos de uma matriz.

Operador de agrupamento ( )

Como em outras linguagens, (...) serve para substituir a precedência do operador em expressões. Por exemplo: (1 + 2) / 3

No entanto, no PowerShell, há comportamentos adicionais.

Agrupando expressões de resultado

(...) permite que você permita que a saída de um comando participe de uma expressão. Por exemplo:

PS> (Get-Item *.txt).Count -gt 10
True

Expressões agrupadas de tubulação

Quando usado como o primeiro segmento de um pipeline, encapsular um comando ou expressão entre parênteses invariavelmente causa a enumeração do resultado da expressão. Se os parênteses encapsularem um comando, ele será executado até a conclusão com toda a saída coletada na memória antes que os resultados sejam enviados pelo pipeline.

Agrupar uma expressão antes da canalização também garante que o processamento subsequente objeto por objeto não possa interferir na enumeração que o comando usa para produzir sua saída.

Agrupando instruções de atribuição

Instruções de atribuição desagrupadas não geram valores. Ao agrupar uma instrução de atribuição, o valor da variável atribuída é passado e pode ser usado em expressões maiores. Por exemplo:

PS> ($var = 1 + 2)
3
PS> ($var = 1 + 2) -eq 3
True

Envolver a instrução entre parênteses a transforma em uma expressão que gera o valor de $var.

Esse comportamento se aplica a todos os operadores de atribuição, incluindo operadores compostos como +=, e os operadores de incremento (++) e decremento (--). No entanto, a ordem de operação para incremento e decréscimo depende de sua posição.

PS> $i = 0
PS> (++$i) # prefix
1
PS> $i = 0
PS> ($i++) # postfix
0
PS> $i
1

No caso do prefixo, o valor de é incrementado antes de $i ser gerado. No caso do sufixo, o valor de é incrementado $i após a saída.

Você também pode usar essa técnica no contexto de uma instrução condicional, como a if instrução.

if ($textFiles = Get-ChildItem *.txt) {
    $textFiles.Count
}

Neste exemplo, se nenhum arquivo corresponder, o Get-ChildItem comando não retornará nada e não atribuirá nada a $textFiles, que é considerado $false em um contexto booleano. Se um ou mais objetos FileInfo forem atribuídos a $textFiles, a condicional será avaliada como $true. Você pode trabalhar com o valor de $textFiles no corpo da if instrução.

Operador de subexpressão $( )

Retorna o resultado de uma ou mais instruções. Para um único resultado, retorna um escalar. Para vários resultados, retorna uma matriz. Use isso quando quiser usar uma expressão dentro de outra expressão. Por exemplo, para inserir os resultados do comando em uma expressão de cadeia de caracteres.

PS> "Today is $(Get-Date)"
Today is 12/02/2019 13:15:20

PS> "Folder list: $((dir c:\ -dir).Name -join ', ')"
Folder list: Program Files, Program Files (x86), Users, Windows

Operador de subexpressão de matriz @( )

Retorna o resultado de uma ou mais instruções como uma matriz. O resultado é sempre uma matriz de 0 ou mais objetos.

PS> $list = @(Get-Process | Select-Object -First 10; Get-Service | Select-Object -First 10 )
PS> $list.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array

PS> $list.Count
20
PS> $list = @(Get-Service | Where-Object Status -eq Starting )
PS> $list.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array

PS> $list.Count
0

Sintaxe literal da tabela de hash @{}

Semelhante à subexpressão de matriz, essa sintaxe é usada para declarar uma tabela de hash. Para obter mais informações, consulte about_Hash_Tables.

Operador de chamada &

Executa um comando, script ou bloco de script. O operador de chamada, também conhecido como operador de invocação, permite executar comandos armazenados em variáveis e representados por cadeias de caracteres ou blocos de script. O operador de chamada é executado em um escopo filho. Para obter mais informações sobre escopos, consulte about_Scopes. Você pode usar isso para criar cadeias de caracteres contendo o comando, os parâmetros e os argumentos necessários e, em seguida, invocar a cadeia de caracteres como se fosse um comando. As cadeias de caracteres que você cria devem seguir as mesmas regras de análise de um comando digitado na linha de comando. Para obter mais informações, consulte about_Parsing.

Este exemplo armazena um comando em uma cadeia de caracteres e o executa usando o operador de chamada.

PS> $c = "get-executionpolicy"
PS> $c
get-executionpolicy
PS> & $c
AllSigned

O operador de chamada não analisa cadeias de caracteres. Isso significa que você não pode usar parâmetros de comando em uma cadeia de caracteres ao usar o operador de chamada.

PS> $c = "Get-Service -Name Spooler"
PS> $c
Get-Service -Name Spooler
PS> & $c
& : The term 'Get-Service -Name Spooler' is not recognized as the name of a
cmdlet, function, script file, or operable program. Check the spelling of
the name, or if a path was included, verify that the path is correct and
try again.

O cmdlet Invoke-Expression pode executar código que causa erros de análise ao usar o operador de chamada.

PS> & "1+1"
&: The term '1+1' is not recognized as a name of a cmdlet, function, script
file, or executable program. Check the spelling of the name, or if a path was
included, verify that the path is correct and try again.

PS> Invoke-Expression "1+1"
2

Você pode executar um script usando seu nome de arquivo. Um arquivo de script deve ter uma extensão de .ps1 arquivo para ser executável. Os arquivos que têm espaços em seu caminho devem ser colocados entre aspas. Se você tentar executar o caminho entre aspas, o PowerShell exibirá o conteúdo da cadeia de caracteres entre aspas em vez de executar o script. O operador de chamada permite que você execute o conteúdo da cadeia de caracteres que contém o nome do arquivo.

PS C:\Scripts> Get-ChildItem

    Directory: C:\Scripts


Mode                LastWriteTime         Length Name
----                -------------         ------ ----
-a----        8/28/2018   1:36 PM             58 script name with spaces.ps1

PS C:\Scripts> ".\script name with spaces.ps1"
.\script name with spaces.ps1
PS C:\Scripts> & ".\script name with spaces.ps1"
Hello World!

Para obter mais informações sobre blocos de script, consulte about_Script_Blocks.

Operador em segundo plano &

Executa o pipeline antes dele em segundo plano, em um trabalho do PowerShell. Esse operador age de forma semelhante ao operador de controle UNIX e comercial (&), que executa o comando antes dele de forma assíncrona no subshell como um trabalho.

Este operador é funcionalmente equivalente a Start-Job. Por padrão, o operador em segundo plano inicia os trabalhos no diretório de trabalho atual do chamador que iniciou as tarefas paralelas. O exemplo a seguir demonstra o uso básico do operador de trabalho em segundo plano.

Get-Process -Name pwsh &

Esse comando é funcionalmente equivalente ao seguinte uso de Start-Job:

Start-Job -ScriptBlock {Get-Process -Name pwsh}

Assim como Start-Job, o & operador de fundo retorna um Job objeto. Esse objeto pode ser usado com Receive-Job e Remove-Job, como se você tivesse usado Start-Job para iniciar o trabalho.

$job = Get-Process -Name pwsh &
Receive-Job $job -Wait

 NPM(K)    PM(M)      WS(M)     CPU(s)      Id  SI ProcessName
 ------    -----      -----     ------      --  -- -----------
      0     0.00     221.16      25.90    6988 988 pwsh
      0     0.00     140.12      29.87   14845 845 pwsh
      0     0.00      85.51       0.91   19639 988 pwsh

Remove-Job $job

O & operador de fundo também é um terminador de instrução, assim como o operador de controle UNIX e comercial (&). Isso permite que você invoque comandos adicionais após o & operador em segundo plano. O exemplo a seguir demonstra a invocação de comandos adicionais após o & operador em segundo plano.

$job = Get-Process -Name pwsh & Receive-Job $job -Wait

 NPM(K)    PM(M)      WS(M)     CPU(s)      Id  SI ProcessName
 ------    -----      -----     ------      --  -- -----------
      0     0.00     221.16      25.90    6988 988 pwsh
      0     0.00     140.12      29.87   14845 845 pwsh
      0     0.00      85.51       0.91   19639 988 pwsh

Isso é equivalente ao seguinte script:

$job = Start-Job -ScriptBlock {Get-Process -Name pwsh}
Receive-Job $job -Wait

Se você quiser executar vários comandos, cada um em seu próprio processo em segundo plano, mas todos em uma linha, basta colocar & entre e depois de cada um dos comandos.

Get-Process -Name pwsh & Get-Service -Name BITS & Get-CimInstance -ClassName Win32_ComputerSystem &

Para obter mais informações sobre trabalhos do PowerShell, consulte about_Jobs.

Operador de elenco [ ]

Converte ou limita objetos ao tipo especificado. Se os objetos não puderem ser convertidos, o PowerShell gerará um erro.

[DateTime] '2/20/88' - [DateTime] '1/20/88' -eq [TimeSpan] '31'

Uma conversão também pode ser executada quando uma variável é atribuída ao uso da notação de conversão.

Operador de vírgula ,

Como um operador binário, a vírgula cria uma matriz ou acrescenta à matriz que está sendo criada. No modo de expressão, como um operador unário, a vírgula cria uma matriz com apenas um membro. Coloque a vírgula antes do membro.

$myArray = 1,2,3
$SingleArray = ,1
Write-Output (,1)

Como Write-Output espera um argumento, você deve colocar a expressão entre parênteses.

Operador de ponto sourcing .

Executa um script no escopo atual para que todas as funções, aliases e variáveis que o script cria sejam adicionadas ao escopo atual, substituindo as existentes. Os parâmetros declarados pelo script tornam-se variáveis. Parâmetros para os quais nenhum valor foi fornecido tornam-se variáveis sem valor. No entanto, a variável $args automática é preservada.

. c:\scripts\sample.ps1 1 2 -Also:3

. .\sample.ps1

Operador de formato -f

Forneça acesso ao recurso de formatação composta do .NET. Uma cadeia de caracteres de formato composto consiste em texto fixo misturado com espaços reservados indexados, chamados de itens de formato. Esses itens de formato correspondem aos objetos na lista.

Cada item de formato assume a forma a seguir e consiste nos seguintes componentes:

{index[,alignment][:formatString]}

As chaves correspondentes ({ e }) são necessárias.

A operação de formatação produz uma cadeia de caracteres de resultado que consiste no texto fixo original intercalado com a representação de cadeia de caracteres dos objetos na lista. Para obter mais informações, veja Formatação de composição.

Insira a cadeia de caracteres de formato composto no lado esquerdo do operador e os objetos a serem formatados no lado direito do operador.

"{0} {1,-10} {2:N}" -f 1,"hello",[math]::pi

1 hello      3.14

Você pode zerar um valor numérico com o especificador personalizado "0". O número de zeros após o : indica a largura máxima para preencher a cadeia de caracteres formatada.

"{0:00} {1:000} {2:000000}" -f 7, 24, 365

07 024 000365

Se você precisar manter as chaves ({}) na cadeia de caracteres formatada, poderá escapar delas dobrando as chaves.

"{0} vs. {{0}}" -f 'foo'

foo vs. {0}

Operador de índice [ ]

Seleciona objetos de coleções indexadas, como matrizes e tabelas de hash. Os índices de matriz são baseados em zero, portanto, o primeiro objeto é indexado como [0]. Você também pode usar índices negativos para obter os últimos valores. As tabelas de hash são indexadas por valor de chave.

Dada uma lista de índices, o operador de índice retorna uma lista de membros correspondentes a esses índices.

PS> $a = 1, 2, 3
PS> $a[0]
1
PS> $a[-1]
3
PS> $a[2, 1, 0]
3
2
1

(Get-HotFix | Sort-Object installedOn)[-1]

$h = @{key="value"; name="PowerShell"; version="2.0"}
$h["name"]

PowerShell

$x = [xml]"<doc><intro>Once upon a time...</intro></doc>"
$x["doc"]

intro
-----
Once upon a time...

Quando um objeto não é uma coleção indexada, usar o operador index para acessar o primeiro elemento retorna o próprio objeto. Os valores de índice além do primeiro elemento retornam $null.

PS> (2)[0]
2
PS> (2)[-1]
2
PS> (2)[1] -eq $null
True
PS> (2)[0,0] -eq $null
True

Operador de tubulação |

Envia ("pipes") a saída do comando que o precede para o comando que o segue. Quando a saída inclui mais de um objeto (uma "coleção"), o operador do pipeline envia os objetos um de cada vez.

Get-Process | Get-Member
Get-Service | Where-Object {$_.StartType -eq 'Automatic'}

Operadores && de cadeia de dutos e ||

Execute condicionalmente o pipeline do lado direito com base no sucesso do pipeline do lado esquerdo.

# If Get-Process successfully finds a process called notepad,
# Stop-Process -Name notepad is called
Get-Process notepad && Stop-Process -Name notepad

# If npm install fails, the node_modules directory is removed
npm install || Remove-Item -Recurse ./node_modules

Para obter mais informações, consulte About_Pipeline_Chain_Operators.

Operador de intervalo ..

O operador de intervalo pode ser usado para representar uma matriz de inteiros ou caracteres sequenciais. Os valores unidos pelo operador de intervalo definem os valores inicial e final do intervalo.

Intervalos de números

1..10
$max = 10
foreach ($a in 1..$max) {Write-Host $a}

Você também pode criar intervalos na ordem inversa.

10..1
5..-5 | ForEach-Object {Write-Output $_}

Os valores inicial e final do intervalo podem ser qualquer par de expressões avaliadas como um inteiro ou um caractere. Os pontos de extremidade do intervalo devem ser conversíveis em inteiros de 32 bits assinados ([int32]). Valores maiores causam um erro. Além disso, se o intervalo for capturado em uma matriz, o tamanho da matriz resultante será limitado a [int]::MaxValue - 56. Esse é o tamanho máximo de uma matriz no .NET.

Por exemplo, você pode usar os membros de uma enumeração para seus valores inicial e final.

PS> enum Food {
      Apple
      Banana = 3
      Kiwi = 10
    }
PS> [Food]::Apple..[Food]::Kiwi
0
1
2
3
4
5
6
7
8
9
10

Intervalos de caracteres

Para criar um intervalo de caracteres, coloque os caracteres entre aspas.

PS> 'a'..'f'
a
b
c
d
e
f

PS> 'F'..'A'
F
E
D
C
B
A

Se você atribuir um intervalo de caracteres a uma cadeia de caracteres, ele será tratado da mesma forma ao atribuir uma matriz de caracteres a uma cadeia de caracteres.

PS> [string]$s = 'a'..'e'
$s
a b c d e
$a = 'a', 'b', 'c', 'd', 'e'
$a
a b c d e

Os caracteres na matriz são unidos em uma cadeia de caracteres. Os caracteres são separados pelo valor da variável de $OFS preferência. Para obter mais informações, consulte about_Preference_Variables.

A ordem dos caracteres na matriz é determinada pelo valor ASCII do caractere. Por exemplo, os valores ASCII de c e X são 99 e 88, respectivamente. Esse intervalo seria apresentado na ordem inversa.

PS> 'c'..'X'
c
b
a
`
_
^
]
\
[
Z
Y
X

Operador de acesso de membro .

Acessa as propriedades e os métodos de um objeto. O nome do membro pode ser uma expressão.

$myProcess.peakWorkingSet
(Get-Process PowerShell).kill()
'OS', 'Platform' | Foreach-Object { $PSVersionTable. $_ }

A partir do PowerShell 3.0, quando você usa o operador em um objeto de coleção de listas que não tem o membro, o PowerShell enumera automaticamente os itens nessa coleção e usa o operador em cada um deles. Para obter mais informações, consulte about_Member-Access_Enumeration.

Operador de membro estático ::

Chama as propriedades estáticas e os métodos de uma classe .NET. Para localizar as propriedades estáticas e os métodos de um objeto, use o Get-Member parâmetro Static do cmdlet. O nome do membro pode ser uma expressão.

[datetime]::Now
'MinValue', 'MaxValue' | Foreach-Object { [int]:: $_ }

Operador ternário ? <if-true> : <if-false>

Você pode usar o operador ternário como um substituto para a if-else instrução em casos condicionais simples.

Para obter mais informações, consulte about_If.

Operador de avaliação de nulo ??

O operador de avaliação de nulo ?? retorna o valor do seu operando esquerdo caso não seja nulo. Caso contrário, ele avalia o operando do lado direito e retorna seu resultado. O operador ?? não avaliará o operando do lado direito se o operando esquerdo for avaliado como não nulo.

$x = $null
$x ?? 100

100

No exemplo a seguir, o operando à direita não será avaliado.

[string] $todaysDate = '1/10/2020'
$todaysDate ?? (Get-Date).ToShortDateString()

1/10/2020

Operador de atribuição de avaliação de nulo ??=

O operador de atribuição de avaliação de nulo ??= atribuirá o valor do operando do lado direito para o operando esquerdo somente se o operando esquerdo for avaliado como nulo. O operador ??= não avaliará o operando do lado direito se o operando esquerdo for avaliado como não nulo.

$x = $null
$x ??= 100
$x

100

No exemplo a seguir, o operando à direita não será avaliado.

[string] $todaysDate = '1/10/2020'
$todaysDate ??= (Get-Date).ToShortDateString()
$todaysDate

1/10/2020

Operadores condicionais nulos ?. e ?[]

Um operador condicional nulo aplicará uma operação de acesso de membro ?. ou de acesso de elemento ?[] ao operando somente se esse operando for avaliado como não nulo; caso contrário, ele retornará nulo.

Como o PowerShell permite que ? faça parte do nome da variável, é necessária uma especificação formal do nome da variável para usar esses operadores. Você deve usar chaves ({}) em torno dos nomes das variáveis como ${a} ou when ? faz parte do nome ${a?}da variável .

No exemplo a seguir, o valor de PropName é retornado.

$a = @{ PropName = 100 }
${a}?.PropName

100

O exemplo a seguir retorna null sem tentar acessar o nome do membro PropName.

$a = $null
${a}?.PropName

Neste exemplo, o valor do elemento indexado é retornado.

$a = 1..10
${a}?[0]

1

O exemplo a seguir retorna null sem tentar acessar o elemento indexado.

$a = $null
${a}?[0]

Confira também

• about_Arithmetic_Operators
• about_Assignment_Operators
• about_Comparison_Operators
• about_Logical_Operators
• about_Operator_Precedence
• about_Member-Access_Enumeration
• about_Type_Operators
• about_Split
• about_Join
• about_Redirection