Explorando as diferentes formas de passar informações para um método no Ruby

Olá, queridos compadres de linguagem!

Hoje vou mostrar algumas das diferentes formas de passar informações para um método no Ruby. Compreender essas técnicas é fundamental para escrever um código mais flexível, modular e de fácil manutenção.

1. Passagem de argumentos posicionais:

A passagem de argumentos posicionais é a forma mais comum de passar informações para um método. Os argumentos são fornecidos na ordem especificada na declaração do método. Isso oferece simplicidade e clareza no código, mas pode ser limitante caso haja muitos argumentos ou se a ordem não for respeitada.

Exemplo de uso:

def greet(name, age)
 puts "Olá, #{name}! Você tem #{age} anos."
end

greet("João", 25)

# Retorno: "Olá, João! Você tem 25 anos."

2. Passagem de argumentos por palavras-chave:

A passagem de argumentos por palavras-chave permite especificar os valores dos argumentos usando suas chaves correspondentes. Isso melhora a legibilidade do código, pois evita confusões com a ordem dos argumentos.

Exemplo de uso:

def greet(name:, age:)
  puts "Olá, #{name}! Você tem #{age} anos."
end

greet(name: "Maria", age: 30)

# Retorno: "Olá, Maria! Você tem 30 anos."

No primeiro exemplo, caso você passe o parâmetro em ordens diferentes irá afetar diretamente o resultado, mas nesse caso a ordem dos parâmetros não importa!

Dica: A partir do Ruby 2.7, você pode usar Type Hints para declarar o tipo esperado para um parâmetro de método. Isso pode ser feito usando a sintaxe param: tipo.

Exemplo de uso:

def greet(name: String, age: Integer)
  puts "Olá, #{name}! Você tem #{age} anos."
end

greet(name: "Maria", age: 30)

# Retorno: "Olá, Maria! Você tem 30 anos."

Neste segundo exemplo, o método greet espera os parâmetro name como do tipo Stringe age como do tipo Integer. Caso você tentar passar um valor de outro tipo, uma exceção TypeError será levantada”

3. Passagem de argumentos com valores padrão:

Essa técnica permite definir valores padrão para argumentos que não são explicitamente fornecidos. Isso torna os argumentos opcionais, facilitando a chamada do método quando alguns valores não são necessários em todas chamadas.

Exemplo de uso:

def greet(name, age = 18)
  puts "Olá, #{name}! Você tem #{age} anos."
end

greet("Pedro")

# Retorno: "Olá, Pedro! Você tem 18 anos."

4. Passagem de argumentos como um hash:

A passagem de argumentos como um hash permite passar um único argumento contendo múltiplos valores nomeados. Essa abordagem é útil quando um método precisa lidar com uma variedade de opções ou configurações.

Exemplo de uso:

def greet(options)
  name = options[:name]
  age = options[:age]
  
  puts "Olá, #{name}! Você tem #{age} anos."
end

greet({ name: "Ana", age: 35 })

# Retorno: "Olá, Ana! Você tem 35 anos."

# greet(name: "Ana", age: 35) Fora da hash também funciona!
# greet(name: "Ana") Fora da hash "faltando" valores funciona!

Pontos importantes: Caso você se esqueça de um dos valores, irá resultar em um erro, apenas exibirá a variável como nil!

5. Passagem de um objeto como argumento:

É possível passar um objeto como argumento para um método. Isso permite que o método utilize os atributos e métodos do objeto para realizar suas operações. Essa técnica promove a reutilização de código e a abstração, use com cuidado e atenção ficar transitando objetos pode levar a graves problemas!

Exemplo de uso:

class Person
  attr_accessor: name,: age

  def initialize(name, age)
    @name = name
    @age = age
  end
end

def greet(person)
  puts "Olá, #{person.name}! Você tem #{person.age} anos."
end
    
person = Person.new("Carlos", 40)
    
greet(person)

# Retorno: "Olá, Carlos! Você tem 40 anos."

6. Passagem de argumentos por referência:

Em Ruby, os argumentos são passados por valor, mas quando se trata de objetos, o valor é uma referência ao objeto. Isso significa que, se modificarmos o objeto dentro do método, as mudanças serão refletidas fora dele. No entanto, se atribuirmos um novo objeto ao argumento dentro do método, isso não afetará o objeto original.

Exemplo de uso:

name = "Sávio"
age = 54

def greet(name, age)
  name =  "Sr. #{name}"
  age = "#{age} anos de idade!"

  puts "Olá, #{name}! Você tem #{age}"
end
 
greet(name, age)

# Retorno: "Olá, Sr. Sávio! Você tem 54 anos de idade!"

puts name
# Retorno: "Sávio

puts age
# Retorno: "54"

7. Uso do operador splat (*) para passar argumentos:

O operador splat (*) permite passar um número variável de argumentos para um método. Ele pode ser utilizado tanto para agrupar argumentos em um array quanto para desempacotar um array em argumentos individuais.

Exemplo de uso:

def greet(*people)
  people.each do |person|
    puts "Olá, #{person}!"
  end
end

greet("Alice", "Bob", "Charlie")

# Retorno:
# Olá, Alice!
# Olá, Bob!
# Olá, Charlie!

8. Uso do método method_missing para lidar com argumentos desconhecidos:

Esse é bem conhecido da comunicadade, método method_missing é chamado automaticamente quando um método desconhecido é invocado em um objeto. É possível aproveitar esse método para lidar com argumentos desconhecidos e fornecer comportamentos personalizados.

Exemplo de uso:

class Person
  def method_missing(method_name, *args)
    puts "Método '#{method_name}' não encontrado."
  end
end

person = Person.new

person.unknown_method 
# Retorno: "Método 'unknown_method' não encontrado."

9. Passagem de blocos:

Em Ruby, é comum passar blocos de código como argumentos para métodos. Os blocos permitem definir comportamentos flexíveis e personalizados, aumentando a reusabilidade do código.

Exemplo de uso:

def with_logging
  puts "Iniciando operação…"
  
  yield
  
  puts "Operação concluída."
end

with_logging do
  puts "Realizando a operação…"
end

# Retorno:
# Iniciando operação…
# Realizando a operação…
# Operação concluída.

10. (Extra, só para Rails!) Uso do módulo Forwardable para delegar argumentos:

O módulo Forwardable fornece uma maneira conveniente de delegar métodos de um objeto para outro. Isso pode ser útil para delegar argumentos de um objeto para outro de forma transparente.

Exemplo de uso:

require 'forwardable'

class Logger
  extend Forwardable

  def_delegator :@logger, :log

  def initialize
    @logger = Rails.logger
  end
end

logger = Logger.new

logger.log("Mensagem de log")

A importância de conhecer as diferentes formas de passar informações para um método é significativa. Essas técnicas permitem flexibilidade no design do código, tornando-o mais legível, reutilizável e adaptável. Com o domínio dessas abordagens, os desenvolvedores podem escolher a melhor opção para cada cenário, aumentando a eficiência do desenvolvimento.

Além disso, o conhecimento sobre essas técnicas auxilia na compreensão e manutenção de código legado, pois você estará familiarizado com diferentes estilos de passagem de argumentos.

Portanto, explorar e entender esses métodos de passagem de informações é crucial para aprimorar suas habilidades de desenvolvimento em Ruby e se tornar um programador mais versátil e eficaz.

Espero que este post tenha sido útil para vocês!

Caso você saiba alguma forma diferente das que eu comentei, por favor deixei um comentário explicando sobre, ficarei muito feliz de aprender com você!

Happy coding!