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.

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 tela por meio 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á como lidar com caracteres especiais, como quebras de linha, apóstrofos e aspas duplas.

Criando e Imprimindo Strings

As strings existem dentro de aspas simples ' ou aspas duplas " em Ruby, então para criar uma string, envolva uma sequência de caracteres em uma ou outra:

'This is a string in single quotes.'

"This is a string in double quotes."

Você pode optar por usar aspas simples ou aspas duplas. Na maioria dos casos, não importa qual você escolha, contanto que seja consistente. No entanto, usar aspas duplas permite que você realize interpolação de string, 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 escrita.

Experimente. 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.

Ao invés 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ê quisesse todas as três strings 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 que você especificou, 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 si mesmo, 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. Então, 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

Ao atribuir strings a variáveis, você pode evitar digitar a mesma string repetidamente sempre que quiser usá-la, tornando mais fácil trabalhar e manipular strings em seus programas.

Vamos ver como unir 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 em operações aritméticas.

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

"sammy" + "shark"

Isso produziria a seguinte saída:

Output
sammyshark

A concatenação une as strings de ponta a ponta, combinando-as e gerando um valor de string completamente novo. Se você quiser ter um espaço entre as palavras sammy e shark, é preciso incluir esse espaço em uma das strings, assim:

"sammy " + "shark"

Agora, você não escreveria realmente código assim em um programa, mas frequentemente precisará misturar strings e variáveis, e é aí que a concatenação entra.

Aqui está um exemplo:

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

Isso resultaria na saída Minha cor favorita é azul. Note que deixamos um espaço após a 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 várias strings dessa 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ê fez anteriormente. Mas desta vez, em vez de imprimir os valores, estamos imprimindo uma string que usa a concatenação para exibir esses valores com um pouco mais de contexto.

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

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

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

Quando você combina duas ou mais strings através da concatenação, você está criando uma nova string que pode ser usada em todo o seu programa, então pode ser interessante atribuir a string que você criou a uma nova variável que poderá ser utilizada posteriormente:

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 como output provavelmente é desnecessário. No entanto, em programas maiores, pode ser útil criar uma string usando concatenação que você utilizará em vários lugares. Também é uma boa prática separar o processamento de dados, como concatenação e aritmética, da saída, já que seus programas eventualmente se tornarão maiores e você desejará separar a lógica e a saída em arquivos ou componentes separados para torná-los mais fáceis de gerenciar.

Esteja atento para não usar o operador + entre dois tipos de dados diferentes. Você não pode concatenar strings e inteiros, 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 a variável my_name, que contém a string Sammy the Shark, e a variável my_number, que contém o número inteiro 27. Sabemos que 27 não é uma string porque não está entre aspas. Também não possui um ponto decimal, então sabemos que é um número 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 para 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 para 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 exibimos, 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á frequentemente ao lidar com códigos postais, moeda, números de telefone e outros dados numéricos que você deseja exibir na tela junto com texto.

A concatenação é poderosa, mas pode ser complicada. Se você esquecer acidentalmente um dos operadores +, pode obter um erro de sintaxe. E se você precisar juntar strings com variáveis que contêm números, terá que converter as variáveis em strings. O Ruby fornece outra maneira de inserir valores de variáveis em uma string, chamada de interpolação de strings, que aborda ambos esses problemas.

Usando a Interpolação de Strings

Ao concatenar strings e variáveis, a saída pode ser difícil de ler e depurar. A interpolação de strings 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 #{}. Esta sintaxe diz ao Ruby para avaliar a expressão e injetá-la na string.

Experimente. Crie um novo programa chamado interpolation.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 strings para criar a saída.

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

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 conforme está escrita no código-fonte, incluindo as aspas. Um valor de string é o que você vê na saída e não inclui as aspas.

Este é um literal de string:

"Sammy the Shark"

O valor da string seria Sammy the Shark.

Na maioria dos casos, você não terá que 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 apóstrofos e aspas em strings.

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

'This isn't what I wanted.'

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

Você enfrentará a mesma situação se usar aspas duplas em uma string entre aspas duplas:

"Sammy says, "Hello!""

Neste exemplo, a aspas dupla de fechamento na frente de Hello termina a string, e a aspas dupla depois de Hello! cria uma nova string que não tem uma aspas 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 você 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: Use a Sintaxe de String Alternativa

A maneira mais fácil de contornar esses problemas é colocar sua string entre aspas simples quando sua string precisar incluir uma aspas dupla, e colocar sua string entre aspas duplas quando sua string precisar usar aspas simples.

Em vez de definir essa string 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 essa string:

"Sammy says, "Hello!""

Use aspas simples:

'Sammy says, "Hello!"'

O uso da sintaxe alternativa pode te tirar de alguns apertos rapidamente, mas nem sempre vai funcionar. Por exemplo, nenhuma das abordagens funcionará para essa string:

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

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

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

Desta vez o apóstrofo em I'm termina a string.

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

Opção 2: Escapando Caracteres em Strings

O caractere de barra invertida ( \ ), frequentemente referido como o 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!\""

Então 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 de aspas que confundirão o Ruby.

Você pode evitar completamente a necessidade de escapar as aspas 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ê deseja usar para fechar sua string, especificando-o após um sinal de percentual, assim:

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

Esta sintaxe 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, você 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 as 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 você 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. Independentemente do método que você escolher, seja consistente em seu código. Você descobrirá 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 você pode querer 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 apenas 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 multilinhas:

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 a indentação e as novas linhas.

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

Output
This is a
longer string
with newlines

Para evitar isso, remova os espaços em branco extras do seu código:

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

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

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

Os marcadores <<-END e END indicam 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

seria impresso com dois espaços de indentação.

O Ruby 2.3 e versões superiores fornecem a sintaxe do “heredoc ondulado”, que remove automaticamente este espaço em branco inicial. Substitua o hífen na definição do heredoc por um til, assim <<- se torna <<~, como este:

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, existem 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, já que cada projeto tende a ter seu próprio estilo. Em seu próprio código, escolha o estilo que seja 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 inteiro, * é o operador de replicação de string, repetindo uma única string quantas vezes você 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 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, as concatenou com outras strings e manipulou quebras de linha, aspas e apóstrofos. Em seguida, você usou interpolação de strings para facilitar a mistura de strings e valores de variáveis, e aprendeu como repetir strings.