Variable didalam Ruby

Pada sub-bagian sebelumnya, kamu sudah mendapatkan sedikit informasi tentang variable yang ada didalam Ruby. Di sub-bagian kali ini kita akan membahas sedikit lebih dalam tentang variable yang digunakan oleh Ruby.

Pengertian singkat dari variable sendiri adalah suatu entitas yang digunakan untuk menyimpan suatu data didalam memori yang digunakan oleh suatu program.

Global Variable

Variable Global atau Global Variable bisa diidentifikasi yakni diawali dengan karakter dolar ($) diawal nama variable. Sesuai dengan namanya, global variable dapat diakses dimana pun didalam sebuah aplikasi Ruby. Kasus penggunaan global variable jarang ditemukan, sehingga jenis variable ini sangat jarang digunakan. Salah satu alasannya adalah tingkat kesulitan dalam proses debugging, dikarenakan sifatnya yang global.

Global variable yang sudah didefinisikan namun tanpa meng-assign sebuah value terhadapnya akan menghasilkan sebuah warning dengan tambahan option -w. Secara default, global variable bernilai nil jika kita tidak memberikan nilai apapun.

Berikut contoh penggunaan global variable. Salin kode dibawah kedalam sebuah file baru, kita beri nama global_variable1.rb:

$global_var = 1

class Foo
    def bar
        puts $global_var
    end
end

class Foo2
    def bar2
        puts $global_var
    end
end

foo = Foo.new
foo.bar
foo2 = Foo2.new
foo2.bar2

Jalankan file global_variable1.rb dan lihat output yang dihasilkan.

Instance Variable

Instanve variable diawali dengan karakter at (@). Instance variable adalah salah satu variable yang paling sering digunakan dalam sebuah aplikasi Ruby. Instance variable akan bernilai nil jika kita tidak memberikan nilai apapun.

Pada sub-bagian sebelumnya, kita sudah pernah mendefinisikan beberapa instance variable, kali ini kita akan coba kembali menulis instance variable. Salin kode dibawah ini kedalam sebuah file baru dengan nama instance_variable1.rb:

class Foo
    def initialize(id, name)
        @id = id
        @name = name
    end

    def bar
        puts "ID: #{@id}"
        puts "Name: #{@name}"
    end
end

foo = Foo.new(1, "User")
foo.bar

Jalankan file instance_variable1.rb dan perhatikan output yang dihasilkan. Pada contoh kode diatas, kita mendefinisikan dua buah instance variable yakni @id dan @name. Umumnya, instance variable diletakkan didalam fungsi konstruktor sebuah class. Ketika kita meng-inisialisasi class Foo dengan mengirimkan parameter id dan name, kita sudah melakukan mapping terhadap masing-masing parameter untuk mendefinisikan nilai dari instance variable terkait.

Class Variable

Class variable didefinisikan dengan menambahkan dua karakter at (@) diawal nama variable. Secara garis besar, class variable sama dengan instance variable. Yang membedakan adalah class variable dapat diakses oleh turunan class dimana class variable itu didefinisikan. Untuk lebih memahami, salin kode dibawah ini kedalam sebuah file baru dengan nama class_variable1.rb:

class Foo
  @@class_var = []
  @instance_var = []

  def self.shared_class_var
    @@class_var
  end

  def shared_class_var
    self.class.shared_class_var
  end

  def self.priv_instance_var
    @instance_var
  end

  def priv_instance_var
    self.class.priv_instance_var
  end
end

class Bar < Foo 
  @instance_var = []
end

Foo.shared_class_var << "first"
Bar.shared_class_var << "second"
foo = Foo.new
bar = Bar.new
foo.shared_class_var << "third"
bar.shared_class_var << "fourth"

puts Foo.shared_class_var.inspect
puts Bar.shared_class_var.inspect
puts foo.shared_class_var.inspect
puts bar.shared_class_var.inspect

# Output yang dihasilkan
# ["first", "second", "third", "fourth"]
# ["first", "second", "third", "fourth"]
# ["first", "second", "third", "fourth"]
# ["first", "second", "third", "fourth"]

Foo.priv_instance_var << "first"
Bar.priv_instance_var << "second"
foo.priv_instance_var << "third"
bar.priv_instance_var << "fourth"

puts Foo.priv_instance_var.inspect
puts Bar.priv_instance_var.inspect
puts foo.priv_instance_var.inspect
puts bar.priv_instance_var.inspect

