Apa itu metaprogramming di Ruby?

Question

Accepted Answer

**Metaprogramming** adalah menulis kode yang **menulis atau memodifikasi kode saat runtime** — mendefinisikan method secara dinamis, merespons method yang tidak terdefinisi, dan menginspeksi/mengubah kelas dengan cepat. Sifat dinamis Ruby (semuanya adalah objek, termasuk kelas) membuatnya luar biasa baik dalam metaprogramming, yang mendukung banyak "magic" Rails.

## Mendefinisikan method secara 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` membuat method saat runtime — di sini menghasilkan accessor dalam loop alih-alih menulis masing-masing secara manual. (Ini pada dasarnya adalah cara `attr_accessor` bekerja secara internal.)

## method_missing — menangani panggilan method yang tidak terdefinisi

```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`** mengintersepsi panggilan ke method yang tidak terdefinisi — memungkinkan API dinamis di mana method tidak perlu didefinisikan secara eksplisit (digunakan banyak di Rails, misalnya dynamic finders).

## Alat metaprogramming lainnya

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

Metaprogramming adalah salah satu fitur Ruby yang paling kuat dan khas, dan memahaminya sangat berharga baik untuk pengembangan Ruby tingkat lanjut dan — terutama — untuk memahami bagaimana **Rails dan framework Ruby lainnya mencapai "magic" mereka.** Kemampuan metaprogramming Ruby yang luar biasa (didukung oleh sifat dinamisnya di mana semuanya, termasuk kelas, adalah objek yang dapat dimanipulasi saat runtime) memungkinkan kode menulis dan memodifikasi kode dengan cepat: **`define_method`** menghasilkan method secara dinamis (menghindari kode berulang yang ditulis tangan — ini adalah cara `attr_accessor` dan atribut dinamis Rails bekerja), dan **`method_missing`** mengintersepsi panggilan method yang tidak terdefinisi (memungkinkan API dinamis yang fleksibel — mekanisme di balik dynamic finders Rails seperti `find_by_name`, method atribut ActiveRecord, dan banyak lagi).

Memahami teknik-teknik ini menjelaskan bagaimana framework seperti Rails menyediakan API mereka yang tampak magical dan ringkas (di mana method yang tidak pernah Anda definisikan secara eksplisit hanya bekerja), yang penting baik untuk menggunakan framework ini secara efektif maupun untuk membangun API dan library yang fleksibel dan mirip DSL Anda sendiri.

Mengetahui alat metaprogramming (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspection) mencerminkan pengetahuan Ruby tingkat lanjut.

Meskipun kuat, metaprogramming harus digunakan dengan bijak (ini dapat membuat kode lebih sulit diikuti, di-debug, dan dianalisis secara statis — trade-off untuk fleksibilitasnya).

Memahami metaprogramming — apa itu (kode yang memanipulasi kode saat runtime), teknik kunci, dan bahwa itu mendukung magic Rails — adalah pengetahuan tingkat senior yang berharga yang menjelaskan bagaimana framework Ruby yang Anda gunakan bekerja, memungkinkan pembuatan metaprogramming dan DSL tingkat lanjut, dan adalah ciri dari keahlian Ruby yang mendalam dan topik wawancara tingkat lanjut umum yang membedakan pengembang yang benar-benar memahami kemampuan dinamis Ruby.