No artigo anterior, discutimos os conceitos básicos dos tipos de dados em programação. Agora, vamos aprofundar nosso entendimento sobre cada tipo, explorando suas características, capacidades e limitações.

Apresentação

Até aqui já sabemos que:

  • Um programa: é um grupo de comandos que o computador segue um por um.

  • Linguagem de programação: é o jeito que nós usamos para escrever esses comandos. Ruby é um exemplo de linguagem de programação.

  • Código Ruby: quando escrevemos um código Ruby, estamos mostrando para o computador o que ele deve fazer com informações ou dados.

Um dado é qualquer coisa que o programa usa: pode ser um número, uma palavra, uma lista de itens, ou até uma resposta de “sim ou não”.

No Ruby, cada dado tem um tipo específico para armazenar e manipular essas informações corretamente mostrando ao computador o que é cada dado.

Exemplo:

idade = 30 
nome  = "Ana"

Aqui:

  • idade é um número inteiro (Integer) que guarda o dado numérico 30.
  • nome é um texto (String) que guarda a palavra “Ana”.

Agora que recapitulamos os conceitos básicos, é importante também entender algumas palavras que vamos usar em todos os exemplos como: objeto, classe, instância e método, além do conceito de variável que já foi apresentado no artigo anterior. Essas definições vão ajudar a entender melhor o conteúdo.

Você não precisa aprender tudo sobre essas definições agora, mas é importante entender o básico para conseguir acompanhar quando falarmos dos tipos de dados de um jeito mais detalhado.

Dito isso, vamos às definições.

Definições Importantes

Vamos falar sobre:

  • Objetos
  • Classes
  • Instâncias
  • Métodos
  • Variáveis

O que é um objeto?

Em Ruby, tudo é objeto. Isso significa que cada pedaço de informação que você usa no seu programa é tratado como um objeto.

Um objeto é algo que o programa consegue usar, como um número, uma palavra, uma lista ou uma data, por exemplo. Cada objeto guarda dados e permite que a pessoa programadora faça tarefas com ele. Por exemplo, você pode ter um objeto que representa um número, e esse objeto pode fazer coisas como somar, subtrair ou comparar (se é maior, menor ou igual) a outros números.

O que é uma classe?

A classe funciona como um modelo para criar objetos. Ela diz que tipo de coisa o objeto é, quais dados ele pode guardar e o que ele pode fazer.

Alguns exemplos de classes em Ruby são:

  • Integer: classe dos números inteiros.
  • Float: classe dos números com ponto decimal (3.14).
  • String: classe dos textos.
  • Array: classe das listas.
  • Hash: classe das tabelas de chave/valor (como {nome: “Ana”, idade: 30}).

Então na prática quando dizemos “tipo de dado”, estamos falando da classe, ou da forma, que faz esse objeto ser o que ele é. Por exemplo: Quando dizemos “tipo Integer”, estamos falando de um objeto criado pela classe Integer. Só de saber isso, já conseguimos imaginar que esse objeto vai guardar um número inteiro e que ele pode fazer operações matemáticas.

Ou seja, a classe define o que o objeto pode fazer e como ele se comporta, como um molde que cria objetos com características e comportamentos específicos. Assim como usamos moldes de “coelhinhos” para fazer vários coelhinhos de chocolate, usamos classes para criar vários objetos com as mesmas características.

Os tipos de dados nesse contexto são classes que definem como os objetos se comportam e o que eles podem fazer no programa em Ruby.

Por exemplo:

  • Quando criamos um número inteiro, estamos criando um objeto da classe Integer.
    • Esse objeto pode fazer coisas como somar, subtrair, multiplicar e dividir.
  • Quando criamos um texto, estamos criando um objeto da classe String.
    • Esse objeto pode fazer coisas como juntar textos, contar letras e transformar tudo em maiúsculas ou minúsculas.
  • Quando criamos uma lista, estamos criando um objeto da classe Array.
    • Esse objeto pode fazer coisas como adicionar itens, remover itens e ordenar os itens.

E assim por diante.

