DEV Community

Alexandre
Alexandre

Posted on • Edited on

Usando os métodos da classe String no Ruby

#ruby #string

Observação: Este artigo foi atualizado, caso queira a versão anterior, pode acessá-la aqui

Bem, primeiramente, vamos entender o que é uma String.

Uma String nada mais é do que um conjunto de caracteres, ou melhor, é um conjunto de bytes que representa o texto.

No Ruby, a classe String possui muitos métodos que você pode usar em seu projeto. Então, vamos explorar esses métodos.

Mas antes de vermos os métodos, primeiro, temos que saber como criar uma String no Ruby. Afinal, como vamos testar os métodos sem uma String?

Índice

Criando Strings

Existem cinco formas, ou melhor, existem seis formas de criar uma String.

Aspas Duplas

As primeiras delas é, simplesmente, usar aspas duplas "". Vamos a um exemplo.

nome = "Alexandre"
Enter fullscreen mode Exit fullscreen mode

Bem, nada demais, né? Certo, mas se eu quisesse, sei lá, ter um texto grande, como posso fazer isso?

Certo, tem uma forma melhor, mas quero abordar como faria usando aspas. Então, veja o exemplo abaixo.

texto = "Mal me lembro quando foi a última vez Que algo que eu falei fez diferença Mesmo depois de todas as coisas que eu fiz..."
Enter fullscreen mode Exit fullscreen mode

Você percebe que isso não é agradável, mas não se preocupe, tem como melhorar isso, vamos lá, então.

texto = "Mal me lembro quando foi a última vez" \
        "Que algo que eu falei fez diferença" \
        "Mesmo depois de todas as coisas que eu fiz..."
Enter fullscreen mode Exit fullscreen mode

Bem melhor, né? Então, suponho que você tenha percebido o \. Mas, bem, como ele funciona?

Não há necessidade de saber como ele funciona, mas, basicamente, quando o interpretador - caso não saiba o que é um interpretador, recomendo que pesquise sobre interpretador e compilador para entender mais sobre isso - "ver" o \ seguido de ", ele verifica se há uma string na próxima linha para fazer uma concatenação, só isso.

Tudo o que você precisa saber é colocar um \ seguido de " e garantir que tenha uma string na próxima linha.

Mas existe um problema sobre isso. Você consegue adivinhar? Copie o código e rode um puts na variável texto para ver o que acontece.

puts texto
#Mal me lembro quando foi a última vezQue algo que eu falei fez diferençaMesmo depois de todas as coisas que eu fiz...=> nil
Enter fullscreen mode Exit fullscreen mode

Pode ver que o texto foi concatenado, sem espaço. Era óbvio que isso iria acontecer, então para resolver, basta colocar o espaço ou, então, colocar \n.

texto = "Mal me lembro quando foi a última vez " \
        "Que algo que eu falei fez diferença " \
        "Mesmo depois de todas as coisas que eu fiz..."
puts texto
#Mal me lembro quando foi a última vez Que algo que eu falei fez diferença Mesmo depois de todas as coisas que eu fiz...=> nil

texto = "Mal me lembro quando foi a última vez\n" \
        "Que algo que eu falei fez diferença\n" \
        "Mesmo depois de todas as coisas que eu fiz..."
puts texto
#Mal me lembro quando foi a última vez
#Que algo que eu falei fez diferença
#Mesmo depois de todas as coisas que eu fiz...=> nil
Enter fullscreen mode Exit fullscreen mode

Caso você não saiba o que é o \n, pesquise sobre "caracteres de escape".

Bem, creio que é só isso. Agora vamos para a segunda forma de criar uma string.

Aspas Simples

É a mesma coisa que a primeira, porém com aspas simples ', só que tem uma coisa que difere com as aspas duplas, que é o uso de caracteres de escape.

Vamos fazer um teste.

# Aspas Duplas
texto = "Um,\nDois,\nTrês"
puts texto
#Um,
#Dois,
#Três

# Aspas Simples
texto = "Um,\nDois,\nTrês"
puts texto
#Um,\nDois,\nTrês
Enter fullscreen mode Exit fullscreen mode

Viu? Os caracteres de escape não funcionam na aspas simples, então preste atenção nisso, caso vá usar as aspas simples.

Heredoc

Agora, vamos para a terceira forma de criar uma string. No entanto, essa forma é só útil para criar uma string multilinha, pois usar vários \ não é agradável, então para fazer isso é simples.

Vou mostrar o exemplo.

texto = <<HEREDOC
Eu sei que nada é pra sempre
Confesso que eu queria um pouco mais
De tempo pra usar pra gente
Ver o sorriso que só você traz
HEREDOC

puts texto
#Eu sei que nada é pra sempre
#Confesso que eu queria um pouco mais
#De tempo pra usar pra gente
#Ver o sorriso que só você traz
Enter fullscreen mode Exit fullscreen mode

É assim que se cria uma string multilinha, só que vou te contar um segredo, o HEREDOC não precisa ser necessariamente HEREDOC, você pode usar qualquer nome, pode ser TEXTÃO, TEXTINHO, seja lá o que for, mas, é claro, o recomendado é HEREDOC.

Mas tem um problema de usar isso. Vamos supor que você tenha um método e esteja atribuindo o textão dentro desse método, você verá que ele vai dar erro de não encontrar o final do texto, mas para resolver isso é simples.

def escrever_textão
    texto = <<-TEXTÃO
Eu sei que nada é pra sempre
Confesso que eu queria um pouco mais
De tempo pra usar pra gente
Ver o sorriso que só você traz
    TEXTÃO

    puts texto
end

