Como Trabalhar com Strings em Ruby

Introdução

A string is a sequence of one or more characters that may consist of letters, numbers, or symbols.

As strings em Ruby são objetos e, ao contrário de outras linguagens, as strings são mutáveis, o que significa que podem ser alteradas no local em vez de criar novas strings.

Você usará strings em quase todos os programas que escrever. As strings permitem que você exiba e se comunique com seus usuários usando texto. Na verdade, a página que você está lendo agora é composta por strings exibidas na sua tela através do seu navegador da web. As strings são um dos fundamentos mais importantes da programação.

Neste tutorial, você aprenderá como trabalhar com strings em Ruby. Você criará strings, as exibirá na tela, as armazenará em variáveis, unirá várias strings e aprenderá a lidar com caracteres especiais, como quebras de linha, apóstrofos e aspas duplas.

Criando e Imprimindo Strings

As strings existem entre aspas simples ' ou aspas duplas " em Ruby, portanto, para criar uma string, coloque uma sequência de caracteres em uma delas:

'This is a string in single quotes.'

"This is a string in double quotes."

Você pode escolher usar aspas simples ou aspas duplas. Na maioria dos casos, não importa qual você escolha, desde que você seja consistente. No entanto, o uso de aspas duplas permite que você faça interpolacão de strings, o que você aprenderá neste tutorial.

Para exibir uma string em seu programa, você pode usar o método print:

print "Let's print out this string."

O método print exibe a string exatamente como ela foi escrita.

Tente isso. Crie um novo programa Ruby chamado print.rb usando seu editor de texto e use o método print para imprimir três strings:

print 'This is the first string.'
print 'This is the second string.'
print 'This is the third string.'

Salve o arquivo e execute o programa:

ruby print.rb

Você verá a seguinte saída:

Output
This is the first string.This is the second string.This is the third string.

Em vez das três strings impressas em suas próprias linhas, todas as três strings foram impressas juntas em uma única linha. O método print imprime a string na tela, mas se você quisesse cada string em sua própria linha, teria que adicionar um caractere de quebra de linha você mesmo.

Se você quiser que as três strings estejam em linhas separadas, use o método puts em vez disso. Modifique seu programa para usar puts em vez de print:

puts 'This is the first string.'
puts 'This is the second string.'
puts 'This is the third string.'

Agora execute o programa novamente e você verá esta saída:

Output
This is the first string.
This is the second string.
This is the third string.

O método puts imprime a string especificada, mas também adiciona um caractere de nova linha ao final da string para você.

Armazenando Strings em Variáveis

Variáveis são uma referência nomeada a um local na memória do computador. Você usa variáveis para armazenar dados e recuperá-los posteriormente.

Para armazenar uma string em uma variável, defina o nome da variável e atribua o valor da string:

my_string = 'This is my string'

Em seguida, para recuperar o valor, use o nome da variável:

print my_string

Para testar isso por conta própria, crie o arquivo string_variables.rb no seu editor com o seguinte comando:

nano string_variables.rb

Em seguida, adicione o seguinte código:

my_name = "Sammy the Shark"
my_age = "none of your business"

puts my_name
puts my_age

Este programa define duas variáveis: my_name e my_age. Cada variável é atribuída a uma string. Em seguida, usamos o método puts para imprimir cada string em sua própria linha.

Salve o arquivo com CTRL + X e y, depois execute o programa:

ruby string_variables.rb

Você verá a seguinte saída:

Output
Sammy the Shark
none of your business

Atribuindo strings a variáveis, você pode evitar digitar a mesma string várias vezes sempre que quiser usá-la, facilitando o trabalho e manipulação de strings em seus programas.

Vamos ver como juntar strings para criar novas strings.

Concatenação de Strings

Concatenação significa unir duas ou mais strings para criar uma nova string. Para concatenar, usamos o operador de concatenação, representado pelo símbolo +. O símbolo + também é o operador de adição quando usado com operações aritméticas.

Aqui está como você concatenaria as strings sammy e shark juntas:

"sammy" + "shark"

Isto produziria a seguinte saída:

Output
sammyshark

