Praticando C#: Strings e Regex

Strings - Apresentação

Olá, meu nome é Iasmin Araújo, sou instrutora na Escola de Programação e irei me autodescrever para fins de acessibilidade.

Audiodescrição: Iasmin se identifica como uma mulher branca. Possui cabelos castanhos-escuros e longos, repartidos ao meio. Veste uma regata azul-escura. Ao fundo, o ambiente é iluminado em tons de azul, e possui uma parede lisa com um interruptor e uma porta à esquerda.

O que aprenderemos?

Neste curso de C#, vamos praticar a habilidade de trabalhar com strings. Vamos aprender a:

• Declarar strings;
• Concatenar strings, criando um único texto;
• Interpolar strings;
• Usar sequências de escape;
• Usar o texto verbatim em strings;
• Transformar strings com métodos de manipulação;
• Escrever padrões de regex (expressões regulares) e como aplicá-los.

Próximos passos

É importante conhecer a teoria, mas também precisamos praticar! Na sequência, iniciaremos essa prática para aprofundar ainda mais nossos conhecimentos.

Bons estudos!

Strings - Strings

Trabalhar com texto é essencial no dia a dia de desenvolvimento. Pensando nisso, as linguagens de programação sempre possuem algum tipo para representar textos. No caso de C#, utilizamos as strings.

Declarando strings

Para declarar uma string, utilizamos a palavra-chave string, seguida do nome da variável, o operador de atribuição e, em seguida, o texto que desejamos armazenar na memória. Esse texto deve estar entre aspas duplas.

Vamos ver como isso é feito na prática:

string variavel = "texto";

Concatenando strings

Uma vez que temos uma string, podemos juntar várias strings, realizando o que chamamos de concatenação. Para juntar duas strings, por exemplo, podemos ter as variáveis variavel1 e variavel2, e utilizar o operador +. Quando fazemos texto1 + texto2, estamos criando um único texto, que será o resultado dessa junção.

string variavel2 = "texto2";
Console.WriteLine("texto" + "texto2");

Utilizamos o operador + tanto para operações matemáticas com números inteiros quanto para concatenar strings. O resultado depende do tipo ao qual aplicamos esse operador.

Capturando e imprimindo dados

Para praticar melhor as strings, vamos acessar o Visual Studio, no qual já temos um exemplo parcialmente pronto no arquivo Program.cs.

Suporemos que estamos criando um programa que interage com a pessoa usuária, pedindo para digitar o nome, a idade e o telefone. Vamos começar capturando essas informações:

Program.cs:

Console.Write("Olá! Digite seu nome: ");
string nome = Console.ReadLine();

Console.Write("Agora, digite sua idade: ");
string idade = Console.ReadLine();

Console.Write("Agora, digite seu telefone: ");
string telefone = Console.ReadLine();

Uma vez que a pessoa usuária digitou todas essas informações, queremos imprimir esses dados na tela. Faremos isso utilizando a concatenação.

Pulando uma linha, utilizaremos o Console.WriteLine() e passaremos entre parênteses toda a informação concatenada. Começaremos com "Nome: ", seguido de um espaço, e concatenaremos com o nome que a pessoa usuária digitou.

Console.WriteLine("Nome: " + nome + ", " + "idade: " + idade + ", " + "telefone: " + telefone);

Nesse caso, juntamos strings que possuem variáveis com string que não as possuem para compor o resultado.

Interpolando strings

Existe uma forma mais fácil de fazer isso: a interpolação de strings. Na interpolação de strings, colocaremos um $ antes das aspas para indicar que a string será interpolada.

Sempre que quisermos inserir uma variável dentro da string, utilizamos chaves. Colocaremos uma chave antes e outra depois de cada variável adicionada para não precisar separar a string que queremos imprimir da string da variável.

Com isso, podemos remover os +, criando uma única string.

Console.WriteLine($"Nome: {nome}, idade: {idade}, telefone: {telefone}");

Geralmente, preferimos utilizar a interpolação em relação à concatenação.

