რა არის მეტაპროგრამირება Ruby-ში?

Question

Accepted Answer

**მეტაპროგრამირება** არის კოდის დაწერა, რომელიც **წერს ან ცვლის კოდს გაშვების დროს** — მეთოდების დინამიურად განსაზღვრა, განუსაზღვრელი მეთოდების დამუშავება და კლასების შინაარსის შემოწმება/შეცვლა ფრენაზე. Ruby-ის დინამიური ბუნება (ყველაფერი ობიექტია, მათ შორის კლასებიც) მას გამორჩეულად კარგს ხდის მეტაპროგრამირებისთვის, რაც Rails-ის დიდი ნაწილის "ჯადოს" კვების საფუძველია.

## მეთოდების დინამიური განსაზღვრა

```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` გაშვების დროს მეთოდებს ქმნის — აქ ხელმისაწვდომელი მეთოდებს წარმოქმნის ციკლში, ნაცვლად ყოველი ხელით დაწერის. (ეს არის არსებითად ის, როგორ მუშაობს `attr_accessor` შიგნით.)

## method_missing — განუსაზღვრელი მეთოდის გამოძახებების დამუშავება

```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`** ჯამდება განუსაზღვრელი მეთოდების გამოძახებებს — ყოველ ხელმისაწვდომელ დინამიურ API-ებს უშვებს სადაც მეთოდები არ უნდა იყოს გამოკვეთილი ცალსახად (ხშირად გამოიყენება Rails-ში, მაგ. დინამიური ძებნები).

## მეტაპროგრამირების სხვა ხელსაწყოები

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

## რატომ აქვს მას მნიშვნელობა

მეტაპროგრამირება არის Ruby-ის ყველაზე მძლავრი და დამახასიათებელი ფიჩერი, და მისი გაგება ღირებული ორივე დაწყებული Ruby განვითარებისთვის და — განსაკუთრებით — იმისთვის, რომ გავიგოთ როგორ ახდენს **Rails და სხვა Ruby ჩარჩოები მათი "ჯადოს" რეალიზებას.** Ruby-ის გამორჩეული მეტაპროგრამირების უნარი (ჩართული მის დინამიურ ბუნებაში სადაც ყველაფერი, კლასებიც, არის ობიექტი რომელიც შეიძლება მანიპულირებული იყოს გაშვების დროს) საშუალებას აძლევს კოდს დაწერა და შეცვლა კოდი ფრენაზე: **`define_method`** მეთოდებს გენერირებს დინამიურად (თავიდან ავცილებს განმეორებითი ხელით დაწერილი კოდი — ეს არის როგორ მუშაობს `attr_accessor` და Rails-ის დინამიური ატრიბუტები), და **`method_missing`** ჯამდება განუსაზღვრელი მეთოდის გამოძახებებს (საშუალებას აძლევს მოქნილი დინამიური API-ებს — მეხანიზმი Rails-ის დინამიური ძებნების უკან `find_by_name`, ActiveRecord ატრიბუტის მეთოდები და ბევრი უფრო მეტი).

ამ ტექნიკის გაგება დემისტიფიკაციას აკეთებს როგორ უპირდებიან ჩარჩოები Rail-ის მსგავსი თავიანთი აკ, კონკრეტული API-ები (სადაც მეთოდები რომლებიც თქვენ აბსოლუტურად არ დაადგინეთ უბრალოდ მუშაობენ), რაც მნიშვნელოვანია ორივე მათი ეფექტურად გამოყენებისთვის და თქვენი საკუთარი მოქნილი, DSL-მსგავსი API-ებისა და ბიბლიოთეკების აწყობის წინაპირობაა.

მეტაპროგრამირების ხელსაწყოების ცოდნა (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, თვითშემეცნება) აჩვენებს მოწინავე Ruby ცოდნას.

მაქს ძლიერი მიუხედავად, მეტაპროგრამირება უნდა იქნას გამოყენებული გამჭვირვალედ (ეს შეიძლება გაკეთდეს კოდი უფრო რთული მიმდევნელი, მოწმენიკი, და სტატიკურად დასაანალიზებელი — ტრეიდოფი მის გმირობის შედეგად).

მეტაპროგრამირების გაგება — რა არის ის (კოდი რომელიც მანიპულირებს კოდს გაშვების დროს), მთავარი ტექნიკა, და რომ ის უძღვება Rails-ის ჯადოს — არის ღირებული უმცროსი მხარდამჭერი დონის ცოდნა რომელიც ხსნის როგორ მუშაობენ Ruby ჩარჩოები რომლებიც იყენებთ, უშვებთ მოწინავე მეტაპროგრამირებას და DSL აწყობას, და არის Ruby გამოცდილებისა და საერთო კითხვა საბეჭდი რომელიც განასხვავებს შემქმნელ რომელიც ნამდვილი გაიღებენ Ruby-ის დინამიური უნარი.