Ruby માં metaprogramming શું છે?

Question

Accepted Answer

**Metaprogramming** એ કોડ લખવું છે જે **રનટાઇમ પર કોડ લખે અથવા તે બદલે** — ડાયનેમિક્‍ કીથી મેથડ્‍સ વ્યાખ્યાયિત કરવા, અણશોધાયેલ મેથડ્‍સને જવાબ આપવો, અને ક્લાસીજ્ઞતાને ફ્લાય પર તપાસવા/બદલવા. Ruby નો ડાયનેમિક સ્વભાવ (બધું કંઈ ઑબ્જેક્ટ છે, ક્લાસીજ્ઞતા સહિત) તેને metaprogramming માટે અસાધારણ રીતે સારું બનાવે છે, જે 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` રનટાઇમ પર મેથડ્‍સ બનાવે છે — અહીં લૂપમાં accessors જોવા આપે છે બદલે દરેક હાથથી લખવાને પસંદ કરે. (આ આવશ્યક રીતે છે કેવી રીતે `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`** અણશોધાયેલ મેથડ્‍સને કલ કરવાને આડકતરો રોક્તો હોય છે — ડાયનેમિક્‍ APIs સક્ષમ કરતો જ્યાં મેથડ્‍સ સ્ફટિક રીતે વ્યાખ્યાયિત થવાની જરૂર નથી (Rails માં ભારે ઉપયોગ, દા.ત. ડાયનેમિક finders).

## અન્ય 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
```

## તે શા માટે મહત્વનું છે

Metaprogramming Ruby ની સૌથી શક્તિશાળી અને અલગ લક્ષણો વચ્ચે એક છે, અને તેને સમજવું દ્વિતીય Ruby વિકાસ માટે અને — ખાસ કરીને — **Rails અને અન્ય Ruby ફ્રેમવર્કોનું "જાદુ" કેવી રીતે પ્રાપ્ત થાય તે સમજવા માટે** મૂલ્યવાન છે. Ruby નું અસાધારણ metaprogramming ક્ષમતા (તેના ડાયનેમિક સ્વભાવ દ્વારા સક્ષમ જ્યાં બધું, ક્લાસીજ્ઞતા સહિત, ઑબ્જેક્ટ છે જે રનટાઇમ પર ચલાવી શકાય) કોડને ફ્લાય પર કોડ લખવાનો અને બદલવાનો સુયોગ આપે છે: **`define_method`** ડાયનેમિક્‍ કીથી મેથડ્‍સ બનાવે છે (પુનરાવર્તિત હાથથી લખવાને અટકાવતું — તે છે કેવી રીતે `attr_accessor` અને Rails ના ડાયનેમિક એટ્રિબ્યુટો કામ કરે છે), અને **`method_missing`** અણશોધાયેલ મેથડ કલ્સને આડકતરો રોક્તો હોય છે (લવણીય ડાયનેમિક્‍ APIs સક્ષમ કરતો — Rails ના ડાયનેમિક finders જેમ કે `find_by_name`, ActiveRecord એટ્રિબ્યુટ મેથડ્‍સ, અને બહુ કંઈ વધુ પાછળનું મિકેનિઝમ).

આ તકનીકોને સમજવું Rails જેવા ફ્રેમવર્કોને demystify કરે છે જે તેમાંનું તેમાં ઓછે પણ જાદુમય, સંક્ષિપ્ત APIs આપે છે (જ્યાં મેથડ્‍સ તમે ક્યારેય સ્ફટિક રીતે વ્યાખ્યાયિત કર્યા નથી તે કામ કરે છે), જે દ્વિતીય આ ફ્રેમવર્કોને અસરકારક રીતે ઉપયોગ કરવા માટે અને તમારા પોતાના લવણીય, DSL જેવા APIs અને લાઇબ્રેરીઝ બાંધવા માટે મહત્વનું છે.

Metaprogramming સાધનો (​​`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, અનુમેય) જાણવું શ્રેષ્ઠ Ruby જ્ઞાન પ્રતિબિંબિત કરે છે.

શક્તિશાળી હોવા છતાં, metaprogramming યોગ્ય રીતે ઉપયોગ કરવું જોઈએ (તે કોડને અનુસરવું, ડીબગ કરવું, અને સ્થિર રીતે વિશ્લેષણ કરવું કઠણ બની શકે છે — તેની લવણીયતા માટે ટ્રેડ-ઓફ).

Metaprogramming સમજવું — તે શું છે (કોડ જે રનટાઇમ પર કોડને હેરફેર કરે), મુખ્ય તકનીકો, અને તે Rails ના જાદુને શક્તિ આપે છે — શ્રેષ્ઠ-સ્તરીય જ્ઞાન છે જે તમે જે Ruby ફ્રેમવર્કોનો ઉપયોગ કરો તેઓ કેવી રીતે કામ કરે તે સમજાવે છે, શ્રેષ્ઠ metaprogramming અને DSL નિર્માણ સક્ષમ કરે છે, અને Ruby નું ગહન જ્ઞાન અને સામાન્ય શ્રેષ્ઠ ઇન્ટરવ્યુ વિષય શોધ કરે છે જે તમે Ruby ના ડાયનેમિક ક્ષમતાને સાચે સમજો તે ભેદ દર્શાવે છે.