O que é uma instância?

Uma instância é um objeto real que foi criado a partir de uma classe. Por exemplo, quando você cria um número inteiro como 5, você está criando uma instância da classe Integer.

Exemplos:

  • 42 é uma instância (um objeto específico) da classe Integer.
  • “Olá, mundo!” é uma instância da classe String.

Isso pode ser testado no IRB usando um recurso chamado .class que mostra a classe (tipo de dado), do objeto.

puts 42.class
puts "Olá, mundo!".class
puts [1, 2, 3].class

A saída será:

Integer
String
Array

Dica: Tente você mesmo no IRB! Experimente criar diferentes tipos de dados e use o .class para ver a classe de cada um.

O que é um método?

Um método é uma ação (uma tarefa) que podemos pedir para o objeto executar. Cada classe tem seus próprios métodos que dizem o que os objetos daquela classe podem fazer.

A estrutura básica é assim:

objeto.nome_do_metodo(argumentos_opcionais)

Aqui, objeto é o objeto que você quer que faça algo, nome_do_metodo é o nome da ação que você quer que ele faça, e argumentos_opcionais são informações extras que você pode passar para o método, se for preciso.

Vamos lembrar disso o tempo todo: método = ação de um objeto.

Exemplo de método:

Para um objeto da classe String (texto), temos o método upcase que transforma todas as letras em maiúsculas:

texto = "olá"
puts texto.upcase

A saída será:

OLÁ

De novo: método = ação de um objeto.

Se nós fossemos um objeto, ações como se comunicar, comer e dormir seriam nossos métodos!

O que é uma variável?

Já foi dito no artigo anterior que variáveis são como “caixinhas” onde colocamos os dados que queremos usar. Elas têm nomes que usamos para lembrar o que está dentro delas.

Exemplo:

nome = "João"
idade = 25

Aqui, nome é uma variável que guarda o texto “João”, e idade é uma variável que guarda o número 25. Ou seja, uma variável é um nome que você escolhe para guardar um valor ou uma informação, assim você pode usar esse valor depois no seu programa.

Essas são as definições básicas que precisamos entender para falar sobre os tipos de dados em Ruby de maneira mais profunda. Vamos explorar cada tipo de dado, suas características, capacidades e limitações, sempre lembrando dessas definições para facilitar o entendimento.

Números inteiros – Integer

O que é um número inteiro? Esse conceito vem da matemática: são números sem partes decimais, o que quer dizer que eles não têm vírgulas ou pontos.

Os números inteiros podem ser:

  • Positivos: 0, 1, 2, 3 e assim por diante.
  • Negativos: −1, −2, −3 e assim por diante.
  • Zero: 0 é considerado um número inteiro também.

Esses números são usados todos os dias para:

  • Contar pessoas. Exemplo: “São 10 pessoas na sala.”
  • Número de itens. Exemplo: “Tenho 5 maçãs.”
  • Quantidade de vezes que algo acontece. Exemplo: “Ele correu 3 vezes hoje.”

Em Ruby os números inteiros são representados pela classe Integer. Todos esses números são objetos dessa classe.

Observe no IRB:

42.class   # A saída será Integer
-7.class   # A saída será Integer
0.class    # A saída será Integer

Como criar inteiros em Ruby

Para criar números inteiros em Ruby podemos criar variáveis e dar (atribuir) valores inteiros a elas.

Exemplo:

idade = 25
quantidade_de_livros = 10
saldo_bancario = -150

Quando queremos usar um número grande, como 1.000.000, em Ruby podemos usar underline (_) para separar os milhares, facilitando a leitura.

Exemplo:

populacao = 1_000_000   # igual a 1000000, só que mais legível

Fazendo operações com inteiros

No mundo da programação e da matemática, quando falamos em operações, estamos nos referindo a coisas como:

  • Adição
  • Subtração
  • Multiplicação
  • Divisão
  • Comparações (maior, menor, igual)
  • E muito mais!

Em Ruby todas essas operações matemáticas são métodos que podemos usar com objetos da classe Integer. Isso quer dizer que as operações são ações que podemos pedir para os números realizarem.