escrever_textão
#Eu sei que nada é pra sempre
#Confesso que eu queria um pouco mais
#De tempo pra usar pra gente
#Ver o sorriso que só você traz
Enter fullscreen mode Exit fullscreen mode

Você percebeu a diferença, claro, tirando o uso do nome TEXTÃO?

Creio que é difícil perceber, mas observe bem no <<-TEXTÃO, é possível ver um - depois do <<, isso vai garantir que não terá erro. E uma coisa que você possa ter percebido é que o texto não está aninhado de acordo com o método, isso porque se ele estiver aninhado com o método, o texto atribuído também vai estar aninhado. Aqui está um exemplo.

def escrever_textão
    texto = <<-TEXTÃO
    Eu sei que nada é pra sempre
    Confesso que eu queria um pouco mais
    De tempo pra usar pra gente
    Ver o sorriso que só você traz
    TEXTÃO

    puts texto
end

escrever_textão
#   Eu sei que nada é pra sempre
#   Confesso que eu queria um pouco mais
#   De tempo pra usar pra gente
#   Ver o sorriso que só você traz
Enter fullscreen mode Exit fullscreen mode

Mas caso você queira que esteja aninhado com o método, basta trocar o - para ~, simples assim.

def escrever_textão
    texto = <<~TEXTÃO
    Eu sei que nada é pra sempre
    Confesso que eu queria um pouco mais
    De tempo pra usar pra gente
    Ver o sorriso que só você traz
    TEXTÃO

    puts texto
end

escrever_textão
#Eu sei que nada é pra sempre
#Confesso que eu queria um pouco mais
#De tempo pra usar pra gente
#Ver o sorriso que só você traz
Enter fullscreen mode Exit fullscreen mode

É só isso. Ainda tem mais alguma coisa, mas mostrarei em outro artigo, pois não envolve muito com o String em si.

String.new

Agora, vamos para a quarta forma de criar uma string.

Essa forma é simples, é simplesmente criar uma instância de String. Veja o código abaixo.

nome = String.new('Alexandre')
Enter fullscreen mode Exit fullscreen mode

Então, você se pergunta, qual é a diferença entre usar aspas duplas ou simples e usar o método new?

Bem, nenhuma, ou melhor, tem uma única diferença, você pode definir a Codificação (Encoding) no new.

Se não sabe o que é Encoding, recomendo pesquisar sobre. Farei um artigo sobre isso no futuro.

Por padrão, ao utilizar aspas duplas ou simples, o encoding será UTF-8, e usando o String.new sem argumentos será ASCII-8BIT. Veja o código abaixo.

nome = 'Alexandre'
nome.encoding
#=> #<Encoding:UTF-8>

nome = String.new
nome.encoding
#=> #<Encoding:ASCII-8BIT>

nome = String.new('Alexandre')
nome.encoding
#=> #<Encoding:UTF-8>
Enter fullscreen mode Exit fullscreen mode

Não aprofundarei o assunto do Encoding, pois farei um artigo sobre isso.

% ou %Q

Agora, vamos para a quinta e a sexta forma de criar uma string. Vou juntar as duas, pois são meio parecidas.

É meio parecido com as aspas, porém a utilidade é que você pode incluir aspas dentro do texto. Não entendeu? Não se preocupe, vou mostrar o código.

texto = %[Esse código é meio "estranho"]
puts texto
#Esse código é meio "estranho"
Enter fullscreen mode Exit fullscreen mode

Viu? Sinceramente, o único ponto forte dele é este, ter a capacidade de colocar as aspas sem ter que usar o \. Por exemplo:

texto = "Esse código é meio \"estranho\""
puts texto
#Esse código é meio "estranho"
Enter fullscreen mode Exit fullscreen mode

Então, se você vai usar as aspas e não quer usar o \, você pode usar ele.

Uma observação, eu falei que tinha duas formas, e só falei uma, mas antes de falar disso, eu quero te mostrar uma coisa.

%[Era uma vez] #=> Era uma vez
%(Era uma vez) #=> Era uma vez
%{Era uma vez} #=> Era uma vez
%<Era uma vez> #=> Era uma vez
%|Era uma vez| #=> Era uma vez
%:Era uma vez: #=> Era uma vez
Enter fullscreen mode Exit fullscreen mode

Entendeu? Você tem essas opções de criar uma string, então você escolhe qual te agrada mais.

%q

Agora, vamos voltar ao assunto anterior. Você sabe que existem diferenças entre as aspas duplas e as aspas simples, mas também tem essa diferença aqui. Para isso, veja o código abaixo.

# Mesmo comportamento de aspas duplas
texto = %["Um",\"nDois",\n"Três"]
puts texto
#"Um",
#"Dois",
#"Três"

# Mesmo comportamento de aspas simples
texto = %q["Um",\n"Dois",\n"Três"]
puts texto
#"Um",\n"Dois",\n"Três"
Enter fullscreen mode Exit fullscreen mode

Como você pode ver, para ter o mesmo comportamento de uma aspa simples, basta usar o %q. Só isso.

Aproveitando o conhecimento da diferença, vou abordar logo a interpolação de strings antes de partir para conhecer os métodos.

Interpolação de Strings

Vou te fazer um desafio.

def ola_fulano(nome_do_fulano)
    # ?
end

ola_fulano('Alexandre')
#Olá, Alexandre!
ola_fulano('Kauane')
#Olá, Kauane!
ola_fulano('Felipe')
#Olá, Felipe!
Enter fullscreen mode Exit fullscreen mode

Como você faria isso para ter o resultado esperado?

Existem duas formas de fazer isso. Primeiro, vou mostrar a menos recomendada.

def ola_fulano(nome_do_fulano)
    puts 'Olá, ' + nome_do_fulano + '!'