# Output yang dihasilkan
# ["first", "third"]
# ["second", "fourth"]
# ["first", "third"]
# ["second", "fourth"]

Jalankan file class_variable1.rb dan cek apakah output yang dihasilkan sesuai dengan contoh diatas. Kita lihat pada kelompok kode puts pertama, menghasilkan output yang sama, dan kelompuk kode puts kedua, menghasilkan output yang berbeda. Itulah yang membedakan antara class variable dan instance variable. class Foo dan Bar berbagi class variable @@class_var, sedangkan instance variable @instance_var hanya terbatas pada masing-masing class.

Local Variable

Local variable diawali dengan huruf kecil atau karakter garis bawah (_). Local variable memiliki scope yang lebih sempit dari semua jenis variable, yakni hanya sampai penutup dari sebuah class, module, method atau penutup sebuah baris kode.

Jika sebuah local variable didefinisikan tanpa memberikannya sebuah nilai, maka Ruby akan menganggap itu sebagai pemanggilan method tanpa memberikan argumen apapun. Jika method yang dipanggil tersebut tidak ada maka akan menghasilkan error kurang lebih seperti ini:

NameError: undefined local variable or method `ban' for main:Object
    from (irb):11
    from /Users/opanmustopah/.rbenv/versions/2.3.3/bin/irb:11:in `<main>'

Pada contoh kode disub-bagian sebelumnya kita sudah pernah menggunakan local variable, salah satunya adalah id dan name.

Constant Variable

Constant variable diawali dengan hurus besar dan biasanya didefinisikan didalam sebuah class atau module atau disebuah file tersendiri. Constant variable yang didefinisikan didalam sebuah class atau module dapat diakses secara langsung. Mendefinisikan constant variable tanpa memberikannya sebuah nilai akan menghasilkan error. Dan jika mendefinisikan sebuah constant variable yang sudah ada akan mengahsilkan sebuah warning.

Pada dasarnya nilai dari sebuah constant variable tidak dapat diubah saat proses sudah berjalan, karena constant variable bersifat immutable atau tidak dapat diubah. Namun dikarenakan Ruby adalah bahasa pemrograman yang bersifat dinamis, maka hampir tidak ada object yang benar-benar bersifat immutable dalam Ruby. Jika kita mencoba untuk mengubah nilainya, maka akan menghasilkan sebuah warning. Kita akan mencoba menulis constant variable didalam sebuah class. Salin kode dibawah ini kedalam sebuah file baru dengan nama constant_variable1.rb:

class Foo
  CONS = 1

  def bar
    puts "Ini adalah constant variable: #{CONS}"
  end
end

foo = Foo.new
foo.bar

# Kita juga bisa mengakses nilai constant variable secara langsung
puts Foo::CONS

# Coba untuk ubah nilainya, maka akan menghasilkan warning
Foo::CONS = 3
puts Foo::CONS

Jalankan file tersebut dan lihat output yang dihasilkan.

Pseudo-Variables

Ini adalah variable khusus yang disediakan oleh Ruby. Kita tidak bisa memberikan nilai terhadap variable jenis ini. Variable ini memiliki tampilan seperti local variable namun memiliki sifat seperti constant variable. Berikut adalah daftarnya:

  • self: Ini adalah object penerima atau receiver object untuk method yang sedang berjalan.
  • true dan false: Merepresentasikan nilai dari class Boolean, yakni true dan false.
  • nil: Merepresentasikan nilai belum didefinisikan atau undefined.
  • __FILE__: Untuk mendapatkan nama file saat ini.
  • __LINE__: Untuk mendapatkan baris nomor di file sumber.

Aturan Dasar Variable dalam Ruby

Untuk mendefinisikan sebuah variable dalam Ruby cukup mudah. Ruby tidak memerlukan pendefinisian tipe data pada variable yang akan didefinisikan seperti yang ada pada static languange semacam Java. Berikut adalah tipe data yang bisa didefinisikan menjadi variable (kita akan mempelajari lebih lanjut masing-masing dari tipe data ini dibagian tersendiri):

  • Fixnum: 123
  • Negatif Fixnum: -123
  • Oktal: 0377
  • Heksamdesimal: 0xff
  • Binari: 0b1011
  • String: "String"
  • Bignum: 12345678901234567890
  • Hash: { key: "value" }
  • Array: [1, 2, 3]
  • Objects: Foo.new
  • dan banyak lagi.

results matching ""

    No results matching ""