Lembre-se: método = ação de um objeto.

Então nesse caso, os números inteiros (objetos da classe Integer) têm métodos que fazem essas operações matemáticas.

Os símbolos usados para essas operações são:

Operação matemática Símbolo na matemática Símbolo em Ruby
Adição + +
Subtração − −
Multiplicação × *
Divisão ÷ /
Módulo (resto da divisão) % %
Potenciação ^ **
Comparação (maior que) > >
Comparação (menor que) < <
Comparação (maior ou igual a) ≥ >=
Comparação (menor ou igual a) ≤ <=
Comparação (igual a) = ==

Observação: Em Ruby, a comparação se algo é igual a outra coisa é feita com dois sinais de igual (==) e não com um só (=), isso acontece porque o sinal de igual sozinho (=) é usado para atribuir valores a variáveis, por exemplo: idade = 30 atribui o valor 30 à variável idade. Então se precisarmos comparar se a idade é igual a 30, usamos idade == 30.

Com os exemplos práticos fica mais fácil de entender.

Vamos declarar duas variáveis com números inteiros e fazer algumas operações com elas:

a = 10
b = 5

puts a + b        # Adição: resultado será 15
puts a - b        # Subtração: resultado será 5
puts a * b        # Multiplicação: resultado será 50
puts a / b        # Divisão: resultado será 2
puts a % b        # Módulo (resto da divisão): resultado será 0
puts a ** 2      # Potenciação: resultado será 100
puts a > b       # Comparação (maior que): resultado será true
puts a < b       # Comparação (menor que): resultado será false
puts a >= 10     # Comparação (maior ou igual a): resultado será true
puts b <= 3      # Comparação (menor ou igual a): resultado será false
puts a == 10     # Comparação (igual a): resultado será true

Métodos comuns para inteiros

De novo lembrando: método = ação de um objeto.

Agora vamos conhecer alguns métodos que o Ruby já deixa prontos para usarmos com números inteiros (objetos da classe Integer).

1 - método even?: verifica se o número é par.

numero = 4
puts numero.even?   # A saída será true

2 - método odd?: verifica se o número é ímpar.

numero = 7
puts numero.odd?    # A saída será true

3 - método next: retorna o próximo número inteiro.

numero = 10
puts numero.next    # A saída será 11

4 - método pred: retorna o número inteiro anterior.

numero = 10
puts numero.pred    # A saída será 9

5 - método abs: retorna o valor absoluto do número (sem o sinal de negativo).

numero = -15
puts numero.abs     # A saída será 15

Esses são apenas alguns exemplos de métodos que podemos usar com números inteiros em Ruby. Existem muitos outros métodos disponíveis que podem ajudar a realizar diversas tarefas com esses dados.

Números com vírgula – Float

O que é um número com vírgula? Também conhecido como número decimal, é um número que tem uma parte fracionária, ou seja, uma parte depois da vírgula (ou ponto, dependendo do país).

Exemplos de números com vírgula:

  • 3,14
  • 0,75
  • −2,5
  • 100,0

Esses números são usados para representar valores que não são inteiros, como:

  • Medidas. Exemplo: “A altura da pessoa é 1,75 metros.”
  • Dinheiro. Exemplo: “O preço do produto é R$ 19,99.”
  • Temperaturas. Exemplo: “A temperatura está em 23,5 graus Celsius.”
  • E muito mais!

Em Ruby, os números com vírgula são representados pela classe Float. Todos esses números são objetos dessa classe.

Observe no IRB:

3.14.class   # A saída será Float
-0.75.class  # A saída será Float
0.0.class    # A saída será Float

Como criar números com vírgula em Ruby

Para criar números com vírgula em Ruby, usamos o ponto (.) como separador decimal, diferente do que usamos na escrita comum em português, onde usamos a vírgula (,).

Exemplo:

altura = 1.75
preco = 19.99
temperatura = -2.5

Fazendo operações com números com vírgula

