Ruby मा metaprogramming भनेको के हो?

Question

Accepted Answer

**Metaprogramming** भनेको **runtime मा code लेख्ने वा परिवर्तन गर्ने** code लेख्नु हो — methods लाई dynamically परिभाषित गर्ने, undefined methods को response दिने, र classes लाई fly मा inspect/alter गर्ने। Ruby को dynamic nature (सबै कुरा object हो, classes समेत) ले यसलाई metaprogramming मा exceptionally राम्रो बनाउँछ, जसले Rails को धेरै "magic" लाई शक्तिशाली बनाउँछ।

## Methods लाई dynamically परिभाषित गर्दै

```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` आन्तरिक रूपमा कसरी काम गर्छ।)

## 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 परिभाषित हुन आवश्यक छैन (Rails मा heavy रूपमा प्रयोग गरिन्छ, उदाहरणका लागि 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 nature द्वारा सक्षम जहाँ सबै कुरा, classes समेत, एक object हो जसलाई runtime मा manipulate गर्न सकिन्छ) ले code लाई fly मा code लेख्न र परिवर्तन गर्न दिन्छ: **`define_method`** ले methods लाई dynamically generate गर्छ (repetitive hand-written code बचाउँदै — यो कसरी `attr_accessor` र Rails को dynamic attributes काम गर्छन्), र **`method_missing`** ले undefined method calls लाई intercept गर्छ (flexible dynamic APIs लाई सक्षम गर्दै — Rails को dynamic finders जस्तै `find_by_name`, ActiveRecord attribute methods, र धेरै अन्य भन्दा पछाडि को mechanism)।

यी techniques लाई बुझ्नुले Rails जस्तै frameworks ले आफनो seemingly magical, concise APIs कसरी प्रदान गर्छन् भनी demystify गर्छ (जहाँ methods तपाईंले कहिले पनि explicitly परिभाषित गरेको छैनन् केवल काम गर्छन्), जो यी frameworks लाई प्रभावकारी रूपमा प्रयोग गर्ने र आफनो flexible, DSL-जस्तै APIs र libraries बनाउन दुबै महत्त्वपूर्ण छ।

Metaprogramming tools लाई जान्नु (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspection) advanced Ruby ज्ञान को प्रतिबिम्ब हो।

शक्तिशाली हुँदा पनि, metaprogramming लाई judiciously प्रयोग गरिनुपर्छ (यसले code लाई follow गर्न, debug गर्न, र statically analyze गर्न गाह्रो बनाउन सक्छ — यसको flexibility को लागि trade-off)।

Metaprogramming लाई बुझ्नु — यो के हो (code को runtime मा manipulate गर्ने code), मुख्य techniques, र यो Rails को magic लाई शक्तिशाली बनाउँछ — valuable senior-level ज्ञान हो जसले तपाईंले प्रयोग गर्ने Ruby frameworks कसरी काम गर्छन् भनी व्याख्या गर्छ, advanced metaprogramming र DSL creation लाई सक्षम गर्छ, र deep Ruby expertise को hallmark छ र advanced interview topic लाई distinguish गर्ने जो developers लाई truly Ruby को dynamic capabilities लाई बुझ्छन्।