Ruby Language
Metaprogramowanie

Wprowadzenie

Implementowanie „z” za pomocą oceny wystąpienia

Wiele języków feature a with stwierdzeniem, że pozwala programistom na pominięcie odbiornika wywołań metod.

with może być łatwo emulowany w Ruby za pomocą instance_eval :

def with(object, &block)
  object.instance_eval &block
end

Za with metody with można bezproblemowo wykonywać metody na obiektach:

hash = Hash.new

with hash do
  store :key, :value
  has_key? :key       # => true
  values              # => [:value]
end

Dynamiczne definiowanie metod

Za pomocą Ruby możesz modyfikować strukturę programu w czasie wykonywania. Jednym ze sposobów jest zdefiniowanie metod dynamicznie za pomocą metody method_missing .

Powiedzmy, że chcemy być w stanie sprawdzić, czy liczba jest większa niż inna liczba przy składni 777.is_greater_than_123? .

# open Numeric class
class Numeric
  # override `method_missing`
  def method_missing(method_name,*args)
    # test if the method_name matches the syntax we want
    if method_name.to_s.match /^is_greater_than_(\d+)\?$/
      # capture the number in the method_name
      the_other_number = $1.to_i
      # return whether the number is greater than the other number or not
      self > the_other_number
    else
      # if the method_name doesn't match what we want, let the previous definition of `method_missing` handle it
      super
    end
  end
end

Jedną ważną rzeczą do zapamiętania podczas korzystania z method_missing że należy również przesłonić odpowiedź na respond_to? metoda:

class Numeric
   def respond_to?(method_name, include_all = false) 
     method_name.to_s.match(/^is_greater_than_(\d+)\?$/) || super
   end
end

Zapomnienie o tym prowadzi do niespójnej sytuacji, w której można z powodzeniem wywołać 600.is_greater_than_123 , ale 600.respond_to(:is_greater_than_123) zwraca false.

Definiowanie metod w instancjach

W Ruby możesz dodawać metody do istniejących instancji dowolnej klasy. Umożliwia to dodawanie zachowania i wystąpienia klasy bez zmiany zachowania pozostałych wystąpień tej klasy.

class Example
  def method1(foo)
    puts foo
  end
end

#defines method2 on object exp
exp = Example.new
exp.define_method(:method2) {puts "Method2"}

#with method parameters
exp.define_method(:method3) {|name| puts name}

metoda send ()

send() służy do przekazywania wiadomości do object . send() to metoda instancji klasy Object . Pierwszym argumentem w send() jest wiadomość, którą wysyłasz do obiektu - to znaczy nazwa metody. Może to być string lub symbol ale symbole są preferowane. Następnie argumenty, które muszą przekazać w metodzie, będą to pozostałe argumenty w send() .

class Hello
  def hello(*args)
    puts 'Hello ' + args.join(' ')
  end
end
h = Hello.new
h.send :hello, 'gentle', 'readers'   #=> "Hello gentle readers"
# h.send(:hello, 'gentle', 'readers') #=> Here :hello is method and rest are the arguments to method.

Oto bardziej opisowy przykład

class Account
  attr_accessor :name, :email, :notes, :address

  def assign_values(values)
    values.each_key do |k, v|
      # How send method would look a like
      # self.name = value[k]
      self.send("#{k}=", values[k])
    end
  end
end

user_info = {
  name: 'Matt',
  email: '[email protected]',
  address: '132 random st.',
  notes: "annoying customer"
}

account = Account.new
If attributes gets increase then we would messup the code
#--------- Bad way --------------
account.name = user_info[:name]
account.address = user_info[:address]
account.email = user_info[:email]
account.notes = user_info[:notes]

# --------- Meta Programing way --------------
account.assign_values(user_info) # With single line we can assign n number of attributes

puts account.inspect

Uwaga: samo send() nie jest już zalecane. Użyj __send__() który może wywoływać metody prywatne, lub (zalecane) public_send()