Utilizando sequências de escape em strings

Vamos pensar em outro problema. Suponhamos que queiramos criar uma variável do tipo string que será uma mensagem exibida. Essa mensagem será: "Olá, meu e-mail é iasmin@email.com".

string mensagem = "Olá! Meu email é iasmin@email.com";

Antes de executar, comentaremos todo o código acima dessa linha para não precisar digitar os dados do João. Após executar, a string é exibida corretamente.

Olá! Meu email é iasmin@email.com

Queremos destacar o texto "iasmin@email.com" colocando esse e-mail entre aspas, por exemplo.

string mensagem = "Olá! Meu email é "iasmin@email.com"";

O Visual Studio apontará um erro, pois entende que as aspas após "é" encerram a string. Tudo que está depois é considerado incorreto.

Para representar "iasmin e-mail" com aspas no meio da frase, diferenciaremos as aspas que declaram o texto das que estão dentro da variável utilizando uma sequência de escape.

As sequências de escape são sempre compostas pela contrabarra (\) e algum caractere. No caso, utilizaremos \" para cada aspa dupla que queremos exibir no texto.

string mensagem = "Olá! Meu email é \"iasmin@email.com\"";

O resultado é o seguinte:

Olá! Meu email é "iasmin@email.com"

Existem outras sequências de escape, mas estas são as mais utilizadas no dia a dia. Por exemplo, temos:

• \n para nova linha;
• \t para tabulação;
• \\ para representar a barra invertida;
• \' para aspas simples e
• \b, que apaga um caractere anterior.

Um exemplo que podemos utilizar está relacionado aos caminhos de arquivo no Windows. Quando copiamos um caminho de arquivo no Windows, ele vem com contra barras (\).

Vamos criar a string caminho e colar um caminho de arquivo do Windows:

string caminho = "C:\Users\adria\Documents\requisicao.txt";

É importante lembrar que a contra barra é usada para representar sequências de escape em linguagens de programação. Por isso, se quisermos representar uma contra barra no código, precisamos usar duas (\\).

string caminho = "C:\\Users\\adria\\Documents\\requisicao.txt";

Assim, conseguimos trabalhar corretamente com caminhos de arquivo. Depois disso, podemos imprimir o caminho para confirmar que está tudo certo.

Console.WriteLine(caminho);

C:\Users\adria\Documents\requisicao.txt

Usando strings verbatim

Há outra forma de lidar com esse formato de string, chamada verbatim. Com ela, não precisamos utilizar sequências de escape. Podemos colocar a string exatamente como é.

Para usar o verbatim, colocamos um @ antes da string e podemos apagar as barras extra. Entretanto, as aspas continuarão quebrando as strings — para evitar esse problema, temos que usar duas aspas para representar uma.

string mensagem = @"Olá! Meu email é ""iasmin@email.com""";
Console.WriteLine(mensagem);

string caminho = @"C:\Users\adria\Documents\requisicao.txt";
Console.WriteLine(caminho);

Executaremos para visualizar. No terminal, teremos os mesmos resultados, mas agora utilizando o verbatim.

Olá! Meu email é "iasmin@email.com"

C:\Users\adria\Documents\requisicao.txt

Essa é uma forma de colocar a mensagem exatamente como queremos, sem utilizar sequências de escape.

Conclusão e próximos passos

Estas são algumas considerações sobre strings. Temos vários conceitos para explorar na sequência.

Strings - Manipulação de Strings

No curso em que praticamos variáveis e tipos, vimos que as strings não são tipos primitivos, mas sim tipos referenciados. A vantagem das strings serem tipos referenciados é que elas possuem diversos métodos que nos permitem modificá-las ao longo do tempo.

Explorando métodos de manipulação de strings

Para modificar as strings, utilizamos vários métodos de manipulação. Alguns exemplos são:

