Ruby ਵਿੱਚ metaprogramming ਕੀ ਹੈ?

Question

Accepted Answer

**Metaprogramming** ਅਜਿਹਾ code ਲਿਖਣਾ ਹੈ ਜੋ **runtime ਤੇ code ਨੂੰ ਲਿਖਦਾ ਜਾਂ modify ਕਰਦਾ ਹੈ** — methods ਨੂੰ dynamically define ਕਰਨਾ, undefined methods ਦਾ جواب ਦੇਣਾ, ਅਤੇ classes ਨੂੰ inspect/alter ਕਰਨਾ। Ruby ਦੀ dynamic ਪ੍ਰਕਿਰਿਆ (ਸਭ ਕੁਝ ਇੱਕ object ਹੈ, classes ਸਮੇਤ) ਇਸਨੂੰ metaprogramming ਲਈ ਬਹੁਤ ਵਧੀਆ ਬਣਾਉਂਦੀ ਹੈ, ਜੋ Rails ਦਾ ਬਹੁਤ ਸਾਰਾ "magic" ਚਲਾਉਂਦੀ ਹੈ।

## 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 ਬਣਾ ਰਿਹਾ ਹੈ। (ਇਹ ਤਾਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਇਹ ਹੈ ਕਿ `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 ਨੂੰ enable ਕਰਦੇ ਹوئے ਜਿਥੇ 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 ਵਿਕਾਸ ਅਤੇ — ਖਾਸ ਤੌਰ ਤੇ — **Rails ਅਤੇ ਹੋਰ Ruby frameworks ਆਪਣਾ "magic" ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ** ਇਹ ਸਮਝਣ ਲਈ ਮੁੱਲਵਾਨ ਹੈ। Ruby ਦੀ ਅਸਾਧਾਰਨ metaprogramming ਸਮਰੱਥਾ (ਇਸਦੀ dynamic ਪ੍ਰਕਿਰਿਆ ਦੁਆਰਾ enabled ਜਿੱਥੇ ਹਰ ਚੀਜ਼, classes ਸਮੇਤ, ਇੱਕ object ਹੈ ਜਿਸ ਨੂੰ runtime ਤੇ manipulate ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ) code ਨੂੰ fly ਤੇ code ਨੂੰ ਲਿਖਣ ਅਤੇ modify ਕਰਨ ਦਿੰਦੀ ਹੈ: **`define_method`** dynamically methods ਬਣਾਉਂਦਾ ਹੈ (repetitive ਹੱਥੋਂ-ਲਿਖੇ code ਤੋਂ ਬਚਦਾ ਹੈ — ਇਹ ਹੈ ਕਿ `attr_accessor` ਅਤੇ Rails ਦੀਆਂ dynamic attributes ਕਿਵੇਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ), ਅਤੇ **`method_missing`** undefined method calls ਨੂੰ intercept ਕਰਦਾ ਹੈ (flexible dynamic APIs ਨੂੰ enable ਕਰਦੇ ਹوئے — Rails ਦੇ dynamic finders ਜਿਵੇਂ `find_by_name`, ActiveRecord attribute methods, ਅਤੇ ਬਹੁਤ ਕੁਝ ਹੋਰ ਦਾ ਤੰਤਰ)।

ਇਹ ਤਕਨੀਕਾਂ ਨੂੰ ਸਮਝਣਾ demystify ਕਰਦਾ ਹੈ ਕਿ Rails ਵਰਗੇ frameworks ਆਪਣੇ seemingly ਜਾਦੂਈ, ਸੰਖਿਪਤ APIs ਕਿਵੇਂ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ (ਜਿੱਥੇ methods ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਮ ਕਦੇ explicitly define ਨਹੀਂ ਕੀਤਾ ਬਸ ਕੰਮ ਕਰਦੇ ਹਨ), ਜੋ ਇਨ੍ਹਾਂ frameworks ਨੂੰ effectively use ਕਰਨ ਅਤੇ ਆਪਣੇ flexible, DSL-ਵਰਗੇ APIs ਅਤੇ libraries ਬਣਾਉਣ ਦੋਨਾਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।

Metaprogramming tools ਨੂੰ ਜਾਣਨਾ (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspection) advanced Ruby ਗਿਆਨ ਨੂੰ ਪ੍ਰਤੀਬਿੰਬਤ ਕਰਦਾ ਹੈ।

en ਹਨਦਾ ਹੈ, metaprogramming ਨੂੰ ਸਦਮਤੀ ਨਾਲ ਵਰਤਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ (ਇਹ code ਨੂੰ follow ਕਰਨਾ, debug ਕਰਨਾ, ਅਤੇ statically analyze ਕਰਨਾ harder ਬਣਾ ਸਕਦਾ ਹੈ — ਇਸਦੀ ਲਚਕਤਾ ਲਈ ਟ੍ਰੇਡ-off)।

Metaprogramming ਨੂੰ ਸਮਝਨਾ — ਇਹ ਕੀ ਹੈ (code ਜੋ runtime ਤੇ code ਨੂੰ manipulate ਕਰਦਾ ਹੈ), ਮੁੱਖ ਤਕਨੀਕਾਂ, ਅਤੇ ਇਹ Rails ਦਾ magic ਚਲਾਉਂਦਾ ਹੈ — valuable senior-level ਗਿਆਨ ਹੈ ਜੋ ਵਿਖਾਉਂਦਾ ਹੈ ਕਿ Ruby frameworks ਜੋ ਤੁਸੀਂ ਵਰਤਦੇ ਹੋ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ, advanced metaprogramming ਅਤੇ DSL ਬਣਾਨਾ enable ਕਰਦਾ ਹੈ, ਅਤੇ deep Ruby ਦੀ ਪਛਾਣ ਹੈ। expertise ਅਤੇ ਇੱਕ common advanced ਇੰਟਰਵਿਊ ਟਾਪਿਕ ਜੋ developers ਨੂੰ ਅਲੱਗ ਕਰਦਾ ਹੈ ਜੋ Ruby ਦੀ dynamic ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਸੱਚਮੁੱਚ ਸਮਝਦੇ ਹਨ।