end
Enter fullscreen mode Exit fullscreen mode

Simples assim, mas por que é a menos recomendada?

Vou citar dois motivos:

  1. Não é bonito.
  2. E neste código, você está criando três strings, ou seja, está alocando três objetos na memória.

Explicando mais sobre o motivo 2, como que está criando três strings? A primeira string criada é "Olá, ", a segunda é "!" e a terceira é o resultado da concatenação.
Sinceramente, isso não é um problema, isso só vai se tornar um problema se você tiver um projeto bem complexo e também bem específico. Mas é bom saber disso, vai que, né?

A forma mais recomendada é:

def ola_fulano(nome_do_fulano)
    puts "Olá, #{nome_do_fulano}!"
end
Enter fullscreen mode Exit fullscreen mode

Simples e bonito, não acha? Basta colocar uma variável dentro do #{} e puf. Mas não é só isso, você pode colocar um método que retorna algum valor ou, então, colocar um número ou uma operação matemática, veja um exemplo abaixo.

def ola
    'Olá'
end

puts "#{ola}, Alexandre!"
#Olá, Alexandre!
puts "Eu tenho #{2024 - 2003}!"
#Eu tenho 21!
Enter fullscreen mode Exit fullscreen mode

Agora, vamos testar com aspas simples, e também com % e %q.

