译：Ruby动态方法

通常情况下，我们使用关键字def来定义方法。

但是当有一系列方法具有相同的结构和逻辑时，继续这样做未免显得有些重复并且违反了DRY原则。

Ruby，作为一个动态语言，允许你在运行时定义方法。

那么，这是什么意思呢？

来看一个最简单的例子：

class A
  define_method :a do
    puts "hello"
  end
  define_method :greeting do |message|
    puts message
  end
end

A.new.a #=> hello
A.new.greeting 'Ram ram' #=> Ram ram
           

define_method 用来定义实例方法，下面的例子展示更加贴合实际的使用场景。

class User
    ACTIVE = 0
    INACTIVE = 1
    PENDING = 2
    attr_accessor :status

    def active?
      status == ACTIVE
    end

    def inactive?
      status == User::INACTIVE
    end

    def pending?
      status == User::PENDING
    end
  end

  user = User.new
  user.status = 1

  user.inactive?
  #=> true
  user.active?
  #=> false
           

使用动态方法定义重构：

class User
    ACTIVE = 0
    INACTIVE = 1
    PENDING = 2
    attr_accessor :status

    [:active, :inactive, :pending].each do |method|
      define_method “#{method}?” do
        status == User.const_get(method.upcase)
      end
    end
  end

  user = User.new
  user.status = 1

  user.inactive?
  #=> true
  user.active?
  #=> false
           

我们使用了define_method来动态的定义方法。

我们也可以使用类方法来定义实例方法，利用这一点我们可以暴露一个用来生成实例方法的类方法。COOL！

例如：

class User
    ACTIVE = 0
    INACTIVE = 1
    PENDING = 2
    attr_accessor :status

    def self.states(*args)
      args.each do |arg|
        define_method “#{arg}?” do
          self.status == User.const_get(arg.upcase)
        end
      end
    end

    states :active, :inactive, :pending
  end
           

定义类方法最简单的方式则为：

class A
  class << self
    define_method method_name do
      #...
    end
  end
end
           

也可以使用 instance_eval和class_eval来动态定义方法。这些方法允许运行特定类或方法中的任意代码。这些方法有时候很让人迷惑，你可以看看 stackoverflow上的讨论或者读读博客来理解它们的用法。

stackoverflow上的讨论我们可以总结如下：

Foo = Class.new
  Foo.class_eval do
    def class_bar
      “class_bar”
    end
  end
  Foo.instance_eval do
    def instance_bar
      “instance_bar”
    end
  end
  Foo.class_bar       #=> undefined method ‘class_bar’ for Foo:Class
  Foo.new.class_bar   #=> “class_bar”
  Foo.instance_bar       #=> “instance_bar”
  Foo.new.instance_bar   #=> undefined method ‘instance_bar’ for #<Foo:0x7dce8>
           

注意，我们没有在_eval中使用*define_method，因为如下例所示，不管在class_eval还是instance_eval内使用define_method方法，它最终定义的都是实例方法。

Foo = Class.new
  Foo.class_eval do
    define_method “class_bar” do
      “class_bar”
    end
  end
  Foo.instance_eval do
    define_method “instance_bar” do
      “instance_bar”
    end
  end

  Foo.class_bar #=> undefined
  Foo.new.class_bar #=> “class_bar”
  Foo.instance_bar #=> undefined
  Foo.new.instance_bar #=> “instance_bar”
           

接下来，我们来看看方法的动态调用。Ruby中一个动态调用方法的方式是向对象发送消息。我们可以向类或类定义本身发送消息发送消息，或者只是发送给类对象。这些都可以通过调用send方法完成。

最简单的例子如下：

s= “hi man”

  p s.length #=> 6
  p s.include? “hi” #=> true

  p s.send(:length) #=> 6
  p s.send(:include?,”hi”) #=> true
           

这个方法在什么时候有用呢？

来看看下面这段代码（取例自:http://www.funonrails.com/2011/12/dynamic-methods-inside-ruby-classes.html)

class ApplicationController < ActionController::Base
    protect_from_forgery
    helper_method :current_staff, :current_employee, current_admin

    def authenticate_staff!(opts={})
      current_staff || not_authorized
    end

    def current_staff
      current_user if current_user.is_a? Staff
    end

    def authenticate_employee!(opts={})
      current_employee || not_authorized
    end

    def current_employee
      current_user if current_user.is_a? Employee
    end

    def authenticate_admin!(opts={})
      current_admin || not_authorized
    end

    def current_admin
      current_user if current_user.is_a? Admin
    end
  end
           

使用send方法重构：

%w(Staff Employee Admin).each do |k|
    define_method “current_#{k.underscore}” do
      current_user if current_user.is_a?(k.constantize)
    end

    define_method “authenticate_#{k.underscore}!” do |opts={}|
      send(“current_#{k.underscore}”) || not_authorized
    end
  end
           

动态方法定义能够减少方法定义的错误，减少重复并且简化代码

享受元编程吧～

原文：http://rohitrox.github.io/2013/07/02/ruby-dynamic-methods/