about_Operators

Breve descrição

Descreve os operadores suportados pelo PowerShell.

Descrição longa

Um operador é um elemento de linguagem que você pode usar em um comando ou expressão. O PowerShell oferece 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, , , StringDateTimeHashtablee Arrays.

Os operadores bitwise (-band, , , -bor-bnot-bxor, , -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-lt-gt, , -le-ge) para 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 (-match-like, -notlike-notmatch-replace) usam curingas.*

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 tipos (-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, , , -not-or-xor, !) 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 saída de Out-File 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

Operadores de divisão e junção

Os -split operadores e dividem e -join combinam substrings. O -split operador divide uma cadeia de caracteres em substrings. 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 Unary

Use o unário ++ e os operadores para incrementar 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 executar comandos, alterar o tipo de dados de um valor ou recuperar elementos de uma matriz.

Operador de agrupamento ( )

Como em outras línguas, (...) 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 resultados

(...) 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, envolver 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 do pipeing também garante que o processamento subsequente objeto a objeto não possa interferir com a enumeração que o comando usa para produzir sua saída.

Agrupando instruções de atribuição

As instruções de atribuição não agrupadas 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 produz 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 decréscimo (++--). No entanto, a ordem de operação para incremento e decréscimo depende da 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 saída. No caso do postfix, o valor de é incrementado após ser produzido $i .

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 ao $textFiles, que é considerado $false em um contexto booleano. Se um ou mais objetos FileInfo forem atribuídos a , a $textFilescondicional será avaliada como $true. Você pode trabalhar com o valor de $textFiles no corpo da if declaração.

Nota

Embora esta técnica seja conveniente e concisa, pode levar a confusão entre o operador de atribuição () e o operador de comparação de igualdade (=-eq).

Operador de subexpressão $( )

Devolve 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 incorporar 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 hash @{}

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

Operador de chamadas &

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.

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

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 dentro de uma cadeia de caracteres quando usa 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 .ps1 extensão de 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 executar 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. Este 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 & plano de fundo retorna um Job objeto. Este 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 em segundo plano também é um terminador de instruções, 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 fundição [ ]

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 transmissão também pode ser executada quando uma variável é atribuída ao uso da notação de transmissã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)

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

Operador de dot sourcing .

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

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

Nota

O operador de dot sourcing é seguido por um espaço. Use o espaço para distinguir o ponto do símbolo de ponto (.) que representa o diretório atual.

No exemplo a seguir, o script Sample.ps1 no diretório atual é executado no escopo atual.

. .\sample.ps1

Operador de formato -f

Formata cadeias de caracteres usando o método format de objetos string. Insira a cadeia de caracteres de formato 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 zero-pad um valor numérico com o especificador personalizado "0". O número de zeros a seguir indica : a largura máxima para inserir 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 formatada, você pode escapar delas dobrando as chaves encaracoladas.

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

Para obter mais informações, consulte o método String.Format e Formatação composta.

Operador de índice [ ]

Seleciona objetos de coleções indexadas, como matrizes e tabelas 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 hash são indexadas pelo valor 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 de índice 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 gasoduto |

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 de pipeline envia os objetos um de cada vez.

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

Operadores de cadeias de oleodutos && 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 gama ..

O operador range pode ser usado para representar uma matriz de inteiros sequenciais ou caracteres. Os valores unidos pelo operador de intervalo definem os valores de início e fim do intervalo.

Nota

O suporte para intervalos de caracteres foi adicionado no PowerShell 6.

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

Para criar um intervalo de caracteres, coloque-os 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 atribuindo 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 são 99 e X 88, respectivamente. Esse intervalo seria apresentado por ordem inversa.

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

Os valores de início e fim do intervalo podem ser qualquer par de expressões avaliadas como um inteiro ou um caractere. Por exemplo, você pode usar os membros de uma enumeração para seus valores de início e fim.

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

Importante

O intervalo resultante não está limitado aos valores da enumeração. Em vez disso, representa o intervalo de valores entre os dois valores fornecidos. Não é possível usar o operador range para representar de forma confiável os membros de uma enumeração.

Operador de acesso a membros .

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

Iniciando o PowerShell 3.0, quando você usa o operador em um objeto de coleção de lista que não tem o membro, o PowerShell enumera automaticamente os itens dessa 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 métodos de uma classe .NET. Para localizar as propriedades estáticas e os métodos de um objeto, use o parâmetro Static do Get-Member 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 coalescência nula ??

O operador ?? de coalescência nula retorna o valor de seu operando esquerdo se ele não for nulo. Caso contrário, ele avalia o operando direito e retorna seu resultado. O ?? operador não avalia seu operando direito se o operando esquerdo for avaliado como não-nulo.

$x = $null
$x ?? 100
100

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

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

Operador de atribuição de coalescência nula ??=

O operador ??= de atribuição de coalescência nula atribui o valor de seu operando direito ao seu operando esquerdo somente se o operando esquerdo for avaliado como nulo. O ??= operador não avalia seu operando direito se o operando esquerdo for avaliado como não-nulo.

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

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

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

Operadores ?. condicionais nulos e ?[]

Nota

Esse recurso foi movido de experimental para mainstream no PowerShell 7.1.

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

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

Nota

A sintaxe do nome da variável não deve ser confundida com o $() operador de ${<name>} subexpressão. Para obter mais informações, consulte a seção Nome da variável do about_Variables.

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]

Consulte também