Nesta aula, vamos mergulhar no universo das variáveis no PowerShell, um dos conceitos mais importantes para qualquer script. As variáveis são como "caixas" que armazenam informações que podem ser usadas e manipuladas ao longo do seu código. Dominar o uso de variáveis é essencial para escrever scripts dinâmicos, que respondem a mudanças de contexto e entrada do usuário.

O PowerShell adota uma abordagem única: as variáveis são identificadas pelo prefixo $ e, por padrão, são dinâmicas, ou seja, podem mudar de tipo durante a execução. No entanto, também podemos especificar tipos fixos para garantir maior controle. Além disso, o PowerShell já vem com uma série de variáveis automáticas que fornecem informações sobre o ambiente e o estado do console. Vamos explorar cada um desses aspectos a seguir.

Declaração ($var)

A declaração de uma variável no PowerShell é simples: basta usar o símbolo $ seguido de um nome. O PowerShell permite que você crie uma variável e atribua um valor na mesma linha, ou que declare sem valor (neste caso, ela recebe $null). O nome da variável deve começar com $ e pode incluir letras, números e sublinhado, mas não pode conter espaços ou caracteres especiais como . ou -.

É importante destacar que o PowerShell não exige declaração explícita: a primeira atribuição já cria a variável. No entanto, você pode usar New-Variable para criar com opções adicionais (como readonly ou constante). Vamos ver exemplos práticos de declaração.

# Atribuição direta
$nome = "Maria"
$idade = 30

# Variável sem valor inicial
$cidade

# Variável com valor nulo explícito
$cep = $null

# Criando variável com New-Variable
New-Variable -Name "pais" -Value "Brasil"

# Exibindo valores
Write-Host "Nome: $nome, Idade: $idade, Cidade: $cidade"

Observe que, ao tentar exibir $cidade, nada será mostrado, pois ela está como $null. Para verificar se uma variável existe, você pode usar Test-Path com o caminho da variável (por exemplo, Test-Path variable:nome).

Uma boa prática é usar nomes descritivos e consistentes, como $nomeUsuario ou $totalVendas. Evite nomes vagos como $a ou $x.

Tipagem

O PowerShell é uma linguagem de tipagem dinâmica, o que significa que as variáveis não têm um tipo fixo por padrão. Você pode atribuir um número a uma variável e depois atribuir uma string a ela sem erro. No entanto, o PowerShell também oferece tipagem forte opcional, permitindo que você restrinja o tipo de dados que uma variável pode armazenar.

Para declarar uma variável com tipo específico, você usa a sintaxe [tipo]$variavel. Os tipos mais comuns são [int], [string], [double], [bool], [datetime] e [array]. Ao fazer isso, o PowerShell tentará converter o valor atribuído para o tipo especificado; se não for possível, lançará um erro.

# Tipagem dinâmica
$valor = 10
Write-Host $valor
$valor = "dez"
Write-Host $valor

# Tipagem forte
[int]$numero = 5
$numero = "7"  # Converte para inteiro (7)
Write-Host $numero

# Tentativa de atribuição inválida
# $numero = "abc"  # Isso gera um erro

# Verificando o tipo com GetType()
$texto = "Olá"
Write-Host $texto.GetType()  # System.String

Além disso, você pode usar a classe [System.Convert] ou métodos como ToInt32() para converter tipos manualmente, se necessário. Por exemplo: $valor = [System.Convert]::ToInt32("123").

É recomendável usar tipagem forte em scripts onde a segurança e a clareza são importantes, pois evita erros sutis de conversão e torna o código mais legível.

Variáveis automáticas

O PowerShell inclui um conjunto de variáveis automáticas que são mantidas pelo próprio PowerShell e fornecem informações sobre o ambiente de execução, o estado do console e a sessão atual. Essas variáveis são definidas pelo PowerShell e não devem ser sobrescritas, pois são usadas internamente. Conhecê-las ajuda a criar scripts mais robustos e dinâmicos.

Algumas das variáveis automáticas mais úteis são: $HOME (diretório inicial do usuário), $PSVersionTable (informações sobre a versão do PowerShell), $PWD (diretório atual), $PID (identificador do processo atual), $args (argumentos passados para um script ou função), e $_ (representa o objeto atual no pipeline). Vamos ver um exemplo prático de uso.

# Exibindo o diretório home
Write-Host "Seu diretório home é: $HOME"

# Versão do PowerShell
Write-Host "Versão: $($PSVersionTable.PSVersion)"

# Diretório atual
Write-Host "Diretório atual: $PWD"

# PID do processo
Write-Host "PID: $PID"

# Usando $_ no pipeline
Get-Process | Where-Object { $_.ProcessName -like "*powershell*" } | Select-Object ProcessName