• Length(): nos informa o tamanho de uma string;
• ToLower() e ToUpper(): convertem todas as letras de uma palavra para minúsculas e maiúsculas, respectivamente;
• Contains(): verifica se a string contém um texto específico;
• StartsWith() e EndsWith(): verifica se o início e o final da string, respectivamente, possuem um texto determinado;
• IndexOf(): identifica a posição de um caractere específico na string;
• Substring(): extrai uma parte da string desde o início até um tamanho determinado;
• Replace(): substitui um texto antigo por um novo;
• Trim(), TrimStart() e TrimEnd(): removem espaços em branco;
• Split(): separa uma string de acordo com um padrão separador;
• Join(): junta uma string seguindo um padrão.

Esses métodos foram apresentados rapidamente, e para compreendê-los melhor, é necessário praticar. Vamos voltar ao nosso código para entender melhor esses métodos.

Extraindo partes da string

Vamos comentar todo o código anterior para focar na parte de manipulação de strings.

No vídeo anterior, exibimos informações digitadas pela pessoa usuária separadas por vírgulas, como nome, idade e telefone. Suponhamos que estivéssemos trabalhando com linhas de um arquivo CSV, que são separadas por vírgulas, assim como o que estávamos escrevendo.

Na próxima linha, criaremos uma string chamada linhaCsv, que conterá "João", a idade "40" e o telefone "999999999":

string linhaCsv = "João, 40, 999999999";

Se quisermos extrair apenas o telefone dessa linha do CSV, utilizaremos o método Split(), que separa a string em partes diferentes. Vamos criar uma variável chamada telefone, que armazenará o resultado da separação, pegando apenas o final da string.

string telefone = 

Para usar o método Split() em uma string, chamamos o nome da variável que contém a string, depois usamos o ponto (.) para acessar os métodos disponíveis. O Visual Studio mostrará uma lista com várias opções, entre as quais escolheremos o Split().

Temos que passar o separador para esse método. No caso do linhaCsv, queremos dividir a string com base na vírgula. Então, usamos:

string telefone = linhaCsv.Split(",")

O Split() vai dividir a string em várias partes e o resultado será armazenado em um array.

Para acessar uma parte específica do array, usamos o índice. Como os índices começam do 0, o terceiro elemento estará na posição 2:

string telefone = linhaCsv.Split(",")[2];

Ou seja, dividimos a string em três partes e pegamos a terceira, que está na posição 2 do array.

Após essa operação, teoricamente, extraímos o telefone. Vamos usar Console.WriteLine() para verificar se o método funcionou corretamente:

Console.WriteLine(telefone);

Ao executar o programa, observamos que o telefone "999999999" de João foi extraído corretamente.

999999999

Formatando strings

Agora, suponhamos que queremos exibir o CSV de forma diferente, separando as palavras com espaços e hifens. Para isso, criaremos uma nova string chamada novaLinha, que será o resultado de uma manipulação de strings usando o método Replace().

Queremos substituir as vírgulas por espaços e hifens. Definiremos a vírgula como padrão para ser substituída. Depois, indicamos o que desejamos colocar no lugar dela, que no caso, é um espaço:

string novaLinha = linhaCsv.Replace(",", " - ");

Vamos verificar se isso está funcionando usando novamente Console.WriteLine() para exibir a novaLinha:

Console.WriteLine(novaLinha);

Vamos executar o programa e observar que a linha está formatada da forma desejada, com o espaço e os hifens.

João - 40 - 999999999

Verificando formatos de arquivos

Vamos pensar em um novo exemplo. Ainda na tarefa de trabalhar com arquivos, suponhamos que estejamos lidando com um sistema no qual a pessoa usuária pode enviar imagens. No entanto, essas imagens devem ser apenas no formato JPG.

Assim, toda vez que a pessoa usuária enviar uma imagem, queremos verificar o nome do arquivo para confirmar se realmente é JPG, antes de armazená-la no banco de dados.

Para isso, declararemos uma string imagem, que terá o nome foto.jpg:

string imagem = "foto.jpg";