Assim como os números inteiros, os números com vírgula (objetos da classe Float) também têm métodos para fazer operações matemáticas.

Os símbolos usados para essas operações são os mesmos apresentados na tabela comparativa anterior.

Vamos declarar duas variáveis com números com vírgula e fazer algumas operações com elas:

x = 5.5
y = 2.0

puts x + y        # Adição: resultado será 7.5
puts x - y        # Subtração: resultado será 3.5
puts x * y        # Multiplicação: resultado será 11.0
puts x / y        # Divisão: resultado será 2.75
puts x % y        # Módulo (resto da divisão): resultado será 1.5
puts x ** 2      # Potenciação: resultado será 30.25
puts x > y       # Comparação (maior que): resultado será true
puts x < y       # Comparação (menor que): resultado será false
puts x >= 5.5    # Comparação (maior ou igual a): resultado será true
puts y <= 3.0    # Comparação (menor ou igual a): resultado será true
puts x == 5.5    # Comparação (igual a): resultado será true

Métodos comuns para números com vírgula

De novo lembrando: método = ação de um objeto.

Alguns métodos disponíveis para números Float em Ruby são:

1 - método round: arredonda o número para o inteiro mais próximo.

numero = 3.6

puts numero.round    # A saída será 4

Nesse método também é possível arredondar a parte decimal para um número específico de casas decimais, passando um argumento para o método.

numero = 3.14159

puts numero.round(1)    # A saída será 3.1

puts numero.round(2)    # A saída será 3.14

puts numero.round(3)    # A saída será 3.142

2 - método ceil: arredonda o número para cima (para o próximo inteiro).

numero = 4.2
puts numero.ceil     # A saída será 5

Qual a diferença entre ceil e round?

  • O método round arredonda para o inteiro mais próximo, seja para cima ou para baixo, dependendo do valor decimal.
  • O método ceil sempre arredonda para cima, independentemente do valor decimal.

Por exemplo:

numero1 = 4.2
numero2 = 4.7

puts numero1.round    # A saída será 4
puts numero2.round    # A saída será 5

puts numero1.ceil     # A saída será 5
puts numero2.ceil     # A saída será 5

3 - método floor: arredonda o número para baixo (para o inteiro anterior).

numero = 4.8
puts numero.floor    # A saída será 4

Números de ponto flutuante (Float) podem ter pequenas imprecisões. Isso acontece porque alguns números decimais não podem ser representados exatamente em binário, que é a forma como os computadores armazenam números. Por exemplo, a soma de 0.1 e 0.2 pode resultar em 0.30000000000000004 em vez de 0.3.

Para lidar com dinheiro em programas mais avançados por exemplo, é melhor usar outros tipos de número, como o BigDecimal. Mas, para quem está começando, basta saber que o tipo Float não é sempre exato e pode dar pequenos erros em algumas situações.

Textos – String

Uma string é um texto. É uma sequência de caracteres que pode incluir letras, números, espaços e símbolos.

Exemplos de strings:


"Olá, mundo!"
"12345"
"Ruby"
"Programação"
"@#%&*()!"

Todas essas sequências de caracteres são objetos da classe String em Ruby.

Como criar strings em Ruby

Para criar strings em Ruby, usamos aspas duplas (“ “) ou aspas simples (‘ ‘), geralmente, as aspas duplas são mais comuns. Precisamos colocar o texto entre aspas para que o Ruby entenda que aquilo é uma string e não um comando, uma variável ou outra coisa que estamos tentando inserir no programa.

Exemplo:

mensagem = "Olá, mundo!"
nome = 'Ana'
vazio = ""

Algo muito legal que podemos fazer com strings se chama interpolação. Interpolação é quando colocamos o valor de uma variável dentro de uma string, para que o valor daquela variável apareça no texto.

Para fazer isso usamos #{} dentro de uma string com aspas duplas.

Exemplo de interpolação:

nome = "Louise"
mensagem = "Olá, #{nome}! Seja bem-vinda."

puts mensagem   # A saída será "Olá, Louise! Seja bem-vinda."