Outra variável muito útil é $null, que representa um valor nulo, e $true/$false para booleanos. Também temos $Error (último erro ocorrido) e $Host (informações sobre o host atual).

É importante não atribuir valores a essas variáveis automáticas, pois isso pode causar comportamentos inesperados. Se você precisar de uma variável com nome similar, use um prefixo diferente, como $meuHome.

Escopo (visão geral)

O escopo de uma variável define onde ela é acessível e por quanto tempo ela existe. No PowerShell, o escopo pode ser global, local ou relativo a um script. Por padrão, as variáveis criadas em um script são locais ao script, o que significa que não são visíveis fora dele. Da mesma forma, variáveis criadas no console são globais, mas podem ser acessadas dentro de scripts se você usar o prefixo $global:.

O PowerShell usa um sistema de escopos hierárquicos: cada script ou função cria um novo escopo. Para acessar uma variável de um escopo pai, você pode usar o prefixo $script: para o escopo do script, ou $global: para o escopo global. Para criar uma variável em um escopo específico, use New-Variable com o parâmetro -Scope.

# Exemplo de escopo global e local
$global:mensagem = "Olá do escopo global"

function Teste-Escopo {
    $local = "Olá do escopo local"
    Write-Host $local
    Write-Host $global:mensagem
}

Teste-Escopo
# A variável $local não está disponível aqui
# Write-Host $local  # Erro: não reconhecida
Write-Host $global:mensagem

Neste exemplo, a variável $local só existe dentro da função Teste-Escopo. Já a variável $global:mensagem pode ser acessada de qualquer lugar. É importante entender o escopo para evitar bugs, como modificar uma variável acidentalmente ou não conseguir acessar dados de outro escopo.

Uma boa prática é evitar o uso excessivo de variáveis globais, pois elas podem tornar o código difícil de depurar. Prefira passar informações como parâmetros para funções ou usar variáveis de script quando necessário.

Boas práticas e observações finais

Ao trabalhar com variáveis no PowerShell, siga estas recomendações para escrever código mais limpo e confiável:

  • Use nomes descritivos e em camelCase (ex.: $nomeUsuario).
  • Prefira tipagem forte quando o tipo for conhecido e não deve variar.
  • Evite sobrescrever variáveis automáticas; use outros nomes.
  • Entenda o escopo das suas variáveis; opte por escopo local sempre que possível.
  • Use Write-Host ou Write-Output para exibir valores, mas lembre-se de que Write-Host não envia para o pipeline.

Lembre-se de que as variáveis são a base para a criação de scripts complexos e interativos. Pratique os exemplos e explore os recursos oferecidos pelo PowerShell para se tornar um profissional mais eficiente.

Exercícios

  1. Crie uma variável chamada $meuNome e atribua seu nome a ela. Em seguida, exiba a mensagem "Olá, [seu nome]!" usando Write-Host.

    ✓ Resposta: 
    $meuNome = "Maria"
Write-Host "Olá, $meuNome!"

  2. Declare uma variável do tipo [int] chamada $idade e atribua o valor 25. Depois, tente atribuir a string "trinta" a ela e observe o erro. Em seguida, atribua a string "30" e veja o que acontece.

    ✓ Resposta: 
    [int]$idade = 25
# $idade = "trinta"  # Isso gera um erro: não é possível converter "trinta" para int
$idade = "30"  # Converte com sucesso para 30
Write-Host $idade

  3. Escreva um script que mostre a versão do PowerShell, o diretório atual e o nome do computador usando variáveis automáticas.

    ✓ Resposta: 
    Write-Host "Versão do PowerShell: $($PSVersionTable.PSVersion)"
Write-Host "Diretório atual: $PWD"
Write-Host "Nome do computador: $env:COMPUTERNAME"

  4. Crie uma função chamada Mostrar-Soma que receba dois números como parâmetros, calcule a soma e exiba o resultado. Use variáveis locais para armazenar os números e o resultado. Teste a função chamando-a com valores diferentes.

    ✓ Resposta: 
    function Mostrar-Soma {
    param(
        [int]$a,
        [int]$b
    )
    $soma = $a + $b
    Write-Host "A soma de $a e $b é $soma"
}

Mostrar-Soma -a 5 -b 3
Mostrar-Soma -a 10 -b 20

  5. Explique a diferença entre escopo global e local e dê um exemplo de quando você precisaria usar uma variável global.

    ✓ Resposta:

    O escopo global refere-se a variáveis acessíveis em todo o ambiente do PowerShell, incluindo scripts e funções. O escopo local é restrito à função ou script onde a variável foi criada. Uma variável global pode ser útil para armazenar configurações que precisam ser acessadas por várias funções, como uma string de conexão com banco de dados. Exemplo:

    $global:config = "servidor=localhost;banco=teste"
function Conectar {
    Write-Host "Conectando com $global:config"
}
Conectar

Referências