puts %[#{ola}, Alexandre!]
#Olá, Alexandre!
puts '#{ola}, Alexandre!'
##{ola}, Alexandre!
puts %q[#{ola}, Alexandre!]
##{ola}, Alexandre!
Enter fullscreen mode Exit fullscreen mode

Ué, bem, isso já era o esperado, eu já disse isso anteriormente. As aspas simples e %q também não aceitam interpolação.

Bem, acho que é isso, agora, finalmente, vamos partir para os métodos. Vamos aprender os métodos de consulta.

Consultando

O que seria consultar uma string? Bem, consultar? Acho que é mais fácil entender vendo os exemplos abaixo.

Consultando o Tamanho da String

Veremos dois métodos para saber quantos caracteres tem na string.

nome = 'Alexandre'
nome.length
#=> 9
nome.size
#=> 9
Enter fullscreen mode Exit fullscreen mode

Não há nenhuma diferença entre os dois métodos, então você pode usar qualquer um.

Mas eu quero saber quantos bytes tem na string. Sem problema.

nome.bytesize
#=> 9
Enter fullscreen mode Exit fullscreen mode

O resultado também foi 9, assim como o length e o size. Mas por quê?

Bem, isso tem a ver com Encoding, mas, resumidamente, a string Alexandre contém apenas caracteres ASCII, ou seja, cada caractere ocupa um byte. Agora, vamos colocar um acento no A para ver o que acontece.

nome = 'Álexandre'
nome.bytesize
#=> 10
Enter fullscreen mode Exit fullscreen mode

Viu? Retornou 10. Isso acontece porque o Á não pertence ao ASCII, então ele ocupa dois bytes. Resumidamente, é isso. Como disse antes, farei um artigo sobre Encoding.

Agora, vamos supor que eu queira saber se a string está vazia. Eu posso fazer assim?

nome = ''
nome.size == 0
#=> true
Enter fullscreen mode Exit fullscreen mode

Sim, você pode, mas temos um método para isso.

Consultando se a String está Vazia

O método é empty?, vamos ver um exemplo.

nome.empty?
#=> true
Enter fullscreen mode Exit fullscreen mode

Bem mais bonito, né?

Certo, agora eu quero saber o número total de um caractere em uma string.

Consultando a Quantidade de Caracteres

Vamos supor que você queira saber quantas vezes o caractere a aparece no texto. É bem simples.

texto = 'Querido diário, desculpe o erro ao digitar. Mas minha mão treme...'
texto.count 'a'
#=> 4
Enter fullscreen mode Exit fullscreen mode

Bem, não tem muito mistério nisso.

Então, funciona somente com um caractere? Bem, antes de eu responder isso, é melhor que você veja o resultado.

Vamos supor que queiramos saber quantas vezes aparece a palavra erro no texto.

texto.count 'erro'
#=> 18
Enter fullscreen mode Exit fullscreen mode

Ué, não era para ser 1?

Então... Nâo. Em momento nenhum citei substrings, eu citei apenas caracteres. Mas por que deu 18?

É uma soma simples. O número total do caractere e que aparece no texto é 6, o de r é 6 e o de o é 6. Somando todos, dá 18.

Tá, mas eu quero saber quantas vezes aparece a substring erro na string.

Bem, não tem método específico para isso, mas vou te mostrar uma forma de fazer isso.

texto.scan('erro').size
#=> 1
Enter fullscreen mode Exit fullscreen mode

É assim... Bem, acho melhor dar um passo para trás. Vamos entender sobre o método scan.

Consultando a Quantidade de Substrings

O método scan pode receber uma string ou um RegEx (Regular expression). No futuro, farei um artigo sobre RegEx. Então, neste artigo, não terá nada de RegEx.

Vamos ver o que o método scan retorna.

texto = 'O sabiá não sabia que o sábio sabia que o sabiá não sabia assobiar.'
texto.scan('sabiá')
#=> ["sabiá", "sabiá"]
Enter fullscreen mode Exit fullscreen mode

Hum... ele retornou um Array com dois elementos. Certo, creio que dá para entender o que aconteceu aqui. É por isso que se utiliza o size ou length para saber a quantidade.

Como disse antes, ele também aceita um RegEx. Vou mostrar um exemplo, mas não explicarei sobre isso.

Vamos supor que eu queira saber quantas vezes aparecem o sabiá e o sábio, juntos, é claro.

texto.scan(/s[áa]bi[áo]/)
#=> ["sabiá", "sábio", "sabiá"]
Enter fullscreen mode Exit fullscreen mode

Bem, acho que é isso.

Aproveitando o embalo, vamos ver um método para saber a posição de um substring.

Consultando a Posição de Substrings

Temos dois métodos: index e rindex. Esses métodos aceitam dois argumentos. O primeiro argumento pode ser uma string ou uma RegEx, e o segundo é o offset, que é opcional.

Vamos para um exemplo.

texto = "Não sei o que dizer, não sei como expressar"
texto.index 'sei'
#=> 4
Enter fullscreen mode Exit fullscreen mode

Se observar o texto, é possível perceber que tem um outro "sei". É possível saber a posição dele?

Sim, você pode usar o segundo argumento.

O que seria o offset? Ele é basicamente o ponto de partida dele.

Sabemos que a posição do primeiro "sei" é 4, então, vamos fazer o método começar a partir da posição 5. Por exemplo:

texto.index('sei', 5)
#=> 25
Enter fullscreen mode Exit fullscreen mode

Bem, e o rindex?

É a mesma coisa, porém ele vai de direita para esquerda. Por exemplo:

texto.rindex 'sei'
#=> 25
Enter fullscreen mode Exit fullscreen mode

Viu? retornou 25.

Mas o que acontece quando não tem a substring no texto? Vamos ver juntos, então.

texto.index 'eu'
#=> nil
Enter fullscreen mode Exit fullscreen mode

Ele retornou nil.

Então, eu posso usar esse método para saber se existe ou não no texto?

Sim, pode, mas temos um método para isso.

Consultando a Existência de Substrings

Temos o método include?. Vamos ver um exemplo.

texto = 'Alexandre é babaca.'
texto.include? 'legal'
#=> false
texto.include? 'babaca'
#=> true
Enter fullscreen mode Exit fullscreen mode

Certo, nada demais.

Também temos os métodos match e match?, mas como isso lida com RegEx, novamente, abordarei esses métodos em outro artigo.

Continuando o embalo de saber se substring está no texto, temos os métodos start_with? e end_with?.

O start_with? verifica se a substring está no começo do texto, e o end_with? verifica se a substring está no final do texto.

Esses métodos aceitam string e RegEx.

Por exemplo:

texto = 'Mas acho que vale a pena.'
texto.start_with? 'Mas'
#=> true
texto.start_with? 'pena.'
#=> false
texto.end_with? 'Mas'
#=> false
texto.end_with? 'pena.'
#=> true
Enter fullscreen mode Exit fullscreen mode

Fácil de entender, tem mais uma coisa que eu quero te mostrar sobre esses dois métodos.

texto.start_with?('Contudo', 'Porém', 'Todavia', 'Mas')
#=> true
texto.start_with?('Contudo', 'Porém', 'Todavia', 'No entanto')
#=> false
Enter fullscreen mode Exit fullscreen mode

Entendeu? Bem, os métodos podem receber "infinitos" argumentos, nos quais eles vão verificar se os argumentos estão no começo ou no fim do texto.

Bem, para finalizar a parte de consulta, vamos saber como comparar duas strings.

Comparando Strings

Com certeza, você já sabe que dá pra comparar usando == ou ===.

Tem um método eql? que é igualzinho a == ou ===, isso é só para pessoas que preferem usar esse método em vez de == ou ===.

Mas, beleza. Como posso comparar duas strings desconsiderando as letras maiúsculas e minúsculas? Tem um método que converte o texto para minúsculas ou para maiúsculas, mas abordarei isso depois.

Mas não se preocupe, temos um método para isso, que é o casecmp?. Veja o exemplo abaixo.

comida = 'Arroz'
comida == 'arroz'
#=> false
comida.casecmp? 'arroz'
#=> true
Enter fullscreen mode Exit fullscreen mode

Simples assim. Também temos o método casecmp sem a interrogação. Esse método, em vez de retornar true ou false, retorna -1, 0 ou 1.

É um pouco difícil explicar isso, então vou mostrar um exemplo.

comida_1 = 'Arroz'
comida_2 = 'Feijão'

# Para retornar -1, a comida_1 deve ser menor que a comida_2
comida_1.casecmp comida_2
#=> -1

# Para retornar 0, a comida_1 deve ser igual à comida_2
comida_2 = 'arroz'
comida_1.casecmp comida_2
#=> 0

# Para retornar 1, a comida_1 deve ser maior que a comida_2
comida_1 = 'Cachorro quente'
comida_1.casecmp comida_2
Enter fullscreen mode Exit fullscreen mode

É um método bem específico, mas vai que, né?

Também tem um outro método que é parecido com o casecmp, só que ele é sensível às letras minúsculas e maiúsculas.

Esse método é o <=>. Veja um exemplo.

comida_1 = 'Arroz'
comida_2 = 'Feijão'

# Para retornar -1, a comida_1 deve ser menor que a comida_2
comida_1 <=> comida_2
#=> -1

# Para retornar 0, a comida_1 deve ser igual à comida_2
comida_2 = 'Arroz'
comida_1 <=> comida_2
#=> 0

# Para retornar 1, a comida_1 deve ser maior que a comida_2
comida_1 = 'Cachorro quente'
comida_1 <=> comida_2
#=> 1
Enter fullscreen mode Exit fullscreen mode

Bem, finalmente, terminamos a parte de consulta. Agora, vamos para a parte de modificação.

Modificando

Vamos aprender a modificar a string, seja inserindo, substituindo, deletando ou capitalizando.

Inserção

Certo, sem muita delonga, vamos ver um exemplo.

nome_completo = 'Alexandre'
nome_completo << ' dos Santos Alves'
nome_completo
#=> "Alexandre dos Santos Alves"
Enter fullscreen mode Exit fullscreen mode

Viu? Simples. Tem uma coisa curiosa que pensei agora. Se eu colocar um inteiro, o que vai acontecer?

texto = 'Alexandre tem ' << 21 << '.'
texto
#=> "Alexandre tem \u0015."
Enter fullscreen mode Exit fullscreen mode

Ué. Por que está \u0015? Onde está o 21? Bem, a resposta é simples.

Quando você está inserindo um inteiro, o método vai considerar esse inteiro como um código ASCII e convertê-lo em um caractere.

Veja a tabela abaixo para entender mais.

ASCII

O número 21 é o Negative Acknowledge, que é \u0015 ou U+0015. Então, para colocar um inteiro na string, você precisa convertê-lo para string. Por exemplo:

texto = 'Alexandre tem ' << String(21) << '.'
# ou
texto = 'Alexandre tem ' << 21.to_s << '.'
Enter fullscreen mode Exit fullscreen mode

Agora, vamos para um outro método.

texto = 'Hoje é o seu dia!'
texto.insert(5, 'não ')
#=> "Hoje não é o seu dia!"
Enter fullscreen mode Exit fullscreen mode

Novamente, é simples. o primeiro argumento é a posição em que será inserido e o segundo argumento é a string que será inserida.

Se o primeiro argumento for negativo, começará pelo final da string. Por exemplo:

texto = 'Hoje é o seu dia!'
texto.insert(-13, 'não ')
#=> "Hoje não é o seu dia!"
Enter fullscreen mode Exit fullscreen mode

Certo, agora vamos para substituição.

Substituição

Vamos supor que eu receba isso: "Por-que-me-olham-estranho?". Como posso trocar o - por espaço?

Temos dois métodos, o sub e o gsub.

Vamos primeiro para o método sub.

texto = 'Por-que-me-olham-estranho?'
texto.sub!('-', ' ')
texto
#=> "Por que-me-olham-estranho?"
Enter fullscreen mode Exit fullscreen mode

Ué? Só trocou o primeiro, e o resto?

Bem, é que este método só troca a primeira ocorrência. Mas temos o outro método gsub, que vai trocar todas as ocorrências.

texto = 'Por-que-me-olham-estranho?'
texto.gsub!('-', ' ')
texto
#=> "Por que me olham estranho?"
Enter fullscreen mode Exit fullscreen mode

Viu?

Não sei se você sabe, mas existem alguns métodos que têm o !. Caso você não saiba, todos os métodos que têm o ! significam que a string em si será alterada. Vamos a um exemplo para facilitar.

# Sem !
texto = 'Por-que-me-olham-estranho?'
texto.gsub('-', ' ')
texto
#=> "Por-que-me-olham-estranho?"

# Com !
texto = 'Por-que-me-olham-estranho?'
texto.gsub!('-', ' ')
texto
#=> "Por que me olham estranho?"
Enter fullscreen mode Exit fullscreen mode

Percebeu a diferença? Basicamente, o método gsub não altera a string da variável texto, o que ele faz é criar uma nova string. Mas como essa nova string não está sendo atribuída a nenhuma variável, ela é jogada fora.

No final deste subcapítulo sobre substituição, vou colocar uma lista de métodos que possuem o !.

Ah, e um aviso, os métodos que possuem o ! podem ser perigosos no sentido de perder a informação, então fique atento.

Certo, agora vamos para um método que seria interessante para você pensar, pois não vou explicar nada sobre isso.

O método é replace, ele é bem simples.

nome = 'Alexandre'
nome.replace 'Zacarias'
nome
#=> "Zacarias"
Enter fullscreen mode Exit fullscreen mode

Agora, deixe-me mostrar um outro código.

nome = 'Alexandre'
nome.replace 'Zacarias'
nome
#=> "Zacarias"

nome = 'Alexandre'
nome = 'Zacarias'
nome
#=> "Zacarias"
Enter fullscreen mode Exit fullscreen mode

Minha pergunta é: Qual é a diferença entre eles? Você sabe responder?

Bem, vamos continuar.

.esrever odotém o rasu a rednerpa somav arogA

Opa, algo deu errado. Deixe-me consertar isso.

texto = ".`esrever` odotém o rasu a rednerpa somav arogA"
texto.reverse!
texto
#=> "Agora vamos aprender a usar o método `reverse`."
Enter fullscreen mode Exit fullscreen mode

Pronto, consertado.

Sinceramente, eu considero este método mais inútil, pois não consigo pensar em que tipo de situação eu usaria isso.

Certo, terminamos a parte de substituição. Mas antes disso, vou mostrar a lista.

  • sub=> sub!
  • gsub=> gsub!
  • reverse=> reverse

Também vou mostrar uma lista de métodos que não abordei, pois deixaria esse artigo muito grande.

  • succ
  • next
  • setbyte
  • tr
  • tr_s

Pronto, agora terminei. Vamos para a deleção.

Capitalização

TOdOs nÓs SaBeMoS qUe LeR uM tExTo DeSse JEItO É nADA AgRaDáVeL, eNtÃO VaMoS CoNsErTaR iSsO. TEmOs tRêS méTOdOs qUe PosSam rESOlvEr iSsO.

paragrafo = 'TOdOs nÓs SaBeMoS qUe LeR uM tExTo DeSse JEItO...'
paragrafo.capitalize!
paragrafo
#=> "Todos nós sabemos que ler um texto desse jeito..."
Enter fullscreen mode Exit fullscreen mode

O método capitalize faz a primeira letra em maiúscula e o resto em minúsculas.

paragrafo = 'TOdOs nÓs SaBeMoS qUe LeR uM tExTo DeSse JEItO...'
paragrafo.downcase!
paragrafo
#=> "todos nós sabemos que ler um texto desse jeito..."
Enter fullscreen mode Exit fullscreen mode

O método downcase deixa todas as letras em minúsculas.

paragrafo = 'TOdOs nÓs SaBeMoS qUe LeR uM tExTo DeSse JEItO...'
paragrafo.upcase!
paragrafo
#=> "TODOS NÓS SABEMOS QUE LER UM TEXTO DESSE JEITO..."
Enter fullscreen mode Exit fullscreen mode

O método upcase deixa todas as letras em maiúsculas.

Também temos um método que inverte as letras maiúsculas para minúsculas e vice-versa.

paragrafo = 'TOdOs nÓs SaBeMoS qUe LeR uM tExTo DeSse JEItO...'
paragrafo.swapcase!
paragrafo
#=> "toDoS NóS sAbEmOs QuE lEr Um TeXtO dEsSE jeiTo..."
Enter fullscreen mode Exit fullscreen mode

Estes quatro métodos que abordei também têm a versão sem o !.

Agora, vamos para a deleção.

Deleção

O método que vou apresentar tem o mesmo comportamento do replace, porém, ele limpa a string.

nome = 'Alexandre'
nome.clear
nome
#=> ""
Enter fullscreen mode Exit fullscreen mode

Vou fazer a mesma pergunta que fiz com replace. Qual é a diferença entre eles?

nome = 'Alexandre'
nome.clear
nome
#=> ""

nome = 'Alexandre'
nome = ''
nome
#=> ""
Enter fullscreen mode Exit fullscreen mode

Certo, mas eu não quero apagar tudo, eu quero remover alguns caracteres.

Simples, é usar o slice.

texto = 'Não seja livre!'
texto.slice! 'Não '
#=> "Não "
texto
#=> "seja livre!"
Enter fullscreen mode Exit fullscreen mode

O método slice aceita vários tipos de argumentos, como String, Range, RegEx, início/tamanho e índice.

Por exemplo:

# Range
texto = 'Não seja livre!'
texto.slice! 0...4
#=> "Não "
texto
#=> "seja livre!"

# RegEx
texto = 'Não seja livre!'
texto.slice!(/s.{4}/)
#=> "seja "
texto
#=> "Não livre!"

# Início/tamanho
texto = 'Não seja livre!'
texto.slice!(0, 4)
#=> "Não "
texto
#=> "seja livre!"

# Índice
texto = 'Não seja livre!'
texto.slice!(0)
#=> "N"
texto
#=> "ão seja livre!"
Enter fullscreen mode Exit fullscreen mode

Agora, vou mostrar um método que, antes, eu pensava ser inútil, mas agora consigo pensar em situações em que ele seria útil. Esse método é o squeeze.

texto = 'Era uma        vez um rei egoísta.'
texto.squeeze!
texto
#=> "Era uma vez um rei egoísta."
Enter fullscreen mode Exit fullscreen mode

O que ele faz é basicamente remover caracteres que se repetem um ao lado do outro.

Existe um problema nisso, você sabe qual é? Deixe-me mostrar um exemplo.

texto = 'Tem um problema nisso.'
texto.squeeze!
texto
#=> "Tem um problema niso."
Enter fullscreen mode Exit fullscreen mode

Viu? Ele removeu o s da palavra nisso, mas para resolver isso, é super de boa.

O método aceita um argumento chamado Character Selector, que é basicamente uma string.

Mas, antes de explicar isso, vamos partir para o método delete, pois ele também aceita o mesmo argumento. A mesma coisa se aplica ao método count, que foi abordado, mas que eu acabei não explicando no momento, pois queria explicar isso agora.

texto = 'O rato roeu a roupa do rei de Roma.'
texto.delete! 'r'
texto
#=> "O ato oeu a oupa do ei de Roma."
Enter fullscreen mode Exit fullscreen mode

Nada complicado, ele deletou todos os caracteres r do texto.

Agora que o método foi explicado, vou falar sobre o Character Selector. A maneira mais fácil de explicar é mostrando o código com comentários.

# Removendo os caracteres A, R e O
texto = 'O rato roeu a roupa do rei de Roma.'
texto.delete! 'aro'
texto
#=> "O t eu  up d ei de Rm."

# Removendo os caracteres de A a E
texto = 'Não soube viver, até que um dia'
texto.delete! 'a-e'
texto
#=> "Não sou vivr, té qu um i"
# Colocando o - entre dois caracteres, será interpretado que é para remover o tal a tal

# Removendo o caractere A e os caracteres de R a U.
texto = 'Então, senta e ouve essa história'
texto.delete! 'ar-u'
texto
#=> "Enão, en e ove e hiói"

# Removendo todos os caracteres com exceção de R
texto = 'O rato roeu a roupa do rei de Roma.'
texto.delete! '^r'
texto
#=> "rrrr"
# Colocando o ^ antes de um caractere, será interpretado que não é para remover esse caractere.

# Removendo o caractere -
texto = 'O-rato-roeu-a-roupa-do-rei-de-Roma.'
texto.delete! '\-'
texto
#=> "OratoroeuaroupadoreideRoma."
# Colocando o \ antes de um caractere, como circunflexo, hífen ou outra barra invertida, atua como escape.
Enter fullscreen mode Exit fullscreen mode

Não sei se ficou boa a explicação, mas espero que você tenha entendido.

Saiba que isso é aplicado somente aos métodos: count, delete, tr, tr_s e squeeze. Qualquer dúvida, pesquise na documentação para saber mais.

Faltam mais cinco métodos para acabar com esse subcapítulo.

Vamos supor uma situação em que um usuário registrou um material, mas o nome do material está estranho. Por exemplo:

"              Parafuso Allen Inox M8 X 20              "
Enter fullscreen mode Exit fullscreen mode

Sabe qual seria o problema? Tem espaço em branco no começo e no final do nome do material, e convenhamos que isso não será agradável quando visualizar o nome, se não for tratado.

Então, antes de registrar o material no banco de dados, vamos tratá-lo.

material = '                    Parafuso Allen Inox M8 X 20              '
material.strip!
material
#=> "Parafuso Allen Inox M8 X 20"
Enter fullscreen mode Exit fullscreen mode

Mas não é só isso, temos também dois métodos parecidos com strip, que são lstrip e rstrip. Vamos ver um exemplo.

# Remove espaços em branco do começo
material = '                    Parafuso Allen Inox M8 X 20'
material.lstrip!
material
#=> "Parafuso Allen Inox M8 X 20"

# Remove espaços em branco do final
material = 'Parafuso Allen Inox M8 X 20              '
material.rstrip!
material
#=> "Parafuso Allen Inox M8 X 20"
Enter fullscreen mode Exit fullscreen mode

Certo, vamos cortar!

Sinceramente, um outro método que considero inútil, veja você mesmo.

"abc\r\n".chop!
#=> "abc"

"abcdd".chop!
#=> "abcd"

"abcd".chop!
#=> "abc"
Enter fullscreen mode Exit fullscreen mode

Eu não consigo pensar em que situação você usaria esse método. Você teria que ter uma condição para o caso de querer remover o \r\n, senão ele vai cortar o último caractere.

O que seria útil é o método chomp, que é a mesma coisa que o chop, porém você pode passar um argumento para especificar o que deseja que ele remova no final da string.

# Por padrão, ele remove os caracteres \n, \r ou \r\n do final da string.
"abc\r".chomp!
#=> "abc"

"abc\n".chomp!
#=> "abc"

"abc\r\n".chomp!
#=> "abc"

"abc\n\r".chomp!
#=> "abc\n"

# Quando o argumento é '', ele removerá todas as ocorrências de \n ou \r\n.
"abc\n\n\n".chomp!('')
#=> "abc"

"abc\r\n\r\n\r\n".chomp!('')
#=> "abc"

"abc\n\n\r\n\r\n\n\n".chomp!('')
#=> "abc"

"abc\n\r\n\r\n\r".chomp!('')
#=> "abc\n\r\n\r\n\r"

"abc\r\r\r".chomp!('')
#=> "abc\r\r\r"

# Quando o argumento não for `\n` ou `''`, ele removerá o caractere que foi passado.
'abcd'.chomp('d')
#=> "abc"

'abcdd'.chomp('d')
#=> "abcd"
Enter fullscreen mode Exit fullscreen mode

Certo, terminamos a parte de deleção. Mas antes disso, vou mostrar a lista de métodos que possuem !.

  • slice=> slice!
  • squeeze=> squeeze!
  • delete=> delete!
  • lstrip=> rstrip!
  • rstrip=> rstrip!
  • strip=> strip!
  • chomp=> chomp!
  • chop=> chop!

Iterando

Bem, tem seis métodos para fazer iteração, mas só vou abordar dois, pois não estou afim de explicar o resto.

Temos o método each_char que itera letra por letra.

texto = "Sou o mestre do meu mar."
texto.each_char { |c| print(c, '-') }
#S-o-u- -o- -m-e-s-t-r-e- -d-o- -m-e-u- -m-a-r-.-
Enter fullscreen mode Exit fullscreen mode

Temos o método each_lineque itera linha por linha

texto = "Sou \no \nmestre \ndo \nmeu \nmar."
texto.each_line { |l| print l }
#Sou 
#o 
#mestre 
#do 
#meu 
#mar.
Enter fullscreen mode Exit fullscreen mode

Pronto, é só isso. Mas eu mostrarei a lista dos métodos que não foram abordados.

  • each_byte
  • each_codepoint
  • each_grapheme_cluster
  • upto

Convertendo em Uma Nova String

Sabe aqueles métodos que têm o !? Então, você deve ter visto esses métodos também sem o !. Isso acontece porque, em vez de modificar a string original, eles retornam uma nova string.

Como já abordei os métodos que têm a versão com !, não vou mostrar novamente aqueles que têm a versão sem o !. Vou apenas apresentar outros métodos que não têm o !.

Extensão

Quando estamos falando de extensão, estamos falando de estender a string.

Vamos com um clássico.

nome = 'Alexandre' + ' ' + 'dos' + ' ' + 'Santos' + ' ' + 'Alves'
nome
#=> "Alexandre dos Santos Alves"
Enter fullscreen mode Exit fullscreen mode

Nada demais, vamos para outro método que é parecido. Só que este método modifica a string original.

nome = 'Alexandre'
nome.concat(' ', 'dos', ' ', 'Santos', ' ', 'Alves')
nome
#=> "Alexandre dos Santos Alves"
Enter fullscreen mode Exit fullscreen mode

Certo, mas qual é a diferença? Bem, descubra você mesmo.

Agora, vamos para outro método que é parecido com concat, só que ele concatena no começo da string.

nome = 'o Grande.'
nome.prepend 'Alexandre, '
#=> "Alexandre, o Grande."
Enter fullscreen mode Exit fullscreen mode

Eu sei que não sou o único que faz isso, mas você já fez uma linha para melhorar a visualização dos dados que estão sendo exibidos no terminal quando tem muita informação?

# O que eu geralmente faço em outra linguagem.
puts '=================================================='
puts 'Informação'
puts '=================================================='
#==================================================
#Informação
#==================================================

# O que faço no Ruby.
puts '=' * 50
puts 'Informação'
puts '=' * 50
#==================================================
#Informação
#==================================================
Enter fullscreen mode Exit fullscreen mode

Certo, agora vamos supor que queira centralizar o texto no terminal, como posso fazer isso?

É só usar o método center.

puts '=' * 50
puts 'Informação'.center 50
puts '=' * 50
#==================================================
#                    Informação                    
#==================================================
Enter fullscreen mode Exit fullscreen mode

O método center aceita dois argumentos, o primeiro argumento é o tamanho e o segundo é o que você deseja preencher nesse espaço criado.

Por padrão, o segundo argumento é um espaço em branco. Vamos ver mais um exemplo.

puts '=' * 50
puts 'Informação'.center(50, '-')
puts '=' * 50
#==================================================
#--------------------Informação--------------------
#==================================================
Enter fullscreen mode Exit fullscreen mode

O que acontece quando o tamanho é menor que o da string? Bem, nada. A centralização só vai acontecer se o tamanho for maior que o da string.

puts 'Informação'.center(5, '-')
#Informação
Enter fullscreen mode Exit fullscreen mode

Mas eu quero deixá-lo à direita. Existe um método para isso? Sim! É a mesma coisa que o center, o método aceita os dois argumentos.

puts '=' * 50
puts 'Informação'.rjust 50
puts '=' * 50
#==================================================
#                                        Informação
#==================================================

puts '=' * 50
puts 'Informação'.rjust(50, '-')
puts '=' * 50
#==================================================
#----------------------------------------Informação
#==================================================
Enter fullscreen mode Exit fullscreen mode

Também tem a de esquerda.

puts '=' * 50
puts 'Informação'.ljust 50
puts '=' * 50
#==================================================
#Informação                                        
#==================================================

puts '=' * 50
puts 'Informação'.ljust(50, '-')
puts '=' * 50
#==================================================
#Informação----------------------------------------
#==================================================
Enter fullscreen mode Exit fullscreen mode

Convertendo Uma String em Uma Não-String

Como assim uma não-string?

Bem, como o nome sugere, é qualquer objeto que não seja uma String, como Integer, Float, Array etc.

Vamos começando convertendo uma String em Array.

Como este artigo já está ficando grande e os métodos que vou apresentar são bem fáceis de entender, vou apresentar todos os métodos de uma vez.

# Retorna um array de caracteres.
'Alexandre'.chars
#=> ["A", "l", "e", "x", "a", "n", "d", "r", "e"]

# Retorna um array de bytes.
'Alexandre'.bytes
#=> [65, 108, 101, 120, 97, 110, 100, 114, 101]

# Retorna um array de palavras de acordo com o delimitador.
# O método split pode receber dois argumentos: o primeiro é o
# delimitador e o segundo é o limite do tamanho do array.
# Por padrão, o delimitador é um espaço em branco.
'Não posso controlar minha mente.'.split
#=> ["Não", "posso", "controlar", "minha", "mente."]

'Não-posso-controlar-minha-mente.'.split
#=> ["Não-posso-controlar-minha-mente."]

'Não-posso-controlar-minha-mente.'.split '-'
#=> ["Não", "posso", "controlar", "minha", "mente."]

'Não-posso-controlar-minha-mente.'.split('-', 3)
#=> ["Não", "posso", "controlar-minha-mente."]

# Retorna um array de linhas de acordo com o delimitador.
# Por padrão, o delimitador é \n
"Os espinhos a protegem\nPois não quer mais ser ferida".lines
#=> ["Os espinhos a protegem\n", "Pois não quer mais ser ferida"]

# Percebeu que ele não removeu o \n? Para remover isso, basta fazer isso.
"Os espinhos a protegem\nPois não quer mais ser ferida".lines(chomp: true)
#=> ["Os espinhos a protegem ", "Pois não quer mais ser ferida"]

# Vamos supor que você queira separar por ---
"Os espinhos a protegem---Pois não quer mais ser ferida".lines('---', chomp: true)
#=> ["Os espinhos a protegem", "Pois não quer mais ser ferida"]

# Agora vamos converter a string em número
# Inteiro
'102'.to_i
#=> 102

'102.92'.to_i
#=> 102

# Float
'102'.to_f
#=> 102.0

'102.92'.to_f
#=> 102.92
Enter fullscreen mode Exit fullscreen mode

Finalmente!!! Terminamos!!!

Aqui está a lista de métodos que não foram abordados:

  • codepoints
  • getbyte
  • grapheme_clusters
  • partition
  • rpartition
  • scan
  • unpack
  • unpack1
  • hex
  • oct
  • ord
  • inspect
  • to_sym
  • intern

Conclusão

Certo, eu sei que não abordei todos os métodos, pois não consegui pensar em uma forma de explicar isso de forma simplificada.

Bem, já estou cansado. Vou terminar por aqui. Então, tchau!

Top comments (0)

Read next

baweaver profile image

Noah Gibbs: Mentor, Friend, Ally

Brandon Weaver -

alexandrecalaca profile image

Vaga Desenvolvedor Backend - Ruby on Rails - AGROS

Alexandre Calaça -

lcsm0n profile image

Transaction Safety in Rails: Identifying and Addressing Non-Atomic Interactions

Lucas M. -

daviducolo profile image

Ollama and Ruby: Building Powerful AI-Powered Applications

Davide Santangelo -