Aqui o valor da variável nome foi colocado dentro da string na variável mensagem usando a interpolação.

Métodos comuns para strings

Alguns métodos comuns que podemos usar com strings em Ruby são:

1 - método upcase: transforma todas as letras da string em maiúsculas.

texto = "olá, mundo!"
puts texto.upcase    # A saída será "OLÁ, MUNDO!"

2 - método downcase: transforma todas as letras da string em minúsculas.

texto = "OLÁ, MUNDO!"
puts texto.downcase    # A saída será "olá, mundo!"

3 - método length: retorna o número de caracteres (incluindo espaços) na string.

texto = "Olá"
texto2 = "Oi, eu sou o Goku!"

puts texto.length      # A saída será 3
puts texto2.length   # A saída será 18

4 - método strip: remove espaços em branco do início e do fim da string.

texto = "   Olá, mundo!   "
puts texto.strip    # A saída será "Olá, mundo!"

5 - método gsub: substitui todas as ocorrências de um texto por outro na string.

texto = "O gato está no telhado."
puts texto.gsub("gato", "cachorro")   # A saída será "O cachorro está no telhado."

Variáveis booleanas – Boolean

Um booleano é um tipo de dado que só pode ter dois valores:

  • true (verdadeiro)
  • false (falso)

Esses valores são usados para representar condições ou respostas de “sim” ou “não” em programas e muitas vezes são usados para tomar decisões no código.

Ruby não tem uma classe específica chamada Boolean, mas os valores true e false são objetos únicos.

  • true é um objeto único da classe TrueClass.
  • false é um objeto único da classe FalseClass.

Como criar variáveis booleanas em Ruby

Para criar variáveis booleanas em Ruby, simplesmente atribuímos os valores true ou false a uma variável.

Exemplo:

esta_chovendo = true
tem_luz = false

É possível também combinar valores booleanos usando ferramentas chamadas de operadores lógicos.

Operadores lógicos

Os operadores lógicos são usados para combinar ou modificar valores booleanos. Por exemplo, podemos usar operadores lógicos para verificar se duas condições são verdadeiras ao mesmo tempo, ou se pelo menos uma delas é verdadeira.

Os principais operadores lógicos em Ruby são:

  • AND lógico (&&): retorna true se ambas as condições forem verdadeiras.
  • OR lógico (||): retorna true se pelo menos uma das condições for verdadeira.
  • NOT lógico (!): inverte o valor booleano (de true para false e vice-versa).

Exemplos:

a = true
b = false

puts a && b    # AND lógico: a saída será false
puts a || b    # OR lógico: a saída será true
puts !a        # NOT lógico: a saída será false
puts !b        # NOT lógico: a saída será true

Mas, para que serve isso na prática? Vamos ver um exemplo.

# Dados simulados do sistema
usuario_correto = true          # O nome do usuário está correto?
senha_correta = true            # A senha está correta?
usuario_eh_admin = false        # Essa pessoa tem permissão de administrador?

# Simulação de login básico
login_valido = usuario_correto && senha_correta

# Verificações usando operadores lógicos
pode_acessar = login_valido || usuario_eh_admin

# Resultado da simulação
puts "Login válido? #{login_valido}"             # Esperado: true
puts "É administrador? #{usuario_eh_admin}"      # Esperado: false
puts "Pode acessar o sistema? #{pode_acessar}"   # true se login for válido ou se for admin
puts "Acesso negado? #{!pode_acessar}"           # true se não puder acessar

O que foi feito aqui? O código simula um sistema de login simples. Ele verifica se o nome do usuário e a senha estão corretos usando o operador AND lógico (&&). Se ambos estiverem corretos, o login é válido.

Para fazer este teste crie um programa Ruby com o código acima e execute-o no terminal. Observe os resultados e tente alterar os valores das variáveis usuario_correto, senha_correta e usuario_eh_admin para ver como isso afeta o resultado final.

Listas – Array

Uma lista, ou array, é uma coleção ordenada de itens. Esses itens podem ser de qualquer tipo de dado, como números, textos, booleanos, ou até mesmo outros arrays.

