A String a Fundo: Trabalhando com Texto

O texto é, provavelmente, o tipo de dado com que você mais lidará ao escrever programas que conversam com pessoas — nomes, mensagens, respostas, títulos, endereços. Já usamos a string desde a primeira aula e sabemos criá-la e concatená-la; agora vamos conhecê-la melhor, aprendendo as operações essenciais que se fazem com texto: medir seu tamanho, combinar valores de forma mais elegante, transformar maiúsculas e minúsculas, remover espaços indesejados, e mais. Nenhuma dessas operações é difícil, mas juntas elas formam um ferramental que você usará constantemente. Esta é a aula que faz de você alguém fluente no trato com texto — e, de quebra, apresenta uma forma de compor mensagens tão prática que aposentará a concatenação repetitiva.

A string é uma sequência de caracteres

Antes das operações, uma ideia estrutural. Uma string é, por dentro, uma sequência ordenada de caracteres. O texto "Ana" é a sequência dos três caracteres 'A', 'n', 'a', nessa ordem. Essa perspectiva — texto como sequência — explica muitas das operações que veremos: podemos perguntar quantos caracteres a sequência tem, olhar um caractere numa posição específica, ou pegar um pedaço dela. Cada caractere ocupa uma posição, e aqui surge uma convenção que atravessa toda a programação e que vale memorizar desde já: as posições começam a contar do zero, não do um. O primeiro caractere está na posição 0, o segundo na posição 1, o terceiro na posição 2, e assim por diante. Estranho no início, natural com o tempo — e universal: você encontrará essa contagem a partir do zero em praticamente tudo em programação.

Medindo o tamanho: Length

A operação mais básica é descobrir quantos caracteres um texto tem. Toda string oferece uma informação chamada Length (comprimento, em inglês), acessada com o ponto que você já conhece:

string nome = "Ana";
Console.WriteLine(nome.Length);   // exibe: 3

O nome.Length nos dá 3, pois "Ana" tem três caracteres. Note o uso do ponto: assim como Console.WriteLine acessava uma ação da caixa de ferramentas Console, aqui nome.Length acessa uma informação de dentro da string nome. Todo valor de texto carrega consigo essa e outras capacidades, acessíveis pelo ponto. O Length é útil sempre que você precisa saber o tamanho de um texto — por exemplo, para verificar se uma senha tem caracteres suficientes, ou se um campo não foi deixado vazio.

Interpolação: a forma elegante de compor mensagens

Na Aula #06, montamos mensagens com concatenação: "Olá, " + nome + "!". Funciona, mas quando há muitos valores a inserir, a concatenação fica trabalhosa e difícil de ler, cheia de aspas e sinais de mais. O C# oferece uma alternativa muito mais elegante, chamada interpolação de strings. Você coloca um $ antes das aspas de abertura e, então, pode inserir variáveis diretamente dentro do texto, entre chaves { }:

string nome = "Ana";
int idade = 30;

// Com interpolação: o $ ativa, e o que está entre { } é substituído pelo valor.
string mensagem = $"Olá, {nome}! Você tem {idade} anos.";
Console.WriteLine(mensagem);   // exibe: Olá, Ana! Você tem 30 anos.

Compare com a concatenação equivalente: "Olá, " + nome + "! Você tem " + idade + " anos.". A versão interpolada é visivelmente mais limpa e mais fácil de ler, porque o texto aparece contínuo, com os valores marcados no lugar onde entram. O $ no início é o que ativa esse comportamento; sem ele, as chaves seriam tratadas como texto literal. Dentro das chaves, você pode colocar qualquer variável, e até pequenas expressões — {idade + 1} inseriria a idade mais um. A interpolação é a forma preferida de compor mensagens no C# moderno, e a partir de agora vou usá-la em favor da concatenação sempre que houver valores a inserir. Adote-a; ela tornará seu código mais legível.

Transformando o texto

O texto oferece várias operações que produzem novas versões transformadas dele. As mais comuns:

string texto = "Olá, Mundo";

Console.WriteLine(texto.ToUpper());   // OLÁ, MUNDO — tudo em maiúsculas
Console.WriteLine(texto.ToLower());   // olá, mundo — tudo em minúsculas

O ToUpper produz uma versão toda em maiúsculas, e o ToLower, toda em minúsculas. Há um detalhe conceitual importante aqui, que aprofundaremos numa aula futura mas convém plantar agora: essas operações não modificam o texto original — elas produzem um texto novo, transformado, e deixam o original intacto. Se você quiser guardar a versão maiúscula, precisa atribuí-la a uma variável (a original continua como estava). Por ora, apenas observe que ToUpper e ToLower devolvem um novo texto, e é esse novo texto que exibimos ou guardamos.

Outra operação frequente é remover espaços em branco sobrando nas pontas do texto — algo comum quando o usuário digita com espaços acidentais antes ou depois. O Trim cuida disso:

string entrada = "   Ana   ";
string limpa = entrada.Trim();       // remove os espaços das pontas
Console.WriteLine($"[{limpa}]");     // exibe: [Ana] — sem os espaços extras

Coloquei o resultado entre colchetes na exibição apenas para tornar visível que os espaços foram removidos. O Trim é especialmente útil logo após ler uma entrada do usuário, para limpar espaços acidentais antes de trabalhar com o valor.