A concatenação une as strings uma ao lado da outra, combinando-as e produzindo um novo valor de string. Se você quiser ter um espaço entre as palavras sammy e shark, você precisa incluir esse espaço em uma das strings, assim:

"sammy " + "shark"

Agora, você realmente não escreverá código assim em um programa, mas precisará misturar strings e variáveis juntas com bastante frequência, e é aí que entra a concatenação.

Aqui está um exemplo:

color = "Blue"
print "My favorite color is " + color

Isto resultaria na saída Minha cor favorita é azul. Note que deixamos um espaço depois da palavra é na string para que a saída tenha um espaço entre a string e o valor da variável na saída.

Você pode concatenar múltiplas strings desta maneira. Crie o arquivo concatenation.rb e adicione este código:

my_name = "Sammy the Shark"
my_age = "none of your business"

puts "My name is " + my_name + " and my age is " + my_age + "."

Este programa define duas variáveis: my_name e my_age, cada uma com sua própria string atribuída, assim como você já fez antes. Mas desta vez, em vez de imprimir os valores, estamos imprimindo uma string que usa concatenação para imprimir esses valores com um pouco mais de contexto.

Quando você executar este programa, verá a seguinte saída:

Output
My name is Sammy the Shark and my age is none of your business.

Neste pequeno programa, você usou concatenação para inserir variáveis nesta string.

Ao combinar duas ou mais strings através da concatenação, você está criando uma nova string que pode usar em todo o seu programa, então pode querer atribuir a string que criou a uma nova variável que pode usar mais tarde:

my_name = "Sammy the Shark"
my_age = "none of your business"

# atribuir a string concatenada a uma variável
output = "My name is " + my_name + " and my age is " + my_age + "."

# Imprimir a saída.
puts output

Em um programa pequeno como este, usar uma variável extra output é provavelmente desnecessário. Mas em programas maiores, pode querer criar uma string usando concatenação que usará em vários lugares. Também é um bom hábito separar o processamento de dados, como concatenação e aritmética, da saída, pois eventualmente seus programas ficarão maiores e você vai querer separar a lógica e a saída em arquivos ou componentes separados para torná-los mais fáceis de gerenciar.

Garanta que não use o operador + entre dois tipos de dados diferentes. Não é possível concatenar strings e inteiros juntos, por exemplo.

Para ver o que acontece, crie um novo programa chamado strings_and_integers.rb com o seguinte conteúdo:

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number

Desta vez temos my_name que contém a string Sammy the Shark e my_number que contém o inteiro 27. Sabemos que 27 não é uma string porque não está entre aspas. Também não tem um ponto decimal, então sabemos que é um inteiro.

Se você executar o programa:

ruby strings_and_ints.rb

Você verá esta mensagem de erro:

Output
strings_and_ints.rb:4:in `+': no implicit conversion of Integer into String (TypeError)
from strings_and_ints.rb:4:in `<main>'

O erro `no implicit conversion of Integer into String` significa que o Ruby só pode concatenar uma string à string existente.

strings_and_ints.rb:4:in `+': no implicit conversion of Fixnum into String (TypeError)
from strings_and_ints.rb:4:in `<main>'

Poderíamos alterar nosso programa e colocar o número `27` entre aspas (`"27"`) para que seja declarado como uma string em vez de um inteiro. Ou podemos converter o número em uma string quando criamos a string, assim:

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number.to_s

O método `.to_s` converte o inteiro em uma string. Esta é uma abordagem melhor, pois nos permite manter nosso número como um inteiro em nosso programa. Só precisamos que seja uma string quando o imprimimos, mas talvez queiramos que seja um inteiro se precisarmos usá-lo em outras partes da lógica do nosso programa.

Execute o programa novamente e você verá `Sammy the Shark27` impresso na tela.

Converter números em strings para concatenação é algo que você encontrará com frequência ao lidar com códigos postais, moeda, números de telefone e outros dados numéricos que você deseja exibir na tela ao lado do texto.

Concatenação é poderosa, mas pode ser complicada. Se você deixar acidentalmente de fora um dos operadores +, pode ocorrer um erro de sintaxe. E se você tiver que unir strings com variáveis que contêm números, será necessário converter as variáveis em strings. Ruby oferece outra maneira de injetar valores de variáveis em uma string, chamada interpolação de string que resolve ambos esses problemas.