Nós já usamos listas no nosso dia a dia, mesmo sem perceber. Por exemplo, uma lista de compras, uma lista de tarefas ou uma lista de contatos no celular.

Em Ruby as listas são representadas pela classe Array. Todos os arrays são objetos dessa classe.

Observe no IRB:

frutas = ["maçã", "banana", "laranja"]
notas  = [7.5, 8.0, 9.0]
idades = [25, 30, 22]
puts frutas.class   # A saída será Array
puts notas.class    # A saída será Array
puts idades.class   # A saída será Array

Como criar listas em Ruby

Para criar listas em Ruby, usamos colchetes [ ] e separamos os itens com vírgulas.

Exemplo:

numeros = [1, 2, 3]                      # array de inteiros
frutas  = ["maçã", "banana", "uva"]      # array de strings
mistura = [1, "dois", :tres, 4.0]        # array misto
vazio   = []                             # array vazio

Conhecendo os índices das listas

Índices são as posições dos itens dentro de uma lista. Em Ruby, os índices começam do zero (0). Isso significa que o primeiro item da lista está na posição 0, o segundo item está na posição 1, o terceiro item está na posição 2, e assim por diante.

A função do índice é a mesma que um índice tem em um livro: ele ajuda a encontrar rapidamente onde algo está localizado.

Exemplo:

frutas = ["maçã", "banana", "laranja"]

puts frutas[0]   # A saída será "maçã" (primeiro item)
puts frutas[1]   # A saída será "banana" (segundo item)
puts frutas[2]   # A saída será "laranja" (terceiro item)

Podemos usar índice positivo (do começo) ou negativo (do fim):

frutas = ["maçã", "banana", "laranja"]

puts frutas[-1]   # A saída será "laranja" (último item)
puts frutas[-2]   # A saída será "banana" (penúltimo item)
puts frutas[-3]   # A saída será "maçã" (antepenúltimo item)

Métodos comuns para listas

Alguns métodos comuns que podemos usar com listas (arrays) em Ruby são:

1 - método push: adiciona um item ao final da lista.

frutas = ["maçã", "banana"]

frutas.push("laranja")

puts frutas.inspect    # A saída será ["maçã", "banana", "laranja"]

O método inspect é usado aqui para mostrar o conteúdo completo do array.

2 - método pop: remove o último item da lista e o retorna.

frutas = ["maçã", "banana", "laranja"]
ultima_fruta = frutas.pop
puts ultima_fruta          # A saída será "laranja"
puts frutas.inspect        # A saída será ["maçã", "banana"]

O que foi feito aqui? O método pop removeu o último item da lista (laranja) e o guardou na variável ultima_fruta. Depois mostramos o valor dessa variável e o conteúdo atualizado da lista.

3 - método length: retorna o número de itens na lista.

frutas = ["maçã", "banana", "laranja"]
puts frutas.length    # A saída será 3

4 - método include?: verifica se um item está presente na lista.

frutas = ["maçã", "banana", "laranja"]
puts frutas.include?("banana")   # A saída será true
puts frutas.include?("uva")      # A saída será false

Tabelas de pares – Hash

Um hash é uma coleção de pares de chave-valor. Cada valor na coleção é associado a uma chave única, que é usada para acessar esse valor.

Por exemplo, em um dicionário, a palavra é a chave e a definição é o valor. Em um hash, podemos pensar em algo semelhante: a chave é como o “nome” do valor, e usamos essa chave para encontrar o valor correspondente.

Em Ruby, os hashes são representados pela classe Hash. Todos os hashes são objetos dessa classe.

Observe no IRB:

pessoa = { "nome" => "João", "idade" => 30 }
puts pessoa.class   # A saída será Hash

Como criar hashes em Ruby

Para criar hashes em Ruby, usamos chaves { } e associamos cada chave a um valor usando o símbolo => .

Exemplo:

pessoa = { "nome" => "Ana", "idade" => 25, " cidade" => "São Paulo" }

