Nesta aula, vamos aprofundar o conhecimento sobre manipulação de strings no PowerShell, uma habilidade essencial para automação e processamento de dados. Strings são onipresentes em scripts, desde saídas de comandos até configurações e logs. Dominar as técnicas avançadas de manipulação permite extrair, transformar e validar informações de forma eficiente.

O PowerShell trata strings como objetos imutáveis da classe System.String. Isso significa que cada operação gera uma nova string, mas a eficiência é garantida pelo .NET. Vamos explorar métodos diretos, formatação, ajuste de largura e extração de substrings, sempre com exemplos práticos.

Métodos de string

Os métodos de string são funções que atuam sobre o objeto string. No PowerShell, você pode chamá-los diretamente, como em outras linguagens .NET. Alguns dos mais úteis incluem ToUpper(), ToLower(), Replace(), Split(), Contains(), StartsWith() e EndsWith().

Esses métodos são essenciais para normalizar dados, buscar padrões e transformar conteúdo. Por exemplo, ao comparar entradas do usuário, é comum converter tudo para minúsculas ou maiúsculas. Vamos ver alguns exemplos:

$texto = "Olá, Mundo!"
# Converter para maiúsculas
$texto.ToUpper()
# Resultado: OLÁ, MUNDO!

# Substituir parte da string
$texto.Replace("Mundo", "PowerShell")
# Resultado: Olá, PowerShell!

# Dividir em partes
$frase = "maçã,banana,laranja"
$frase.Split(",")
# Resultado: um array com três elementos

# Verificar se contém
$texto.Contains("Mundo")  # True
$texto.StartsWith("Olá")  # True
$texto.EndsWith("!")      # True

Além disso, métodos como IndexOf() e LastIndexOf() retornam a posição de um caractere ou substring, o que é útil para localizar padrões. Exemplo:

$caminho = "C:\pasta\arquivo.txt"
$posicao = $caminho.IndexOf("\")
# Retorna 2 (posição do primeiro backslash)
$ultimaBarra = $caminho.LastIndexOf("\")
# Retorna 8 (posição da última barra)
$nomeArquivo = $caminho.Substring($ultimaBarra + 1)
# Extrai "arquivo.txt"

Lembre-se de que métodos que retornam booleanos (como Contains) são frequentemente usados em condições. Combine-os com operadores lógicos para criar validações robustas.

Formatação (-f)

O operador -f é uma forma elegante de formatar strings, similar ao String.Format do .NET. Ele substitui placeholders {0}, {1}, etc., pelos valores fornecidos. Isso melhora a legibilidade e evita concatenação confusa.

A sintaxe básica é: "texto {0} mais {1}" -f $valor1, $valor2. Você pode especificar largura, alinhamento e formato numérico. Exemplos:

$nome = "Maria"
$idade = 30
"Nome: {0}, Idade: {1}" -f $nome, $idade
# Resultado: Nome: Maria, Idade: 30

# Formatação numérica: moeda, percentual, casas decimais
$preco = 49.90
"Preço: {0:C}" -f $preco   # R$ 49,90 (depende da cultura)
"Taxa: {0:P}" -f 0.25      # 25,00%
"Valor: {0:N2}" -f 1234.567 # 1.234,57

# Alinhamento e largura
"{0,-10}|" -f "Esquerda"   # Alinha à esquerda (10 espaços)
"{0,10}|" -f "Direita"     # Alinha à direita

O operador -f é especialmente útil para gerar relatórios formatados ou mensagens dinâmicas. Ele também aceita índices repetidos e formatos compostos. Por exemplo, para preencher zeros à esquerda:

$codigo = 42
"Código: {0:D4}" -f $codigo  # Código: 0042

Uma boa prática é usar -f em vez de concatenação com + para melhorar a clareza e o desempenho, especialmente em loops.

Trim e Pad

Os métodos Trim(), TrimStart() e TrimEnd() removem espaços em branco (ou outros caracteres) das extremidades de uma string. Isso é crucial ao processar entradas do usuário ou arquivos CSV, onde espaços indesejados podem causar erros.

Exemplo básico:

$entrada = "   texto com espaços   "
$entrada.Trim()          # "texto com espaços"
$entrada.TrimStart()     # "texto com espaços   "
$entrada.TrimEnd()       # "   texto com espaços"

# Remover caracteres específicos
$dados = "---123---"
$dados.Trim('-')         # "123"

Os métodos PadLeft() e PadRight() adicionam caracteres (por padrão, espaços) para atingir um comprimento específico. São úteis para alinhar texto em colunas ou formatar números com zeros à esquerda.

$numero = 5
$numero.ToString().PadLeft(3, '0')  # "005"

$texto = "abc"
$texto.PadRight(5, '.')             # "abc.."

# Alinhar em tabelas
$col1 = "Nome"
$col2 = "Idade"
"{0,-10} {1,5}" -f $col1, $col2
# Mas também pode usar PadRight/PadLeft:
$col1.PadRight(10) + $col2.PadLeft(5)

Combine Trim e Pad para limpar e padronizar dados. Por exemplo, ao ler um arquivo delimitado, use Trim() em cada campo para remover espaços extras.

Substring

O método Substring() extrai uma parte de uma string, dado um índice inicial e, opcionalmente, um comprimento. Se o comprimento não for especificado, vai até o final. Isso é essencial para extrair informações de strings estruturadas, como datas, códigos ou caminhos.

Sintaxe: Substring(início) ou Substring(início, comprimento). O índice é baseado em zero. Exemplo:

$dataHora = "2025-03-15 14:30:00"
$ano = $dataHora.Substring(0, 4)   # "2025"
$mes = $dataHora.Substring(5, 2)   # "03"
$dia = $dataHora.Substring(8, 2)   # "15"
$hora = $dataHora.Substring(11, 2) # "14"

# Extrair até o final
$url = "https://exemplo.com/pagina"
$dominio = $url.Substring(8)  # "exemplo.com/pagina"

Um uso comum é extrair a extensão de um arquivo ou o nome do diretório. Use LastIndexOf para encontrar a posição do separador e então extrair a substring:

$caminho = "C:\pasta\subpasta\arquivo.log"
$indice = $caminho.LastIndexOf("\")
$nomeArquivo = $caminho.Substring($indice + 1)  # "arquivo.log"
$extensao = $nomeArquivo.Substring($nomeArquivo.LastIndexOf('.') + 1)  # "log"

Cuidado com índices fora dos limites: se o início for maior que o comprimento da string, ocorrerá uma exceção. Sempre valide o comprimento antes de usar Substring, ou use Length para calcular.

Boas práticas e observações finais

Ao manipular strings, considere a imutabilidade: cada operação cria uma nova string, o que pode impactar a performance em loops grandes. Para muitas concatenações, use StringBuilder ou o operador -join.

Prefira métodos como Contains, StartsWith e EndsWith em vez de IndexOf para verificações booleanas, pois são mais legíveis. Use -f para formatação complexa e Substring com cautela, sempre verificando limites.

Teste seus scripts com entradas variadas, incluindo strings vazias ou com espaços, para evitar surpresas. Utilize o método IsNullOrWhiteSpace para validar entradas.

Referências

Exercícios

  1. Exercício 1: Dada a string " PowerShell é incrível! ", remova os espaços das extremidades e converta para maiúsculas. Qual é o resultado?

    ✓ Resposta: O resultado é "POWERSHELL É INCRÍVEL!". Código: 
    $str = "   PowerShell é incrível!   "
$str.Trim().ToUpper()
  2. Exercício 2: Formate a seguinte mensagem usando o operador -f: o nome do usuário é "Ana" e ela tem 25 anos. A mensagem deve ser: "Ana tem 25 anos.".

    ✓ Resposta: 
    $nome = "Ana"
$idade = 25
"{0} tem {1} anos." -f $nome, $idade
  3. Exercício 3: Dada a string "12345", use PadLeft para preencher com zeros até o comprimento 8. Qual é o resultado?

    ✓ Resposta: O resultado é "00012345". Código: 
    "12345".PadLeft(8, '0')
  4. Exercício 4: Extraia a substring "2025" da string "2025-03-15" usando Substring.

    ✓ Resposta: 
    $data = "2025-03-15"
$ano = $data.Substring(0, 4)  # "2025"
  5. Exercício 5: Escreva um código que remova todos os espaços de uma string usando Replace(). Teste com "a b c".

    ✓ Resposta: 
    $str = "a b c"
$str.Replace(" ", "")  # "abc"