Usando os métodos da classe String no Ruby
Tags: ruby, string, classe
Published: 2022-11-18 08:37:05

String é uma sequência de caracteres.

O objeto string tem muitos métodos que você pode usar no seu projeto.

Aqui você vai aprender quase todos os métodos.

## Índice

* [Consultando string] (#consultando)
  - [Checando o tamanho da string] (#tamanho)
  - [Checando se a string está vazia] (#vazio)
  - [Checando a quantidade de letras] (#quantidade)
  - [Checando a existência de uma palavra] (#existencia)
  - [Comparando as strings] (#comparando)
* [Modificando string] (#modificando)
  - [Inserção] (#insercao)
  - [Substituição] (#substituicao)
  - [Maiúscula e minúscula] (#maiuminu)
  - [Deletar uma palavra] (#deletar)
  - [Convertendo para um novo string] (#novo_string)
  - [Convertendo para um não string] (#nao_string)
* [Métodos para Iterar] (#iterar)
* [Conclusão] (#conclusao)

***

Então, vamos começar consultando a string.

## Consultando string <a name="consultando"></a>

### Checando o tamanho da string <a name="tamanho"></a>

Primeiro, vamos saber qual é o tamanho da string.

Nós temos dois métodos que pode verificar o tamanho da string.

#### Exemplo:

```ruby
nome = "Alexandre"
nome.length
#=> 9
# ou
nome.size
#=> 9
```
Ambos métodos são iguais, então não faz diferenças você usar o `length` ou o `size`.


Agora vamos checar se a string está vazia.

### Checando se a string está vazia <a name="vazio"></a>


Aposto que você usaria o método `length` e compararia se ele é igual `0` para checar se ele está vazio.

Não tem problema usar ele, porém, no ruby temos método para isso.

#### Exemplo:

```ruby
minha_barriga = ""
minha_barriga.empty?
#=> true
```
Convenhamos que isso é mais bonito, né?

Agora vamos checar quantas letras que existe na string.

### Checando a quantidade de letras <a name="quantidade"></a>


Às vezes, você quer saber a quantidade da letra "a" tem no string.

#### Exemplo:

```ruby
letra = "Querido diário, desculpe o erro ao digitar..."
letra.count "i"
#=> 5
```

Saiba que ele não conta a quantidade de palavra e sim os caracteres.

#### Exemplo:

```ruby
letra = "Querido diário, desculpe o erro ao digitar..."
letra.count "dia"
#=> 11
```

Viu, ele contou a letra "d", depois "i" e por fim o "a", e somou no final.

Agora sim, vamos verificar se existe uma palavra na string.

### Checando a existência de uma palavra <a name="existencia"></a>


Agora você quer saber se existe uma palavra ou conhecer a sua posição.

Tem alguns métodos que utiliza regex para buscar, porém, eu não vou demonstrar eles, então deixarei isso para outro tema.

Chega de papo, vamos ver os métodos.

Para saber a posição de um palavra, podemos usar o `index`.

#### Exemplo:

```ruby
texto = "Você achou que eu estava brincando, hein, você achou!?"
texto.index "achou"
#=> 5
```

Se você observar o texto, pode perceber que existe outro "achou", é possível pegar a posição dele?

Sim, é possível, basta usar `rindex`, ele busca a última palavra que existe no texto.

```ruby
texto.rindex "achou"
#=> 47
```

Mas eu não quero a posição dele, só quero saber se ele está na string.

Não tem problema, amigo!

Você pode usar `include?`.

```ruby
texto = "Alexandre é um bacaca"
texto.include? "gente boa"
#=> false

texto.include? "bacaca"
#=> true
```

Tem como eu saber que ele começa com uma palavra, ou se termina com ela?

Pode crer, meu amigo, existem métodos para isso.

Apresento-lhes os `start_with?` e `end_with?`.

```ruby
nome_completo = "Alexandre dos Santos Alves"
nome.start_with? "Alexandre"
#=> true

nome.end_with? "Ferreira"
#=> false
```

Acabamos com os métodos que checar a string, agora vamos para aprender a comparar as strings.

### Comparando as strings <a name="comparando"></a>


Não tem muitos mistérios em comparar, basta usar o `==` ou `===` que resolve o problema, só que, como que compara as string ignorando maiúsculas e as minúsculas?

Talvez você pense, deve ter um método que deixa a string  maiúsculas/minúsculas e assim compara com `==`.

Bem, Você não está errado, afinal de conta, existe o método que transformar a string em maiúsculas/minúsculas, que irei abordar lá abaixo.

Mas sabe como é, ruby tem método para isso.

#### Exemplo:

```ruby
nome = "AlExaNDre"
nome.casecmp? "alexandre"
#=> true
```

Simples.

Tem outros métodos que comparar, porém, não vou abordar-las.
Mas vou deixar uma lista de métodos que não abordei lá no final.

Agora vamos aprender a modificar o string.

## Modificando string <a name="modificando"></a>


### Inserção <a name="insercao"></a>

Bem, não tenho muito o que falar sobre inserção, então veja os exemplos.

#### Exemplos:

```ruby
nome = "Alexandre"
nome << " dos Santos Alves"
nome
#=> "Alexandre dos Santos Alves"
```

Tem uma coisa curiosa que vem em mente, e se eu colocar número, vai preencher com número?

Bem, se pensar superficialmente, sim deveria, porem... Vamos testar.

```ruby
texto = "Alexandre tem " << 19
texto
#=> "Alexandre tem \u0013"
```

Ué, cadê o 19?

Se você estudou um assunto que envolva isso, talvez tenha pego o que aconteceu, se não entendeu, não tem problema, vou explicar.

Eu te apresento a tabela ASCII.

Vou mostrar uma imagem de uma tabela.

![Tabela ASCII](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vrsfowvs164o081vs1kg.png)

Podemos ver a tabela que contém números e caracteres, o que são eles?

Vamos pegar a nossa amiga Wikipédia para explicar isso.

> Código Padrão Americano para o Intercâmbio de Informação (do inglês American Standard Code for Information Interchange - ASCII, pronunciado [áski]) é um sistema de representação de letras, algarismos e sinais de pontuação e de controle, através de um sinal codificado em forma de código binário (cadeias de bits formada por vários 0 e 1), desenvolvido a partir de 1960, que representa um conjunto de 128 sinais: 95 sinais gráficos (letras do alfabeto latino, algarismos arábicos, sinais de pontuação e sinais matemáticos) e 33 sinais de controle, utilizando 7 bits para representar todos os seus símbolos.

Ou seja, se você não entendeu a explicação, vou explicar de maneira fácil e resumida e ignorando coisa que não importa.

O número indica qual é o caractere que pertence a ele.

Por exemplo, 101, ele pertence a caractere "e", ou vice-versa, a letra "e" pertence o número 101, simples assim.

Agora vamos ver a tabela novamente, o número 19 fala sobre device control 3, ou seja, são informações irrelevantes para nós.

O que importa para gente são os números 32 até o 126, que são visíveis para nós, então vamos testar esses números.

```ruby
texto = "Alexandre tem " << 49 << 57
texto
#=> "Alexandre tem 19"
```

Ai está, mas sinceramente hein, para que fazer isso, basta colocar entre aspas no 19, que vai ser mais legível.

Mas é bom saber esse tipo de coisa, vai que algum momento da sua vida, você está usando isso e descobre que está dando erro em algum lugar e você não sabe.

Bem, vamos continuar.

Agora, você quer colocar uma letra ou palavra em um determinada posição. Por exemplo.

```ruby
texto = "Hoje é o seu dia!"
texto.insert 5, "não "
#=> "Hoje não é o seu dia!"
```

O primeiro parâmetro aceita o índice, e segundo aceita um string.

Agora vamos substituir uma palavra pela outra palavra.

### Substituição <a name="substituicao"></a>

Bem, e se eu receber uma string desse jeito, "opa-como-vai", 
beleza dá pra ler, só que eu não gosto esse simbolo de menos, então vamos trocar pelos espaços.

```ruby
string = "opa-como-vai"
string.sub "-", " "
#=> "opa como-vai"
```

Ué! Não trocou todos os símbolos.

Hum, deixe-me observar o método, o primeiro argumento é o "-" e segundo é " ", em que, logicamente, é para substituir o "-" para " ".

Ah, sou estúpido, esse método `sub` só troca a primeira letra ou palavra que for encontrado.

Vamos usar o método correto agora.

```ruby
string = "opa-como-vai"
string.gsub "-", " "
#=> "opa como vai"
```

Agora foi. Esse método `gsub` vai substituir todas as letras ou palavras que foi declarado no primeiro argumento para o segundo argumento.


Bem, agora eu não sei que vou explicar profundamente sobre o método `replace` ou se mostro um exemplo e você tira a sua própria conclusão.

Gostei mais da segunda opção, tome um exemplo.

```ruby
nome = "Alexandre"
nome.replace "Paulo"
#=> "Paulo"
```

Vou deixar um dever de casa para você.

```ruby
nome = "Alexandre"
nome = "Paulo"
nome
#=> "Paulo"

nome = "Alexandre"
nome.replace "Paulo"
#=> "Paulo"
```

Qual é a diferença entre atribuir uma string e usar o método `replace`?

Quero que você descubra, se for possível, poste a resposta no comentário.

Bem, vamos continuar.

.`esrever` o rasu a rednerpa somav arogA

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

```ruby
texto = ".`esrever` o rasu a rednerpa somav arogA"
texto.reverse
#=> "Agora vamos aprender a usar o `reverse`."
```

Pronto consertei.

Para mim, considero esse é o método mais inútil. Pois, eu não consigo pensar em usar esse método em algum lugar. A não ser que alguém esclareça para mim a utilidade dele.

Bem, vamos voltar com métodos úteis.

### Maiúscula e minúscula <a name="maiuminu"></a>

ToDoS NóS sAbeMos qUe um TEXtO BeM FEitO TEM que sEgUir aS rEGRas de maIúScUlas E minúSCuLas, sEnÃo vOCê vAi TeR difiCuLDAde em leR, cOmo AgORa.

Caso você receba um mensagem assim, basta usar o método `capitalize` que o ruby cuida disso.

```ruby
paragrafo = "ToDoS NóS sAbeMos qUe um TEXtO BeM FEitO TEM..."
paragrafo.capitalize
#=> "Todos nós sabemos que um texto bem feito tem..."
```

Agora quero deixar todas as letras em minúsculas.

Sem problema.

```ruby
paragrafo = "ToDoS NóS sAbeMos qUe um TEXtO BeM FEitO TEM..."
paragrafo.downcase
#=> "todos nós sabemos que um texto bem feito tem..."
```

E maiúsculas?

```ruby
paragrafo = "ToDoS NóS sAbeMos qUe um TEXtO BeM FEitO TEM..."
paragrafo.upcase
#=> "TODOS NÓS SABEMOS QUE UM TEXTO BEM FEITO TEM..."
```

E se eu quero trocar o maiúscula pela minúscula e vice-versa?

```ruby
paragrafo = "ToDoS NóS sAbeMos qUe um TEXtO BeM FEitO TEM..."
paragrafo.swapcase
#=> "tOdOs nÓs SaBEmOS QuE UM texTo bEm feITo tem..."
```

Isso é tudo sobre maiúscula e minúscula.

Agora vamos remover alguns caracteres da string.

### Deletar uma palavra <a name="deletar"></a>


Novamente, tenho dúvida com o método `clear`, parecido com `replace`, então eu vou mostrar um exemplo.

E se você soube responder sobre a diferença no método `replace`, aqui vai ser a mesma coisa.

```ruby
nome = "Alexandre"
nome.clear
nome
#=> ""
```

Mas, eu não quero apagar tudo, somente algumas coisas.

```ruby
texto = "Não seja livre!"
texto.slice! "Não"
#=> "Não"
texto
#=> " seja livre!"
```

O método `slice` aceita o vário tipo de argumento, como string, regex, range, começo/tamanho ou índice.

Vou mostrar um exemplo para cada argumento, menos regex.

Eu já mostrei do string acima.

```ruby
# range
texto = "Não seja livre!"
texto.slice! 0..2
#=> "Não"
texto
#=> " seja livre!"

# começo/tamanho
texto = "Não seja livre!"
texto.slice! 0, 3
#=> "Não"
texto
#=> " seja livre!"

# índice
texto = "Não seja livre!"
texto.slice! 0
#=> "N"
texto
#=> "ão seja livre!"
```

Eu não sei se você sabe a diferença de um método que tem exclamação e que não tem.

Então vou explicar, os métodos que tem exclamação como o `slice`, modifica o valor da variável, para que evite ficar atribuindo. Por exemplo.

```ruby
nome = "alexandre"
nome = nome.capitalize
nome
#=> "Alexandre"
```

Ao invés de fazer isso, faça isto.

```ruby
nome = "alexandre"
nome.capitalize!
#=> "Alexandre"
```

Muito mais reduzido, e mais legível. Porém, ele é perigoso, foi avisado.

Porque ele é perigoso?

Pelo fato de que pode modificar o próprio valor, e se houver uma situação em que você vai precisar o valor anterior, só que você acabou de perder e ai meu amigo, nem vou falar nada.

No final, eu vou colocar uma lista, os métodos que tem essa exclamação.

Bem, vamos continuar.

Agora, vamos supor que você recebe uma string assim "Allleexxandddrre", e quer tratar ele, removendo letra que se repete adjacente.

```ruby
nome = "Allleexxandddrre"
nome.squeeze!
#=> "Alexandre"
```

Tem vezes que um cliente da sua aplicação faz por engano ou pela maldade de colocar espaço em branco na esquerda, ou direita de uma string. Por exemplo.

```ruby
campo = "                         opa"
# ou
campo = "opa                         "
# ou até
campo = "                         opa                       "
```

Então para resolver, basta usar `lstrip`, `rstrip`ou `strip`.

#### Exemplo
```ruby
campo = "                         opa"
campo.lstrip! # remove espaço em braco da esquerda
#=> "opa"

campo = "opa                         "
campo.rstrip! # remove espaço em braco da direita
#=> "opa"

campo = "                         opa                       "
campo.strip! # remove espaço em braco ambos lados
#=> "opa"
```

Se você já pediu ao usuário alguma entrada usando o método gets, então já deve ter visto a quebra de linha no final da string.

```ruby
string = gets
#=> "opa\n"
```

Então remover isso basta usar o `chomp`, que remove o \n do final.

```ruby
string = gets.chomp
#=> "opa"
```

### Convertendo para um novo string <a name="novo_string"></a>


Existem alguns métodos que acabam gerando um novo string, o que é o caso de não usar o "!" no final do método, porém, eu não vou abordar eles novamente, então sobra somente aqueles que não tem esse "!" no final.


Eu não sei se sou o único que faz isso, de printar uma linha no terminal para facilitar o meu "debug", por exemplo.

```ruby
puts "--" * 20
# ----------------------------------------
```

Isso me ajuda bastante, quando uso o ruby on rails que tem muita informação sendo mostrado no terminal.

Mas bem, esse é asterisco que faz uma operação de multiplicação de concatenar ele mesmo.

Não tem segredo sobre isso.

Mas quero concatenar duas string, simples use o +.

```ruby
nome_1 = "Alexandre"
nome_2 = "Desconhecida"

nome_1 + " com " + nome_2
#=> "Alexandre com Desconhecida"
```

Só que é meio feio, vamos dizer assim.

Mas não se preocupe tem um outro método que é o `concat` e adivinhe o que ele pode fazer.

```ruby
nome = "Alexandre"

nome.concat(32, "com", 32, "Desconhecida")
#=> "Alexandre com Desconhecida"
```

Viu teve o mesmo resultado, só que eu coloquei o número e ele transformou em espaço?

Vou te dar um spoiler sobre isso.

Começa com A e termina com I. suba que tem resposta lá em cima.

Bem, também é possível concatenar no começo da string usando o `prepend`.

```ruby
nome = "Fome"
nome.prepend "Estou com "
#=> "Estou com Fome"
```

Porém ele não aceita números, somente string.

Não sei se você já brincou com terminal, e queria deixa organizado o texto, como centralizar ele ou deixar na direita.

E saiu frustado, pois não conseguia.

Bem, o ruby vai facilitar esse trabalho para você.

```ruby
texto = "Calculadora Foda"
texto.center 34
#=> "         Calculadora Foda         "
```

voilá, ele centralizou.

Bem, vamos entender esse método.

Os argumentos que ele aceita é comprimento e o que vai cobrir nesse espaço vazio.

Um detalhe importante de se notar, é que o número que passei no exemplo acima é grande, porém, se você ver o que ele retornou, nem parece que foi 34 em espaço em branco.

Só que se você contar quantos caracteres tem, você vai ver que tem exatamente 34.

vamos usar o ruby para contar.

```ruby
texto = "Calculadora Foda"
texto = texto.center 34
texto.length
#=> 34
```

E se eu passar um número menor do tamanho da string?

Bem, não vai acontecer nada, veja.

```ruby
texto = "Calculadora Foda"
texto.center 1
#=> "Calculadora Foda"
```

E aquilo que você citou de cobrir o espaço vazio?

Observe.

```ruby
texto = "Calculadora Foda"
texto.center 34, "="
#=> "=========Calculadora Foda========="
```

Viu, é isso o que ele faz.

Mas se eu não quero centralizar e sim deixar ele na direita.

Sem problema, o método `rjust` é igual o `center`, só que colocar espaço branco a esquerda.

```ruby
texto = "Status: 34%"
texto.center 34
#=> "                       Status: 34%"
```

Então, se tem para esquerda, deve ter para direita?

Sim.

```ruby
texto = "Baixando"
texto.center 34, "."
#=> "Baixando.........................."
```

Pronto, acabamos com os métodos que gera um novo string, agora vamos partir para gera um não string.

### Convertendo para um não string <a name="nao_string"></a>


Como assim um não string?

É qualquer classe que não seja `String`, por exemplo, `Integer`, `Float`, `Array` etc.

Vamos começar com `Array`.

Como eu posso transformar um texto em array?

Bem, depende, você quer um array com letras ou palavras?

Se quer letras, pode usar o métodos `chars` ou usar `split` para palavras.

#### Exemplos

```ruby
texto = "Quem sou eu?"
texto.chars
#=> ["Q", "u", "e", "m", " ", "s", "o", "u", " ", "e", "u", "?"]

texto.split
#=> ["Quem", "sou", "eu?"]
```

Bem, não tem nada para explicar sobre o método `chars`, então vamos para `split`.

Os argumentos que o `split` aceita são o delimitador e o tamanho do array.

Vamos para exemplos.

```ruby
# definindo o delimitador
texto = "Me-perdi-na-profundeza-de-um-vasto-oceano..."
texto.split "-"
#=> ["Me", "perdi", "na", "profundeza", "de", "um", "vasto", "oceano..."]

# definindo o tamanho do array
texto.split "-", 3
#=> ["Me", "perdi", "na-profundeza-de-um-vasto-oceano..."]
```

E se quisemos separar o texto de acordo com a quebra de linha?

Podemos usar o método `lines`.

```ruby
texto = "Eu já tentei de tudo\nA minha mente acelera..."
texto.lines
#=> ["Eu já tentei de tudo\n", "A minha mente acelera..."]

# se quer tirar esse \n
texto.lines chomp: true
#=> ["Eu já tentei de tudo", "A minha mente acelera..."]
```

Agora vamos string em inteiro ou float.

Não tem mistério.

```ruby
numero_string = "120"
numero_strin.to_i
#=> 120

# transformando para float
numero_strin.to_f
#=> 120.0

# e se string for um float e transformar para inteiro
numero_string = "120.12"
numero_strin.to_i
#=> 120
```

Tamos quase no fim.

Só mais dois métodos.

## Métodos para Iterar <a name="iterar"></a>

Usando `each_char` para iterar caracteres.

```ruby
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 .
```

Usando `each_line` para iterar linhas.
```ruby
texto = "Sou \no \nmestre \ndo \nmeu \nmar."
texto.each_line { |c| print c }
# Sou 
# o 
# mestre 
# do 
# meu 
# mar.
```

E fim.

## Conclusão <a name="conclusao"></a>

Se você chegou até aqui, meus parabéns por ter aguentando dessa longa jornada.

Com isso, você sabe quais são os métodos que existem na classe `String`, e usará ao seu favor, sem ter que reinventar a roda.

Bem, agora vou colocar as listas que prometi.

### Lista de métodos que terminam com !

- sub!
- gsub!
- reverse!
- capitalize!
- downcase!
- upcase!
- swapcase!
- slice!
- squeeze!
- delete!
- lstrip!
- rstrip!
- strip!
- chomp!
- chop!

### Lista de métodos que não foram mencionados

- #+string
- #-string
- bytesize
- #=~
- match
- match?
- encoding
- unicode_normalized?
- valid_encoding?
- ascii_only?
- sum
- hash
- eql?
- #<=>
- casecmp
- succ!, next!
- setbyte
- tr!
- tr_s!
- encode!
- unicode_normalize!
- scrub!
- force_encoding
- b
- dump
- undump
- %
- delete_prefix
- delete_suffix
- byteslice
- chr
- to_s, $to_str
- bytes
- codepoints
- getbyte
- grapheme_clusters
- partition
- rpartition
- unpack
- unpack1
- hex
- oct
- ord
- inspect
- to_sym, intern
- each_byte
- each_codepoint
- each_grapheme_cluster
- upto

Grande né. Talvez um dia eu abordo eles.

Bem, Agradeço por ter lido até aqui e espero que isso tenha ajudado.

Tchau!