Acessando valores em hashes

Para acessar um valor em um hash, usamos a chave correspondente entre colchetes [ ].

Exemplo:

pessoa = { "nome" => "Ana", "idade" => 25, " cidade" => "São Paulo" }
puts pessoa["nome"]      # A saída será "Ana"
puts pessoa["idade"]     # A saída será 25
puts pessoa["cidade"]    # A saída será "São Paulo"

Como podemos alterar o valor associado a uma chave em um hash? Simplesmente atribuímos um novo valor àquela chave.

Exemplo:

pessoa = { "nome" => "Ana", "idade" => 25, "cidade" => "São Paulo" }
pessoa["idade"] = 26
puts pessoa["idade"]     # A saída será 26

Métodos comuns para hashes

Alguns métodos comuns que podemos usar com hashes em Ruby são:

1 - método keys: retorna uma lista com todas as chaves do hash.

pessoa = { "nome" => "Ana", "idade" => 25, "cidade" => "São Paulo" }
puts pessoa.keys.inspect    # A saída será ["nome", "idade", "cidade"]

2 - método values: retorna uma lista com todos os valores do hash.

pessoa = { "nome" => "Ana", "idade" => 25, "cidade" => "São Paulo" }
puts pessoa.values.inspect    # A saída será ["Ana", 25, "São Paulo"]

3 - método delete: remove um par chave-valor do hash com base na chave fornecida.

pessoa = { "nome" => "Ana", "idade" => 25, "cidade" => "São Paulo" }
pessoa.delete("idade")
puts pessoa.inspect    # A saída será {"nome"=>"Ana", "cidade"=>"São Paulo"}

Nada - nil / NilClass

Em Ruby, nil é um valor especial que representa a ausência de um valor ou a falta de um objeto. É usado para indicar que algo não existe ou não foi definido.

Muitas vezes precisamos dizer “não tem valor aqui”.

Em Ruby, nil é um objeto único da classe NilClass que serve justamente para representar essa ausência de valor.

  • nil significa ausência de valor.
  • Não é zero.
  • Não é uma string vazia.
  • Não é falso.
  • É simplesmente nada.

Como usar nil em Ruby

Podemos usar nil para inicializar variáveis que ainda não têm um valor definido.

Exemplo:

resultado = nil
puts resultado    # A saída será nil

Ou podemos verificar se uma variável é nil usando o método nil?.

Exemplo:

nome = nil
nome.nil?   # => true

"oi".nil?   # => false
0.nil?      # => false
"".nil?     # => false

puts nome.nil?    # A saída será true

Símbolos – Symbol

Um símbolo é um tipo de dado em Ruby que representa um nome ou identificador. Símbolos são frequentemente usados como chaves em hashes ou para representar estados ou opções em programas.

Em Ruby, os símbolos são representados pela classe Symbol. Todos os símbolos são objetos dessa classe.

Como criar símbolos em Ruby

Para criar um símbolo em Ruby, usamos dois pontos (:) seguidos do nome do símbolo.

Exemplo:

:nome
:idade
:cidade

Usando símbolos em hashes

Os símbolos são frequentemente usados como chaves em hashes, pois são mais eficientes em termos de memória e desempenho do que strings.

Para criar um hash com símbolos como chaves, usamos a seguinte sintaxe (sintaxe é a forma de escrever algo):

estado_sp = :SP
estado_rj = :RJ

endereco = {
  rua:    "Av. Paulista",
  numero: 1000,
  cidade: "São Paulo",
  uf:     :SP
}

No exemplo anterior , as chaves do hash endereco são símbolos (:rua, :numero, :cidade, :uf). Para acessar os valores do hash, usamos os símbolos como chaves:

puts endereco[:rua]      # A saída será "Av. Paulista"
puts endereco[:numero]   # A saída será 1000
puts endereco[:cidade]   # A saída será "São Paulo"
puts endereco[:uf]       # A saída será :SP

Em outras palavras, símbolos são como etiquetas que usamos para identificar coisas em nosso código. Eles são leves e rápidos, o que os torna ideais para uso em situações onde precisamos de muitos identificadores únicos, como em hashes.