Precisamos filtrar essa foto.jpg de alguma forma. Faremos esse filtro usando outro método de manipulação de strings, que nos fornecerá um resultado booliano.

Declararemos um bool chamado valido, que indicará se a imagem é válida ou não, e utilizaremos a string imagem, adicionando um ponto. Para verificar se o formato é JPG, precisamos ver se o final do arquivo contém os caracteres .jpg.

Para verificar se uma string termina com algo específico, podemos usar o método EndsWith() com o trecho ".jpg":

bool valido = imagem.EndsWith(".jpg");

Assim, descobriremos se a imagem é válida e, então, podemos usar um if(). Se a imagem for válida, exibiremos "carregando para o banco de dados" com Console.WriteLine():

if(valido)
{
    Console.WriteLine("Carregando para o banco de dados");
}

Caso contrário, exibiremos "formato inválido" com else:

else
{
    Console.WriteLine("Formato invalido!");
}

Comentaremos as linhas anteriores para evitar saídas confusas e executaremos o programa para verificar se está funcionando.

Observamos que ele exibiu "carregando para o banco de dados" porque temos uma imagem foto.jpg. Se tivéssemos, por exemplo, um arquivo mp4, o resultado seria "formato inválido". É assim que o método EndsWith() funciona.

Existem outros métodos, como Contains() e StartsWith(), que também fornecem resultados boolianos, true ou false.

Analisando domínios de e-mail

Vamos para outro exemplo. Suponhamos que trabalhamos em uma empresa que deseja analisar todas as outras empresas que estão criando contas em seu site. Para realizar essa análise, precisamos verificar o domínio do e-mail das pessoas que estão criando contas.

Suponhamos que criemos a conta "iasmin@alura.com.br" com uma string email:

string email = "iasmin@alura.com.br";

Queremos saber o domínio do e-mail, que vem após o arroba. Esse domínio nos ajudará a traçar estatísticas e identificar quais empresas estão interessadas na nossa.

Para obter o domínio do e-mail, poderíamos pensar em usar alguns dos métodos mencionados anteriormente, como verificar se o e-mail termina com "alura". No entanto, não é isso que queremos.

Queremos obter o domínio sem saber qual é. Não queremos verificar se "alura" existe, mas descobrir que "alura" existe. Para isso, precisamos usar outras estratégias.

O e-mail sempre contém um arroba. Podemos descobrir a posição desse arroba. Uma vez que sabemos essa posição, trabalhamos com tudo que está após o arroba.

Precisaremos de alguns métodos para isso. O primeiro será IndexOf(). Vamos declarar int posicao, que será a posição do arroba, usando o método IndexOf() para encontrar a posição do caractere @:

int posicao = email.IndexOf("@");

Dessa forma, já sabemos onde está o arroba. Em seguida, pegaremos tudo que está a partir do arroba.

Declararemos uma string dominio, que é o que queremos descobrir. Esse domínio será email.Substring(posicao):

string dominio = email.Substring(posicao);

Vamos usar Console.WriteLine para exibir o domínio:

Console.WriteLine(dominio);

Ao usar o IndexOf("@"), pegamos a posição onde está o caractere @. Mas, se queremos apenas o domínio do e-mail (como "alura.com.br"), não queremos incluir o @.

Para isso, somamos 1 à posição encontrada, começando a extração logo após o @.

string dominio = email.Substring(posicao+1);

Agora sim, ao executar, teremos o e-mail desejado.

alura.com.br

Conseguimos recuperar todos os domínios e traçar as estatísticas conforme desejado.

Conclusão e próximos passos

Exploramos alguns métodos de manipulação de strings. Existem muitos outros, e é interessante explorar a documentação para entender como funcionam.

Temos outras questões a discutir no campo de strings. Na sequência, falaremos um pouco sobre expressões regulares (regex).

Sobre o curso Praticando C#: Strings e Regex

O curso Praticando C#: Strings e Regex possui 46 minutos de vídeos, em um total de 20 atividades. Gostou? Conheça nossos outros cursos de .NET em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Strings
• Regex