Menene metaprogramming a Ruby?

Question

Accepted Answer

**Metaprogramming** shine rubuta code da **rubuta ko canja code a lokacin aiki** — bayyana hanyoyi ta hanya, amsa ga hanyoyi da ba a ayyana, da kula/canja azuzuwan aiki. Yanayin Ruby na dynamic (kome abu ne object, gaba da azuzuwa) yana sa shi ya kasance kyakkyawan sosai a metaprogramming, wanda ke jiha yawancin "sihiri" na Rails.

## Bayyana hanyoyi ta hanya

```ruby
class Product
  # define methods programmatically at runtime
  [:name, :price, :sku].each do |attribute|
    define_method(attribute) do            # creates a getter method for each
      instance_variable_get("@#{attribute}")
    end
    define_method("#{attribute}=") do |value|   # and a setter
      instance_variable_set("@#{attribute}", value)
    end
  end
end
# → Product now has name/name=, price/price=, sku/sku= — generated, not hand-written
```

`define_method` yana haifar da hanyoyi a lokacin aiki — a nan yana samar da accessors cikin lanƙwasa maimakon rubuta kowacce gida. (Wannan shine sosai yadda `attr_accessor` ke aiki a ciki.)

## method_missing — kula da kiran hanyoyin da ba a ayyana

```ruby
class DynamicConfig
  def initialize = @settings = {}

def method_missing(name, *args)         # called when an UNDEFINED method is invoked
    name_str = name.to_s
    if name_str.end_with?("=")            # a setter like config.timeout = 30
      @settings[name_str.chomp("=")] = args.first
    else                                  # a getter like config.timeout
      @settings[name_str]
    end
  end
  def respond_to_missing?(name, include_private = false) = true
end

config = DynamicConfig.new
config.timeout = 30      # no `timeout=` method defined → method_missing handles it
config.timeout           # 30 — also via method_missing
```

**`method_missing`** yana tsare kiran hanyoyin da ba a ayyana — wajen baiwa damar APIs na dynamic inda hanyoyi ba sa bukatarsu a bayyana a sarari (ana amfani da shi sosai a Rails, misali: bincike na dynamic).

## Sauran kayan metaprogramming

```ruby
obj.send(:method_name, args)        # call a method by name (even private)
obj.respond_to?(:method_name)        # check if a method exists
Object.const_get("ClassName")        # get a class by name string
self.class.instance_methods          # introspect methods
user.define_singleton_method(:special) { ... }   # add a method to one object
```

## Me ya sa ya matuhi

Metaprogramming shine ɗaya daga cikin mafi karfin da nuni-nuni fasali na Ruby, kuma fahimtarsa yana da thamani duka ga Ruby kawar-kawar da — musamman — ga gano yadda **Rails da sauran Ruby frameworks ke samun "sihirinsu."** Karfin Ruby a metaprogramming mai banƙyame (wajen sa'a duk abu, gaba da azuzuwa, ne object wanda za a iya sarrafa a lokacin aiki) yana baiwa code damar rubutawa da canja code a jiya: **`define_method`** yana samar da hanyoyi ta hanya (karkatar da ruwan rubuta da aka rubuta gida — wannan ne yadda `attr_accessor` da attributes na Rails ke aiki), kuma **`method_missing`** yana tsare kiran hanyoyin da ba a ayyana (wajen baiwa damar APIs na dynamic — hanya ta bayan dynamic finders na Rails kamar `find_by_name`, methods na ActiveRecord, da yawancin ɗa).

Ganin waɗannan dabarun yana baiwa damar lalata yadda frameworks kamar Rails ke baiwa APIs na sihiri, gajere (inda hanyoyi ba ka sarari bari sai sai suka aiki), wanda ke da mahimmanci saboda amfani da waɗannan frameworks da kyau kuma saboda gina kananka flexible, DSL-kamar APIs da libraries.

Sanin kayan metaprogramming (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspection) yana nuna ilimi mai zurfi na Ruby.

Duk da karfinta, metaprogramming yakamata a yi amfani da ita ta hanyar tunani (tana iya sa code ya zama mafi wahala a bi, duba, da static analyze — jujjuya lamari daga karfinta).

Ganin metaprogramming — me ya sa (code da ke sarrafa code a lokacin aiki), hanyoyin matakai, da cewa yana jiha sihiri na Rails — shine ilimi na jiya-jiya na jiya wanda ya bayyana yadda Ruby frameworks da ke yi amfani da su ke aiki, yana baiwa damar metaprogramming na kawar-kawar da creation na DSL, kuma shine alama na ilimi mai zurfi na Ruby da common advanced interview jiya wanda ke bambanta masu karatu waɗanda suka fahimci da gaske karfin dynamic na Ruby.