Diferença entre símbolos e strings

  • Use String quando quiser trabalhar com palavras, frases ou qualquer texto que será mostrado para uma pessoa ou usado como mensagem, campo de formulário etc.
  • Use Symbol quando precisar de um nome fixo para identificar algo no seu código, como:
    • chaves em tabelas (hashes),
    • nomes de opções,
    • estados.

Símbolos são mais eficientes em termos de memória e desempenho do que strings, especialmente quando usados repetidamente como identificadores.

Converção entre tipos de dados

Às vezes, precisamos converter um tipo de dado em outro. Por exemplo, podemos querer transformar uma string que representa um número em um número inteiro para fazer cálculos com ele.

Em Ruby, podemos fazer conversões entre tipos de dados usando métodos específicos.

Convertendo strings em números

Para converter uma string em um número inteiro, usamos o método to_i.

numero_string = "42"
numero_inteiro = numero_string.to_i
puts numero_inteiro    # A saída será 42
puts numero_inteiro.class   # A saída será Integer

Para converter uma string em um número com vírgula (float), usamos o método to_f.

numero_string = "3.14"
numero_float = numero_string.to_f
puts numero_float    # A saída será 3.14
puts numero_float.class   # A saída será Float

Convertendo números em strings

Para converter um número inteiro em uma string, usamos o método to_s.

numero_inteiro = 42
numero_string = numero_inteiro.to_s
puts numero_string    # A saída será "42"
puts numero_string.class   # A saída será String

Para converter um número com vírgula (float) em uma string, também usamos o método to_s.

numero_float = 3.14
numero_string = numero_float.to_s
puts numero_string    # A saída será "3.14"
puts numero_string.class   # A saída será String

Convertendo strings em símbolos

Para converter uma string em um símbolo, usamos o método to_sym.

texto = "nome"
simbolo = texto.to_sym
puts simbolo    # A saída será :nome
puts simbolo.class   # A saída será Symbol

Convertendo símbolos em strings

Para converter um símbolo em uma string, usamos o método to_s.

simbolo = :idade
texto = simbolo.to_s
puts texto    # A saída será "idade"
puts texto.class   # A saída será String

Resumo

Neste artigo, aprofundamos nosso conhecimento sobre tipos de dados em Ruby, explorando conceitos fundamentais e características específicas de cada tipo.

Começamos entendendo conceitos importantes como objetos, classes, instâncias, métodos e variáveis, que são a base para compreender como Ruby trabalha com dados. Aprendemos que em Ruby tudo é objeto e que cada tipo de dado é representado por uma classe específica.

Exploramos os tipos numéricos:

  • Integer: números inteiros (positivos, negativos e zero) com operações matemáticas e métodos como even?, odd?, abs
  • Float: números com vírgula (decimais) com métodos para arredondamento como round, ceil e floor

Conhecemos os tipos textuais e simbólicos:

  • String: textos que podem ser manipulados com métodos como upcase, downcase, length, strip e gsub, além da interpolação de variáveis
  • Symbol: identificadores eficientes usados principalmente como chaves em hashes

Vimos os tipos de coleção:

  • Array: listas ordenadas de itens acessados por índices, com métodos como push, pop, length e include?
  • Hash: tabelas de pares chave-valor para organizar dados relacionados, com métodos como keys, values e delete

Entendemos os tipos lógicos:

  • Boolean: valores true e false usados em condições e decisões
  • Operadores lógicos: AND (&&), OR (||) e NOT (!) para combinar condições
  • NilClass: o valor especial nil que representa ausência de valor

Por fim, aprendemos sobre conversão entre tipos, usando métodos como to_i, to_f, to_s e to_sym para transformar dados de um tipo em outro conforme necessário.

Cada tipo de dado tem suas características, capacidades e limitações específicas. Apesar de parecer muita informação no começo, com a prática você se familiarizará com esses conceitos e saberá quando e como usar cada tipo de dado em seus programas Ruby.