Verificando e buscando dentro do texto

Frequentemente queremos saber algo sobre o conteúdo de um texto. Duas operações úteis: Contains, que verifica se um texto contém um certo trecho, devolvendo verdadeiro ou falso; e a verificação de texto vazio. Veja:

string email = "ana@exemplo.com";
Console.WriteLine(email.Contains("@"));   // True — o texto contém uma arroba

string vazio = "";
Console.WriteLine(vazio.Length == 0);     // True — o texto está vazio (Length é 0)

O Contains devolve um bool (verdadeiro/falso), o que o torna perfeito para decisões — por exemplo, verificar se um e-mail contém "@", ainda que isso, sozinho, não garanta que seja um e-mail válido. Para verificar se um texto está vazio, uma forma é comparar seu Length com zero, como acima; existe também uma ferramenta pronta e mais robusta para isso (string.IsNullOrWhiteSpace), que você encontrará ao longo do curso, capaz de detectar tanto texto vazio quanto texto só com espaços. Por ora, saber medir e verificar o conteúdo já lhe dá bastante controle.

Um panorama do que você ganhou

Recapitulando o ferramental de texto desta aula: Length mede o tamanho; a interpolação ($"...") compõe mensagens de forma elegante, no lugar da concatenação repetitiva; ToUpper e ToLower transformam maiúsculas e minúsculas; Trim remove espaços das pontas; e Contains verifica a presença de um trecho. Essas operações, todas acessadas pelo ponto a partir de uma variável de texto, cobrem a grande maioria das necessidades cotidianas de manipulação de strings. Com elas, você está bem equipado para todo programa que lida com nomes, mensagens e entradas de texto — que é dizer, praticamente todo programa interativo.

O texto deixou de ser uma caixa-preta. Você sabe medir uma string com Length, compor mensagens por interpolação em vez de somar pedaços, transformar o conteúdo com operações de caixa e limpeza, e verificar se um trecho existe dentro de outro. São operações que aparecem em praticamente todo programa que lida com informação humana.

Duas ideias estruturais ficaram plantadas e vão render depois: posições em uma sequência começam a contar do zero, uma convenção que atravessa toda a programação; e as operações sobre uma string não a alteram, elas produzem uma nova — o original permanece intacto.

Fontes e leituras recomendadas

• O tipo string (guia de programação) — a referência oficial sobre texto em C#, com suas operações; a base desta aula.
• Interpolação de strings — o tutorial oficial da sintaxe $"..." que compõe mensagens elegantemente.
• Métodos comuns de string — a referência completa de Length, ToUpper, ToLower, Trim, Contains e muitos outros.
• String.Trim (referência) — os detalhes da remoção de espaços das pontas do texto.
• Verificando strings vazias ou nulas — a ferramenta robusta para detectar texto vazio ou só com espaços.

Exercícios

Exercício 1

Escreva um programa que peça o nome do usuário, e depois exiba: o nome em maiúsculas, o nome em minúsculas, e a quantidade de caracteres do nome (usando Length). Teste com nomes de tamanhos diferentes.

Console.Write("Seu nome: ");
string nome = Console.ReadLine();
Console.WriteLine($"Maiúsculas: {nome.ToUpper()}");
Console.WriteLine($"Minúsculas: {nome.ToLower()}");
Console.WriteLine($"Quantidade de caracteres: {nome.Length}");

Exercício 2

Reescreva a seguinte mensagem, atualmente com concatenação, usando interpolação de strings: "O produto " + produto + " custa R$ " + preco + " e temos " + estoque + " em estoque.". Compare a legibilidade das duas versões.

$"O produto {produto} custa R$ {preco} e temos {estoque} em estoque."

Exercício 3

Escreva um programa que peça um texto ao usuário com espaços acidentais nas pontas (peça que ele digite espaços de propósito), aplique Trim, e exiba o resultado entre colchetes para evidenciar que os espaços foram removidos. Explique por que o Trim é útil logo após uma entrada do usuário.

Console.Write("Digite algo com espaços nas pontas: ");
string entrada = Console.ReadLine();
string limpa = entrada.Trim();
Console.WriteLine($"[{limpa}]");

Exercício 4

Escreva um programa que peça um endereço de e-mail e use Contains para verificar se ele contém o caractere "@", exibindo uma mensagem apropriada em cada caso. Reflita: o fato de conter "@" garante que o texto é um e-mail válido? Por quê?

Console.Write("Digite seu e-mail: ");
string email = Console.ReadLine();
if (email.Contains("@"))
    Console.WriteLine("O texto contém uma arroba.");
else
    Console.WriteLine("Faltou a arroba — não parece um e-mail.");

Exercício 5

A aula afirma que ToUpper "não modifica o texto original, mas produz um novo texto transformado". Escreva um pequeno programa que demonstre isso: crie uma string, chame ToUpper guardando o resultado em outra variável, e exiba as duas — a original e a transformada — mostrando que a original permaneceu inalterada.

string original = "programação";
string maiuscula = original.ToUpper();
Console.WriteLine($"Original: {original}");       // programação (inalterada)
Console.WriteLine($"Transformada: {maiuscula}");  // PROGRAMAÇÃO