Apa iku metaprogramming ing Ruby?

Question

Accepted Answer

**Metaprogramming** yaiku nulis kode sing **nulis utawa ngubah kode nalika runtime** — nggawe metode kanthi dinamis, nanggepi metode sing durung didefinisikan, lan ngmriksa/ngowahi kelas kanthi langsung. Sifat dinamis Ruby (kabeh yaiku obyek, kalebu kelas) ndadekake metaprogramming luar biasa apik, sing nduweni kekuatan akeh saka Rails "magic."

## Nggawe metode kanthi dinamis

```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` nggawe metode nalika runtime — ing kene nggawe accessor kanthi loop tinimbang nulis saben-saben kanthi tangan. (Iki pada dasarnya carane `attr_accessor` makarya kanthi internal.)

## method_missing — tanggapi panggilan metode sing durung didefinisikan

```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`** ngrintangi panggilan menyang metode sing durung didefinisikan — ngidupake API dinamis kang metode ora perlu didefinisikan kanthi eksplisit (digunakake sacara akeh ing Rails, contone dynamic finders).

## Piranti metaprogramming liya

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

## Mengapa iki penting

Metaprogramming yaiku salah siji fitur Ruby sing paling kuat lan khas, lan ngerti iku berharga kanggo pengembangan Ruby tingkat lanjut lan — utamane — kanggo ngerti carane **Rails lan framework Ruby liyane ngapai "magic" mereka.** Kemampuan metaprogramming Ruby sing luar biasa (dimungkinake déning sifat dinamise nang kabeh, kalebu kelas, yaiku obyek sing bisa dimanipulasi nalika runtime) ngidupake kode nulis lan ngubah kode kanthi langsung: **`define_method`** nggawe metode kanthi dinamis (nyegah kode berulang sing ditulis tangan — carane `attr_accessor` lan atribut dinamis Rails makarya), lan **`method_missing`** ngrintangi panggilan metode sing durung didefinisikan (ngidupake API dinamis sing fleksibel — mekanisme sadurunge Rails dynamic finders kayata `find_by_name`, metode atribut ActiveRecord, lan luwih akeh).

Ngerti teknik iki ndadekake cara framework kayata Rails nyedhiyakake API mereka sing keliatan ajaib lan ringkes (kang metode sing ora diarani kanthi eksplisit mung makarya), sing penting kanggo nggunakake framework iki kanthi efektif lan kanggo nggawe API fleksibel dhewe, DSL-like, lan perpustakaan.

Ngerti piranti metaprogramming (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspection) nunjukake kawruh Ruby tingkat lanjut.

Senadyan kuat, metaprogramming kudu digunakake kanthi bijaksana (bisa ndadekake kode luwih angel diikuti, debug, lan nganalisis kanthi statis — trade-off kanggo fleksibilitas mereka).

Ngerti metaprogramming — apa iku (kode sing memanipulasi kode nalika runtime), teknik kunci, lan yen iku nduweni kekuatan magic Rails — yaiku kawruh tingkat senior sing berharga sing nerangake carane framework Ruby sing kamu gunakake makarya, ngidupake metaprogramming tingkat lanjut lan pembuatan DSL, lan tandha kawruh Ruby sing jero lan topik wawancara tingkat lanjut umum sing mbedakake pengembang sing tenan ngerti kemampuan dinamis Ruby.