Pembolehubah rubi


Pembolehubah ialah lokasi storan yang menyimpan sebarang data yang boleh digunakan oleh mana-mana program.

Ruby menyokong lima jenis pembolehubah.

  • Biasanya huruf kecil, bermula dengan garis bawah: Pembolehubah. Bermula dengan

  • $: Pembolehubah global. Bermula dengan

  • @: Pembolehubah instance.

  • @@ bermula dengan: Pembolehubah kelas Pembolehubah kelas dikongsi sepanjang rantaian warisan

  • Bermula dengan huruf besar: pemalar ( Dimalarkan).

Anda telah pun memahami secara kasar pembolehubah ini dalam bab-bab sebelumnya Bab ini akan menerangkan lima jenis pembolehubah ini kepada anda secara terperinci.

Pembolehubah Global Ruby

Pembolehubah global bermula dengan $. Nilai pembolehubah global yang tidak dimulakan ialah nil, yang akan menjana amaran selepas menggunakan pilihan -w.

Menetapkan nilai kepada pembolehubah global akan mengubah keadaan global, jadi tidak disyorkan untuk menggunakan pembolehubah global.

Contoh berikut menunjukkan penggunaan pembolehubah global. 

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

$global_variable = 10
class Class1
  def print_global
      puts "全局变量在 Class1 中输出为 #$global_variable"
  end
end
class Class2
  def print_global
      puts "全局变量在 Class2 中输出为 #$global_variable"
  end
end

class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global


Di sini, $global_variable ialah pembolehubah global. Ini akan menghasilkan keputusan berikut:

Nota: Dalam Ruby, anda boleh mengakses nilai mana-mana pembolehubah atau pemalar dengan meletakkan aksara # di hadapan pembolehubah atau pemalar. 

全局变量在 Class1 中输出为 10
全局变量在 Class2 中输出为 10

Pembolehubah tika Ruby

Pembolehubah tikar bermula dengan @. Pembolehubah contoh yang tidak dimulakan mempunyai nilai nihil, yang akan menjana amaran selepas menggunakan pilihan -w.

Contoh berikut menunjukkan penggunaan pembolehubah contoh. 

#!/usr/bin/ruby

class Customer
   def initialize(id, name, addr)
      @cust_id=id
      @cust_name=name
      @cust_addr=addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
    end
end

# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")

# 调用方法
cust1.display_details()
cust2.display_details()


Di sini, @cust_id, @cust_name dan @cust_addr ialah pembolehubah tika. Ini akan menghasilkan keputusan berikut: 

Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala

Pembolehubah Kelas Ruby

Pembolehubah kelas bermula dengan @@ dan mesti dimulakan sebelum ia boleh digunakan dalam definisi kaedah.

Merujuk pembolehubah kelas yang tidak dimulakan akan menghasilkan ralat. Pembolehubah kelas boleh dikongsi antara subkelas atau submodul kelas atau modul di mana ia ditakrifkan.

Melebihi pembolehubah kelas menghasilkan amaran selepas menggunakan pilihan -w.

Contoh berikut menunjukkan penggunaan pembolehubah kelas. 

#!/usr/bin/ruby

class Customer
   @@no_of_customers=0
   def initialize(id, name, addr)
      @cust_id=id
      @cust_name=name
      @cust_addr=addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
    end
    def total_no_of_customers()
       @@no_of_customers += 1
       puts "Total number of customers: #@@no_of_customers"
    end
end

# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")

# 调用方法
cust1.total_no_of_customers()
cust2.total_no_of_customers()


Di sini, @@no_of_customers ialah pembolehubah kelas. Ini akan menghasilkan keputusan berikut: 

Total number of customers: 1
Total number of customers: 2

Pembolehubah Tempatan Ruby

Pembolehubah setempat bermula dengan huruf kecil atau garis bawah _. Pembolehubah setempat diskop daripada kelas, modul, def atau lakukan ke hujung yang sepadan atau daripada pendakap buka ke pendakap tutup {}.

Apabila pembolehubah tempatan yang tidak dimulakan dipanggil, ia ditafsirkan sebagai memanggil kaedah tanpa parameter.

Menetapkan nilai kepada pembolehubah tempatan yang tidak dimulakan juga boleh dianggap sebagai pengisytiharan pembolehubah. Pembolehubah akan wujud sehingga akhir skop semasa. Jangka hayat pembolehubah tempatan ditentukan apabila Ruby menghuraikan atur cara.

Dalam contoh di atas, pembolehubah tempatan ialah id, nama dan addr.

Pemalar Ruby

Pemalar bermula dengan huruf besar. Pemalar yang ditakrifkan dalam kelas atau modul boleh diakses dari dalam kelas atau modul, dan pemalar yang ditakrifkan di luar kelas atau modul boleh diakses secara global.

Malar tidak boleh ditakrifkan dalam kaedah. Merujuk kepada pemalar yang tidak dimulakan akan menghasilkan ralat. Menetapkan nilai kepada pemalar yang dimulakan akan menghasilkan amaran. 

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

class Example
   VAR1 = 100
   VAR2 = 200
   def show
       puts "第一个常量的值为 #{VAR1}"
       puts "第二个常量的值为 #{VAR2}"
   end
end

# 创建对象
object=Example.new()
object.show


Di sini, VAR1 dan VAR2 ialah pemalar. Ini akan menghasilkan keputusan berikut: 

第一个常量的值为 100
第二个常量的值为 200

Ruby Pseudo-Variables

Ia adalah pembolehubah khas yang mempunyai rupa pembolehubah tempatan tetapi berkelakuan seperti pemalar. Anda tidak boleh memberikan sebarang nilai kepada pembolehubah ini.

  • diri: Objek penerima kaedah semasa.

  • benar: mewakili nilai benar.

  • salah: mewakili nilai palsu.

  • nihil: mewakili nilai yang tidak ditentukan.

  • __FAIL__: Nama fail sumber semasa.

  • __LINE__: Nombor baris semasa dalam fail sumber.