Usando a Interpolação de String

Ao concatenar strings e variáveis, a saída pode ser difícil de ler e depurar. A interpolação de string resolve isso permitindo que você incorpore expressões em uma string entre aspas duplas.

Em vez de escrever isso:

"My name is " + my_name + "!"

Você pode fazer isso:

"My name is #{my_name}!"

Em vez de terminar a string e usar o operador +, você envolve a variável com a sintaxe #{}. Essa sintaxe diz ao Ruby para avaliar a expressão e injetá-la na string.

Experimente. Crie um novo programa chamado interpolacao.rb e adicione este código:

my_name = "Sammy the Shark"
my_age = "none of your business"

output = "My name is #{my_name} and my age is #{my_age}."

puts output

Este é o mesmo programa que você já escreveu, mas desta vez estamos usando interpolação de string para criar a saída.

A interpolação de string tem outro benefício: ela pode converter valores numéricos em strings automaticamente. Lembre-se do seu programa strings_and_integers.rb? Abra esse arquivo no seu editor novamente, mas altere a última linha para que pareça com o seguinte:

my_name = "Sammy the Shark"
my_number = 27

# use interpolação em vez de concatenação
print "My name is #{my_name} and my favorite number is #{my_number}."

O Ruby converterá automaticamente my_number em uma string, e seu programa imprimirá a seguinte saída quando você o executar:

Output
My name is Sammy the Shark and my favorite number is 27.

A interpolação de string é poderosa e conveniente. Também é o método preferido para concatenar strings com variáveis.

Literais de String e Valores de String

Observe que todas as strings que você criou estão entre aspas no código, mas a saída impressa real não inclui as aspas.

Há uma distinção ao se referir a cada uma delas. Um literal de string é a string como está escrita no código-fonte, incluindo as aspas. Um valor de string é o que você vê na saída e não inclui aspas.

Este é um literal de string:

"Sammy the Shark"

O valor da string seria Sammy the Shark.

Na maioria dos casos, você não precisará se preocupar com essa diferença, a menos que queira usar caracteres especiais como aspas ou apóstrofos em suas strings.

Escapando de Aspas e Apóstrofos em Strings

Devido ao fato de que as aspas são usadas para denotar strings, você terá que fazer um pouco de trabalho extra se quiser apostrofos e aspas em strings.

Se você tentar usar um apóstrofo no meio de uma string entre aspas simples, como este:

'This isn't what I wanted.'

O apóstrofo em isn't termina a string, como você pode ver no destaque estranho neste exemplo. Como resultado, o interpretador Ruby tentará analisar o restante da string pretendida como código e você obterá um erro.

Você teria a mesma situação se usasse aspas duplas em uma string cercada por aspas duplas:

"Sammy says, "Hello!""

Neste exemplo, a aspa dupla de fechamento na frente de Hello termina a string, e a aspa dupla depois de Hello! cria uma nova string que não tem uma aspa dupla correspondente para terminá-la, então o Ruby exibirá um erro.

Para evitar esse problema, você tem algumas opções. Primeiro, você pode usar a sintaxe alternativa para criar strings; se precisar usar aspas duplas na string, use aspas simples para definir a string, e vice-versa. Você também poderia escapar das aspas, ou poderia usar uma sintaxe Ruby diferente para definir as strings. Vamos analisar cada abordagem.

Opção 1: Usar a Sintaxe de String Alternativa

A maneira mais fácil de lidar com esses problemas é envolver sua cadeia de caracteres em aspas simples quando ela precisar incluir uma aspa dupla, e envolver sua cadeia de caracteres em aspas duplas quando ela precisar usar aspas simples.

Em vez de definir esta cadeia de caracteres com aspas simples:

'This isn't what I wanted.'

Defina-a com aspas duplas:

"This isn't what I wanted."

E em vez de usar aspas duplas para definir esta cadeia de caracteres:

"Sammy says, "Hello!""

Use aspas simples:

'Sammy says, "Hello!"'

Usar a sintaxe alternativa pode ajudar em algumas situações, mas nem sempre vai funcionar. Por exemplo, nenhuma abordagem funcionará para esta cadeia de caracteres:

"Sammy says, "I'm a happy shark!""

Neste exemplo, a aspa dupla de fechamento na frente de I'm realmente complica as coisas. Isso encerra a primeira cadeia de caracteres e, em seguida, o Ruby encontra o apóstrofo em I'm, que inicia uma nova cadeia de caracteres com o valor m a happy shark!"". Mas esta nova cadeia de caracteres não tem uma aspa simples correspondente para encerrá-la. E usar aspas simples para envolver a cadeia de caracteres introduz um problema semelhante:

'Sammy says, "I'm a happy shark!"'

Desta vez, o apóstrofo em I'm encerra a cadeia de caracteres.

O uso da sintaxe alternativa também pode tornar seu código inconsistente. Alternar constantemente entre a sintaxe de cadeia de caracteres pode ficar confuso. Podemos escapar caracteres para contornar esse problema.

Opção 2: Escapando Caracteres em Cadeias de Caracteres

O caractere de barra invertida (\), frequentemente chamado de caractere de escape em strings, impedirá que o Ruby interprete o próximo caractere na string literalmente.

Aqui está nossa string problemática, codificada entre aspas duplas, com aspas duplas no interior:

"Sammy says, "I'm a happy shark!""

Crie um novo programa Ruby chamado quoting.rb e adicione este código ao arquivo:

print "Sammy says, "I'm a happy shark!""

Execute o programa:

ruby quoting.rb

E você verá esta saída:

Output
quoting.rb:1: syntax error, unexpected tCONSTANT, expecting end-of-input
print "Sammy says, "I'm a happy shark!""
^

Para corrigir o erro, use a barra invertida na frente das aspas duplas internas:

print "Sammy says, \"I'm a happy shark!\""

Em seguida, execute o programa novamente e você verá a saída esperada:

Sammy says, "I'm a happy shark!"

Observe que você não precisa escapar o apóstrofo neste exemplo, já que não há conflito. Você só precisa escapar as aspas que confundirão o Ruby.

Você pode evitar escapar as aspas totalmente usando uma sintaxe diferente para definir strings.

Opção 3: Usando Sintaxe Alternativa para Strings

Até agora, você usou aspas para definir os limites de suas strings. Você pode criar strings em Ruby usando outros caracteres também. Você pode definir o delimitador, ou caractere que você gostaria de usar para cercar sua string, especificando-o após um sinal de porcentagem, assim:

%$Sammy says, "I'm a happy shark!"$

Esta sintaxe irá escapar automaticamente as strings incorporadas para você. A string real se parece com isso:

"Sammy says, \"I'm a happy shark!\""

No entanto, mudar o delimitador significa que você precisa escapar o delimitador se precisar usá-lo. Neste caso, se você precisasse usar um sinal de dólar em sua string, precisaria escapar o sinal de dólar literal na string.

Para evitar isso, você também pode usar pares de chaves, colchetes ou parênteses como delimitadores. Chaves são mais comuns:

%{Sammy says, "I'm a happy shark!"}

Essas formas todas suportam interpolação de string se você precisar.

droplets = 5
print %{Sammy says, "I just created #{droplets} droplets!"}

Você também verá %Q{} e %q{} usados para definir strings em programas Ruby. A sintaxe %Q{} funciona exatamente como strings entre aspas duplas, o que significa que você não precisa escapar as aspas duplas, e poderá usar interpolação de string:

droplets = 5
print %Q{Sammy says, "I just created #{droplets} droplets!"}

A sintaxe %q{} funciona exatamente como strings entre aspas simples:

%q{Sammy says, "I'm a happy shark!"}

Você pode ver a sintaxe %q e %Q usada com parênteses ou colchetes em alguns programas em vez de chaves.

Como você pode ver, existem muitas maneiras de criar strings em Ruby. Qualquer que seja o método que você escolha, seja consistente em seu código. Você verá que os métodos %Q{} e %{} são os mais comuns.

Agora que você sabe como lidar com caracteres especiais, vamos ver como lidar com strings longas e caracteres de nova linha.

Strings Longas e Caracteres de Nova Linha

