Strings são um dos tipos de dados mais fundamentais em qualquer linguagem de programação, e no PowerShell não é diferente. Elas são usadas para representar texto, desde nomes de arquivos até mensagens para o usuário. Nesta aula, vamos explorar os aspectos essenciais das strings no PowerShell: como declará-las, como controlar a interpretação de variáveis e caracteres especiais, como criar blocos de texto multilinha e como usar os métodos disponíveis para manipular e transformar strings.

Dominar esses conceitos é crucial para escrever scripts eficientes e legíveis. Você verá que o PowerShell oferece uma sintaxe flexível, mas com regras claras que, quando bem compreendidas, evitam erros comuns e tornam seu código mais poderoso.

Aspas simples vs duplas

No PowerShell, você pode definir uma string usando aspas simples (') ou aspas duplas ("). A escolha entre elas afeta diretamente como o conteúdo é interpretado. A diferença fundamental é que aspas duplas permitem a expansão de variáveis e caracteres de escape, enquanto aspas simples tratam tudo literalmente.

Quando você usa aspas simples, o PowerShell não expande variáveis dentro da string. Isso é útil quando você precisa de uma string exatamente como está escrita, sem qualquer substituição. Por exemplo, se você quiser exibir o texto "A variável $nome não será expandida", as aspas simples garantirão que o símbolo $ seja tratado literalmente.

Por outro lado, aspas duplas permitem que você insira variáveis diretamente no texto, e elas serão substituídas pelo seu valor. Isso é conhecido como interpolação de strings, que veremos em detalhes no próximo tópico. Além disso, aspas duplas permitem o uso de caracteres de escape, como `n para nova linha e `t para tabulação.

Veja um exemplo prático:

$nome = "Maria"

# Com aspas simples, a variável não é expandida
$string1 = 'Olá, $nome!'
Write-Host $string1  # Saída: Olá, $nome!

# Com aspas duplas, a variável é expandida
$string2 = "Olá, $nome!"
Write-Host $string2  # Saída: Olá, Maria!

# Caracteres de escape só funcionam com aspas duplas
$string3 = "Primeira linha`nSegunda linha"
Write-Host $string3
# Saída:
# Primeira linha
# Segunda linha

No exemplo acima, $string1 exibe literalmente $nome, enquanto $string2 exibe o valor da variável. O caractere `n (crase seguida de n) é um caractere de escape que representa uma nova linha, e só é interpretado dentro de aspas duplas.

Interpolação

Interpolação é o processo de inserir valores de variáveis ou expressões dentro de uma string. No PowerShell, isso é feito principalmente com aspas duplas, onde você pode colocar $variavel diretamente no texto. Para expressões mais complexas, como acessar propriedades de objetos ou executar métodos, você pode usar a subexpressão $().

Por exemplo, se você tem uma variável $produto e quer incluir seu preço, pode fazer:

$produto = "Notebook"
$preco = 2500.99

# Interpolação simples de variável
$mensagem = "O produto $produto custa R$ $preco."
Write-Host $mensagem

# Interpolação com subexpressão para calcular
$quantidade = 3
$total = "Total: $($preco * $quantidade)"
Write-Host $total

No segundo exemplo, $($preco * $quantidade) calcula o produto e insere o resultado na string. Isso é especialmente útil quando você precisa de uma expressão mais complexa do que uma simples variável.

Além disso, você pode usar interpolação para formatar valores, como datas e números, usando o operador -f ou o método .ToString(), mas a interpolação com $() já cobre a maioria dos casos. Lembre-se de que, se você precisar incluir uma chave literal { ou } em uma string interpolada, será necessário escapá-la com crase: `{ e `}.

Here-strings

Here-strings são uma forma de criar strings multilinha sem precisar usar caracteres de escape para quebras de linha. Elas são extremamente úteis para textos longos, como mensagens de ajuda, conteúdo de e-mails, scripts embutidos ou qualquer texto que precise manter a formatação.

No PowerShell, uma here-string começa com @" (aspas duplas) ou @' (aspas simples) no final de uma linha, e termina com "@ ou '@ no início de uma linha. A diferença entre aspas duplas e simples é a mesma das strings regulares: aspas duplas permitem interpolação, enquanto aspas simples não.

Aqui está um exemplo de here-string com aspas duplas:

$nome = "João"
$idade = 30

$texto = @"
Olá, $nome!
Você tem $idade anos.
Este é um exemplo de here-string
com múltiplas linhas.
"@

Write-Host $texto

Observe que a abertura @" deve estar no final da linha, e o fechamento "@ deve estar no início da linha, sem espaços antes. O conteúdo entre eles pode incluir quebras de linha, e elas serão preservadas na string.

Se você não quiser que variáveis sejam expandidas, use @' e '@:

$textoLiteral = @'
Este texto não expande $variaveis.
Ele é útil para conteúdo que deve ser literal.
'@

Write-Host $textoLiteral

Here-strings são particularmente úteis para gerar arquivos de configuração, relatórios ou até mesmo código em outras linguagens dentro de um script PowerShell.

Métodos de string

O PowerShell trata strings como objetos .NET da classe System.String, o que significa que você tem acesso a uma vasta gama de métodos para manipulação. Esses métodos permitem modificar, analisar e transformar strings de maneiras poderosas.

Alguns dos métodos mais comuns incluem:

  • Substring() – extrai uma parte da string.
  • Replace() – substitui ocorrências de um texto por outro.
  • Split() – divide a string em um array com base em um delimitador.
  • ToUpper() e ToLower() – convertem para maiúsculas ou minúsculas.
  • Trim() – remove espaços em branco das extremidades.
  • Contains(), StartsWith(), EndsWith() – verificam se a string contém, começa ou termina com um texto específico.
  • IndexOf() – retorna a posição de um caractere ou substring.

Vamos ver alguns exemplos práticos:

$frase = "  O PowerShell é incrível!  "

# Trim remove espaços das bordas
$fraseLimpa = $frase.Trim()
Write-Host "Trim: [$fraseLimpa]"

# ToUpper e ToLower
Write-Host "Maiúsculas: $($fraseLimpa.ToUpper())"
Write-Host "Minúsculas: $($fraseLimpa.ToLower())"

# Replace substitui texto
$novaFrase = $fraseLimpa.Replace("incrível", "fantástico")
Write-Host "Replace: $novaFrase"

# Split divide em palavras
$palavras = $fraseLimpa.Split(" ")
Write-Host "Número de palavras: $($palavras.Count)"

# Substring extrai parte
$sub = $fraseLimpa.Substring(2, 6)
Write-Host "Substring: $sub"

# Contains verifica existência
Write-Host "Contém 'PowerShell'? $($fraseLimpa.Contains("PowerShell"))"

# IndexOf retorna posição
$posicao = $fraseLimpa.IndexOf("é")
Write-Host "Posição da palavra 'é': $posicao"

Além desses, existem métodos estáticos como [string]::Join() para unir um array em uma string, e [string]::Concat() para concatenar vários valores. Você também pode usar o operador + para concatenar strings, mas cuidado com a eficiência em loops grandes; nesses casos, use o StringBuilder.

Outra técnica útil é usar o operador -split e -join do PowerShell, que são alternativas mais idiomáticas a Split() e [string]::Join(). Por exemplo:

$lista = "maçã,banana,laranja"
$frutas = $lista -split ","
$frutas -join " | "

Isso mostra a flexibilidade do PowerShell para manipular strings de maneiras concisas.

Boas práticas

Ao trabalhar com strings, é importante seguir algumas boas práticas:

  • Preferir aspas simples quando não houver interpolação, para evitar expansões indesejadas.
  • Usar aspas duplas quando precisar de interpolação, mas tenha cuidado com caracteres especiais.
  • Para strings multilinha, sempre usar here-strings, pois melhora a legibilidade.
  • Escolher o método adequado para a tarefa: Replace() para substituições, Split() para quebrar, etc.
  • Em loops com muitas concatenações, usar System.Text.StringBuilder para melhor desempenho.
  • Testar strings vazias ou nulas antes de chamar métodos, para evitar exceções.

Essas práticas ajudarão a evitar erros e a manter seu código claro e eficiente.

Referências

Exercícios

  1. Crie uma string com aspas simples que contenha o texto: O valor é $100. Exiba a string.

    ✓ Resposta: 
    $texto = 'O valor é $100'
Write-Host $texto

  2. Use interpolação com aspas duplas para exibir a seguinte mensagem: "O usuário João tem 25 anos." usando as variáveis $usuario e $idade.

    ✓ Resposta: 
    $usuario = "João"
$idade = 25
Write-Host "O usuário $usuario tem $idade anos."

  3. Crie uma here-string com aspas duplas que contenha três linhas de texto, incluindo uma variável interpolada. Exiba o resultado.

    ✓ Resposta: 
    $nome = "Maria"
$texto = @"
Linha 1
Olá, $nome!
Linha 3
"@
Write-Host $texto

  4. Dada a string "PowerShell é poderoso", use métodos para: (a) converter para maiúsculas, (b) substituir "poderoso" por "incrível", (c) verificar se contém "Shell".

    ✓ Resposta: 
    $s = "PowerShell é poderoso"
Write-Host $s.ToUpper()
Write-Host $s.Replace("poderoso", "incrível")
Write-Host $s.Contains("Shell")

  5. Escreva um script que receba uma frase do usuário e exiba o número de palavras (usando Split ou -split).

    ✓ Resposta: 
    $frase = Read-Host "Digite uma frase"
$palavras = $frase -split "\s+"
Write-Host "Número de palavras: $($palavras.Count)"