PowerShell 💠

Este guia é um material de apoio para quem está começando em PowerShell, especialmente para estudantes que já possuem uma base em lógica de programação.

PowerShell é o shell e linguagem de automação da Microsoft, disponível nativamente no Windows (e, desde a versão 7, também em Linux/macOS como PowerShell Core, multiplataforma e open-source). É usado no projeto Saudações em PowerShell deste curso.

🔹 A diferença fundamental em relação ao Bash

Em Bash, tudo que passa entre comandos é texto puro. Em PowerShell, tudo que passa entre comandos é um objeto .NET — com propriedades e métodos de verdade, não texto que precisa ser recortado com cut/grep. Isso torna PowerShell mais parecido com uma linguagem de programação completa do que um shell tradicional.

🛠️ Instalação e Configuração do Ambiente

PowerShell (Windows PowerShell, versão 5.1) já vem instalado por padrão no Windows. Para a versão moderna multiplataforma (PowerShell 7+), baixe o PowerShell Core do site da Microsoft.

Verifique a versão instalada:

$PSVersionTable.PSVersion

🚀 Seu Primeiro Programa em PowerShell

Crie um arquivo chamado:

ola.ps1

Escreva:

Write-Host "Ola, Universo PowerShell!"

Execute no terminal:

./ola.ps1

O resultado será:

Ola, Universo PowerShell!

Análise do Código

Write-Host exibe texto diretamente no console.
Comandos PowerShell seguem o padrão Verbo-Substantivo (Write-Host, Read-Host, Get-Content) — isso torna a biblioteca de comandos bastante previsível uma vez que você aprende os verbos comuns (Get, Set, New, Remove).
Pode ser necessário ajustar a política de execução (Set-ExecutionPolicy) antes de rodar scripts .ps1 pela primeira vez no Windows.

📊 Variáveis

Variáveis em PowerShell sempre começam com $:

$nome = "Ana Souza"
$idade = 25
$salario = 6200.75

Diferente de Bash, pode haver espaço ao redor do =. PowerShell também suporta tipagem explícita, se desejado:

[int]$idade = 25 [string]$nome = "Ana"

🔢 Operadores

Aritméticos

Operador	Significado
`+`	Adição
`-`	Subtração
`*`	Multiplicação
`/`	Divisão
`%`	Resto da divisão

Comparativos

PowerShell usa operadores nomeados (com -), não símbolos como </> para comparação de valores:

Operador	Significado
`-eq`	Igual
`-ne`	Diferente
`-lt`	Menor que
`-gt`	Maior que
`-le`	Menor ou igual
`-ge`	Maior ou igual

if ($idade -ge 18) {
    Write-Host "Maior de idade"
}

Nota: o projeto Saudações usa -lt/-le para a lógica horária, mas dentro de blocos aritméticos simples PowerShell também aceita </<= em alguns contextos — os operadores nomeados são o padrão idiomático.

📤 Saída e 📥 Entrada de Dados

Write-Host "Digite uma hora do dia (formato HH:MM): "
$input = Read-Host Write-Host "Você digitou:$input"

Read-Host lê uma linha do terminal. Repare que strings com $variavel dentro fazem interpolação automática, como em Bash — mas só dentro de aspas duplas; aspas simples tratam o conteúdo como texto literal.

🔀 Validação com Expressão Regular

O projeto Saudações em PowerShell valida o formato HH:MM com o operador -match (veja o tópico de Regex para entender a sintaxe do padrão):

if ($input -notmatch '^([01][0-9]|2[0-3]):([0-5][0-9])$') {
    Write-Host "Formato inválido! Por favor, digite no formato HH:MM."
    exit 1
}

-match/-notmatch são os operadores de regex do PowerShell — o equivalente ao =~ do Bash.

Extraindo partes de uma string

$hour = [int]($input -split ":")[0]
$minute = [int]($input -split ":")[1]

-split ":" divide a string num array usando : como separador — o equivalente PowerShell do split(':') de outras linguagens. [int](...) converte o texto extraído para número.

🔀 Estrutura Condicional

if ($hour -lt 6) { Write-Host "Boa madrugada!" } elseif ($hour -lt 12) {
    Write-Host "Bom dia!"
} elseif ($hour -lt 18) {
    Write-Host "Boa tarde!"
} else {
    Write-Host "Boa noite!"
}

Sintaxe com chaves {}, parecida com C/JavaScript — mais familiar pra quem já viu essas linguagens do que a sintaxe then/fi do Bash.

🔀 Fluxo completo

flowchart TD
    A("Início") --> B["Ler HH:MM com Read-Host"]
    B --> C{"-match bate com o padrao regex?"}
    C -- Não --> E["Formato invalido!"]
    C -- Sim --> F{"hour -lt 6?"}
    F -- Sim --> G["Boa madrugada!"]
    F -- Não --> H{"hour -lt 12?"}
    H -- Sim --> I["Bom dia!"]
    H -- Não --> J{"hour -lt 18?"}
    J -- Sim --> K["Boa tarde!"]
    J -- Não --> L["Boa noite!"]
    G --> M("Fim")
    I --> M
    K --> M
    L --> M
    E --> M
    style A fill:#cfc,stroke:#333,stroke-width:2px
    style M fill:#f99,stroke:#333,stroke-width:2px

