Ruby में metaprogramming क्या है?

Question

Accepted Answer

**Metaprogramming** ऐसा code लिखना है जो **runtime पर code लिखता या modify करता है** — methods को dynamically define करना, undefined methods का जवाब देना, और on the fly classes का निरीक्षण/परिवर्तन करना। Ruby की dynamic प्रकृति (सब कुछ एक object है, classes सहित) इसे metaprogramming में असाधारण रूप से अच्छा बनाती है, जो Rails के अधिकांश "magic" को powered करता है।

## Methods को dynamically define करना

```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` runtime पर methods बनाता है — यहाँ प्रत्येक को हाथ से लिखने के बजाय एक loop में accessors generate करता है। (यह मूलतः वही है जैसे `attr_accessor` internally काम करता है।)

## method_missing — undefined method calls को handle करना

```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`** undefined methods की calls को intercept करता है — dynamic APIs को सक्षम बनाता है जहाँ methods को explicitly define करने की आवश्यकता नहीं होती (Rails में भारी रूप से उपयोग किया जाता है, जैसे dynamic finders)।

## अन्य metaprogramming tools

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

## यह क्यों महत्वपूर्ण है

Metaprogramming Ruby की सबसे शक्तिशाली और विशिष्ट विशेषताओं में से एक है, और इसे समझना advanced Ruby development के लिए तथा — विशेष रूप से — यह समझने के लिए मूल्यवान है कि **Rails और अन्य Ruby frameworks अपना "magic" कैसे प्राप्त करते हैं।** Ruby की असाधारण metaprogramming क्षमता (इसकी dynamic प्रकृति द्वारा सक्षम जहाँ सब कुछ, classes सहित, एक object है जिसे runtime पर manipulate किया जा सकता है) code को on the fly code लिखने और modify करने देती है: **`define_method`** methods को dynamically generate करता है (दोहराव वाले हाथ से लिखे code से बचता है — यह वही तरीका है जैसे `attr_accessor` और Rails के dynamic attributes काम करते हैं), और **`method_missing`** undefined method calls को intercept करता है (flexible dynamic APIs को सक्षम बनाता है — यही mechanism Rails के dynamic finders जैसे `find_by_name`, ActiveRecord attribute methods, और बहुत कुछ के पीछे है)।

इन techniques को समझना यह demystify करता है कि Rails जैसे frameworks अपने प्रतीत होने वाले magical, concise APIs (जहाँ ऐसे methods जिन्हें आपने कभी explicitly define नहीं किया वे बस काम करते हैं) कैसे प्रदान करते हैं, जो इन frameworks को प्रभावी ढंग से उपयोग करने और अपने स्वयं के flexible, DSL-जैसे APIs व libraries बनाने दोनों के लिए महत्वपूर्ण है।

Metaprogramming tools (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspection) को जानना advanced Ruby ज्ञान को दर्शाता है।

शक्तिशाली होते हुए भी, metaprogramming का उपयोग समझदारी से किया जाना चाहिए (यह code को follow करने, debug करने, और statically analyze करने में कठिन बना सकता है — इसकी flexibility का trade-off)।

Metaprogramming को समझना — यह क्या है (code जो runtime पर code को manipulate करता है), key techniques, और यह कि यह Rails के magic को powered करता है — मूल्यवान senior-level ज्ञान है जो समझाता है कि आप जिन Ruby frameworks का उपयोग करते हैं वे कैसे काम करते हैं, advanced metaprogramming और DSL creation को सक्षम बनाता है, और गहन Ruby विशेषज्ञता की पहचान तथा एक सामान्य advanced interview topic है जो उन developers को अलग करता है जो वास्तव में Ruby की dynamic capabilities को समझते हैं।