Tutorial de Ruby

Métodos

Definições de métodos são iniciadas com a palavra def, e terminam com a palavra end.

def oi
  puts "oi!"
end

A declaração dos argumentos pode não ser feita entre parênteses, e estes podem ter expressões padrão (avaliadas, da esquerda para a direita, quando o método é chamado), especificados com o símbolo =.

def ola(p="pessoal", v=", "+p+"!\n")
  print "Olá ", p, v
end

ola                         # >> Olá pessoal, pessoal!
ola "mortais"               # >> Olá mortais, mortais!
ola "enfermeira", " ...\n"  # >> Olá enfermeira ...

Também não é necessário usar parênteses para chamar métodos, mas, a menos que a precedência das operações seja trivial, é recomendável. Deve ser notado que Ruby (ao menos por enquanto) tem algumas particularidades quanto a isso, e por vezes pode-se ter surpresas. O primeiro '(' encontrado após um nome é interpretado como sendo de uma chamada de método, portanto:

Math.sqrt (1-2).abs  =>  (Math.sqrt(1-2)).abs
p (1..10).to_a       =>  (p(1..10)).to_a

Métodos são uma seqüência de expressões. O valor retornado pelo método é o valor da expressão avaliada por um comando return, ou o valor da última expressão avaliada.

def maior(a, b)
  if a >= b
    return a    # >> retorna a imediatamente
  end
  b             # >> retorna b
end

Caso o último argumento seja precedido por '*', este será um Array com os argumentos passados que excedam os declarados. Caso o último argumento seja precedido por '&', um bloco passado ao método é atribuído a este argumento como um objeto Proc. Pode-se ter ambos (*args e &bloco), sendo que *args seja o penúltimo, e &bloco o último.

Para resumir o comportamento das variáveis prefixadas por '*' em métodos e atribuições, pode-se pensar da seguinte maneira:

• quando quem recebe é prefixado por '*', ele recebe um Array com os valores restantes;
• quando quem passa é prefixado por '*', ele é "expandido" se for um Array;

Pode-se definir métodos singleton, que são métodos específicos a um objeto, não a uma classe. Métodos de classe são implementados assim (lembre-se, classes são objetos). A especificação de tais métodos é feita da forma variável.método, ou usando a definição de classes singleton:

abc = "abc"
def abc.def   # Método singleton
  "def"
end
puts abc.def  # >> def

Para "desdefinir" um método, usa-se undef. Para redefinir um método, basta defini-lo novamente. Caso seja necessário chamar o método original, deve-se usar o comando alias para dar um novo nome ao método antigo:

def aie
  puts "aie"
end

alias aie_antigo aie

def aie
  puts "aie novo"
  aie_antigo
end

Ao criar uma nova classe, pode-se chamar um método da classe base, que estiver sendo redefinido, com o comando super. Se nenhum argumento for explicitamente passado a super, os argumentos recebidos pelo método serão passados.

class Texto < String
  def capitalize
    puts "chamando capitalize ..."
    super
  end
end

a = Texto.new "aie"
a.capitalize  # >> chamando capitalize ...
              # >> "Aie"

A nomenclatura de métodos, em geral, segue algumas convenções:

• métodos que retornam true ou false têm seu nome terminado por '?';
• métodos que modificam seu objeto (self, no método) são terminados por '!';
• métodos que atribuem (setters) a um atributo de mesmo nome do método do objeto, são terminados por '=', e chamados automaticamente em uma expressão de atribuição, tendo como argumento o elemento à direita da atribuição. Tais métodos são definidos automaticamente ao usar os métodos attr, attr_accessor, e attr_writer, de Module, para declarar atributos;

a = "oi!"
b = "oi!"
a.empty?      # >> false
a.capitalize! # >> "Oi!"
a             # >> "Oi!"
b.capitalize  # >> "Oi!"
b             # >> "oi!"

def a.teste=(val)
  @teste = val
end
def a.teste
  @teste
end

a.teste = "aie"
puts a.teste  # >> "aie"