🔁 Estruturas de Repetição

# for
for ($i = 1; $i -le 5; $i++) { Write-Host$i
}

# while
$contador = 0 while ($contador -lt 5) {
    Write-Host $contador$contador++
}

# foreach (percorrer coleções)
foreach ($item in @(1, 2, 3)) { Write-Host$item
}

📏 Arrays

$numeros = @(10, 20, 30, 40)

Write-Host $numeros[0] Write-Host$numeros.Length

foreach ($n in $numeros) {
    Write-Host $n
}

🧩 Funções

function Get-Greeting {
    param (
        [string]$input
    )

    if ($input -match "^([01]?[0-9]|2[0-3]):([0-5]?[0-9])$") {
        $hour = [int]($input -split ":")[0]
        if ($hour -lt 12) { return "Bom dia! Você digitou:$input"
        } else {
            return "Boa tarde! Você digitou: $input"
        }
    } else {
        return "Formato inválido! Por favor, digite no formato HH:MM."
    }
}

Get-Greeting -input "08:30"

param(...) declara parâmetros nomeados e tipados — mais parecido com uma linguagem de programação tradicional do que os $1/$2 posicionais do Bash. Funções seguem a mesma convenção Verbo-Substantivo dos comandos nativos (Get-Greeting, não GreetingGetter).

📝 Comentários

# Comentário de uma linha

<#
   Comentário
   de múltiplas linhas
#>

🐞 Depuração (Debugging)

Set-PSDebug -Trace 1

Ativa o modo de rastreamento, imprimindo cada linha executada — similar ao bash -x. Também é possível usar Write-Host "DEBUG: valor = $variavel" para depuração manual, ou breakpoints reais no VS Code com a extensão PowerShell.

⚠️ Erros Comuns de Iniciantes

Usar `<`/`>` para comparação em vez de `-lt`/`-gt`

if ($idade < 18) # ERRO: "<" é redirecionamento, nao comparacao if ($idade -lt 18) # Correto

Em PowerShell, < e > são reservados para redirecionamento de entrada/saída (como em Bash) — comparação numérica sempre usa os operadores nomeados.

Esquecer o `$` na frente do nome da variável

idade = 25          # ERRO: PowerShell tenta interpretar "idade" como comando
$idade = 25          # Correto

Confundir aspas simples e duplas

Write-Host '$nome'   # imprime literalmente "$nome"
Write-Host "$nome"    # imprime o valor de $nome

🧓 E o Batch (.bat/CMD)?

Batch é a linguagem de script mais antiga do Windows — existe desde os tempos do MS-DOS e ainda roda nativamente via cmd.exe, sem precisar instalar nada. PowerShell foi criado justamente para substituir Batch como shell padrão do Windows, mas Batch ainda aparece em scripts de instalação e automação legada, então vale conhecer o essencial:

@echo off
set /a contador=0

:loop
if %contador% geq 5 goto fim
echo %contador%
set /a contador=%contador%+1
goto loop

:fim
echo Terminou!

Batch não tem while nativo — o jeito clássico de repetir código é com rótulos (:nome) e goto, um laço bem mais primitivo que o while/for do PowerShell. Também não tem elif/elseif como palavra única (usa else if, duas palavras), e uma pegadinha clássica: set /a hora=08 trata números com zero à esquerda como octal, então 08/09 se comportam de forma incorreta e silenciosa.

🧠 PowerShell x Bash x Batch

Característica	PowerShell	Bash	Batch
O que passa entre comandos	Objetos .NET	Texto puro	Texto puro
Comparação numérica	`-lt`, `-gt`, `-eq`	`<`, `>`, `-eq` (dentro de `(( ))`)	`lss`, `gtr`, `equ` (letras)
Laço `while` nativo	Sim	Sim	Não (usa `goto`)
Convenção de nomes de comando	Verbo-Substantivo (`Get-Content`)	Nomes curtos tradicionais Unix (`cat`, `ls`)	Comandos internos do `cmd.exe`
Plataforma nativa	Windows (também Linux/macOS via PowerShell 7+)	Linux/macOS (Windows via WSL)	Windows (desde MS-DOS)
Orientação a objetos	Sim (tudo é objeto .NET)	Não (tudo é texto)	Não (tudo é texto)

🎓 Conclusão

PowerShell traz o poder de uma linguagem orientada a objetos completa para dentro do terminal — em vez de recortar texto com cut/grep como em Bash, você manipula propriedades e métodos de objetos .NET reais, e substitui de vez as limitações do Batch legado (sem while, sem funções de verdade). Compare com Bash para ver a mesma lógica de saudação resolvida com duas filosofias de shell bem diferentes.