Os operadores são fundamentais em qualquer linguagem de programação, e no PowerShell não é diferente. Eles permitem realizar cálculos, comparar valores, combinar condições e manipular dados de forma eficiente. Nesta aula, vamos explorar os principais operadores do PowerShell, suas sintaxes, comportamentos específicos e boas práticas de uso.

Dominar os operadores é essencial para escrever scripts claros e funcionais, seja para automação de tarefas administrativas, manipulação de arquivos ou processamento de dados. Vamos começar com os operadores aritméticos, depois os de comparação, lógicos e, por fim, algumas particularidades que tornam o PowerShell único.

Aritméticos

Os operadores aritméticos no PowerShell são usados para realizar operações matemáticas básicas. Eles funcionam com números, mas também podem ser aplicados a outros tipos de dados, como strings e arrays, o que pode gerar resultados interessantes.

A tabela a seguir resume os operadores aritméticos mais comuns:

OperadorDescriçãoExemploResultado
+Soma5 + 38
-Subtração5 - 32
*Multiplicação5 * 315
/Divisão10 / 33.333...
%Módulo (resto da divisão)10 % 31
**Potência2 ** 38

Um aspecto interessante é que o operador + também concatena strings. Por exemplo:

$nome = "João"
$sobrenome = "Silva"
$nomeCompleto = $nome + " " + $sobrenome
Write-Host $nomeCompleto  # Saída: João Silva

Além disso, você pode usar operadores aritméticos com arrays para concatená-los ou realizar operações elemento a elemento (embora isso seja menos comum). Por exemplo:

$array1 = 1,2,3
$array2 = 4,5,6
$soma = $array1 + $array2  # Concatena os arrays: 1,2,3,4,5,6
$soma

É importante lembrar que a divisão por zero gera um erro no PowerShell, então sempre verifique os valores antes de dividir.

Comparação (-eq, -lt, -like)

Os operadores de comparação no PowerShell são utilizados para testar relações entre valores. Eles retornam $true ou $false e são amplamente usados em estruturas condicionais como if e switch.

Ao contrário de muitas linguagens que usam símbolos como ==, o PowerShell adota nomes de operadores que começam com hífen. Os principais são:

  • -eq: igualdade (equal)
  • -ne: diferente (not equal)
  • -gt: maior que (greater than)
  • -ge: maior ou igual (greater or equal)
  • -lt: menor que (less than)
  • -le: menor ou igual (less or equal)
  • -like: correspondência com curinga (wildcard)
  • -notlike: negação do like
  • -match: correspondência com expressão regular
  • -notmatch: negação do match
  • -contains: verifica se uma coleção contém um valor
  • -notcontains: negação do contains

Vejamos exemplos práticos:

$idade = 25
if ($idade -ge 18) {
    Write-Host "Maior de idade"
} else {
    Write-Host "Menor de idade"
}

$fruta = "banana"
if ($fruta -eq "maçã") {
    Write-Host "É uma maçã"
} else {
    Write-Host "Não é uma maçã"
}

# -like com curinga
if ($fruta -like "ba*") {
    Write-Host "Começa com 'ba'"
}

Os operadores de comparação no PowerShell são, por padrão, case-insensitive (não diferenciam maiúsculas de minúsculas). Para diferenciar, você deve usar as versões com c no início: -ceq, -clike, etc. Por exemplo:

"ABC" -eq "abc"  # $true
"ABC" -ceq "abc" # $false

Outro ponto importante: ao comparar arrays, -eq retorna os elementos que correspondem, não um booleano. Por exemplo:

$numeros = 1,2,3,4,5
$resultado = $numeros -gt 3
$resultado  # Retorna 4 e 5 (como uma coleção)

Já -contains verifica se um valor está presente no array e retorna $true ou $false:

$numeros = 1,2,3,4,5
if ($numeros -contains 3) {
    Write-Host "O array contém o número 3"
}

Lógicos (-and, -or)

Os operadores lógicos no PowerShell permitem combinar múltiplas condições em uma única expressão. Eles são essenciais para criar testes mais complexos. Os principais são:

  • -and: verdadeiro se ambas as condições forem verdadeiras.
  • -or: verdadeiro se pelo menos uma condição for verdadeira.
  • -xor: verdadeiro se exatamente uma condição for verdadeira (ou exclusivo).
  • -not ou !: negação lógica.

Exemplo com -and e -or:

$idade = 25
$temCarteira = $true

if ($idade -ge 18 -and $temCarteira) {
    Write-Host "Pode dirigir"
} else {
    Write-Host "Não pode dirigir"
}

$dia = "sábado"
if ($dia -eq "sábado" -or $dia -eq "domingo") {
    Write-Host "É fim de semana"
}

Você pode combinar operadores lógicos para formar condições mais complexas, usando parênteses para agrupar e controlar a precedência:

$usuario = "admin"
$senha = "123"
$ip = "192.168.0.1"

if (($usuario -eq "admin" -and $senha -eq "123") -or $ip -eq "localhost") {
    Write-Host "Acesso permitido"
}

O operador -not é útil para inverter uma condição:

$arquivoExiste = Test-Path "C:\temp\arquivo.txt"
if (-not $arquivoExiste) {
    Write-Host "O arquivo não existe"
}

Lembre-se de que o PowerShell avalia as condições em curto-circuito, ou seja, se a primeira condição já determina o resultado, a segunda não é avaliada. Por exemplo, em $false -and (1/0), a divisão não ocorre, evitando erro.

Particularidades

O PowerShell possui algumas particularidades em relação aos operadores que merecem destaque:

  • Comparação de strings é case-insensitive por padrão, mas você pode usar as variantes com c para tornar sensível a maiúsculas/minúsculas.
  • Operador -like usa curingas como * (qualquer sequência) e ? (um caractere). Já -match usa expressões regulares completas.
  • Em expressões booleanas, o PowerShell aceita qualquer valor como booleano: $null, 0, string vazia e $false são considerados falsos; qualquer outro valor é verdadeiro.
  • O operador -eq com arrays retorna os elementos correspondentes, não um booleano. Para obter um booleano, use -contains ou .Contains().
  • Atribuição com = é diferente de comparação; em if ($x = 5) o valor 5 é atribuído a $x e a condição é sempre verdadeira (pois 5 é considerado verdadeiro). Use -eq para comparar.

Além disso, o PowerShell permite usar operadores de atribuição compostos, como +=, -=, *=, /=, %=, que combinam uma operação aritmética com a atribuição:

$total = 100
$total += 50  # $total = $total + 50 = 150
$total -= 20  # $total = 130
$total *= 2   # $total = 260
Write-Host $total

Outra particularidade é que o PowerShell suporta operadores unários, como ++ e -- para incremento e decremento:

$contador = 0
$contador++  # $contador = 1
$contador--  # $contador = 0

Por fim, vale mencionar que os operadores -is e -isnot são usados para testar o tipo de um objeto:

$numero = 42
if ($numero -is [int]) {
    Write-Host "É um inteiro"
}

Esses são alguns dos operadores e comportamentos que tornam o PowerShell expressivo e poderoso para automação.

Boas Práticas e Observações

Ao usar operadores no PowerShell, siga estas boas práticas:

  • Use parênteses para agrupar condições compostas e evitar ambiguidades.
  • Preferir -eq em vez de = em condições para não confundir atribuição.
  • Esteja ciente da diferença entre -like e -match: use -like para padrões simples com curingas e -match para expressões regulares.
  • Evite comparar $null com -eq em arrays, pois o resultado pode ser inesperado; use -contains $null ou .Contains().
  • Quando testar se uma variável é $null, use $null -eq $variavel em vez de $variavel -eq $null para evitar problemas quando a variável for um array.

Essas práticas tornarão seus scripts mais legíveis e menos propensos a erros.

Exercícios

  1. Escreva um script que calcule a área de um retângulo. Solicite ao usuário a largura e a altura, armazene em variáveis e exiba o resultado usando o operador de multiplicação.

    2. ✓ Resposta:
    $largura = Read-Host "Digite a largura"
$altura = Read-Host "Digite a altura"
$area = $largura * $altura
Write-Host "A área do retângulo é: $area"
  2. Dada uma variável $idade, use operadores de comparação para verificar se a pessoa é maior de idade (18 anos ou mais) e exiba uma mensagem adequada.

    3. ✓ Resposta:
    $idade = 20
if ($idade -ge 18) {
    Write-Host "Você é maior de idade."
} else {
    Write-Host "Você é menor de idade."
}
  3. Crie uma lista de nomes e use o operador -like para encontrar todos os nomes que começam com a letra "A".

    4. ✓ Resposta:
    $nomes = "Ana", "Bruno", "Carlos", "Alice", "André"
$nomesComA = $nomes -like "A*"
$nomesComA
  4. Use operadores lógicos para verificar se um número é divisível por 3 e por 5 ao mesmo tempo (ou seja, divisível por 15).

    5. ✓ Resposta:
    $numero = 30
if (($numero % 3 -eq 0) -and ($numero % 5 -eq 0)) {
    Write-Host "O número é divisível por 3 e por 5."
} else {
    Write-Host "O número não é divisível por 3 e por 5."
}
  5. Escreva um script que verifique se uma string fornecida pelo usuário é vazia ou nula, e exiba uma mensagem apropriada.

    6. ✓ Resposta:
    $entrada = Read-Host "Digite algo"
if ([string]::IsNullOrEmpty($entrada)) {
    Write-Host "A entrada é vazia ou nula."
} else {
    Write-Host "Você digitou: $entrada"
}

Referências