Há momentos em que pode ser desejável inserir um caractere de nova linha, ou retorno de carro em sua string. Você pode usar os caracteres de escape \n ou \r para inserir uma nova linha no código:

output = "This is\na string\nwith newlines"
puts output

Este programa produzirá esta saída:

Output
This is
a string
with newlines

Isso tecnicamente funciona para obter nossa saída em várias linhas. No entanto, escrever uma string muito longa em uma única linha rapidamente se tornará muito difícil de ler e trabalhar. Existem algumas soluções.

Primeiro, você pode usar o operador de concatenação para dividir a string em várias linhas:

output = "This is a\n" +
"longer string\n" +
"with newlines."
puts output

Isso simplesmente concatena três strings juntas, semelhante ao que você já fez.

Você também pode simplesmente colocar as quebras de linha diretamente na string:

output = "This is a
longer string
with newlines"
puts output

Você também pode usar qualquer uma das sintaxes de string alternativas para criar strings de várias linhas:

output = %{This is a
longer string
with newlines}
puts output

Em ambos os exemplos, observe que não precisamos dos caracteres de nova linha (\n). Esta abordagem preserva espaços em branco, incluindo indentação e novas linhas.

Como resultado, a saída conterá as quebras de linha, bem como toda a indentação principal, como esta:

Output
This is a
longer string
with newlines

Para evitar isso, remova o espaço em branco extra do seu código:

output = %{This is a
longer string
with newlines
}

Você também pode criar strings de várias linhas usando um heredoc, ou “aqui documento”, um termo usado para literais de string de várias linhas em programas. Veja como você escreveria esse código:

output = <<-END
This is a
longer string
with newlines
END

Os marcadores <<-END e END denotam o início e o fim do heredoc.

Heredocs em Ruby também preservam caracteres de espaço em branco, o que significa que se você indentar o código no heredoc, a indentação inicial também será preservada. Então, este código:

output = <<-END
This is a
longer string
with newlines
END

imprimiria com dois espaços de indentação.

O Ruby 2.3 e superior fornecem a sintaxe “squiggly heredoc”, que remove automaticamente esse espaço em branco inicial. Substitua o hífen na definição do heredoc por um til, então <<- torna-se <<~, assim:

output = <<~END
This is a
longer string
with newlines
and the code is indented
but the output is not.
END

Isto produz a seguinte saída:

Output
This is a
longer string
with newlines
and the code is indented
but the output is not.

Isto permite que você use heredocs e mantenha seu código bem indentado.

Heredocs em Ruby também suportam interpolação de strings.

Como você pode ver, há muitas maneiras de lidar com quebras de linha e strings multilinhas em Ruby. Você encontrará todos esses métodos ao trabalhar com código Ruby existente, pois cada projeto tende a ter seu próprio estilo. Em seu próprio código, escolha o estilo que é adequado para você e seja consistente.

Replicação de Strings

Pode haver momentos em que você precise usar Ruby para repetir uma string de caracteres várias vezes. Você pode fazer isso com o operador *. Assim como o operador +, o operador * tem um uso diferente quando usado com números, onde é o operador de multiplicação. Quando usado com uma string e um número inteiro, * é o operador de replicação de string, repetindo uma única string quantas vezes desejar usando o inteiro fornecido.

Para imprimir Sammy nove vezes, você usaria o seguinte código:

print "Sammy" * 9

Este código produz a seguinte saída:

Output
SammySammySammySammySammySammySammySammySammy

Você pode usar isso para criar algumas artes em ASCII legais. Crie um arquivo chamado banner.rb e adicione o seguinte código:

puts "=" * 15
puts "| Hello World |"
puts "=" * 15

Você consegue imaginar o que o programa irá produzir antes de executá-lo?

Ele produz esta saída:

Output
===============
| Hello World |
===============

Este é apenas um pequeno exemplo de como você pode fazer o computador realizar tarefas repetitivas para você.

Conclusão

Neste tutorial, você aprendeu como trabalhar com o tipo de dado string na linguagem de programação Ruby. Você criou novas strings, concatenou-as com outras strings e lidou com quebras de linha, aspas e apóstrofos. Então, você usou interpolação de string para facilitar a mistura de strings e valores de variáveis, e aprendeu como repetir strings.