Kas yra metaprogramavimas Ruby?

Question

Accepted Answer

**Metaprogramavimas** yra kodas, kuris **rašo arba modifikuoja kodą vykdymo metu** — dinamiškai apibrėžiant metodus, reaguojant į neapibrėžtus metodus bei inspektuojant/keičiant klases skrendančiu metu. Ruby dinaminis pobūdis (viskas yra objektas, įskaitant klases) daro ją išskirtinai gerą metaprogramavimui, kuris suteikia daug Rails "magijos".

## Metodų dinaminis apibrėžimas

```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` kurie metodus vykdymo metu — čia generuojant prieigos metodus cikle, vietoj to, kad kiekvieną rašytumėte rankomis. (Tai iš esmės tai, kaip `attr_accessor` veikia viduje.)

## method_missing — tvarkyti neapibrėžtų metodų iškvietimus

```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`** perimti neapibrėžtų metodų iškvietimus — suteikiant galimybę dinaminiams API, kur metodai neturi būti aiškiai apibrėžti (plačiai naudojama Rails, pvz. dinaminės paieškos).

## Kiti metaprogramavimo įrankiai

```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
```

## Kodėl tai svarbu

Metaprogramavimas yra viena iš galingiausių ir pačių išskirtimiausių Ruby savybių, ir jo supratimas yra vertingas tiek pažangiam Ruby vystymuui, tiek — ypač — norint suprasti, kaip **Rails ir kiti Ruby framework'ai pasiekia savo "magiją".** Ruby išskirtinė metaprogramavimo gebėjimai (suteikiami jos dinaminio pobūdžio, kuriame viskas, įskaitant klases, yra objektas, kuris gali būti manipuliojamas vykdymo metu) leidžia kodui rašyti ir modifikuoti kodą skrendančiu metu: **`define_method`** dinamiškai generuoja metodus (vengiant pasikartojančio ranko rašyto kodo — tai yra tas, kaip veikia `attr_accessor` ir Rails dinaminiai atributai), o **`method_missing`** perimti neapibrėžtų metodų iškvietimus (suteikiant galimybę lankstems dinaminiems API — mehanizmas už Rails dinamines paieškas kaip `find_by_name`, ActiveRecord atributo metodus ir daug daugiau).

Supratimas šių metodų demistralinami, kaip framework'ai kaip Rails suteikia savo tarsi magiškus, lakoniškus API (kur metodai, kuriuos niekada aiškiai neapibrėžėte, tiesiog veikia), tai svarbu tiek šiems framework'ams efektyviai naudoti, tiek kurti savo lankstus, DSL panašius API ir bibliotekas.

Žinojimas metaprogramavimo įrankių (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspeksija) atspindi pažangų Ruby žinojimą.

Nors galingas, metaprogramavimas turėtų būti naudojamas apdairiai (jis gali padaryti kodą sunkiau suprantamą, derinimą ir statinę analizę — pasikeitimas jo lankstumui).

Supratimas metaprogramavimo — kas tai yra (kodas, kuris manipuliuoja kodu vykdymo metu), pagrindiniai metodai ir tai, kad jis suteikia Rails magiją — yra vertingas aukštos lygio žinojimas, kuris paaiškina, kaip veikia Ruby framework'ai, kuriuos naudojate, suteikia galimybę pažangiam metaprogramavimui ir DSL kūrimui bei yra gilaus Ruby žinojimo ženklas ir dažna pažangi pokalbio tema, skirianti kūrėjus, kurie tikrai supranta Ruby dinamines galimybes.