Ruby saf bir nesne yönelimli programlama dilidir. 1993 yılında Japonya'dan Yukihiro Matsumoto tarafından oluşturuldu.

Yukihiro Matsumoto adını www.ruby-lang.org adresindeki Ruby posta listesinde bulabilirsiniz . Matsumoto, Ruby topluluğunda Matz olarak da bilinir.

Ruby is "A Programmer's Best Friend".

Ruby, Smalltalk, Perl ve Python'unkilere benzer özelliklere sahiptir. Perl, Python ve Smalltalk komut dosyası dilleridir. Smalltalk gerçek bir nesne yönelimli dildir. Ruby, Smalltalk gibi mükemmel bir nesne yönelimli dildir. Ruby sözdizimini kullanmak, Smalltalk sözdizimini kullanmaktan çok daha kolaydır.

Ruby'nin Özellikleri

• Ruby açık kaynak kodludur ve Web'de ücretsiz olarak mevcuttur, ancak bir lisansa tabidir.

• Ruby, genel amaçlı, yorumlanmış bir programlama dilidir.

• Ruby gerçek bir nesne yönelimli programlama dilidir.

• Ruby, Python ve PERL'e benzer bir sunucu tarafı kodlama dilidir.

• Ruby, Common Gateway Interface (CGI) betikleri yazmak için kullanılabilir.

• Ruby, Hypertext Markup Language (HTML) içine gömülebilir.

• Ruby, yeni bir geliştiricinin çok hızlı ve kolay bir şekilde öğrenmesini sağlayan temiz ve kolay bir sözdizimine sahiptir.

• Ruby, C ++ ve Perl gibi birçok programlama diline benzer sözdizimine sahiptir.

• Ruby çok ölçeklenebilir ve Ruby'de yazılan büyük programların bakımı kolaylıkla yapılabilir.

• Ruby, İnternet ve intranet uygulamaları geliştirmek için kullanılabilir.

• Ruby, Windows ve POSIX ortamlarına kurulabilir.

• Ruby, Tcl / Tk, GTK ve OpenGL gibi birçok GUI aracını destekler.

• Ruby, DB2, MySQL, Oracle ve Sybase'e kolayca bağlanabilir.

• Ruby, doğrudan Ruby komut dosyalarına kullanılabilen zengin bir yerleşik işlevler kümesine sahiptir.

İhtiyacınız Olacak Araçlar

Bu eğiticide tartışılan örnekleri gerçekleştirmek için, en az 2 GB RAM (4 GB RAM önerilir) ile Intel Core i3 veya i5 gibi en yeni bir bilgisayara ihtiyacınız olacak. Ayrıca aşağıdaki yazılıma da ihtiyacınız olacak -

• Linux veya Windows 95/98/2000 / NT veya Windows 7 işletim sistemi.

• Apache 1.3.19-5 Web sunucusu.

• Internet Explorer 5.0 veya üzeri Web tarayıcısı.

• Yakut 1.8.5

Bu eğitici, Ruby kullanarak GUI, ağ oluşturma ve Web uygulamaları oluşturmak için gerekli becerileri sağlayacaktır. Ayrıca Ruby uygulamalarını genişletme ve yerleştirme hakkında da konuşacak.

Sırada ne var?

Sonraki bölüm, Ruby'yi ve belgelerini nereden edinebileceğiniz konusunda size rehberlik edecek. Son olarak, Ruby'nin nasıl kurulacağı ve Ruby uygulamaları geliştirmek için bir ortamın nasıl hazırlanacağı konusunda size talimat verir.

Yerel Ortam Kurulumu

Hala Ruby programlama dili için ortamınızı kurmaya istekli iseniz, devam edelim. Bu eğitim, size ortam kurulumuyla ilgili tüm önemli konuları öğretecektir. Önce aşağıdaki konuları incelemenizi ve ardından ilerlemenizi tavsiye ederiz -

• Linux / Unix üzerinde Ruby Kurulumu - Geliştirme ortamınızı Linux / Unix Makinesinde yapmayı planlıyorsanız, bu bölümü gözden geçirin.

• Windows'ta Ruby Kurulumu - Geliştirme ortamınızı Windows Makinede bulundurmayı planlıyorsanız, bu bölüme gidin.

• Ruby Komut Satırı Seçenekleri - Bu bölüm, Ruby yorumlayıcısı ile birlikte kullanabileceğiniz tüm komut satırı seçeneklerini listeler.

• Ruby Ortam Değişkenleri - Bu bölümde Ruby Yorumlayıcı'nın çalışması için ayarlanacak tüm önemli ortam değişkenlerinin bir listesi vardır.

Popüler Ruby Editörleri

Ruby programlarınızı yazmak için bir düzenleyiciye ihtiyacınız olacak -

• Windows makinesinde çalışıyorsanız, Not Defteri veya Edit plus gibi herhangi bir basit metin düzenleyiciyi kullanabilirsiniz.

• VIM (Vi IMproved) çok basit bir metin editörüdür. Bu hemen hemen tüm Unix makinelerinde ve şimdi Windows'ta da mevcuttur. Aksi takdirde, Ruby programlarını yazmak için favori vi editörünüzü kullanabilirsiniz.

• RubyWin , Windows için bir Ruby Entegre Geliştirme Ortamıdır (IDE).

• Ruby Geliştirme Ortamı (RDE) ayrıca Windows kullanıcıları için çok iyi bir IDE'dir.

Etkileşimli Ruby (IRb)

Etkileşimli Ruby (IRb), deneyler için bir kabuk sağlar. IRb kabuğu içinde, ifade sonuçlarını satır satır anında görüntüleyebilirsiniz.

Bu araç Ruby kurulumuyla birlikte gelir, böylece IRb'nin çalışması için fazladan yapabileceğiniz hiçbir şey yoktur.

Sadece yaz irb komut isteminizde ve aşağıda belirtildiği gibi bir Etkileşimli Ruby Oturumu başlayacaktır -

$irb
irb 0.6.1(99/09/16)
irb(main):001:0> def hello
irb(main):002:1> out = "Hello World"
irb(main):003:1> puts out
irb(main):004:1> end
nil
irb(main):005:0> hello
Hello World
nil
irb(main):006:0>

Burada ne yaptığımız konusunda endişelenme. Tüm bu adımları sonraki bölümlerde öğreneceksiniz.

Sırada ne var?

Artık çalışan bir Ruby Ortamınız olduğunu ve ilk Ruby Programını yazmaya hazır olduğunuzu varsayıyoruz. Bir sonraki bölüm size Ruby programlarının nasıl yazılacağını öğretecek.

Ruby'de basit bir program yazalım. Tüm Ruby dosyalarının uzantısı olacaktır.rb. Bu nedenle, aşağıdaki kaynak kodunu bir test.rb dosyasına koyun.

#!/usr/bin/ruby -w

puts "Hello, Ruby!";

Burada, / usr / bin dizininde Ruby yorumlayıcınız olduğunu varsaydık. Şimdi, bu programı aşağıdaki gibi çalıştırmayı deneyin -

$ ruby test.rb

Bu, aşağıdaki sonucu verecektir -

Hello, Ruby!

Basit bir Ruby programı gördünüz, şimdi Ruby Sözdizimi ile ilgili birkaç temel kavramı görelim.

Ruby Programında Boşluk

Boşluklar ve sekmeler gibi boşluk karakterleri, dizelerde göründükleri durumlar dışında, Ruby kodunda genellikle yok sayılır. Ancak bazen belirsiz ifadeleri yorumlamak için kullanılırlar. Bu tür yorumlar, -w seçeneği etkinleştirildiğinde uyarılar üretir.

Misal

a + b is interpreted as a+b ( Here a is a local variable)
a  +b is interpreted as a(+b) ( Here a is a method call)

Ruby Programında Satır Sonları

Ruby, noktalı virgül ve satırsonu karakterlerini bir ifadenin sonu olarak yorumlar. Bununla birlikte, Ruby bir satırın sonunda +, - veya ters eğik çizgi gibi operatörlerle karşılaşırsa, bunlar bir ifadenin devam ettiğini gösterir.

Ruby Tanımlayıcıları

Tanımlayıcılar, değişkenlerin, sabitlerin ve yöntemlerin adlarıdır. Ruby tanımlayıcıları büyük / küçük harfe duyarlıdır. Ram ve RAM'in Ruby'de iki farklı tanımlayıcı olduğu anlamına gelir.

Ruby tanımlayıcı adları alfanümerik karakterlerden ve alt çizgi karakterinden (_) oluşabilir.

Ayrılmış kelimeler

Aşağıdaki liste Ruby'deki ayrılmış kelimeleri göstermektedir. Bu ayrılmış sözcükler sabit veya değişken adlar olarak kullanılamaz. Bununla birlikte, yöntem adları olarak kullanılabilirler.

BAŞLA	yapmak	Sonraki	sonra
SON	Başka	sıfır	doğru
takma ad	elsif	değil	undef
ve	son	veya	sürece
başla	sağlamak	yeniden yapmak	a kadar
kırmak	yanlış	kurtarmak	ne zaman
durum	için	yeniden dene	süre
sınıf	Eğer	dönüş	süre
def	içinde	kendini	__DOSYA__
tanımlı mı?	modül	Süper	__HAT__

Ruby'de Belge

"Here Document", birden çok satırdan dizeler oluşturmayı ifade eder. Bir << 'den sonra, dize değişmezini sonlandırmak için bir dize veya tanımlayıcı belirtebilirsiniz ve mevcut satırı sonlandırıcıya kadar takip eden tüm satırlar, dizenin değeridir.

Sonlandırıcı tırnak içine alınmışsa, tırnak türü satır yönelimli dizge değişmezinin türünü belirler. << ile sonlandırıcı arasında boşluk olmamasına dikkat edin.

İşte farklı örnekler -

#!/usr/bin/ruby -w

print <<EOF
   This is the first way of creating
   here document ie. multiple line string.
EOF

print <<"EOF";                # same as above
   This is the second way of creating
   here document ie. multiple line string.
EOF

print <<`EOC`                 # execute commands
	echo hi there
	echo lo there
EOC

print <<"foo", <<"bar"  # you can stack them
	I said foo.
foo
	I said bar.
bar

Bu, aşağıdaki sonucu verecektir -

This is the first way of creating
   her document ie. multiple line string.
   This is the second way of creating
   her document ie. multiple line string.
hi there
lo there
      I said foo.
      I said bar.

Ruby BEGIN İfadesi

Sözdizimi

BEGIN {
   code
}

Program çalıştırılmadan önce çağrılacak kodu bildirir .

Misal

#!/usr/bin/ruby

puts "This is main Ruby Program"

BEGIN {
   puts "Initializing Ruby Program"
}

Bu, aşağıdaki sonucu verecektir -

Initializing Ruby Program
This is main Ruby Program

Ruby END İfadesi

Sözdizimi

END {
   code
}

Programın sonunda çağrılacak kodu bildirir .

Misal

#!/usr/bin/ruby

puts "This is main Ruby Program"

END {
   puts "Terminating Ruby Program"
}
BEGIN {
   puts "Initializing Ruby Program"
}

Bu, aşağıdaki sonucu verecektir -

Initializing Ruby Program
This is main Ruby Program
Terminating Ruby Program

Ruby Yorumları

Yorum, Ruby yorumlayıcısından bir satırı, bir satırın bir bölümünü veya birkaç satırı gizler. Satır başındaki hash karakterini (#) kullanabilirsiniz -

# I am a comment. Just ignore me.

Veya bir yorum, bir ifade veya ifadeden sonra aynı satırda olabilir -

name = "Madisetti" # This is again comment

Birden çok satırı aşağıdaki gibi yorumlayabilirsiniz -

# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.

İşte başka bir form. Bu blok açıklaması yorumlayıcıdan = begin / = end - ile birkaç satır gizler

=begin
This is a comment.
This is a comment, too.
This is a comment, too.
I said that already.
=end

Ruby mükemmel bir Nesneye Dayalı Programlama Dilidir. Nesne yönelimli programlama dilinin özellikleri şunları içerir:

• Veri Kapsülleme
• Veri soyutlama
• Polymorphism
• Inheritance

Bu özellikler, Object Oriented Ruby bölümünde tartışılmıştır .

Nesne yönelimli bir program, sınıfları ve nesneleri içerir. Bir sınıf, tek tek nesnelerin oluşturulduğu plandır. Nesneye yönelik terimlerle, bisikletinizin bisiklet olarak bilinen nesneler sınıfının bir örneği olduğunu söylüyoruz .

Herhangi bir aracın örneğini alın. Tekerlekler, beygir gücü ve yakıt veya gaz tankı kapasitesinden oluşur. Bu özellikler, Araç sınıfının veri üyelerini oluşturur. Bu özelliklerin yardımıyla bir aracı diğerinden ayırt edebilirsiniz.

Bir aracın ayrıca durma, sürüş ve hız yapma gibi belirli işlevleri olabilir. Bu işlevler bile Araç sınıfının veri üyelerini oluşturur. Bu nedenle, bir sınıfı, özelliklerin ve işlevlerin bir kombinasyonu olarak tanımlayabilirsiniz.

Araç sınıfı şu şekilde tanımlanabilir -

Class Vehicle {

   Number no_of_wheels
   Number horsepower
   Characters type_of_tank
   Number Capacity
   Function speeding {
   }
   
   Function driving {
   }
   
   Function halting {
   }
}

Bu veri üyelerine farklı değerler atayarak, Araç sınıfının birkaç örneğini oluşturabilirsiniz. Örneğin, bir uçağın üç tekerleği, 1000 beygir gücü, depo tipi olarak yakıt ve 100 litre kapasitesi vardır. Aynı şekilde bir arabanın dört tekerleği, 200 beygir gücü, depo tipi olarak gaz ve 25 litre kapasitesi vardır.

Ruby'de Sınıf Tanımlama

Ruby kullanarak nesneye dayalı programlamayı uygulamak için, önce Ruby'de nesneler ve sınıflar oluşturmayı öğrenmeniz gerekir.

Ruby'de bir sınıf her zaman class anahtar sözcüğüyle başlar ve ardından sınıfın adı gelir. İsim her zaman büyük harflerle yazılmalıdır. Müşteri sınıfı şu şekilde görüntülenebilir -

class Customer
end

End anahtar sözcüğünü kullanarak bir sınıfı sonlandırırsınız . Sınıftaki tüm veri üyeleri , sınıf tanımı ile end anahtar sözcüğü arasındadır.

Ruby Sınıfındaki Değişkenler

Ruby dört tür değişken sağlar -

• Local Variables- Yerel değişkenler, bir yöntemde tanımlanan değişkenlerdir. Yerel değişkenler yöntemin dışında kullanılamaz. Sonraki bölümde yöntem hakkında daha fazla ayrıntı göreceksiniz. Yerel değişkenler küçük harf veya _ ile başlar.

• Instance Variables- Örnek değişkenleri, herhangi bir belirli örnek veya nesne için yöntemler arasında kullanılabilir. Bu, örnek değişkenlerinin nesneden nesneye değiştiği anlamına gelir. Örnek değişkenlerinin başında @ işareti ve ardından değişken adı gelir.

• Class Variables- Sınıf değişkenleri farklı nesnelerde mevcuttur. Bir sınıf değişkeni sınıfa aittir ve bir sınıfın özelliğidir. Önlerinde @@ işareti bulunur ve ardından değişken adı gelir.

• Global Variables- Sınıf değişkenleri, sınıflar arasında kullanılamaz. Sınıflar arasında kullanılabilen tek bir değişkene sahip olmak istiyorsanız, bir global değişken tanımlamanız gerekir. Global değişkenlerin önünde her zaman dolar işareti ($) bulunur.

Misal

@@ no_of_customers sınıf değişkenini kullanarak, yaratılmakta olan nesnelerin sayısını belirleyebilirsiniz. Bu, müşteri sayısını elde etmeyi sağlar.

class Customer
   @@no_of_customers = 0
end

Ruby'de Yeni Yöntem Kullanarak Nesne Oluşturma

Nesneler, sınıfın örnekleridir. Şimdi Ruby'de bir sınıfın nesnelerini nasıl yaratacağınızı öğreneceksiniz. Ruby'de sınıfın new yöntemini kullanarak nesneler oluşturabilirsiniz .

Yöntem yeni Yakut kütüphane önceden tanımlanmış olan yönteme eşsiz bir türüdür. Yeni yöntem, sınıf yöntemlerine aittir .

Burada, Customer sınıfının cust1 ve cust2 adlı iki nesnesini oluşturma örneği verilmiştir -

cust1 = Customer. new
cust2 = Customer. new

Burada cust1 ve cust2 iki nesnenin isimleridir. Nesne adını ve ardından eşittir işaretini (=) yazarsınız, ardından sınıf adı gelir. Ardından nokta operatörü ve yeni anahtar kelime gelecektir.

Ruby Nesneleri Oluşturmak için Özel Yöntem

Yeni yönteme parametreler iletebilirsiniz ve bu parametreler sınıf değişkenlerini başlatmak için kullanılabilir.

Yeni yöntemi parametrelerle bildirmeyi planladığınızda , yöntemi sınıf oluşturma sırasında başlatmanız gerekir .

İnitialize yöntemi zaman çalıştırılacaktır yöntemin özel bir tipidir yeni sınıfın yöntem parametreleri ile çağrılır.

Başlatma yöntemini oluşturmak için örnek şu şekildedir -

class Customer
   @@no_of_customers = 0
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
end

Bu örnekte, initialize yöntemini şu şekilde bildirirsiniz:id, name, ve addryerel değişkenler olarak. Burada, def ve end , bir Ruby yöntemini ilklendirmek için kullanılır . Sonraki bölümlerde yöntemler hakkında daha fazla bilgi edineceksiniz.

Gelen initialize yöntemle, sen @cust_name ve @cust_addr, @cust_id örnek değişkenleri bu yerel değişkenlerin değerler ileten. Burada yerel değişkenler, yeni yöntemle birlikte iletilen değerleri tutar.

Şimdi, aşağıdaki gibi nesneler oluşturabilirsiniz -

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

Ruby Sınıfındaki Üye İşlevleri

Ruby'de işlevlere yöntemler denir. Bir sınıftaki her yöntem, def anahtar sözcüğüyle başlar ve ardından yöntem adı gelir.

Yöntem adı her zaman tercih edilir lowercase letters. Ruby'de bir yöntemi end anahtar sözcüğünü kullanarak sonlandırırsınız .

Ruby yöntemini tanımlayan örnek şu şekildedir -

class Sample
   def function
      statement 1
      statement 2
   end
end

Burada ifade 1 ve ifade 2 , Sample sınıfı içindeki yöntem işlevinin gövdesinin bir parçasıdır . Bu ifadeler herhangi bir geçerli Ruby ifadesi olabilir. Örneğin bir yöntem koyabilirsiniz koyar yazdırmak için Merhaba Ruby şöyle -

class Sample
   def hello
      puts "Hello Ruby!"
   end
end

Şimdi aşağıdaki örnekte, bir Sample sınıfı nesnesi oluşturun ve merhaba yöntemini çağırın ve sonucu görün -

#!/usr/bin/ruby

class Sample
   def hello
      puts "Hello Ruby!"
   end
end

# Now using above class to create objects
object = Sample. new
object.hello

Bu, aşağıdaki sonucu verecektir -

Hello Ruby!

Basit Örnek Olay İncelemesi

Sınıf ve nesnelerle daha fazla pratik yapmak istiyorsanız işte bir örnek olay.

Ruby Sınıfı Örnek Olay İncelemesi

Değişkenler, herhangi bir program tarafından kullanılacak herhangi bir veriyi tutan hafıza yerleridir.

Ruby tarafından desteklenen beş tür değişken vardır. Bir önceki bölümde de bu değişkenlerin küçük bir açıklamasından geçtiniz. Bu beş tür değişken bu bölümde açıklanmıştır.

Ruby Global Değişkenleri

Global değişkenler $ ile başlar. İlklendirilmemiş global değişkenler nil değerine sahiptir ve -w seçeneği ile uyarılar üretir.

Global değişkenlere atama, global durumu değiştirir. Global değişkenlerin kullanılması tavsiye edilmez. Programları şifreli yaparlar.

İşte global değişkenin kullanımını gösteren bir örnek.

#!/usr/bin/ruby

$global_variable = 10 class Class1 def print_global puts "Global variable in Class1 is #$global_variable"
   end
end
class Class2
   def print_global
      puts "Global variable in Class2 is #$global_variable"
   end
end

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

Burada $ global_variable global bir değişkendir. Bu, aşağıdaki sonucu verecektir -

NOTE - Ruby'de, herhangi bir değişkenin veya sabitin değerine, o değişkenin veya sabitin hemen önüne bir hash (#) karakteri koyarak erişebilirsiniz.

Global variable in Class1 is 10
Global variable in Class2 is 10

Ruby Örneği Değişkenleri

Örnek değişkenleri @ ile başlar. Başlatılmamış örnek değişkenleri nil değerine sahiptir ve -w seçeneğiyle uyarılar üretir.

Örnek Değişkenlerin kullanımını gösteren bir örnek aşağıda verilmiştir.

#!/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

# Create Objects
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# Call Methods
cust1.display_details()
cust2.display_details()

Burada @cust_id, @cust_name ve @cust_addr örnek değişkenlerdir. Bu, aşağıdaki sonucu verecektir -

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

Ruby Sınıfı Değişkenleri

Sınıf değişkenleri @@ ile başlar ve yöntem tanımlarında kullanılmadan önce başlatılmalıdır.

Başlatılmamış bir sınıf değişkenine başvurmak bir hata oluşturur. Sınıf değişkenleri, sınıf değişkenlerinin tanımlandığı sınıfın veya modülün soyundan gelenler arasında paylaşılır.

Sınıf değişkenlerini geçersiz kılmak, -w seçeneğiyle uyarılar üretir.

İşte sınıf değişkeninin kullanımını gösteren bir örnek -

#!/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

# Create Objects
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# Call Methods
cust1.total_no_of_customers()
cust2.total_no_of_customers()

Burada @@ no_of_customers bir sınıf değişkenidir. Bu, aşağıdaki sonucu verecektir -

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

Ruby Yerel Değişkenleri

Yerel değişkenler küçük harf veya _ ile başlar. Yerel bir değişkenin kapsamı, sınıf, modül, def veya do'dan karşılık gelen uca veya bir bloğun açılış ayracından yakın ayracına {} kadar değişir.

Başlatılmamış bir yerel değişkene başvurulduğunda, bağımsız değişken içermeyen bir yönteme yapılan çağrı olarak yorumlanır.

Başlatılmamış yerel değişkenlere atama da değişken bildirimi olarak işlev görür. Değişkenler, geçerli kapsamın sonuna ulaşılana kadar var olmaya başlar. Yerel değişkenlerin yaşam süresi, Ruby programı ayrıştırdığında belirlenir.

Yukarıdaki örnekte, yerel değişkenler id, name ve addr'dir.

Ruby Sabitleri

Sabitler büyük harfle başlar. Bir sınıf veya modül içinde tanımlanan sabitlere, o sınıf veya modül içinden erişilebilir ve bir sınıf veya modül dışında tanımlananlara genel olarak erişilebilir.

Sabitler, yöntemler içinde tanımlanamaz. Başlatılmamış bir sabite başvurmak bir hata oluşturur. Zaten başlatılmış bir sabite atama yapmak bir uyarı oluşturur.

#!/usr/bin/ruby

class Example
   VAR1 = 100
   VAR2 = 200
   def show
      puts "Value of first Constant is #{VAR1}"
      puts "Value of second Constant is #{VAR2}"
   end
end

# Create Objects
object = Example.new()
object.show

Burada VAR1 ve VAR2 sabitlerdir. Bu, aşağıdaki sonucu verecektir -

Value of first Constant is 100
Value of second Constant is 200

Ruby Sözde Değişkenleri

Yerel değişkenlerin görünümüne sahip olan ancak sabitler gibi davranan özel değişkenlerdir. Bu değişkenlere herhangi bir değer atayamazsınız.

• self - Geçerli yöntemin alıcı nesnesi.

• true - Doğruyu temsil eden değer.

• false - Yanlışı temsil eden değer.

• nil - Tanımsız olanı temsil eden değer.

• __FILE__ - Mevcut kaynak dosyanın adı.

• __LINE__ - Kaynak dosyadaki geçerli satır numarası.

Ruby Temel Değişmezleri

Ruby'nin değişmez değerler için kullandığı kurallar basit ve sezgiseldir. Bu bölümde tüm temel Ruby Literatürü açıklanmaktadır.

Tam Sayılar

Ruby tam sayıları destekler. Bir tam sayı -2 uzanabilir ³⁰ 2 ^30-1 veya -2 ⁶² 2 ^62-1 . Bu aralıktaki tam sayılar Fixnum sınıfının nesneleridir ve bu aralığın dışındaki tamsayılar Bignum sınıfındaki nesnelerde saklanır .

Tamsayıları isteğe bağlı bir işaret, isteğe bağlı bir temel gösterge (sekizlik için 0, onaltılık için 0x veya ikili için 0b) ve ardından uygun tabanda bir rakam dizisi kullanarak yazarsınız. Alt çizgi karakterler, rakam dizesinde yok sayılır.

Ayrıca bir ASCII karakterine karşılık gelen tamsayı değerini alabilir veya önüne bir soru işareti koyarak diziden kaçabilirsiniz.

Misal

123                  # Fixnum decimal
1_234                # Fixnum decimal with underline
-500                 # Negative Fixnum
0377                 # octal
0xff                 # hexadecimal
0b1011               # binary
?a                   # character code for 'a'
?\n                  # code for a newline (0x0a)
12345678901234567890 # Bignum

NOTE - Sınıf ve Nesneler, bu eğitimin ayrı bir bölümünde açıklanmıştır.

Kayan Sayılar

Ruby, kayan sayıları destekler. Aynı zamanda sayılardır, ancak ondalık sayılar vardır. Kayan noktalı sayılar Float sınıfının nesneleridir ve aşağıdakilerden herhangi biri olabilir -

Misal

123.4                # floating point value
1.0e6                # scientific notation
4E20                 # dot not required
4e+20                # sign before exponential

Dize Değişmezleri

Ruby dizeleri basitçe 8 bitlik bayt dizileridir ve String sınıfının nesneleridir. Çift tırnaklı dizeler değiştirmeye ve ters eğik çizgiye izin verir, ancak tek tırnaklı dizeler değiştirmeye izin vermez ve yalnızca \\ ve \ 'için ters eğik çizgi gösterimine izin verir

Misal

#!/usr/bin/ruby -w

puts 'escape using "\\"';
puts 'That\'s right';

Bu, aşağıdaki sonucu verecektir -

escape using "\"
That's right

Herhangi bir Ruby ifadesinin değerini sırayı kullanarak bir dizeye değiştirebilirsiniz. #{ expr }. Burada ifade, herhangi bir yakut ifade olabilir.

#!/usr/bin/ruby -w

puts "Multiplication Value : #{24*60*60}";

Bu, aşağıdaki sonucu verecektir -

Multiplication Value : 86400

Ters Eğik Çizgi Gösterimleri

Ruby tarafından desteklenen Ters Eğik Çizgi notasyonlarının listesi aşağıdadır -

Gösterim	Temsil edilen karakter
\ n	Yeni Satır (0x0a)
\ r	Satır başı (0x0d)
\ f	Form besleme (0x0c)
\ b	Geri tuşu (0x08)
\ a	Zil (0x07)
\ e	Kaçış (0x1b)
\ s	Boşluk (0x20)
\ nnn	Sekizli gösterim (n 0-7)
\ xnn	Onaltılık gösterim (n 0-9, af veya AF)
\ cx, \ Cx	Ctrl-x
\ Mx	Meta-x (c | 0x80)
\ M- \ Cx	Meta-Control-x
\ x	Karakter x

Yakut Strings ilgili daha fazla ayrıntı için geçmesi Yakut Strings .

Ruby Dizileri

Ruby Dizisinin değişmezleri, köşeli parantezler arasına virgülle ayrılmış nesne referansları dizisi yerleştirilerek oluşturulur. Sondaki virgül yok sayılır.

Misal

#!/usr/bin/ruby

ary = [  "fred", 10, 3.14, "This is a string", "last element", ]
ary.each do |i|
   puts i
end

Bu, aşağıdaki sonucu verecektir -

fred
10
3.14
This is a string
last element

Ruby Dizileri hakkında daha fazla ayrıntı için Ruby Dizilerini inceleyin .

Ruby Hashes

Değişmez bir Ruby Hash, anahtar ve değer arasına virgül veya => dizisiyle ayraçlar arasına anahtar / değer çiftlerinin bir listesi yerleştirilerek oluşturulur. Sondaki virgül yok sayılır.

Misal

#!/usr/bin/ruby

hsh = colors = { "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
hsh.each do |key, value|
   print key, " is ", value, "\n"
end

Bu, aşağıdaki sonucu verecektir -

red is 3840
green is 240
blue is 15

Yakut sağlamalarının daha fazla ayrıntı için geçmesi Yakut karmaları .

Ruby Serileri

Aralık, başlangıcı ve bitişi olan bir dizi değerden oluşan bir aralığı temsil eder. Aralıklar, s..e ve s ... e değişmezleri kullanılarak veya Range.new ile oluşturulabilir.

.. kullanılarak oluşturulan aralıklar, baştan sona dahil olmak üzere çalışır. ... kullanılarak oluşturulanlar son değeri hariç tutar. Yineleyici olarak kullanıldığında, aralıklar dizideki her değeri döndürür.

Aralık (1..5), 1, 2, 3, 4, 5 değerleri içerdiği anlamına gelir ve aralık (1 ... 5), 1, 2, 3, 4 değerleri içerdiği anlamına gelir.

Misal

#!/usr/bin/ruby

(10..15).each do |n| 
   print n, ' ' 
end

Bu, aşağıdaki sonucu verecektir -

10 11 12 13 14 15

Ruby Aralıkları hakkında daha fazla ayrıntı için Ruby Aralıklarını inceleyin .

Ruby, modern bir dilden bekleyebileceğiniz gibi zengin bir operatör grubunu destekler. Çoğu operatör aslında yöntem çağrılarıdır. Örneğin, a + b, a. + (B) olarak yorumlanır, burada a değişkeni tarafından belirtilen nesnedeki + yöntemi , argümanı olarak b ile çağrılır .

Her operatör için (+ - * /% ** & | ^ << >> && ||), karşılık gelen bir kısaltılmış atama operatörü formu vardır (+ = - = vb.).

Ruby Aritmetik Operatörleri

A değişkeninin 10 ve b değişkeninin 20 olduğunu varsayın, o zaman -

Şebeke	Açıklama	Misal
+	Ekleme - İşlecin her iki tarafına da değerler ekler.	a + b 30 verir
-	Çıkarma - Sağ el işleneni sol el işlenenden çıkarır.	a - b -10 verir
*	Çarpma - Operatörün her iki tarafındaki değerleri çarpar.	a * b 200 verir
/	Bölme - Sol el işleneni sağ el işlenene böler.	b / a 2 verecek
%	Modulus - Sol el işleneni sağ el işlenene böler ve kalanı döndürür.	b% a 0 verir
**	Üs - Operatörlerde üstel (güç) hesaplama gerçekleştirir.	a ** b, 20 üssüne 10 verir

Ruby Karşılaştırma Operatörleri

A değişkeninin 10 ve b değişkeninin 20 olduğunu varsayın, o zaman -

Şebeke	Açıklama	Misal
==	İki işlenenin değerinin eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a == b) doğru değil.
! =	İki işlenenin değerinin eşit olup olmadığını kontrol eder, değerler eşit değilse koşul doğru olur.	(a! = b) doğrudur.
>	Sol işlenenin değerinin sağ işlenenin değerinden büyük olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a> b) doğru değil.
<	Soldaki işlenenin değerinin sağ işlenenin değerinden küçük olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a <b) doğrudur.
> =	Sol işlenenin değerinin sağ işlenenin değerinden büyük veya ona eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a> = b) doğru değil.
<=	Sol işlenenin değerinin sağ işlenenin değerinden küçük veya ona eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a <= b) doğrudur.
<=>	Kombine karşılaştırma operatörü. İlk işlenen saniyeye eşitse 0, ilk işlenen ikinciden büyükse 1 ve ilk işlenen ikinciden küçükse -1 döndürür.	(a <=> b) -1 döndürür.
===	Bir case ifadesinin when cümlesi içinde eşitliği test etmek için kullanılır .	(1 ... 10) === 5 true değerini döndürür.
.eql?	Alıcı ve bağımsız değişken aynı türe ve eşit değerlere sahipse doğrudur.	1 == 1.0 doğru döndürür, ancak 1.eql? (1.0) yanlıştır.
eşit?	Alıcı ve bağımsız değişken aynı nesne kimliğine sahipse doğrudur.	aObj, bObj'nin kopyasıysa, aObj == bObj doğrudur, a.equal? ​​bObj yanlıştır, ancak a.equal? ​​aObj doğrudur.

Ruby Atama Operatörleri

A değişkeninin 10 ve b değişkeninin 20 olduğunu varsayın, o zaman -

Şebeke	Açıklama	Misal
=	Basit atama operatörü, sağ taraftaki işlenenlerden sol taraftaki işlenenlere değerler atar.	c = a + b, a + b'nin değerini c'ye atar
+ =	VE atama işleci ekleyin, sağ işleneni sol işlenenlere ekler ve sonucu sol işlenenlere atar.	c + = a eşdeğerdir c = c + a
- =	VE atama işlecini çıkar, sağ işleneni sol işlenenden çıkarır ve sonucu sol işlenenlere atar.	c - = a eşdeğerdir c = c - a
* =	AND atama operatörünü çarpın, sağ operandı sol operandla çarpar ve sonucu sol operanda atar.	c * = a, c = c * a'ya eşdeğerdir
/ =	VE atama işlecini böl, soldaki işleneni sağ işlenenle böler ve sonucu sol işlenenlere atar.	c / = a, c = c / a'ya eşdeğerdir
% =	Modül VE atama operatörü, iki işlenen kullanarak modülü alır ve sonucu sol operanda atar.	c% = a eşdeğerdir c = c% a
** =	Üslü AND atama operatörü, operatörler üzerinde üstel (güç) hesaplaması yapar ve sol operanda değer atar.	c ** = a eşdeğerdir c = c ** a

Ruby Paralel Ataması

Ruby ayrıca değişkenlerin paralel olarak atanmasını destekler. Bu, birden çok değişkenin tek bir Ruby kodu satırıyla başlatılmasını sağlar. Örneğin -

a = 10
b = 20
c = 30

Bu, paralel atama kullanılarak daha hızlı bildirilebilir -

a, b, c = 10, 20, 30

Paralel atama, iki değişkende tutulan değerleri değiştirmek için de kullanışlıdır -

a, b = b, c

Ruby Bitsel Operatörleri

Bitsel operatör bitler üzerinde çalışır ve bit işlem gerçekleştirir.

Varsayalım ki a = 60; ve b = 13; şimdi ikili biçimde aşağıdaki gibi olacaklar -

a    =  0011 1100
 b    =  0000 1101
 ------------------
 a&b  =  0000 1100
 a|b  =  0011 1101
 a^b  =  0011 0001
 ~a   =  1100 0011

Aşağıdaki Bitwise operatörleri Ruby dili tarafından desteklenmektedir.

Şebeke	Açıklama	Misal
&	İkili VE İşleci, her iki işlenende de varsa sonuca bir bit kopyalar.	(a & b) 0000 1100 olan 12 verir
|	İkili VEYA İşleci, işlenenlerden herhangi birinde varsa bir bit kopyalar.	(a | b), 0011 1101 olan 61 verecek
^	İkili XOR İşleci, bir işlenen içinde ayarlanmışsa, ancak her ikisinde birden ayarlanmamışsa biti kopyalar.	(a ^ b), 0011 0001 olan 49 verecek
~	İkili Birler Tamamlayıcı Operatörü tekli ve bitleri 'çevirme' etkisine sahiptir.	(~ a), işaretli bir ikili sayı nedeniyle 2'nin tamamlayıcı formunda 1100 0011 olan -61'i verecektir.
<<	İkili Sol Kaydırma Operatörü. Soldaki işlenenler değeri, sağ işlenen tarafından belirtilen bit sayısı kadar sola taşınır.	a << 2 240 verir, yani 1111 0000
>>	İkili Sağ Shift Operatörü. Soldaki işlenenler değeri, sağ işlenen tarafından belirtilen bit sayısı kadar sağa taşınır.	a >> 2, 0000 1111 olan 15 verir

Ruby Mantıksal Operatörleri

Aşağıdaki mantıksal operatörler Ruby dili tarafından desteklenmektedir

Varsayalım değişken bir 10 tutar ve değişken b , daha sonra 20 tutar -

Şebeke	Açıklama	Misal
ve	Mantıksal AND operatörü çağrıldı. Her iki işlenen de doğruysa, koşul doğru olur.	(a ve b) doğrudur.
veya	Mantıksal VEYA Operatörü çağrıldı. İki işlenenden herhangi biri sıfır değilse, koşul doğru olur.	(a veya b) doğrudur.
&&	Mantıksal AND operatörü çağrıldı. Her iki işlenen de sıfır değilse, koşul doğru olur.	(a && b) doğrudur.
||	Mantıksal VEYA Operatörü çağrıldı. İki işlenenden herhangi biri sıfır değilse, koşul doğru olur.	(a || b) doğrudur.
!	Mantıksal NOT Operatörü olarak adlandırıldı. İşleneninin mantıksal durumunu tersine çevirmek için kullanın. Bir koşul doğruysa, Mantıksal NOT operatörü yanlış yapar.	! (a && b) yanlıştır.
değil	Mantıksal NOT Operatörü olarak adlandırıldı. İşleneninin mantıksal durumunu tersine çevirmek için kullanın. Bir koşul doğruysa, Mantıksal NOT operatörü yanlış yapar.	not (a && b) yanlıştır.

Ruby Üçlü İşleci

Üçlü Operatör adında bir operatör daha var. Önce doğru veya yanlış değer için bir ifadeyi değerlendirir ve ardından değerlendirmenin sonucuna bağlı olarak verilen iki ifadeden birini yürütür. Koşullu operatör bu sözdizimine sahiptir -

Şebeke	Açıklama	Misal
? :	Koşullu İfade	Koşul doğruysa? Ardından X değeri: Aksi takdirde Y değeri

Ruby Aralığı Operatörleri

Ruby'deki sıra aralıkları, bir başlangıç ​​değeri, bir bitiş değeri ve aradaki bir dizi değerden oluşan bir dizi ardışık değer oluşturmak için kullanılır.

Ruby'de bu diziler ".." ve "..." aralık operatörleri kullanılarak oluşturulur. İki noktalı form, kapsayıcı bir aralık oluştururken, üç noktalı form, belirtilen yüksek değeri hariç tutan bir aralık oluşturur.

Şebeke	Açıklama	Misal
..	Başlangıç ​​noktasından bitiş noktasına kadar dahil bir aralık oluşturur.	1..10 1'den 10'a kadar bir aralık oluşturur.
...	Başlangıç ​​noktasından bitiş noktasına özel bir aralık oluşturur.	1 ... 10 1 ile 9 arasında bir aralık oluşturur.

Ruby tanımlandı mı? Operatörler

tanımlı mı? aktarılan ifadenin tanımlanıp tanımlanmadığını belirlemek için bir yöntem çağrısı şeklini alan özel bir operatördür. İfadenin açıklama dizesini döndürür veya ifade tanımlanmamışsa nil döndürür .

Tanımlanmış çeşitli kullanımları vardır? Şebeke

Kullanım 1

defined? variable # True if variable is initialized

For Example

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil (undefined)

Kullanım 2

defined? method_call # True if a method is defined

For Example

defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is not defined here)
defined? unpack      # => nil (not defined here)

Kullanım 3

# True if a method exists that can be called with super user
defined? super

For Example

defined? super     # => "super" (if it can be called)
defined? super     # => nil (if it cannot be)

Kullanım 4

defined? yield   # True if a code block has been passed

For Example

defined? yield    # => "yield" (if there is a block passed)
defined? yield    # => nil (if there is no block)

Ruby Dot "." ve Çift İki Nokta "::" Operatörleri

Adından önce modül adı ve bir nokta koyarak bir modül yöntemini çağırırsınız ve modül adını ve iki iki nokta üst üste kullanarak bir sabite başvurursunuz.

:: Bir sınıf veya modül içinde tanımlanan sabitlere, örnek yöntemlerine ve sınıf yöntemlerine, sınıf veya modülün dışındaki herhangi bir yerden erişilmesine izin veren tekli bir operatördür.

Remember Ruby'de sınıflar ve yöntemler de sabitler olarak kabul edilebilir.

Sadece önek olarak :: Uygun sınıf veya modül nesnesini döndüren bir ifade ile Const_name.

Önek ifadesi kullanılmazsa, varsayılan olarak ana Object sınıfı kullanılır.

İşte iki örnek -

MR_COUNT = 0         # constant defined on main Object class
module Foo
   MR_COUNT = 0
   ::MR_COUNT = 1    # set global count to 1
   MR_COUNT = 2      # set local count to 2
end
puts MR_COUNT        # this is the global constant
puts Foo::MR_COUNT   # this is the local "Foo" constant

Second Example

CONST = ' out there'
class Inside_one
   CONST = proc {' in there'}
   def where_is_my_CONST
      ::CONST + ' inside one'
   end
end
class Inside_two
   CONST = ' inside two'
   def where_is_my_CONST
      CONST
   end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_two::CONST + CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST

Ruby Operatörleri Önceliği

Aşağıdaki tablo en yüksek öncelikten en düşüğe doğru tüm operatörleri listeler.

Yöntem	Şebeke	Açıklama
Evet	::	Sabit çözünürlük operatörü
Evet	[] [] =	Öğe referansı, öğe kümesi
Evet	**	Üs alma (kuvvete yükseltme)
Evet	! ~ + -	Değil, tamamlayıcı, tekli artı ve eksi (son ikisi için yöntem adları + @ ve - @)
Evet	* /%	Çarp, böl ve modulo
Evet	+ -	Toplama ve çıkarma
Evet	>> <<	Sağa ve sola bitsel kaydırma
Evet	&	Bitsel "VE"
Evet	^ |	Bit düzeyinde özel "VEYA" ve normal "VEYA"
Evet	<= <>> =	Karşılaştırma operatörleri
Evet	<=> == ===! = = ~! ~	Eşitlik ve örüntü eşleştirme operatörleri (! = Ve! ~ Yöntem olarak tanımlanmayabilir)
	&&	Mantıksal "VE"
	||	Mantıksal "VEYA"
	.. ...	Aralık (kapsayıcı ve özel)
	? :	Üçlü eğer-ise-değilse
	=% = {/ = - = + = | = & = >> = << = * = && = || = ** =	Görev
	tanımlı mı?	Belirtilen sembolün tanımlanıp tanımlanmadığını kontrol edin
	değil	Mantıksal olumsuzluk
	veya ve	Mantıksal kompozisyon

NOTE- Yöntem sütununda Evet olan işleçler aslında yöntemlerdir ve bu nedenle geçersiz kılınabilir.

Yorumlar, çalışma zamanında göz ardı edilen Ruby kodu içindeki açıklama satırlarıdır. Tek satırlık bir açıklama # karakteriyle başlar ve aşağıdaki gibi # karakterinden satırın sonuna kadar uzanır -

#!/usr/bin/ruby -w
# This is a single line comment.

puts "Hello, Ruby!"

Çalıştırıldığında, yukarıdaki program aşağıdaki sonucu verir -

Hello, Ruby!

Ruby Multiline Yorumları

Kullanarak birden çok satırı yorumlayabilirsiniz =begin ve =end sözdizimi aşağıdaki gibidir -

#!/usr/bin/ruby -w

puts "Hello, Ruby!"

=begin
This is a multiline comment and con spwan as many lines as you
like. But =begin and =end should come in the first line only. 
=end

Çalıştırıldığında, yukarıdaki program aşağıdaki sonucu verir -

Hello, Ruby!

Sondaki yorumların koddan yeterince uzakta olduğundan ve kolayca ayırt edilebildiğinden emin olun. Bir blokta birden fazla takip eden yorum varsa, bunları hizalayın. Örneğin -

@counter      # keeps track times page has been hit
@siteCounter  # keeps track of times all pages have been hit

Ruby, modern dillerde oldukça yaygın olan koşullu yapılar sunar. Burada, Ruby'de bulunan tüm koşullu ifadeleri ve değiştiricileri açıklayacağız.

Ruby if ... else İfadesi

Sözdizimi

if conditional [then]
   code...
[elsif conditional [then]
   code...]...
[else
   code...]
end

Eğer ifadeler koşullu yürütülmesi için kullanılır. False ve nil değerleri yanlıştır ve diğer her şey doğrudur. Ruby'nin elsif kullandığına dikkat edin, else if ne de elif.

Yürütür kod eğer koşullu doğrudur. Eğer koşullu doğru değildir, kod başka fıkrada belirtilen yürütülür.

Bir if ifadesinin koşullu , koddan ayrılmış sözcük, o zaman bir satırsonu veya noktalı virgül ile ayrılır.

Misal

#!/usr/bin/ruby

x = 1
if x > 2
   puts "x is greater than 2"
elsif x <= 2 and x!=0
   puts "x is 1"
else
   puts "I can't guess the number"
end

x is 1

Değiştirici ise Ruby

Sözdizimi

code if condition

Yürütür kod eğer koşullu doğrudur.

Misal

#!/usr/bin/ruby

$debug = 1
print "debug\n" if $debug

Bu, aşağıdaki sonucu verecektir -

debug

Ruby ifadesiz

Sözdizimi

unless conditional [then]
   code
[else
   code ]
end

Çalıştırır kod eğer koşullu yanlıştır. Eğer koşullu doğrudur, başka maddede belirtilen kod yürütülür.

Misal

#!/usr/bin/ruby

x = 1 
unless x>=2
   puts "x is less than 2"
 else
   puts "x is greater than 2"
end

Bu, aşağıdaki sonucu verecektir -

x is less than 2

Değiştirici olmadıkça Ruby

Sözdizimi

code unless conditional

Çalıştırır kod eğer koşullu yanlıştır.

Misal

#!/usr/bin/ruby

$var =  1
print "1 -- Value is set\n" if $var print "2 -- Value is set\n" unless $var

$var = false print "3 -- Value is set\n" unless $var

Bu, aşağıdaki sonucu verecektir -

1 -- Value is set
3 -- Value is set

Ruby case İfadesi

Sözdizimi

case expression
[when expression [, expression ...] [then]
   code ]...
[else
   code ]
end

Durum tarafından belirtilen ifadeyi ve === operatörünü kullanırken tarafından belirtilen ifadeyi karşılaştırır ve eşleşen when cümlesinin kodunu yürütür .

Sentezleme zaman maddesi ile belirtilen sola işlenen olarak değerlendirilir. No when cümleleri eşleşirse, case else cümlesinin kodunu yürütür .

Bir when ifadesinin ifadesi, koddan ayrılmış sözcük, ardından bir satırsonu veya bir noktalı virgül ile ayrılır. Böylece -

case expr0
when expr1, expr2
   stmt1
when expr3, expr4
   stmt2
else
   stmt3
end

temelde aşağıdakine benzer -

_tmp = expr0
if expr1 === _tmp || expr2 === _tmp
   stmt1
elsif expr3 === _tmp || expr4 === _tmp
   stmt2
else
   stmt3
end

Misal

#!/usr/bin/ruby

$age = 5 case $age
when 0 .. 2
   puts "baby"
when 3 .. 6
   puts "little child"
when 7 .. 12
   puts "child"
when 13 .. 18
   puts "youth"
else
   puts "adult"
end

Bu, aşağıdaki sonucu verecektir -

little child

Ruby'deki döngüler, aynı kod bloğunu belirli sayıda çalıştırmak için kullanılır. Bu bölüm, Ruby tarafından desteklenen tüm döngü ifadelerinin ayrıntılarını içerir.

Ruby while İfadesi

Sözdizimi

while conditional [do]
   code
end

Çalıştırır kodu ise koşullu doğrudur. Bir while döngüsünün koşulu , koddan ayrılmış sözcük do, yeni satır, ters eğik çizgi \ veya noktalı virgül; ile ayrılır.

Misal

#!/usr/bin/ruby

$i = 0
$num = 5

while $i < $num  do
   puts("Inside the loop i = #$i" )
   $i +=1
end

Bu, aşağıdaki sonucu verecektir -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4

Değiştirici iken Ruby

Sözdizimi

code while condition

OR

begin 
  code 
end while conditional

Çalıştırır kodu ise koşullu doğrudur.

Bir while değiştiricisi , kurtarma veya sağlama yan tümceleri içermeyen bir begin ifadesini takip ederse , koşul değerlendirilmeden önce kod bir kez çalıştırılır.

Misal

#!/usr/bin/ruby

$i = 0
$num = 5
begin
   puts("Inside the loop i = #$i" )
   $i +=1
end while $i < $num

Bu, aşağıdaki sonucu verecektir -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4

Ruby İfadeye Kadar

until conditional [do]
   code
end

Çalıştırır kod ise koşullu yanlıştır. Bir until ifadesinin koşulu, koddan ayrılmış olan do , yeni satır veya noktalı virgül ile ayrılır.

Misal

#!/usr/bin/ruby

$i = 0
$num = 5

until $i > $num  do
   puts("Inside the loop i = #$i" )
   $i +=1;
end

Bu, aşağıdaki sonucu verecektir -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Inside the loop i = 5

Değiştiriciye kadar Ruby

Sözdizimi

code until conditional

OR

begin
   code
end until conditional

Çalıştırır kod ise koşullu yanlıştır.

Bir until değiştirici , kurtarma veya sağlama yan tümceleri içermeyen bir begin deyimini takip ederse , koşul değerlendirilmeden önce kod bir kez çalıştırılır .

Misal

#!/usr/bin/ruby

$i = 0
$num = 5
begin
   puts("Inside the loop i = #$i" )
   $i +=1;
end until $i > $num

Bu, aşağıdaki sonucu verecektir -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Inside the loop i = 5

Ruby for Statement

Sözdizimi

for variable [, variable ...] in expression [do]
   code
end

Çalıştırır kodu her bir eleman için bir kere ifadesi .

Misal

#!/usr/bin/ruby

for i in 0..5
   puts "Value of local variable is #{i}"
end

Burada 0..5 aralığını tanımladık. İçin deyim i 0..5 yılında sağlayacak ı (5 dahil), 0 ile 5 arasında değerler almaya. Bu, aşağıdaki sonucu verecektir -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

Bir for ... in döngüsü neredeyse tam olarak aşağıdakine eşdeğerdir -

(expression).each do |variable[, variable...]| code end

bir for döngüsünün yerel değişkenler için yeni bir kapsam oluşturmaması dışında . Bir for döngüsünün ifadesi , ayrılmış sözcük do, yeni satır veya noktalı virgül ile koddan ayrılır.

Misal

#!/usr/bin/ruby

(0..5).each do |i|
   puts "Value of local variable is #{i}"
end

Bu, aşağıdaki sonucu verecektir -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

Ruby break İfadesi

Sözdizimi

break

En dahili döngüyü sonlandırır. Blok içinde çağrılırsa, ilişkili bir blokla bir yöntemi sonlandırır (yöntem sıfır döndürür).

Misal

#!/usr/bin/ruby

for i in 0..5
   if i > 2 then
      break
   end
   puts "Value of local variable is #{i}"
end

Bu, aşağıdaki sonucu verecektir -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2

Ruby next İfadesi

Sözdizimi

next

En dahili döngünün bir sonraki yinelemesine atlar. Bir blok içinde çağrılırsa bir bloğun yürütülmesini sonlandırır ( getiri veya sıfır dönen çağrı ile ).

Misal

#!/usr/bin/ruby

for i in 0..5
   if i < 2 then
      next
   end
   puts "Value of local variable is #{i}"
end

Bu, aşağıdaki sonucu verecektir -

Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

Ruby redo İfadesi

Sözdizimi

redo

En dahili döngünün bu yinelemesini, döngü koşulunu kontrol etmeden yeniden başlatır. Bir blok içinde çağrılırsa verimi veya çağrıyı yeniden başlatır .

Misal

#!/usr/bin/ruby

for i in 0..5
   if i < 2 then
      puts "Value of local variable is #{i}"
      redo
   end
end

Bu, aşağıdaki sonucu üretecek ve sonsuz bir döngüye girecek -

Value of local variable is 0
Value of local variable is 0
............................

Ruby yeniden deneme İfadesi

Sözdizimi

retry

Eğer yeniden deneme başlangıcından itibaren ifadesini, yeniden başlamak kurtarma maddesi görünen bedeni başlar.

begin
   do_something # exception raised
rescue
   # handles error
   retry  # restart from beginning
end

For ifadesinin yineleyicide, bloğunda veya gövdesinde yeniden deneme görünürse , yineleyici çağrısının çağrılmasını yeniden başlatır. Yineleyiciye yönelik bağımsız değişkenler yeniden değerlendirilir.

for i in 1..5
   retry if some_condition # restart from i == 1
end

Misal

#!/usr/bin/ruby
for i in 0..5
   retry if i > 2
puts "Value of local variable is #{i}"
end

Bu, aşağıdaki sonucu üretecek ve sonsuz bir döngüye girecek -

Value of local variable is 1
Value of local variable is 2
Value of local variable is 1
Value of local variable is 2
Value of local variable is 1
Value of local variable is 2
............................

Ruby yöntemleri, diğer programlama dillerindeki işlevlere çok benzer. Ruby yöntemleri, bir veya daha fazla tekrarlanabilir ifadeyi tek bir birimde paketlemek için kullanılır.

Yöntem adları küçük harfle başlamalıdır. Bir yöntem adına büyük harfle başlarsanız, Ruby bunun bir sabit olduğunu düşünebilir ve bu nedenle çağrıyı yanlış ayrıştırabilir.

Yöntemler çağırılmadan önce tanımlanmalıdır, aksi takdirde Ruby tanımsız yöntem çağırma için bir istisna oluşturur.

Sözdizimi

def method_name [( [arg [= default]]...[, * arg [, &expr ]])]
   expr..
end

Dolayısıyla, aşağıdaki gibi basit bir yöntem tanımlayabilirsiniz -

def method_name 
   expr..
end

Bunun gibi parametreleri kabul eden bir yöntemi temsil edebilirsiniz -

def method_name (var1, var2)
   expr..
end

Yöntem gerekli parametreleri geçmeden çağrılırsa kullanılacak parametreler için varsayılan değerleri ayarlayabilirsiniz -

def method_name (var1 = value1, var2 = value2)
   expr..
end

Basit yöntemi her çağırdığınızda, yalnızca yöntem adını aşağıdaki gibi yazarsınız -

method_name

Ancak, parametreli bir yöntemi çağırdığınızda, yöntem adını parametrelerle birlikte yazarsınız, örneğin -

method_name 25, 30

Yöntemleri parametrelerle kullanmanın en önemli dezavantajı, bu tür yöntemleri her çağırdığınızda parametrelerin sayısını hatırlamanız gerekmesidir. Örneğin, bir yöntem üç parametreyi kabul ederse ve yalnızca ikisini geçerseniz, Ruby bir hata görüntüler.

Misal

#!/usr/bin/ruby

def test(a1 = "Ruby", a2 = "Perl")
   puts "The programming language is #{a1}"
   puts "The programming language is #{a2}"
end
test "C", "C++"
test

Bu, aşağıdaki sonucu verecektir -

The programming language is C
The programming language is C++
The programming language is Ruby
The programming language is Perl

Yöntemlerden Dönen Değerler

Ruby'deki her yöntem varsayılan olarak bir değer döndürür. Bu döndürülen değer, son ifadenin değeri olacaktır. Örneğin -

def test
   i = 100
   j = 10
   k = 0
end

Bu yöntem çağrıldığında, bildirilen son değişken k'yi döndürür .

Ruby dönüş Bildirimi

Dönüş Ruby ifadesi Ruby Yöntem itibaren bir veya daha fazla değer döndürmek için kullanılır.

Sözdizimi

return [expr[`,' expr...]]

İkiden fazla ifade verilirse, bu değerleri içeren dizi dönüş değeri olacaktır. İfade verilmemişse, dönüş değeri nil olacaktır.

Misal

return

OR

return 12

OR

return 1,2,3

Bu örneğe bir göz atın -

#!/usr/bin/ruby

def test
   i = 100
   j = 200
   k = 300
return i, j, k
end
var = test
puts var

Bu, aşağıdaki sonucu verecektir -

100
200
300

Değişken Parametre Sayısı

Diyelim ki, iki parametre alan bir yöntem tanımladınız, bu yöntemi her çağırdığınızda, onunla birlikte iki parametre iletmeniz gerekir.

Ancak Ruby, değişken sayıda parametrelerle çalışan yöntemleri bildirmenize izin verir. Bunun bir örneğini inceleyelim -

#!/usr/bin/ruby

def sample (*test)
   puts "The number of parameters is #{test.length}"
   for i in 0...test.length
      puts "The parameters are #{test[i]}"
   end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"

Bu kodda, bir parametre testini kabul eden bir yöntem örneği bildirdiniz. Ancak bu parametre değişken bir parametredir. Bu, bu parametrenin herhangi bir sayıda değişkeni alabileceği anlamına gelir. Bu nedenle, yukarıdaki kod aşağıdaki sonucu verecektir -

The number of parameters is 3
The parameters are Zara
The parameters are 6
The parameters are F
The number of parameters is 4
The parameters are Mac
The parameters are 36
The parameters are M
The parameters are MCA

Sınıf Yöntemleri

Sınıf tanımının dışında bir yöntem tanımlandığında, yöntem varsayılan olarak özel olarak işaretlenir . Öte yandan, sınıf tanımında tanımlanan yöntemler varsayılan olarak genel olarak işaretlenir. Yöntemlerin varsayılan görünürlüğü ve özel işareti , Modülün genel veya özel olarak değiştirilebilir .

Bir sınıfın bir yöntemine erişmek istediğinizde, önce sınıfı başlatmanız gerekir. Ardından, nesneyi kullanarak sınıfın herhangi bir üyesine erişebilirsiniz.

Ruby, bir sınıfı somutlaştırmadan bir yönteme erişmenin bir yolunu sunar. Bir sınıf yönteminin nasıl bildirildiğini ve erişildiğini görelim -

class Accounts
   def reading_charge
   end
   def Accounts.return_date
   end
end

Return_date yönteminin nasıl bildirildiğini görün. Sınıf adı ve ardından bir nokta ve ardından yöntemin adı ile bildirilir. Bu sınıf yöntemine doğrudan aşağıdaki şekilde erişebilirsiniz -

Accounts.return_date

Bu yönteme erişmek için, Hesaplar sınıfının nesnelerini oluşturmanız gerekmez.

Ruby takma adı İfadesi

Bu, yöntemlere veya genel değişkenlere takma ad verir. Takma adlar, yöntem gövdesi içinde tanımlanamaz. Yöntemin diğer adı, yöntemler geçersiz kılındığında bile yöntemin mevcut tanımını korur.

Numaralandırılmış global değişkenler ($ 1, $ 2, ...) için takma adlar yapmak yasaktır. Yerleşik genel değişkenlerin geçersiz kılınması ciddi sorunlara neden olabilir.

Sözdizimi

alias method-name method-name
alias global-variable-name global-variable-name

Misal

alias foo bar
alias $MATCH $&

Burada bar için foo takma adı tanımladık ve $ MATCH, $ & için bir takma addır.

Ruby undef İfadesi

Bu, yöntem tanımını iptal eder. Yöntem gövdesinde bir undef görünemez.

Undef ve takma ad kullanılarak , sınıfın arabirimi üst sınıftan bağımsız olarak değiştirilebilir, ancak self'e yapılan dahili yöntem çağrısıyla programların bozuk olabileceğine dikkat edin.

Sözdizimi

undef method-name

Misal

Bar adlı bir yöntemi tanımsız hale getirmek için aşağıdakileri yapın -

undef bar

Ruby'nin çeşitli ifadeleri koyabileceğiniz yöntemleri nasıl tanımladığını gördünüz ve sonra bu yöntemi çağırıyorsunuz. Benzer şekilde, Ruby'nin de Blok kavramı vardır.

• Bir blok kod parçalarından oluşur.

• Bir bloğa bir isim atarsınız.

• Bloktaki kod her zaman küme parantezi ({}) içine alınır.

• Bir blok her zaman bloğunki ile aynı ada sahip bir fonksiyondan çağrılır. Bu , test adında bir bloğunuz varsa , bu bloğu çağırmak için fonksiyon testini kullanacağınız anlamına gelir .

• Getiri ifadesini kullanarak bir blok çağırırsınız .

Sözdizimi

block_name {
   statement1
   statement2
   ..........
}

Burada, basit bir getiri ifadesi kullanarak bir bloğu çağırmayı öğreneceksiniz . Ayrıca , bir bloğu çağırmak için parametrelerle bir verim ifadesini kullanmayı da öğreneceksiniz . Örnek kodu her iki türden getiri ifadesi ile kontrol edeceksiniz .

Getiri Beyanı

Getiri ifadesinin bir örneğine bakalım -

#!/usr/bin/ruby

def test
   puts "You are in the method"
   yield
   puts "You are again back to the method"
   yield
end
test {puts "You are in the block"}

Bu, aşağıdaki sonucu verecektir -

You are in the method
You are in the block
You are again back to the method
You are in the block

Ayrıca, getiri ifadesiyle parametreleri de iletebilirsiniz. İşte bir örnek -

#!/usr/bin/ruby

def test
   yield 5
   puts "You are in the method test"
   yield 100
end
test {|i| puts "You are in the block #{i}"}

Bu, aşağıdaki sonucu verecektir -

You are in the block 5
You are in the method test
You are in the block 100

Burada, verim ifadesinin ardından parametreler yazılır. Hatta birden fazla parametreyi bile geçebilirsiniz. Blokta, parametreleri kabul etmek için iki dikey çizgi (||) arasına bir değişken yerleştirirsiniz. Bu nedenle, önceki kodda, verim 5 ifadesi 5 değerini bir parametre olarak test bloğuna geçirir.

Şimdi şu ifadeye bakın -

test {|i| puts "You are in the block #{i}"}

Burada i değişkeninde 5 değeri alınır . Şimdi, aşağıdaki puts ifadesine bakın -

puts "You are in the block #{i}"

Bu puts ifadesinin çıktısı -

You are in the block 5

Birden fazla parametreyi geçirmek istiyorsanız, verim ifadesi şu olur -

yield a, b

ve blok -

test {|a, b| statement}

Parametreler virgülle ayrılacaktır.

Bloklar ve Yöntemler

Bir bloğun ve bir yöntemin birbiriyle nasıl ilişkilendirilebileceğini gördünüz. Normalde, bloğunki ile aynı ada sahip bir yöntemden getiri ifadesini kullanarak bir bloğu çağırırsınız. Bu nedenle, yazarsın -

#!/usr/bin/ruby

def test
   yield
end
test{ puts "Hello world"}

Bu örnek, bir bloğu uygulamanın en basit yoludur. Test bloğunu verim ifadesini kullanarak çağırırsınız .

Ancak bir yöntemin son bağımsız değişkeninden önce & gelirse, bu yönteme bir blok geçirebilirsiniz ve bu blok son parametreye atanacaktır. Bağımsız değişken listesinde hem * hem de & varsa, & daha sonra gelmelidir.

#!/usr/bin/ruby

def test(&block)
   block.call
end
test { puts "Hello World!"}

Bu, aşağıdaki sonucu verecektir -

Hello World!

BEGIN ve END Blokları

Her Ruby kaynak dosyası, dosya yüklenirken (BEGIN blokları) ve programın yürütülmesi bittikten sonra (END blokları) çalıştırılacak kod bloklarını bildirebilir.

#!/usr/bin/ruby

BEGIN { 
   # BEGIN block code 
   puts "BEGIN code block"
} 

END { 
   # END block code 
   puts "END code block"
}
   # MAIN block code 
puts "MAIN code block"

Bir program birden çok BEGIN ve END bloğu içerebilir. BEGIN blokları karşılaştıkları sırayla yürütülür. END blokları ters sırada yürütülür. Çalıştırıldığında, yukarıdaki program aşağıdaki sonucu verir -

BEGIN code block
MAIN code block
END code block

Modüller, yöntemleri, sınıfları ve sabitleri bir arada gruplamanın bir yoludur. Modüller size iki büyük fayda sağlar.

• Modüller bir ad alanı sağlar ve ad çatışmalarını önler.

• Modüller, mixin tesisini uygular .

Modüller, yöntemleriniz ve sabitlerinizin başka yöntemler ve sabitler tarafından üzerine basılma endişesi duymadan oynayabileceği bir sanal alan olan bir ad alanını tanımlar.

Sözdizimi

module Identifier
   statement1
   statement2
   ...........
end

Modül sabitleri, ilk büyük harfle, sınıf sabitleri gibi adlandırılır. Yöntem tanımları da benzer görünür: Modül yöntemleri tıpkı sınıf yöntemleri gibi tanımlanır.

Sınıf yöntemlerinde olduğu gibi, bir modül yöntemini, modülün adı ve bir nokta ile isminin önüne geçerek çağırırsınız ve modül adı ve iki iki nokta üst üste kullanarak bir sabite başvurursunuz.

Misal

#!/usr/bin/ruby

# Module defined in trig.rb file

module Trig
   PI = 3.141592654
   def Trig.sin(x)
   # ..
   end
   def Trig.cos(x)
   # ..
   end
end

Aynı işlev adına ancak farklı işlevselliğe sahip bir modül daha tanımlayabiliriz -

#!/usr/bin/ruby

# Module defined in moral.rb file

module Moral
   VERY_BAD = 0
   BAD = 1
   def Moral.sin(badness)
   # ...
   end
end

Sınıf yöntemleri gibi, bir modülde bir yöntem tanımladığınızda, modül adını ve ardından bir nokta ve ardından yöntem adını belirtirsiniz.

Ruby, İfade gerektirir

Required ifadesi, C ve C ++ 'nın include deyimine ve Java'nın import deyimine benzer. Üçüncü bir program herhangi bir tanımlı modülü kullanmak isterse, modül dosyalarını Ruby need deyimini kullanarak kolayca yükleyebilir -

Sözdizimi

require filename

Burada vermek gerekmez .rb uzantısı bir dosya adı ile birlikte.

Misal

$LOAD_PATH << '.'

require 'trig.rb'
require 'moral'

y = Trig.sin(Trig::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)

Burada kullanıyoruz $LOAD_PATH << '.'Ruby'nin içerilen dosyaların mevcut dizinde aranması gerektiğini bilmesini sağlamak için. $ LOAD_PATH kullanmak istemiyorsanız,require_relative göreceli bir dizinden dosyaları dahil etmek için.

IMPORTANT- Burada her iki dosya da aynı işlev adını içerir. Bu nedenle, bu program çağırırken kod belirsizliğine neden olur, ancak modüller bu kod belirsizliğini önler ve modül adını kullanarak uygun işlevi çağırabiliriz.

Ruby include İfadesi

Bir modülü bir sınıfa yerleştirebilirsiniz. Bir modülü bir sınıfa gömmek için , sınıfta include ifadesini kullanırsınız -

Sözdizimi

include modulename

Bir modül ayrı bir dosyada tanımlanmışsa, modülü bir sınıfa yerleştirmeden önce bu dosyayı need ifadesini kullanarak dahil etmek gerekir .

Misal

Support.rb dosyasında yazılı aşağıdaki modülü düşünün .

module Week
   FIRST_DAY = "Sunday"
   def Week.weeks_in_month
      puts "You have four weeks in a month"
   end
   def Week.weeks_in_year
      puts "You have 52 weeks in a year"
   end
end

Şimdi, bu modülü aşağıdaki gibi bir sınıfa dahil edebilirsiniz -

#!/usr/bin/ruby
$LOAD_PATH << '.'
require "support"

class Decade
include Week
   no_of_yrs = 10
   def no_of_months
      puts Week::FIRST_DAY
      number = 10*12
      puts number
   end
end
d1 = Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month
Week.weeks_in_year
d1.no_of_months

Bu, aşağıdaki sonucu verecektir -

Sunday
You have four weeks in a month
You have 52 weeks in a year
Sunday
120

Ruby'deki karışımlar

Bu bölüme geçmeden önce, Nesne Yönelimli Kavramlar bilgisine sahip olduğunuzu varsayıyoruz.

Bir sınıf, birden fazla üst sınıftan özellikleri devralabildiğinde, sınıfın birden çok miras göstermesi beklenir.

Ruby çoklu kalıtımı doğrudan desteklemez ancak Ruby Modüllerinin başka bir harika kullanımı vardır. Bir vuruşta, mixin adı verilen bir kolaylık sağlayarak, çoklu miras ihtiyacını hemen hemen ortadan kaldırırlar .

Mixins, sınıflara işlevsellik eklemenin harika bir şekilde kontrol edilmesini sağlar. Ancak, karışımdaki kod, onu kullanan sınıftaki kodla etkileşime girdiğinde gerçek güçleri ortaya çıkar.

Mixin'i anlamak için aşağıdaki örnek kodu inceleyelim -

module A
   def a1
   end
   def a2
   end
end
module B
   def b1
   end
   def b2
   end
end

class Sample
include A
include B
   def s1
   end
end

samp = Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1

Modül A, a1 ve a2 yöntemlerinden oluşur. Modül B, b1 ve b2 yöntemlerinden oluşur. Sample sınıfı hem A hem de B modüllerini içerir. Sample sınıfı a1, a2, b1 ve b2 olmak üzere dört yöntemin tamamına erişebilir. Bu nedenle, Sample sınıfının her iki modülden de miras aldığını görebilirsiniz. Bu nedenle, Sample sınıfının çoklu kalıtım veya bir karışım gösterdiğini söyleyebilirsiniz .

Ruby'deki bir String nesnesi, tipik olarak insan dilini temsil eden karakterleri temsil eden bir veya daha fazla baytın rastgele bir dizisini tutar ve işler.

En basit dize değişmezleri tek tırnaklar (kesme işareti karakteri) içine alınır. Tırnak işaretlerinin içindeki metin dizenin değeridir -

'This is a simple Ruby string literal'

Tek tırnaklı bir dize değişmezi arasına kesme işareti yerleştirmeniz gerekiyorsa, önüne ters eğik çizgi koyun, böylece Ruby yorumlayıcısı dizeyi sonlandırdığını düşünmez -

'Won\'t you read O\'Reilly\'s book?'

Ters eğik çizgi, başka bir ters eğik çizgiden kaçmak için de çalışır, böylece ikinci ters eğik çizgi bir çıkış karakteri olarak yorumlanmaz.

Ruby'nin dizelerle ilgili özellikleri aşağıdadır.

İfade Değiştirme

İfade ikamesi, # {ve} kullanarak herhangi bir Ruby ifadesinin değerini bir dizeye yerleştirmenin bir yoludur -

#!/usr/bin/ruby

x, y, z = 12, 36, 72
puts "The value of x is #{ x }."
puts "The sum of x and y is #{ x + y }."
puts "The average was #{ (x + y + z)/3 }."

Bu, aşağıdaki sonucu verecektir -

The value of x is 12.
The sum of x and y is 48.
The average was 40.

Genel Sınırlandırılmış Dizeler

Genel sınırlandırılmış dizelerle, bir çift eşleme içinde, keyfi sınırlayıcı karakterler, örneğin,!, (, {, <, Vb., Önünde yüzde karakteri (%) bulunan dizeler oluşturabilirsiniz. Q, q ve x'in özel anlamları vardır. . Genel sınırlandırılmış dizeler olabilir -

%{Ruby is fun.}  equivalent to "Ruby is fun."
%Q{ Ruby is fun. } equivalent to " Ruby is fun. "
%q[Ruby is fun.]  equivalent to a single-quoted string
%x!ls! equivalent to back tick command output `ls`

Kaçış Karakterleri

Aşağıdaki tablo, ters eğik çizgi gösterimi ile gösterilebilecek bir kaçış veya yazdırılamayan karakterlerin listesidir.

NOTE- Çift tırnaklı bir dizede, bir çıkış karakteri yorumlanır; tek tırnaklı bir dizede, bir çıkış karakteri korunur.

Ters eğik çizgi gösterimi	Onaltılık karakter	Açıklama
\ a	0x07	Zil veya uyarı
\ b	0x08	Geri tuşu
\ cx		Ctrl-x
\ Cx		Ctrl-x
\ e	0x1b	Kaçış
\ f	0x0c	Form besleme
\ M- \ Cx		Meta-Control-x
\ n	0x0a	Yeni hat
\ nnn		Sekizli gösterim, burada n 0.7 aralığında
\ r	0x0d	Satırbaşı
\ s	0x20	Uzay
\ t	0x09	Sekme
\ v	0x0b	Dikey sekme
\ x		Karakter x
\ xnn		Onaltılık gösterim, burada n 0.9, af veya AF aralığındadır

Karakter kodlaması

Ruby için varsayılan karakter seti, karakterleri tek baytlarla temsil edilebilen ASCII'dir. UTF-8 veya başka bir modern karakter seti kullanırsanız, karakterler bir ila dört bayt arasında gösterilebilir.

Karakter setinizi programınızın başında $ KCODE kullanarak şu şekilde değiştirebilirsiniz -

$KCODE = 'u'

$ KCODE için olası değerler aşağıdadır.

Sr.No.	Kod ve Açıklama
1	a ASCII (hiçbiri ile aynı). Bu varsayılandır.
2	e EUC.
3	n Yok (ASCII ile aynı).
4	u UTF-8.

Dize Yerleşik Yöntemleri

Bir String yöntemini çağırmak için bir String nesnesine ihtiyacımız var. String nesnesinin bir örneğini oluşturmanın yolu aşağıdadır -

new [String.new(str = "")]

Bu, str'nin bir kopyasını içeren yeni bir dizge nesnesi döndürür . Şimdi, str nesnesini kullanarak , mevcut herhangi bir örnek yöntemini kullanabiliriz. Örneğin -

#!/usr/bin/ruby

myStr = String.new("THIS IS TEST")
foo = myStr.downcase

puts "#{foo}"

Bu, aşağıdaki sonucu verecektir -

this is test

Aşağıda genel String yöntemleri verilmiştir (str'nin bir String nesnesi olduğu varsayılır) -

Sr.No.	Yöntemler ve Açıklama
1	str % arg Bir biçim belirtimi kullanarak bir dizeyi biçimlendirir. Birden fazla ikame içeriyorsa, arg bir dizi olmalıdır. Biçim belirtimi hakkında bilgi için, "Kernel Module" altındaki sprintf'e bakın.
2	str * integer Tamsayı çarpı str içeren yeni bir dize döndürür. Başka bir deyişle, str, tekrarlanan tam sayı imleridir.
3	str + other_str Other_str ile str'yi bitiştirir.
4	str << obj Bir nesneyi str'ye birleştirir. Nesne 0.255 aralığında bir Fixnum ise, bir karaktere dönüştürülür. Concat ile karşılaştırın.
5	str <=> other_str Str'yi diğer_dize ile karşılaştırarak -1 (küçüktür), 0 (eşittir) veya 1 (büyüktür) sonucunu verir. Karşılaştırma büyük / küçük harfe duyarlıdır.
6	str == obj Eşitlik için str ve obj'i test eder. Obj bir String değilse, false döndürür; str <=> obj 0 döndürürse doğru döndürür.
7	str =~ obj Str'yi normal ifade deseniyle eşleştirir obj. Maçın başladığı konumu döndürür; aksi takdirde, false.
8	str.capitalize Bir dizeyi büyük harf yapar.
9	str.capitalize! Büyük harfle aynıdır, ancak yerinde değişiklikler yapılır.
10	str.casecmp Dizelerin büyük / küçük harf duyarlı bir karşılaştırmasını yapar.
11	str.center Bir dizeyi ortalar.
12	str.chomp Kayıt ayırıcısını ($ /), genellikle \ n, dizenin sonundan kaldırır. Kayıt ayırıcısı yoksa, hiçbir şey yapmaz.
13	str.chomp! Chomp ile aynıdır, ancak yerinde değişiklikler yapılır.
14	str.chop Str'deki son karakteri kaldırır.
15	str.chop! Chop ile aynıdır, ancak yerinde değişiklikler yapılır.
16	str.concat(other_str) Other_str ile str'yi bitiştirir.
17	str.count(str, ...) Bir veya daha fazla karakter kümesini sayar. Birden fazla karakter kümesi varsa, bu kümelerin kesişimini sayar
18	str.crypt(other_str) Str'ye tek yönlü bir kriptografik hash uygular. Bağımsız değişken, iki karakter uzunluğunda olması gereken, her karakter az, AZ, 0.9, aralığındaki tuz dizesidir. veya /.
19	str.delete(other_str, ...) Str'nin, argümanlarının kesişimindeki tüm karakterlerin silinmiş bir kopyasını döndürür.
20	str.delete!(other_str, ...) Silme ile aynı, ancak yerinde değişiklikler yapılır.
21	str.downcase Tümü büyük harflerin küçük harfle değiştirildiği str'nin bir kopyasını döndürür.
22	str.downcase! Küçük kasa ile aynıdır, ancak yerinde değişiklikler yapılır.
23	str.dump Tüm yazdırılmayan karakterlerin \ nnn gösterimi ile değiştirildiği ve tüm özel karakterlerin çıkış yaptığı bir str sürümü döndürür.
24	str.each(separator = $/) { |substr| block } Str'yi kayıt ayırıcı olarak (varsayılan olarak $ /) kullanarak her bir alt dizeyi sağlanan bloğa geçirerek böler.
25	str.each_byte { |fixnum| block } Her baytı str'den bloğa geçirir, her baytı baytın ondalık gösterimi olarak döndürür.
26	str.each_line(separator=$/) { |substr| block } Str'yi kayıt ayırıcı olarak (varsayılan olarak $ /) kullanarak her bir alt dizeyi sağlanan bloğa geçirerek böler.
27	str.empty? Str boşsa (sıfır uzunluğa sahipse) doğru döndürür.
28	str.eql?(other) Aynı uzunluk ve içeriğe sahiplerse iki dizge eşittir.
29	str.gsub(pattern, replacement) [or] str.gsub(pattern) { |match| block } Tüm desen oluşumlarının yerine veya blok değeriyle değiştirilmiş str'nin bir kopyasını döndürür. Kalıp tipik olarak bir Regexp olacaktır; bu bir Dize ise, o zaman normal ifade meta karakterleri yorumlanmayacaktır (yani / \ d / bir rakamla eşleşecektir, ancak '\ d' bir ters eğik çizgiyi takip eden bir 'd' ile eşleşecektir)
30	str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str] References str, aşağıdaki bağımsız değişkenleri kullanarak: bir Fixnum, fixnum'da bir karakter kodu döndürür; iki Fixnum, bir uzaklıktan (ilk sabit değer) uzunluğa (ikinci sabit değer) başlayan bir alt dizeyi döndürür; aralık, aralıktaki bir alt dize döndürür; regexp eşleşen dizgenin bir kısmını döndürür; fixnum ile regexp, eşleşen verileri fixnum'da döndürür; other_str, other_str ile eşleşen alt dizeyi döndürür. Negatif bir Fixnum, -1 ile dizenin sonunda başlar.
31	str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or] str[regexp] = new_str [or] str[regexp, fixnum] = new_str [or] str[other_str] = new_str ] Bir dizenin tamamını veya bir kısmını değiştirin (atayın). Dilimin eşanlamlısı !.
32	str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match|block } Yerinde Dize # gsub değiştirme, herhangi bir değiştirme yapılmadıysa str veya nil değerini döndürür.
33	str.hash Dizenin uzunluğuna ve içeriğine bağlı olarak bir karma döndürür.
34	str.hex Str'den önde gelen karakterleri onaltılık sayılar dizisi olarak ele alır (isteğe bağlı bir işaret ve isteğe bağlı bir 0x ile) ve karşılık gelen sayıyı döndürür. Hata durumunda sıfır döndürülür.
35	str.include? other_str [or] str.include? fixnum Str verilen dizeyi veya karakteri içeriyorsa doğru döndürür.
36	str.index(substring [, offset]) [or] str.index(fixnum [, offset]) [or] str.index(regexp [, offset]) Str'de verilen alt dizenin, karakterin (fixnum) veya desenin (regexp) ilk oluşumunun dizinini döndürür. Bulunmazsa sıfır döndürür. İkinci parametre varsa, aramaya başlamak için dizedeki konumu belirtir.
37	str.insert(index, other_str) Diğer_dize belirtilen dizindeki karakterden önce, dizeyi değiştirerek ekler. Negatif dizinler dizenin sonundan itibaren sayılır ve verilen karakterden sonra eklenir. Amaç, verilen dizinde başlaması için bir dize eklemektir.
38	str.inspect Str'nin yazdırılabilir bir sürümünü, özel karakterlerin çıkışıyla döndürür.
39	str.intern [or] str.to_sym Str'ye karşılık gelen Sembolü döndürür, daha önce yoksa sembolü oluşturur.
40	str.length Str uzunluğunu döndürür. Boyutu karşılaştırın.
41	str.ljust(integer, padstr = ' ') Tamsayı, str uzunluğundan büyükse, str sola yaslanmış ve padstr ile doldurulmuş yeni bir Uzunluk tamsayı String döndürür; aksi takdirde str döndürür.
42	str.lstrip Baştaki boşluk kaldırılmış olarak str'nin bir kopyasını döndürür.
43	str.lstrip! Baştaki boşluğu dizeden kaldırır, değişiklik yapılmadıysa sıfır döndürür.
44	str.match(pattern) Deseni bir Regexp'e dönüştürür (zaten değilse), ardından str üzerinde eşleşme yöntemini çağırır.
45	str.oct Str'nin önde gelen karakterlerini sekizlik rakamlardan oluşan bir dizi olarak ele alır (isteğe bağlı işaretli) ve karşılık gelen sayıyı döndürür. Dönüştürme başarısız olursa 0 döndürür.
46	str.replace(other_str) Dizenin içeriğini ve bozukluğunu other_str'deki karşılık gelen değerlerle değiştirir.
47	str.reverse Str'deki karakterleri ters sırada içeren yeni bir dize döndürür.
48	str.reverse! Str'yi yerinde ters çevirir.
49	str.rindex(substring [, fixnum]) [or] str.rindex(fixnum [, fixnum]) [or] str.rindex(regexp [, fixnum]) Str'de verilen alt dizenin, karakterin (fixnum) veya kalıbın (regexp) son oluşumunun dizinini döndürür. Bulunmazsa sıfır döndürür. İkinci parametre mevcutsa, arama sonlandırmak için dizedeki konumu belirtir. Bu noktanın ötesinde karakterler dikkate alınmayacaktır.
50.	str.rjust(integer, padstr = ' ') Tamsayı, str uzunluğundan büyükse, str sağa yaslanmış ve padstr ile doldurulmuş uzunlukta yeni bir String tamsayı döndürür; aksi takdirde str döndürür.
51	str.rstrip Sondaki boşluk kaldırılmış str'nin bir kopyasını döndürür.
52	str.rstrip! Sondaki beyaz boşluğu str'den kaldırır, değişiklik yapılmadıysa sıfır döndürür.
53	str.scan(pattern) [or] str.scan(pattern) { |match, ...| block } Her iki form da (bir Regexp veya bir String olabilir) desenle eşleşerek str boyunca yinelenir. Her eşleşme için bir sonuç oluşturulur ve sonuç dizisine eklenir veya bloğa iletilir. Kalıp grup içermiyorsa, her bir sonuç eşleşen dizeden ($ &) oluşur. Kalıp gruplar içeriyorsa, her bir sonucun kendisi grup başına bir girdi içeren bir dizidir.
54	str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or] str.slice(range) [or] str.slice(regexp) [or] str.slice(regexp, fixnum) [or] str.slice(other_str) See str[fixnum], etc. str.slice!(fixnum) [or] str.slice!(fixnum, fixnum) [or] str.slice!(range) [or] str.slice!(regexp) [or] str.slice!(other_str) Belirtilen kısmı str'den siler ve silinen kısmı döndürür. Bir Fixnum alan formlar, değer aralık dışındaysa bir IndexError yükseltir; Aralık formu bir RangeError oluşturur ve Regexp ve String formları atamayı sessizce yoksayar.
55	str.split(pattern = $, [limit]) Dizeyi bir sınırlayıcıya göre alt dizelere böler ve bu alt dizelerin bir dizisini döndürür. Eğer model , bir String, daha sonra içeriğinin sınırlayıcı bölme str olarak kullanılır. Desen tek bir boşluksa, str boşlukta bölünür, baştaki beyaz boşluklar ve bitişik boşluk karakterleri yoksayılır. Eğer desen bir Normal İfade olduğunu str nerede desen eşleşmeleri bölünür. Desen sıfır uzunluklu bir dizeyle eşleştiğinde, str ayrı karakterlere bölünür. Eğer model atlanırsa, değeri$; is used. If $; nil (öntanımlıdır), str boşlukta `` belirtilmiş gibi bölünür. Eğer sınır parametresi atlanırsa, arka boş alanları bastırılmaktadır. Sınır pozitif bir sayı ise, en fazla bu alan sayısı döndürülür (sınır 1 ise, dizinin tamamı bir dizideki tek girdi olarak döndürülür). Negatifse, döndürülen alanların sayısı için bir sınır yoktur ve sondaki boş alanlar bastırılmaz.
56	str.squeeze([other_str]*) Dize # sayısı için açıklanan yordamı kullanarak other_str parametrelerinden bir dizi karakter oluşturur. Bu kümede meydana gelen aynı karakterin çalıştırmalarının tek bir karakterle değiştirildiği yeni bir dize döndürür. Herhangi bir bağımsız değişken belirtilmezse, aynı karakterlerin tüm dizileri tek bir karakterle değiştirilir.
57	str.squeeze!([other_str]*) Str'yi yerinde sıkıştırır, herhangi bir değişiklik yapılmamışsa str veya nil döndürür.
58	str.strip Baştaki ve sondaki boşluklar kaldırılmış olarak str'nin bir kopyasını döndürür.
59	str.strip! Str'den baştaki ve sondaki beyaz boşluğu kaldırır. Str değiştirilmediyse sıfır döndürür.
60	str.sub(pattern, replacement) [or] str.sub(pattern) { |match| block } İlk örüntü oluşumunun blok değeri veya değişimle değiştirildiği str'nin bir kopyasını döndürür. Kalıp tipik olarak bir Regexp olacaktır; bir Dize ise, hiçbir normal ifade meta karakterleri yorumlanmaz.
61	str.sub!(pattern, replacement) [or] str.sub!(pattern) { |match| block } Yerine Dize # alt değiştirme, dizge döndürme veya değiştirme yapılmadıysa nil gerçekleştirir.
62	str.succ [or] str.next Halefi str'ye döndürür.
63	str.succ! [or] str.next! Dize # succ ile eşdeğerdir, ancak alıcıyı yerinde değiştirir.
64	str.sum(n = 16) Str'deki karakterlerin temel bir n bitlik sağlama toplamını döndürür; burada n, isteğe bağlı Fixnum parametresidir ve varsayılan olarak 16'dır. Sonuç basitçe str modulo 2n - 1'deki her bir karakterin ikili değerinin toplamıdır. iyi sağlama toplamı.
65	str.swapcase Büyük harfli alfabetik karakterlerin küçük harfe ve küçük harfli karakterlerin büyük harfe dönüştürüldüğü bir str kopyası döndürür.
66	str.swapcase! String # swapcase'e eşdeğerdir, ancak alıcıyı yerinde değiştirir, hiçbir değişiklik yapılmamışsa str veya nil döndürür.
67	str.to_f > Str'deki baştaki karakterlerin kayan nokta sayısı olarak yorumlanmasının sonucunu döndürür. Geçerli bir sayının sonunu geçen gereksiz karakterler göz ardı edilir. Str başlangıcında geçerli bir sayı yoksa 0.0 döndürülür. Bu yöntem asla bir istisna yaratmaz.
68	str.to_i(base = 10) Str'deki baştaki karakterlerin tamsayı tabanı olarak yorumlanmasının sonucunu döndürür (2, 8, 10 veya 16 tabanı). Geçerli bir sayının sonunu geçen gereksiz karakterler göz ardı edilir. Str başlangıcında geçerli bir sayı yoksa 0 döndürülür. Bu yöntem asla bir istisna yaratmaz.
69	str.to_s [or] str.to_str Alıcıyı döndürür.
70	str.tr(from_str, to_str) Str'nin bir kopyasını, başlangıç_dize içindeki karakterlerin, to_str'deki karşılık gelen karakterlerle değiştirilmiş olarak döndürür. To_str, from_str'den daha kısaysa, son karakteri ile doldurulur. Her iki dizge de karakter aralıklarını belirtmek için c1.c2 gösterimini kullanabilir ve from_str, listelenenler dışındaki tüm karakterleri belirten bir ^ ile başlayabilir.
71	str.tr!(from_str, to_str) String # tr ile aynı kuralları kullanarak str'yi yerinde çevirir. Hiçbir değişiklik yapılmamışsa str veya nil döndürür.
72	str.tr_s(from_str, to_str) Dize # tr altında açıklandığı gibi dizenin bir kopyasını işler, ardından çeviriden etkilenen bölgelerdeki yinelenen karakterleri kaldırır.
73	str.tr_s!(from_str, to_str) Yerinde str üzerinde dize # tr_s işlemeyi gerçekleştirir, herhangi bir değişiklik yapılmadıysa str veya nil döndürür.
74	str.unpack(format) > Biçim dizesine göre str (ikili veriler içerebilir) kodunu çözer ve çıkarılan her değerden bir dizi döndürür. Biçim dizgesi, Tablo 18'de özetlenen bir dizi tek karakterli yönergeden oluşur. Her yönergeyi, bu yönergeyle kaç kez tekrarlanacağını belirten bir sayı izleyebilir. Yıldız işareti (*) kalan tüm öğeleri kullanacaktır. SSiIlL yönergelerinin her birinin ardından, temel alınan platformun yerel boyutunu belirtilen tür için kullanmak üzere bir alt çizgi (_) gelebilir; aksi takdirde, platformdan bağımsız tutarlı bir boyut kullanır. Biçim dizesinde boşluklar yok sayılır.
75	str.upcase Tüm küçük harfler büyük harflerle değiştirilmiş str'nin bir kopyasını döndürür. İşlem yerel ayara duyarlı değildir. Yalnızca a'dan z'ye karakterler etkilenir.
76	str.upcase! Str'nin içeriğini büyük harfe değiştirir, hiçbir değişiklik yapılmazsa sıfır döndürür.
77	str.upto(other_str) { |s| block } Str'den başlayıp other_str inclusive ile biten ardışık değerleri yineler, her değeri sırayla bloğa iletir. String # succ yöntemi, her bir değeri oluşturmak için kullanılır.

String unpack Direktifleri

Aşağıdaki tablo, String # unpack yöntemi için paket açma yönergelerini listeler.

Direktif	İadeler	Açıklama
Bir	Dize	Sondaki boşluklar ve boşluklar kaldırılarak.
a	Dize	Dize.
B	Dize	Her karakterden bitleri çıkarır (en önemli bit önce).
b	Dize	Her karakterden bitleri çıkarır (en az anlamlı bit önce).
C	Fixnum	Bir karakteri işaretsiz tamsayı olarak ayıklar.
c	Fixnum	Bir karakteri tam sayı olarak çıkarır.
D, d	Yüzer	Sizeof (double) karakterleri yerel bir çift olarak değerlendirir.
E	Yüzer	Sizeof (double) karakterlerini littleendian bayt sırasına göre double olarak değerlendirir.
e	Yüzer	Sizeof (float) karakterleri littleendian bayt sırasına göre bir kayan nokta olarak ele alır.
F, f	Yüzer	Sizeof (float) karakterleri yerel bir kayan nokta olarak değerlendirir.
G	Yüzer	Sizeof (double) karakterleri ağ bayt sırasına göre ikili olarak ele alır.
g	Dize	Sizeof (float) karakterleri ağ bayt sırasına göre kayan nokta olarak değerlendirir.
H	Dize	Her karakterden onaltılık yarımları çıkarır (en önemli bit önce)
h	Dize	Her karakterden onaltılık yarımları çıkarır (en az anlamlı bit önce).
ben	Tamsayı	Sizeof (int) (_ ile değiştirilmiş) ardışık karakterleri işaretsiz yerel tamsayı olarak değerlendirir.
ben	Tamsayı	Sizeof (int) (_ ile değiştirilmiş) ardışık karakterleri işaretli yerel tamsayı olarak değerlendirir.
L	Tamsayı	Dört (_ ile değiştirilmiş) ardışık karakteri işaretsiz yerel uzun tam sayı olarak ele alır.
l	Tamsayı	Dört (_ ile değiştirilmiş) ardışık karakteri imzalı yerel uzun tamsayı olarak ele alır.
M	Dize	Alıntılı yazdırılabilir.
m	Dize	Base64 ile kodlanmış.
N	Tamsayı	Dört karakteri, ağ bayt sırasına göre işaretsiz uzun olarak değerlendirir.
n	Fixnum	İki karakteri ağ bayt sırasına göre işaretsiz bir kısa olarak ele alır.
P	Dize	Sizeof (char *) karakterlerini bir işaretçi olarak ele alır ve referans alınan konumdan \ emp {len} karakterlerini döndürür.
p	Dize	Sizeof (char *) karakterlerini boş sonlandırılmış bir dizeye işaretçi olarak değerlendirir.
Q	Tamsayı	Sekiz karaktere işaretsiz dörtlü sözcük (64 bit) muamelesi yapar.
q	Tamsayı	Sekiz karakteri işaretli dörtlü sözcük (64 bit) olarak ele alır.
S	Fixnum	İki (_ kullanılmışsa farklı) ardışık karakteri yerel bayt sırasına göre işaretsiz bir kısa olarak ele alır.
s	Fixnum	İki (_ kullanılmışsa farklı) ardışık karakteri yerel bayt sırasına göre imzalanmış kısa bir karakter olarak ele alır.
U	Tamsayı	İşaretsiz tamsayılar olarak UTF-8 karakterleri.
sen	Dize	UU kodlu.
V	Fixnum	Küçük endian bayt sırasına göre dört karaktere işaretsiz long olarak davranır.
v	Fixnum	İki karakteri küçük endian bayt sırasına göre işaretsiz kısa olarak ele alır.
w	Tamsayı	BER ile sıkıştırılmış tamsayı.
X		Bir karakter geri atlar.
x		Bir karakter ileri atlar.
Z	Dize	Sondaki boş değerler * ile ilk boş değere kadar kaldırılır.
@		Uzunluk bağımsız değişkeni tarafından verilen uzaklığa atlar.

Misal

Çeşitli verileri açmak için aşağıdaki örneği deneyin.

"abc \0\0abc \0\0".unpack('A6Z6')   #=> ["abc", "abc "]
"abc \0\0".unpack('a3a3')           #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*')       #=> ["abc ", "abc "]
"aa".unpack('b8B8')                 #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c')               #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS')     #=> [-2, 65534]
"now = 20is".unpack('M*')           #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a')    #=> ["h", "e", "l", "l", "o"]

Ruby dizileri, herhangi bir nesnenin sıralı, tamsayı dizinli koleksiyonlarıdır. Bir dizideki her eleman bir indeksle ilişkilendirilir ve bir indeks tarafından anılır.

Dizi indeksleme, C veya Java'da olduğu gibi 0'dan başlar. Dizinin sonuna göre negatif bir indeks varsayılır - yani -1 indisi dizinin son öğesini belirtir, -2 dizideki sondan sonraki öğedir ve bu böyle devam eder.

Ruby dizileri String, Integer, Fixnum, Hash, Symbol gibi nesneleri ve hatta diğer Array nesnelerini tutabilir. Ruby dizileri, diğer dillerdeki diziler kadar katı değildir. Ruby dizileri, onlara eleman eklerken otomatik olarak büyür.

Diziler Oluşturma

Bir dizi yaratmanın veya başlatmanın birçok yolu vardır. Bunun bir yolu, yeni sınıf yöntemidir -

names = Array.new

Dizi yaratma anında bir dizinin boyutunu ayarlayabilirsiniz -

names = Array.new(20)

Dizi adlarının boyutu veya uzunluğu artık 20 öğedir. Bir dizinin boyutunu boyut veya uzunluk yöntemleriyle döndürebilirsiniz -

#!/usr/bin/ruby

names = Array.new(20)
puts names.size  # This returns 20
puts names.length # This also returns 20

Bu, aşağıdaki sonucu verecektir -

20
20

Dizideki her öğeye aşağıdaki gibi bir değer atayabilirsiniz -

#!/usr/bin/ruby

names = Array.new(4, "mac")
puts "#{names}"

Bu, aşağıdaki sonucu verecektir -

["mac", "mac", "mac", "mac"]

Ayrıca, her bir öğeyi bloğun değerlendirdiği şeyle dolduran yeni bir blok da kullanabilirsiniz -

#!/usr/bin/ruby

nums = Array.new(10) { |e| e = e * 2 }
puts "#{nums}"

Bu, aşağıdaki sonucu verecektir -

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

[] Adlı başka bir Array yöntemi daha var. Bu şekilde çalışır -

nums = Array.[](1, 2, 3, 4,5)

Aşağıdaki gibi bir dizi oluşturma şekli daha -

nums = Array[1, 2, 3, 4,5]

Çekirdek çekirdek Ruby uygun modülü yalnızca tek bir bağımsız değişken kabul eden bir dizi yöntemi vardır. Burada yöntem, bir rakam dizisi oluşturmak için argüman olarak bir aralık alır -

#!/usr/bin/ruby

digits = Array(0..9)
puts "#{digits}"

Bu, aşağıdaki sonucu verecektir -

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Dizi Yerleşik Yöntemleri

Bir Array yöntemini çağırmak için Array nesnesinin bir örneğine ihtiyacımız var. Gördüğümüz gibi, Array nesnesinin bir örneğini yaratmanın yolu aşağıdadır -

Array.[](...) [or] Array[...] [or] [...]

Bu, verilen nesnelerle doldurulmuş yeni bir dizi döndürecektir. Şimdi, oluşturulan nesneyi kullanarak, mevcut herhangi bir örnek yöntemini çağırabiliriz. Örneğin -

#!/usr/bin/ruby

digits = Array(0..9)
num = digits.at(6)
puts "#{num}"

Bu, aşağıdaki sonucu verecektir -

6

Aşağıda genel dizi yöntemleri verilmiştir (dizinin bir dizi nesnesi olduğu varsayılır) -

Sr.No.	Yöntemler ve Açıklama
1	array & other_array Yinelenmeyen, iki dizide ortak olan öğeleri içeren yeni bir dizi döndürür.
2	array * int [or] array * str Self'in int kopyalarını birleştirerek oluşturulmuş yeni bir dizi döndürür. Self.join (str) ile eşdeğer bir String bağımsız değişkeniyle.
3	array + other_array Üçüncü bir dizi oluşturmak için iki diziyi birleştirerek oluşturulmuş yeni bir dizi döndürür.
4	array - other_array Diğer_dizide de görünen tüm öğeleri kaldırarak, orijinal dizinin bir kopyası olan yeni bir dizi döndürür.
5	array <=> other_array Str'yi diğer_dize ile karşılaştırarak -1 (küçüktür), 0 (eşittir) veya 1 (büyüktür) sonucunu verir. Karşılaştırma büyük / küçük harf duyarlıdır.
6	array | other_array Diğer_diziler ile diziyi birleştirip kopyaları kaldırarak yeni bir dizi döndürür.
7	array << obj Verilen nesneyi dizinin sonuna iter. Bu ifade dizinin kendisini döndürür, bu nedenle birkaç uzantı birbirine zincirlenmiş olabilir.
8	array <=> other_array Bu dizi diğer_diziden küçükse, ona eşitse veya ondan büyükse bir tamsayı (-1, 0 veya +1) döndürür.
9	array == other_array Aynı sayıda öğe içeriyorlarsa ve her öğe diğer dizideki karşılık gelen öğeye eşitse (Object. =='ye göre) iki dizi eşittir.
10	array[index] [or] array[start, length] [or] array[range] [or] array.slice(index) [or] array.slice(start, length) [or] array.slice(range) En İade elemanı indeksi veya döner bir altdizilim başlayan başlangıcı ve devam eden uzunluk elemanları veya belirlediği bir SubArray döndüren aralığında . Negatif indisler, dizinin sonundan geriye doğru sayılır (-1, son öğedir). Dizin (veya başlangıç ​​dizini) aralık dışındaysa sıfır döndürür .
11	array[index] = obj [or] array[start, length] = obj or an_array or nil [or] array[range] = obj or an_array or nil En Setleri elemanı indeksi veya cümledeki bir altdizilim başlayan başlangıcı ve devam eden uzunluk elemanları veya belirlediği bir SubArray değiştirir aralığında . Dizinler dizinin mevcut kapasitesinden büyükse, dizi otomatik olarak büyür. Negatif endeksler, dizinin sonundan geriye doğru sayılır. Uzunluk sıfırsa eleman ekler . Eğer sıfır , ikinci ve üçüncü şeklinde kullanılır, elemanları siler öz .
12	array.abbrev(pattern = nil) Kendindeki dizeler için belirsiz olmayan kısaltmalar kümesini hesaplar . Bir desen veya dizge geçirilirse, yalnızca kalıpla eşleşen veya dizeyle başlayan dizeler dikkate alınır.
13	array.assoc(obj) Nesneleri aynı zamanda diziler olan bir dizide arar ve obj. Eşleşme bulunmazsa eşleşen veya nil olan ilk içerilen diziyi döndürür .
14	array.at(index) Dizindeki öğeyi döndürür. Negatif bir indeks kendiliğin sonundan itibaren sayılır. Dizin aralık dışındaysa sıfır döndürür.
15	array.clear Diziden tüm öğeleri kaldırır.
16	array.collect { |item| block } [or] array.map { |item| block } Benliğin her bir öğesi için bir kez blok çağırır . Blok tarafından döndürülen değerleri içeren yeni bir dizi oluşturur.
17	array.collect! { |item| block } [or] array.map! { |item| block } Kendinin her bir öğesi için bloğu bir kez çağırır , öğeyi blok tarafından döndürülen değerle değiştirir .
18	array.compact İade bir kopyasını kendini tüm nil elemanları kaldırıldı.
19	array.compact! Diziden nil öğeleri kaldırır . Hiçbir değişiklik yapılmadıysa sıfır döndürür .
20	array.concat(other_array) İçin other_array öğeleri ekler kendini .
21	array.delete(obj) [or] array.delete(obj) { block } Den siler öğe kendine eşittir obj . Öğe bulunmazsa, sıfır döndürür . İsteğe bağlı kod bloğu verilirse, öğe bulunamazsa bloğun sonucunu döndürür .
22	array.delete_at(index) Belirtilen dizindeki öğeyi siler, bu öğeyi döndürür veya dizin aralık dışındaysa sıfırdır .
23	array.delete_if { |item| block } Her eleman siler kendini hangi blok değerlendirir true.
24	array.each { |item| block } Aramalar bloke her eleman için bir kere kendini bir parametre olarak o öğeyi geçen.
25	array.each_index { |index| block } Her biri Array # ile aynıdır, ancak öğenin kendisi yerine öğenin dizinini iletir.
26	array.empty? Self dizisi hiç öğe içermiyorsa doğru döndürür.
27	array.eql?(other) Dizi ve diğerleri aynı nesneyse veya her ikisi de aynı içeriğe sahip dizilerse doğru döndürür .
28	array.fetch(index) [or] array.fetch(index, default) [or] array.fetch(index) { |index| block } Öğeyi konum dizininde döndürmeye çalışır . Eğer göstergesi dizisi dışında bulunan birinci formu bir atar IndexError durum, ikinci kalıp döner varsayılan ve üçüncü bir şekilde döner çağırarak değeri blok geçen, dizin . Dizinin sonundan itibaren dizin sayımının negatif değerleri .
29	array.fill(obj) [or] array.fill(obj, start [, length]) [or] array.fill(obj, range) [or] array.fill { |index| block } [or] array.fill(start [, length] ) { |index| block } [or] array.fill(range) { |index| block } İlk üç formları seçilen unsurları ayarlamak kendini için obj . Sıfır değerinin başlangıcı, sıfıra eşittir. Bir uzunluğu sıfıra denktir self.length . Son üç form , diziyi bloğun değeriyle doldurur . Blok her elemanın mutlak göstergesi doldurulacak ile geçirilir.
30	array.first [or] array.first(n) Dizinin ilk öğesini veya ilk n öğesini döndürür . Dizi boşsa, birinci form nil döndürür ve ikinci form boş bir dizi döndürür.
31	array.flatten Bu dizinin tek boyutlu düzleştirilmesi olan (özyinelemeli olarak) yeni bir dizi döndürür.
32	array.flatten! Düzleştirir dizisi yerinde. Hiçbir değişiklik yapılmamışsa sıfır döndürür . (dizi alt dizi içermez.)
33	array.frozen? Dizi dondurulmuşsa (veya sıralanırken geçici olarak dondurulmuşsa) doğru döndürür .
34	array.hash Dizi için bir karma kod hesaplar. Aynı içeriğe sahip iki dizi aynı hash koduna sahip olacaktır.
35	array.include?(obj) Obj kendi içinde mevcutsa true , aksi takdirde false döndürür.
36	array.index(obj) Self içindeki ilk nesnenin == obj olan indeksini döndürür . Eşleşme bulunmazsa sıfır döndürür .
37	array.indexes(i1, i2, ... iN) [or] array.indices(i1, i2, ... iN) Bu yöntemler Ruby'nin en son sürümünde kullanımdan kaldırılmıştır, bu nedenle lütfen Array # values_at kullanın.
38	array.indices(i1, i2, ... iN) [or] array.indexes(i1, i2, ... iN) Bu yöntemler Ruby'nin en son sürümünde kullanımdan kaldırılmıştır, bu nedenle lütfen Array # values_at kullanın.
39	array.insert(index, obj...) Verilen dizine sahip öğenin önüne verilen değerleri ekler (negatif olabilir).
40	array.inspect Dizinin yazdırılabilir bir sürümünü oluşturur.
41	array.join(sep = $,) Dizinin her öğesini sep ile ayrılmış bir dizeye dönüştürerek oluşturulan bir dize döndürür .
42	array.last [or] array.last(n) Kendinin son elemanlarını verir . Dizi boşsa , ilk form nil değerini döndürür .
43	array.length Kendi içindeki öğelerin sayısını verir . Sıfır olabilir.
44	array.map { |item| block } [or] array.collect { |item| block } Benliğin her bir öğesi için bir kez blok çağırır . Blok tarafından döndürülen değerleri içeren yeni bir dizi oluşturur .
45	array.map! { |item| block } [or] array.collect! { |item| block } Dizinin her öğesi için bloğu bir kez çağırır , öğeyi blok tarafından döndürülen değerle değiştirir.
46	array.nitems Kendi içindeki sıfır olmayan öğelerin sayısını döndürür . Sıfır olabilir.
47	array.pack(aTemplateString) Dizinin içeriğini bir TemplateString'deki yönergelere göre ikili bir sıraya paketler. A, a ve Z direktiflerinin ardından, ortaya çıkan alanın genişliğini veren bir sayı gelebilir. Kalan yönergeler de dönüştürülecek dizi öğelerinin sayısını gösteren bir sayım alabilir. Sayı bir yıldız işaretiyse (*), kalan tüm dizi öğeleri dönüştürülür. Belirtilen tür için temel platformun yerel boyutunu kullanmak için yönergelerden herhangi birinin ardından bir alt çizgi (_) gelebilir; aksi takdirde, platformdan bağımsız bir boyut kullanırlar. Şablon dizesinde boşluklar yok sayılır.
48	array.pop Son öğesini kaldırır dizisi ve getiri o ya da sıfır ise dizi boştur.
49	array.push(obj, ...) Verilen nesneyi bu dizinin sonuna iter (ekler). Bu ifade dizinin kendisini döndürür, bu nedenle birkaç uzantı birbirine zincirlenmiş olabilir.
50	array.rassoc(key) Elemanları aynı zamanda dizi olan dizi içinde arama yapar. Karşılaştırır anahtar == kullanarak her bir alan dizinin ikinci elemanı. Eşleşen ilk içerilen diziyi döndürür.
51	array.reject { |item| block } Öğe içeren yeni bir dizi döndürür dizi blok olmadığı için geçerlidir .
52	array.reject! { |item| block } Bloğun kendisi için doğru olarak değerlendirildiği diziden öğeleri siler , ancak hiçbir değişiklik yapılmadıysa sıfır döndürür . Array # delete_if ile eşdeğerdir.
53	array.replace(other_array) İçeriğini değiştirir dizinin içeriğiyle other_array kısaltılıyor veya gerekirse genişleyen.
54	array.reverse Dizinin öğelerini ters sırada içeren yeni bir dizi döndürür.
55	array.reverse! Diziyi yerinde ters çevirir .
56	array.reverse_each {|item| block } Her biri Array # ile aynıdır, ancak diziyi ters sırada dolaşır.
57	array.rindex(obj) Dizi == içindeki son nesnenin dizinini obj öğesine döndürür. Eşleşme bulunmazsa sıfır döndürür .
58	array.select {|item| block } Diziden ardışık öğelerden geçen bloğu çağırır ve bloğun gerçek bir değer döndürdüğü öğeleri içeren bir dizi döndürür .
59	array.shift Benliğin ilk öğesini döndürür ve onu kaldırır (diğer tüm öğeleri birer birer aşağı kaydırır). Dizi boşsa nil döndürür .
60	array.size Dizinin uzunluğunu (öğe sayısı) döndürür . Uzunluk için takma ad.
61	array.slice(index) [or] array.slice(start, length) [or] array.slice(range) [or] array[index] [or] array[start, length] [or] array[range] En İade elemanı indeksi veya döner bir altdizilim başlayan başlangıcı ve devam eden uzunluk elemanları veya belirlediği bir SubArray döndüren aralığında . Negatif indisler, dizinin sonundan geriye doğru sayılır (-1, son öğedir). İade nil eğer endeks (veya başlangıç indeks) aralığın dışında.
62	array.slice!(index) [or] array.slice!(start, length) [or] array.slice!(range) Bir dizin (isteğe bağlı olarak bir uzunluk ile) veya bir aralık tarafından verilen öğeleri siler . İade silinen nesne, altdizilim veya nil eğer endeks aralık dışında.
63	array.sort [or] array.sort { | a,b | block } Self sıralamasıyla oluşturulan yeni bir dizi döndürür.
64	array.sort! [or] array.sort! { | a,b | block } Kendini sıralar.
65	array.to_a Kendini döndürür . Array alt sınıfında çağrılırsa , alıcıyı bir Array nesnesine dönüştürür.
66	array.to_ary Kendini döndürür.
67	array.to_s Self.join döndürür.
68	array.transpose Self'in bir dizi dizisi olduğunu ve satırların ve sütunların yerini değiştirdiğini varsayar.
69	array.uniq Yinelenen değerleri atarak yeni dizi döndürür dizisi .
70	array.uniq! Yinelenen öğeleri kendinden kaldırır . Hiçbir değişiklik yapılmazsa (yani kopya bulunmazsa) sıfır döndürür .
71	array.unshift(obj, ...) Nesneleri dizinin önüne, diğer öğeleri bir yukarıya ekler.
72	array.values_at(selector,...) Verilen seçiciye (bir veya daha fazla) karşılık gelen kendi içindeki öğeleri içeren bir dizi döndürür . Seçiciler, tamsayı endeksleri veya aralıklar olabilir.
73	array.zip(arg, ...) [or] array.zip(arg, ...){ | arr | block } Herhangi bir argümanı dizilere dönüştürür, ardından dizi öğelerini her argümandan karşılık gelen öğelerle birleştirir .

Dizi paketi yönergeleri

Aşağıdaki tablo, Array # paketi ile kullanılacak paket direktiflerini listeler.

Sr.No.	Yönerge ve Açıklama
1	@ Mutlak konuma geçer.
2	A ASCII dizesi (boşluk doldurulmuş, sayı genişliktir).
3	a ASCII dizesi (boş doldurulmuş, sayı genişliktir).
4	B string (azalan bit sırası).
5	b Bit dizesi (artan bit sırası).
6	C İmzasız karakter.
7	c Char.
8	D, d Çift hassasiyetli kayan nokta, yerel format.
9	E Çift duyarlıklı kayan nokta, küçük endian bayt sırası.
10	e Tek duyarlıklı kayan nokta, küçük endian bayt sırası.
11	F, f Tek duyarlıklı kayan nokta, yerel biçim.
12	G Çift duyarlıklı kayan nokta, ağ (büyük endian) bayt sırası.
13	g Tek duyarlıklı kayan nokta, ağ (büyük endian) bayt sırası.
14	H Hex string (önce yüksek yarım bayt).
15	h Hex string (önce düşük yarım bayt).
16	I İşaretsiz tam sayı.
17	i Tamsayı.
18	L İmzasız uzun.
19	l Uzun.
20	M Yazdırılabilir alıntı, MIME kodlaması (bkz. RFC 2045).
21	m Base64 ile kodlanmış dize.
22	N Uzun, ağ (big-endian) bayt sırası.
23	n Kısa, ağ (büyük endian) bayt sırası.
24	P Bir yapının işaretçisi (sabit uzunluklu dizge).
25	p Boş sonlu bir dizeye işaretçi.
26	Q, q 64 bitlik sayı.
27	S İmzasız kısa.
28	s Kısa.
29	U UTF-8.
30	u UU kodlu dize.
31	V Uzun, küçük endian bayt sırası.
32	v Kısa, küçük endian bayt sırası.
33	w BER ile sıkıştırılmış tamsayı \ fnm.
34	X Bir bayt yedekleyin.
35	x Boş bayt.
36	Z Null değerinin * ile eklenmesi dışında a ile aynıdır.

Misal

Çeşitli verileri paketlemek için aşağıdaki örneği deneyin.

a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
puts a.pack("A3A3A3")   #=> "a  b  c  "
puts a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
puts n.pack("ccc")      #=> "ABC"

Bu, aşağıdaki sonucu verecektir -

a  b  c
abc
ABC

Hash, şuna benzer anahtar / değer çiftlerinin bir koleksiyonudur: "Employee" => "maaş". Dizin oluşturma işleminin bir tamsayı dizini ile değil, herhangi bir nesne türünün keyfi anahtarları aracılığıyla yapılması dışında, bir Dizi'ye benzer.

Bir hash'i anahtar veya değer ile geçirdiğiniz sıra rastgele görünebilir ve genellikle ekleme sırasında olmayacaktır. Var olmayan bir anahtarla bir karmaya erişmeye çalışırsanız, yöntem sıfır döndürür .

Hash Oluşturma

Dizilerde olduğu gibi, karmalar oluşturmanın çeşitli yolları vardır. Yeni sınıf yöntemiyle boş bir hash oluşturabilirsiniz -

months = Hash.new

Ayrıca kullanabilirsiniz yeni aksi takdirde sadece bir varsayılan değer ile bir karma oluşturmak için nil -

months = Hash.new( "month" )

or

months = Hash.new "month"

Varsayılan bir değeri olan bir karma içindeki herhangi bir anahtara eriştiğinizde, anahtar veya değer yoksa, karmaya erişmek varsayılan değeri döndürür -

#!/usr/bin/ruby

months = Hash.new( "month" )

puts "#{months[0]}"
puts "#{months[72]}"

Bu, aşağıdaki sonucu verecektir -

month
month

#!/usr/bin/ruby

H = Hash["a" => 100, "b" => 200]

puts "#{H['a']}"
puts "#{H['b']}"

Bu, aşağıdaki sonucu verecektir -

100
200

Herhangi bir Ruby nesnesini bir anahtar veya değer, hatta bir dizi olarak kullanabilirsiniz, bu nedenle aşağıdaki örnek geçerli bir örnektir -

[1,"jan"] => "January"

Hash Yerleşik Yöntemleri

Bir Hash yöntemini çağırmak için Hash nesnesinin bir örneğine ihtiyacımız var. Gördüğümüz gibi, Hash nesnesinin bir örneğini oluşturmanın yolu aşağıdadır -

Hash[[key =>|, value]* ] or

Hash.new [or] Hash.new(obj) [or]
Hash.new { |hash, key| block }

Bu, verilen nesnelerle doldurulmuş yeni bir hash döndürecektir. Şimdi oluşturulan nesneyi kullanarak, mevcut herhangi bir örnek yöntemini çağırabiliriz. Örneğin -

#!/usr/bin/ruby

$, = ", "
months = Hash.new( "month" )
months = {"1" => "January", "2" => "February"}

keys = months.keys
puts "#{keys}"

Bu, aşağıdaki sonucu verecektir -

["1", "2"]

Kamu karma yöntemleri aşağıda (varsayarak karma bir dizi amacı,) -

Sr.No.	Yöntemler ve Açıklama
1	hash == other_hash Aynı sayıda anahtar / değer çiftine sahip olup olmadıklarına ve anahtar / değer çiftlerinin her karmadaki karşılık gelen çiftle eşleşip eşleşmediğine bağlı olarak iki karmanın eşit olup olmadığını test eder.
2	hash.[key] Bir anahtar kullanarak, hash'den bir değere başvurur. Anahtar bulunmazsa, varsayılan bir değer döndürür.
3	hash.[key] = value Değer tarafından verilen değeri , anahtar tarafından verilen anahtarla ilişkilendirir .
4	hash.clear Tüm anahtar / değer çiftlerini hash'den kaldırır.
5	hash.default(key = nil) Varsayılan olarak ayarlanmamışsa, karma için varsayılan değeri , nil döndürür =. (Anahtar içinde mevcut değilse [], bir varsayılan değeri geri gönderir karma ).
6	hash.default = obj Karma için varsayılan bir değer ayarlar .
7	hash.default_proc Hash bir blok tarafından oluşturulmuşsa bir blok döndürür .
8	hash.delete(key) [or] array.delete(key) { |key| block } Bir anahtar-değer çifti siler karma göre anahtar . Blok kullanılıyorsa, çift bulunamazsa bir bloğun sonucunu döndürür. Delete_if ile karşılaştırın .
9	hash.delete_if { |key,value| block } Bir anahtar-değer çifti siler karma her bir çift blok değerlendirir için geçerlidir .
10	hash.each { |key,value| block } Karma üzerinde yineler , bloğu her anahtar için bir kez çağırır, anahtar / değer çiftini iki öğeli bir dizi olarak iletir.
11	hash.each_key { |key| block } Karma üzerinde yineler , bloğu her anahtar için bir kez çağırır ve anahtarı parametre olarak iletir.
12	hash.each_key { |key_value_array| block } Karma üzerinde yineler , bloğu her anahtar için bir kez çağırır , anahtarı ve değeri parametre olarak iletir.
13	hash.each_key { |value| block } Yineler karma , her biri için bir kez blok çağrı anahtar , geçen değer , bir parametre olarak.
14	hash.empty? Karmanın boş olup olmadığını (anahtar / değer çifti içermediğini) test eder, doğru veya yanlış döndürür .
15	hash.fetch(key [, default] ) [or] hash.fetch(key) { | key | block } Verilen anahtar için karma değerden bir değer döndürür . Eğer anahtar bulundu ve başka hiçbir argüman bulunmadığını edilemez, bir yükseltir IndexError istisna; eğer varsayılan verilir, bu döndürülür; isteğe bağlı blok belirtilirse, sonucu döndürülür.
16	hash.has_key?(key) [or] hash.include?(key) [or] hash.key?(key) [or] hash.member?(key) Verilen bir anahtarın karma olarak mevcut olup olmadığını test eder , doğru mu yanlış mı döndürür .
17	hash.has_value?(value) Hash'in verilen değeri içerip içermediğini test eder .
18	hash.index(value) Eşleşen bir değer bulunmazsa , verilen değer için anahtarı karma, nil olarak döndürür .
19	hash.indexes(keys) Verilen anahtarlar için değerlerden oluşan yeni bir dizi döndürür. Bulunamayan anahtarlar için varsayılan değeri ekler. Bu yöntem kullanımdan kaldırılmıştır. Seçimi kullanın.
20	hash.indices(keys) Verilen anahtarlar için değerlerden oluşan yeni bir dizi döndürür. Bulunamayan anahtarlar için varsayılan değeri ekler. Bu yöntem kullanımdan kaldırılmıştır. Seçimi kullanın.
21	hash.inspect Hash'in oldukça basılmış bir dize versiyonunu döndürür.
22	hash.invert Yeni bir oluşturur karma tersini, anahtarlar ve değerler gelen karma ; olduğunu, yeni karma, gelen anahtarlar karma haline değerler ve değerler tuşları olurlar.
23	hash.keys Dan tuşları ile yeni bir dizi oluşturur karma .
24	hash.length Boyutunu veya uzunluğunu döndürür karma bir tam sayı olarak.
25	hash.merge(other_hash) [or] hash.merge(other_hash) { |key, oldval, newval| block } Hash ve other_hash içeriklerini içeren yeni bir hash döndürür , diger_hash'ten gelen anahtarlar ile hash içindeki çiftlerin üzerine yazılır .
26	hash.merge!(other_hash) [or] hash.merge!(other_hash) { |key, oldval, newval| block } Birleştirme ile aynıdır, ancak değişiklikler yerinde yapılır.
27	hash.rehash Yeniden Yapıyor karma her biri için geçerli değerlere dayalı tuşu . Değerler eklendikten sonra değiştiyse, bu yöntem hash'i yeniden dizine ekler .
28	hash.reject { |key, value| block } Bloğun doğru olarak değerlendirdiği her çift için yeni bir hash oluşturur
29	hash.reject! { |key, value| block } Reddetmeyle aynı , ancak yerinde değişiklikler yapılır.
30	hash.replace(other_hash) İçeriğini değiştirir karma içeriğiyle other_hash .
31	hash.select { |key, value| block } İade anahtar değer çifti aşağıdakilerden oluşan yeni bir dizi karma olan blok döner doğru .
32	hash.shift Bir anahtar-değer çifti kaldırır karma iki öğeli bir dizi olarak dönen.
33	hash.size İade boyutu ya da uzunluğunu karma bir tam sayı olarak.
34	hash.sort Dönüştürür karma anahtar değer çiftleri dizileri içeren bir iki boyutlu dizi, daha sonra bir dizi olarak sıralar.
35	hash.store(key, value) Bir anahtar / değer çiftini karma biçiminde saklar .
36	hash.to_a Hash'ten iki boyutlu bir dizi oluşturur. Her anahtar / değer çifti bir diziye dönüştürülür ve tüm bu diziler içeren bir dizide saklanır.
37	hash.to_hash Hash (self) döndürür .
38	hash.to_s Dönüştürür karma bir dizi, daha sonra bir dizeye bu diziyi dönüştürür.
39	hash.update(other_hash) [or] hash.update(other_hash) {|key, oldval, newval| block} İçeriğini içeren yeni karma döndürür karma ve other_hash de, üzerine yazılmasını çiftleri karma gelenler ile yinelenen anahtarlar ile other_hash .
40	hash.value?(value) Test eder karma verilen içeren bir değer .
41	hash.values Tüm hash değerlerini içeren yeni bir dizi döndürür .
42	hash.values_at(obj, ...) Verilen anahtar veya anahtarlarla ilişkili karma değerlerinden değerleri içeren yeni bir dizi döndürür .

Timeclass, Ruby'deki tarihleri ​​ve saatleri temsil eder. İşletim sistemi tarafından sağlanan sistem tarih ve saat işlevselliği üzerinde ince bir katmandır. Bu sınıf, sisteminizde 1970'den önceki veya 2038'den sonraki tarihleri ​​temsil edemeyebilir.

Bu bölüm sizi en çok aranan tarih ve saat kavramlarına aşina hale getirir.

Güncel Tarih ve Saati Alma

Geçerli tarih ve saati almak için basit bir örnek aşağıdadır -

#!/usr/bin/ruby -w

time1 = Time.new
puts "Current Time : " + time1.inspect

# Time.now is a synonym:
time2 = Time.now
puts "Current Time : " + time2.inspect

Bu, aşağıdaki sonucu verecektir -

Current Time : Mon Jun 02 12:02:39 -0700 2008
Current Time : Mon Jun 02 12:02:39 -0700 2008

Tarih ve Saatin Bileşenlerini Alma

Tarih ve saatin çeşitli bileşenlerini elde etmek için Time nesnesini kullanabiliriz . Aynı şeyi gösteren örnek aşağıdadır -

#!/usr/bin/ruby -w

time = Time.new

# Components of a Time
puts "Current Time : " + time.inspect
puts time.year    # => Year of the date 
puts time.month   # => Month of the date (1 to 12)
puts time.day     # => Day of the date (1 to 31 )
puts time.wday    # => 0: Day of week: 0 is Sunday
puts time.yday    # => 365: Day of year
puts time.hour    # => 23: 24-hour clock
puts time.min     # => 59
puts time.sec     # => 59
puts time.usec    # => 999999: microseconds
puts time.zone    # => "UTC": timezone name

Bu, aşağıdaki sonucu verecektir -

Current Time : Mon Jun 02 12:03:08 -0700 2008
2008
6
2
1
154
12
3
8
247476
UTC

Time.utc, Time.gm ve Time.local İşlevleri

Bu iki işlev, tarihi aşağıdaki gibi standart bir biçimde biçimlendirmek için kullanılabilir -

# July 8, 2008
Time.local(2008, 7, 8)  
# July 8, 2008, 09:10am, local time
Time.local(2008, 7, 8, 9, 10)   
# July 8, 2008, 09:10 UTC
Time.utc(2008, 7, 8, 9, 10)  
# July 8, 2008, 09:10:11 GMT (same as UTC)
Time.gm(2008, 7, 8, 9, 10, 11)

Aşağıda, bir dizideki tüm bileşenleri aşağıdaki biçimde almak için örnek verilmiştir -

[sec,min,hour,day,month,year,wday,yday,isdst,zone]

Aşağıdakileri deneyin -

#!/usr/bin/ruby -w

time = Time.new
values = time.to_a
p values

Bu, aşağıdaki sonucu oluşturacaktır -

[26, 10, 12, 2, 6, 2008, 1, 154, false, "MST"]

Bu dizi , aşağıdaki gibi farklı tarih biçimleri elde etmek için Time.utc veya Time.local işlevlerine geçirilebilir -

#!/usr/bin/ruby -w

time = Time.new
values = time.to_a
puts Time.utc(*values)

Bu, aşağıdaki sonucu oluşturacaktır -

Mon Jun 02 12:15:36 UTC 2008

Aşağıda, (platforma bağlı) dönemden bu yana dahili olarak saniye olarak temsil edilen zamanı almanın yolu -

# Returns number of seconds since epoch
time = Time.now.to_i  

# Convert number of seconds into Time object.
Time.at(time)

# Returns second since epoch which includes microseconds
time = Time.now.to_f

Saat Dilimleri ve Yaz Saati Uygulaması

Saat dilimleri ve gün ışığından yararlanma ile ilgili tüm bilgileri aşağıdaki gibi almak için bir Saat nesnesi kullanabilirsiniz -

time = Time.new

# Here is the interpretation
time.zone       # => "UTC": return the timezone
time.utc_offset # => 0: UTC is 0 seconds offset from UTC
time.zone       # => "PST" (or whatever your timezone is)
time.isdst      # => false: If UTC does not have DST.
time.utc?       # => true: if t is in UTC time zone
time.localtime  # Convert to local timezone.
time.gmtime     # Convert back to UTC.
time.getlocal   # Return a new Time object in local zone
time.getutc     # Return a new Time object in UTC

Saatleri ve Tarihleri ​​Biçimlendirme

Tarih ve saati biçimlendirmenin çeşitli yolları vardır. İşte birkaçını gösteren bir örnek -

#!/usr/bin/ruby -w

time = Time.new
puts time.to_s
puts time.ctime
puts time.localtime
puts time.strftime("%Y-%m-%d %H:%M:%S")

Bu, aşağıdaki sonucu verecektir -

Mon Jun 02 12:35:19 -0700 2008
Mon Jun  2 12:35:19 2008
Mon Jun 02 12:35:19 -0700 2008
2008-06-02 12:35:19

Zaman Biçimlendirme Direktifleri

Aşağıdaki tablodaki bu yönergeler Time.strftime yöntemiyle kullanılır .

Sr.No.	Yönerge ve Açıklama
1	%a Kısaltılmış hafta içi adı (Paz).
2	%A Tam gün adı (Pazar).
3	%b Kısaltılmış ay adı (Jan).
4	%B Tam ay adı (Ocak).
5	%c Tercih edilen yerel tarih ve saat gösterimi.
6	%d Ayın günü (01 - 31).
7	%H Günün saati, 24 saatlik zaman biçimi (00-23).
8	%I Günün saati, 12 saatlik zaman (01 - 12).
9	%j Yılın günü (001 - 366).
10	%m Yılın ayı (01 - 12).
11	%M Saatin dakikası (00 ila 59).
12	%p Meridyen göstergesi (AM veya PM).
13	%S Dakikanın saniyesi (00 - 60).
14	%U İlk haftanın ilk günü olarak ilk Pazar gününden başlayarak geçerli yılın hafta numarası (00 - 53).
15	%W Mevcut yılın hafta numarası, ilk haftanın ilk günü olan ilk Pazartesi ile başlar (00 - 53).
16	%w Haftanın günü (Pazar 0, 0 - 6).
17	%x Yalnızca tarih için tercih edilen temsil, zaman yok.
18	%X Yalnızca zaman için tercih edilen temsil, tarih yok.
19	%y Yüzyılı olmayan yıl (00 - 99).
20	%Y Yüzyıl.
21	%Z Saat dilimi adı.
22	%% Değişmez% karakteri.

Zaman Aritmetiği

Zamanla basit aritmetik işlemleri aşağıdaki gibi gerçekleştirebilirsiniz -

now = Time.now          # Current time
puts now

past = now - 10         # 10 seconds ago. Time - number => Time
puts past

future = now + 10  # 10 seconds from now Time + number => Time
puts future

diff = future - past     # => 10  Time - Time => number of seconds
puts diff

Bu, aşağıdaki sonucu verecektir -

Thu Aug 01 20:57:05 -0700 2013
Thu Aug 01 20:56:55 -0700 2013
Thu Aug 01 20:57:15 -0700 2013
20.0

Aralıklar her yerde görülür: Ocak - Aralık, 0 - 9, 50 - 67 arası satırlar vb. Ruby aralıkları destekler ve aralıkları çeşitli şekillerde kullanmamıza izin verir -

• Diziler Olarak Aralıklar
• Koşullar Olarak Aralıklar
• Aralıklar Olarak Aralıklar

Diziler Olarak Aralıklar

Aralıkların ilk ve belki de en doğal kullanımı bir diziyi ifade etmektir. Dizilerin bir başlangıç ​​noktası, bir bitiş noktası ve dizide ardışık değerler üretme yolu vardır.

Ruby bu dizileri, ''..'' ve ''...''menzil operatörleri. İki noktalı form, kapsayıcı bir aralık oluştururken, üç noktalı form, belirtilen yüksek değeri hariç tutan bir aralık oluşturur.

(1..5)        #==> 1, 2, 3, 4, 5
(1...5)       #==> 1, 2, 3, 4
('a'..'d')    #==> 'a', 'b', 'c', 'd'

1..100 dizisi , iki Fixnum nesnesine referanslar içeren bir Range nesnesi olarak tutulur . Gerekirse, bir aralığı to_a yöntemini kullanarak listeye dönüştürebilirsiniz . Aşağıdaki örneği deneyin -

#!/usr/bin/ruby

$, =", "   # Array value separator
range1 = (1..10).to_a
range2 = ('bar'..'bat').to_a

puts "#{range1}"
puts "#{range2}"

Bu, aşağıdaki sonucu verecektir -

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
["bar", "bas", "bat"]

Aralıklar, üzerlerinde yineleme yapmanıza ve içeriklerini çeşitli şekillerde test etmenize olanak tanıyan yöntemler uygular -

#!/usr/bin/ruby

# Assume a range
digits = 0..9

puts digits.include?(5)
ret = digits.min
puts "Min value is #{ret}"

ret = digits.max
puts "Max value is #{ret}"

ret = digits.reject {|i| i < 5 }
puts "Rejected values are #{ret}"

digits.each do |digit|
   puts "In Loop #{digit}"
end

Bu, aşağıdaki sonucu verecektir -

true
Min value is 0
Max value is 9
Rejected values are 5, 6, 7, 8, 9
In Loop 0
In Loop 1
In Loop 2
In Loop 3
In Loop 4
In Loop 5
In Loop 6
In Loop 7
In Loop 8
In Loop 9

Koşullar Olarak Aralıklar

Aralıklar, koşullu ifadeler olarak da kullanılabilir. Örneğin, aşağıdaki kod parçası, standart girdiden satır kümelerini yazdırır; burada her kümedeki ilk satır, sözcüğün başlangıcını ve sözcüğün bittiği son satırı içerir -

while gets
   print if /start/../end/
end

Aralıklar, durum ifadelerinde kullanılabilir -

#!/usr/bin/ruby

score = 70

result = case score
   when 0..40 then "Fail"
   when 41..60 then "Pass"
   when 61..70 then "Pass with Merit"
   when 71..100 then "Pass with Distinction"
   else "Invalid Score"
end

puts result

Bu, aşağıdaki sonucu verecektir -

Pass with Merit

Aralıklar Olarak Aralıklar

Çok yönlü aralığın son bir kullanımı, aralık testidir: bazı değerlerin, aralık tarafından temsil edilen aralık dahilinde olup olmadığının görülmesi. Bu, durum eşitliği operatörü olan === kullanılarak yapılır.

#!/usr/bin/ruby

if ((1..10) === 5)
   puts "5 lies in (1..10)"
end

if (('a'..'j') === 'c')
   puts "c lies in ('a'..'j')"
end

if (('a'..'j') === 'z')
   puts "z lies in ('a'..'j')"
end

Bu, aşağıdaki sonucu verecektir -

5 lies in (1..10)
c lies in ('a'..'j')

Yineleyiciler, koleksiyonlar tarafından desteklenen yöntemlerden başka bir şey değildir . Bir grup veri üyesini depolayan nesnelere koleksiyon adı verilir. Ruby'de diziler ve karmalar koleksiyonlar olarak adlandırılabilir.

Yineleyiciler, bir koleksiyonun tüm öğelerini birbiri ardına döndürür. Burada, her biri ve toplanan iki yineleyiciyi tartışacağız . Bunlara detaylı bir şekilde bakalım.

Her Yineleyici Ruby

Her yineleyici, bir dizinin veya karmanın tüm öğelerini döndürür.

Sözdizimi

collection.each do |variable|
   code
end

Koleksiyondaki her öğe için kodu yürütür . Burada koleksiyon bir dizi veya yakut karması olabilir.

Misal

#!/usr/bin/ruby

ary = [1,2,3,4,5]
ary.each do |i|
   puts i
end

Bu, aşağıdaki sonucu verecektir -

1
2
3
4
5

Her yineleyiciyi her zaman bir blokla ilişkilendirirsiniz. Dizinin her değerini tek tek bloğa döndürür. Değer değişkende saklanıri ve sonra ekranda görüntülenir.

Ruby toplama Yineleyicisi

Toplamak yineleyici döndürür bir koleksiyonun tüm unsurları.

Sözdizimi

collection = collection.collect

Toplamak yöntem her zaman bloğu ile ilişkili olması gerekmez. Toplamak yöntem ne olursa olsun bir dizi ya da bir karma olmasına bakılmaksızın, tüm koleksiyonu döndürür.

Misal

#!/usr/bin/ruby

a = [1,2,3,4,5]
b = Array.new
b = a.collect
puts b

Bu, aşağıdaki sonucu verecektir -

1
2
3
4
5

NOTE- Collect yöntemi, diziler arasında kopyalama yapmanın doğru yolu değildir. Bir diziyi başka bir diziye kopyalamak için kullanılması gereken klon adı verilen başka bir yöntem vardır .

Yeni diziyi elde etmek için değerlerin her biriyle bir şeyler yapmak istediğinizde normalde toplama yöntemini kullanırsınız. Örneğin, bu kod, bir dizi üreten b 10 kez her değer içeren bir .

#!/usr/bin/ruby

a = [1,2,3,4,5]
b = a.collect{|x| 10*x}
puts b

Bu, aşağıdaki sonucu verecektir -

10
20
30
40
50

Ruby, Kernel modülünde uygulanan G / Ç ile ilgili bir dizi yöntem sağlar. Tüm G / Ç yöntemleri, sınıf IO'dan türetilmiştir.

Sınıf IO , okuma, yazma, alır, koyar, readline, getc ve printf gibi tüm temel yöntemleri sağlar .

Bu bölüm, Ruby'de bulunan tüm temel I / O işlevlerini kapsayacaktır. Daha fazla işlev için lütfen Ruby Class IO'ya bakın .

Puts İfadesi

Önceki bölümlerde, değişkenlere değerler atadınız ve ardından çıktıyı puts deyimini kullanarak yazdırdınız .

Koyar deyim değişken saklanan değeri görüntülemek için programı talimatını verir. Bu, yazdığı her satırın sonuna yeni bir satır ekleyecektir.

Misal

#!/usr/bin/ruby

val1 = "This is variable one"
val2 = "This is variable two"
puts val1
puts val2

Bu, aşağıdaki sonucu verecektir -

This is variable one
This is variable two

Gets İfadesi

Alır açıklamada STDIN adlandırılan standart ekrandan kullanıcıdan herhangi bir giriş almak için kullanılabilir.

Misal

Aşağıdaki kod, gets ifadesinin nasıl kullanılacağını gösterir. Bu kod, kullanıcıdan bir değer girmesini isteyecek ve bu değer bir değişken val'de saklanacak ve sonunda STDOUT'a yazdırılacaktır.

#!/usr/bin/ruby

puts "Enter a value :"
val = gets
puts val

Bu, aşağıdaki sonucu verecektir -

Enter a value :
This is entered value
This is entered value

Putc Bildirimi

Tüm dizgeyi ekrana çıkaran puts ifadesinin aksine, putc ifadesi her seferinde bir karakter çıktı vermek için kullanılabilir.

Misal

Aşağıdaki kodun çıktısı sadece H karakteridir -

#!/usr/bin/ruby

str = "Hello Ruby!"
putc str

Bu, aşağıdaki sonucu verecektir -

H

Baskı Beyanı

Baskı deyimi benzer koyar açıklamada. Tek fark, puts ifadesinin içeriği yazdırdıktan sonra bir sonraki satıra gitmesidir, oysa print ifadesi ile imleç aynı satıra yerleştirilir.

Misal

#!/usr/bin/ruby

print "Hello World"
print "Good Morning"

Bu, aşağıdaki sonucu verecektir -

Hello WorldGood Morning

Dosyaları Açma ve Kapatma

Şimdiye kadar, standart girdi ve çıktıyı okuyup yazıyordunuz. Şimdi, gerçek veri dosyalarıyla nasıl oynanacağını göreceğiz.

File.new Yöntemi

Mod dizesine göre okumak, yazmak veya her ikisi için File.new yöntemini kullanarak bir File nesnesi oluşturabilirsiniz . Son olarak, bu dosyayı kapatmak için File.close yöntemini kullanabilirsiniz .

Sözdizimi

aFile = File.new("filename", "mode")
   # ... process the file
aFile.close

File.open Yöntemi

Yeni bir dosya nesnesi oluşturmak ve bu dosya nesnesini bir dosyaya atamak için File.open yöntemini kullanabilirsiniz . Ancak, File.open ve File.new yöntemleri arasında bir fark vardır . Aradaki fark, File.open yönteminin bir blokla ilişkilendirilebilirken, File.new yöntemini kullanarak aynısını yapamazsınız .

File.open("filename", "mode") do |aFile|
   # ... process the file
end

İşte bir Dosyayı açmanın Farklı Modlarının bir listesi -

Sr.No.	Modlar ve Açıklama
1	r Salt okunur mod. Dosya tanıtıcısı dosyanın başlangıcına yerleştirilir. Bu varsayılan moddur.
2	r+ Okuma-yazma modu. Dosya tanıtıcısı dosyanın başlangıcında olacaktır.
3	w Yalnızca yazma modu. Dosya varsa dosyanın üzerine yazar. Dosya yoksa, yazmak için yeni bir dosya oluşturur.
4	w+ Okuma-yazma modu. Dosya varsa mevcut dosyanın üzerine yazar. Dosya yoksa, okumak ve yazmak için yeni bir dosya oluşturur.
5	a Yalnızca yazma modu. Dosya varsa, dosya işaretçisi dosyanın sonundadır. Yani dosya ekleme modundadır. Dosya yoksa, yazmak için yeni bir dosya oluşturur.
6	a+ Okuma ve yazma modu. Dosya varsa, dosya işaretçisi dosyanın sonundadır. Dosya, ekleme modunda açılır. Dosya yoksa, okuma ve yazma için yeni bir dosya oluşturur.

Dosyaları Okuma ve Yazma

'Basit' G / Ç için kullandığımız yöntemlerin aynısı tüm dosya nesneleri için mevcuttur. Yani, standart girdiden bir satırı okur ve aFile.gets , aFile dosya nesnesinden bir satır okur.

Bununla birlikte, G / Ç nesneleri hayatımızı kolaylaştırmak için ek erişim yöntemleri kümesi sağlar.

Sysread Yöntemi

Bir dosyanın içeriğini okumak için sysread yöntemini kullanabilirsiniz . Sysread yöntemini kullanırken dosyayı herhangi bir modda açabilirsiniz. Örneğin -

Giriş metin dosyası aşağıdadır -

This is a simple text file for testing purpose.

Şimdi bu dosyayı okumaya çalışalım -

#!/usr/bin/ruby

aFile = File.new("input.txt", "r")
if aFile
   content = aFile.sysread(20)
   puts content
else
   puts "Unable to open file!"
end

Bu ifade, dosyanın ilk 20 karakterini çıkaracaktır. Dosya işaretçisi şimdi dosyadaki 21. karaktere yerleştirilecektir.

Syswrite Yöntemi

İçeriği bir dosyaya yazmak için syswrite yöntemini kullanabilirsiniz. Syswrite yöntemini kullanırken dosyayı yazma modunda açmanız gerekir. Örneğin -

#!/usr/bin/ruby

aFile = File.new("input.txt", "r+")
if aFile
   aFile.syswrite("ABCDEF")
else
   puts "Unable to open file!"
end

Bu ifade dosyaya "ABCDEF" yazacaktır.

Each_byte Yöntemi

Bu yöntem File sınıfına aittir . Each_byte yöntemi her zaman bir blokla ilişkilendirilir. Aşağıdaki kod örneğini düşünün -

#!/usr/bin/ruby

aFile = File.new("input.txt", "r+")
if aFile
   aFile.syswrite("ABCDEF")
   aFile.each_byte {|ch| putc ch; putc ?. }
else
   puts "Unable to open file!"
end

Karakterler ch değişkenine birer birer aktarılır ve ardından ekranda aşağıdaki gibi görüntülenir -

s. .a. .s.i.m.p.l.e. .t.e.x.t. .f.i.l.e. .f.o.r. .t.e.s.t.i.n.g. .p.u.r.p.o.s.e...
.
.

IO.readlines Yöntemi

Sınıf Dosya sınıfı IO bir alt sınıfıdır. Sınıf IO'nun ayrıca dosyaları işlemek için kullanılabilecek bazı yöntemleri vardır.

IO sınıfı yöntemlerinden biri IO.readlines'dır . Bu yöntem, dosyanın içeriğini satır satır döndürür. Aşağıdaki kod, IO.readlines yönteminin kullanımını görüntüler -

#!/usr/bin/ruby

arr = IO.readlines("input.txt")
puts arr[0]
puts arr[1]

Bu kodda, dizi değişkeni bir dizidir. İnput.txt dosyasının her satırı dizi dizisindeki bir öğe olacaktır. Bu nedenle, arr [0] ilk satırı, arr [1] ise dosyanın ikinci satırını içerecektir.

IO.foreach Yöntemi

Bu yöntem aynı zamanda satır satır çıktı verir. Yöntem arasındaki fark foreach ve yöntem readlines yöntem olup foreach bir blok ile ilişkilidir. Ancak, yöntem okuma satırlarının aksine, foreach yöntemi bir dizi döndürmez. Örneğin -

#!/usr/bin/ruby

IO.foreach("input.txt"){|block| puts block}

Bu kod, dosya testinin içeriğini satır satır değişken bloğa geçirecek ve ardından çıktı ekranda görüntülenecektir.

Dosyaları Yeniden Adlandırma ve Silme

Yeniden adlandırma ve silme yöntemleriyle dosyaları Ruby ile programlı olarak yeniden adlandırabilir ve silebilirsiniz .

Aşağıda, var olan bir dosyayı yeniden adlandırmak için örnek verilmiştir test1.txt -

#!/usr/bin/ruby

# Rename a file from test1.txt to test2.txt
File.rename( "test1.txt", "test2.txt" )

Mevcut bir test2.txt dosyasını silme örneği aşağıdadır -

#!/usr/bin/ruby

# Delete file test2.txt
File.delete("test2.txt")

Dosya Modları ve Sahiplik

Bir dosyanın modunu veya izinlerini / erişim listesini değiştirmek için chmod yöntemini bir maske ile kullanın -

Aşağıda, var olan bir test.txt dosyasının modunu bir maske değerine değiştirmek için örnek verilmiştir -

#!/usr/bin/ruby

file = File.new( "test.txt", "w" )
file.chmod( 0755 )

Chmod yöntemi için farklı maske seçmenize yardımcı olabilecek tablo aşağıdadır -

Sr.No.	Maske ve Açıklama
1	0700 sahibi için rwx maskesi
2	0400 sahibi için r
3	0200 w sahibi için
4	0100 sahibi için x
5	0070 grup için rwx maskesi
6	0040 grup için r
7	0020 w grubu için
8	0010 grup için x
9	0007 diğerleri için rwx maskesi
10	0004 diğerleri için r
11	0002 w diğeri için
12	0001 diğeri için x
13	4000 Yürütme sırasında kullanıcı kimliğini ayarlayın
14	2000 Yürütme sırasında grup kimliğini ayarlayın
15	1000 Değiştirilen metni kullandıktan sonra bile kaydedin

Dosya Sorguları

Aşağıdaki komut, açmadan önce bir dosyanın var olup olmadığını test eder -

#!/usr/bin/ruby

File.open("file.rb") if File::exists?( "file.rb" )

Aşağıdaki komut, dosyanın gerçekten bir dosya olup olmadığını sorgular -

#!/usr/bin/ruby

# This returns either true or false
File.file?( "text.txt" )

Aşağıdaki komut, verilen dosya adının bir dizin olup olmadığını bulur -

#!/usr/bin/ruby

# a directory
File::directory?( "/usr/local/bin" ) # => true

# a file
File::directory?( "file.rb" ) # => false

Aşağıdaki komut dosyanın okunabilir mi, yazılabilir mi yoksa yürütülebilir mi olduğunu bulur -

#!/usr/bin/ruby

File.readable?( "test.txt" )   # => true
File.writable?( "test.txt" )   # => true
File.executable?( "test.txt" ) # => false

Aşağıdaki komut dosyanın boyutunun sıfır olup olmadığını bulur -

#!/usr/bin/ruby

File.zero?( "test.txt" )      # => true

Aşağıdaki komut dosyanın boyutunu döndürür -

#!/usr/bin/ruby

File.size?( "text.txt" )     # => 1002

Aşağıdaki komut, bir dosya türünü bulmak için kullanılabilir -

#!/usr/bin/ruby

File::ftype( "test.txt" )     # => file

Ftype yöntemi , dosya, dizin, characterSpecial, blockSpecial, fifo, bağlantı, soket veya bilinmeyenlerden birini döndürerek dosyanın türünü tanımlar .

Aşağıdaki komut, bir dosyanın ne zaman oluşturulduğunu, değiştirildiğini veya en son ne zaman erişildiğini bulmak için kullanılabilir -

#!/usr/bin/ruby

File::ctime( "test.txt" ) # => Fri May 09 10:06:37 -0700 2008
File::mtime( "text.txt" ) # => Fri May 09 10:44:44 -0700 2008
File::atime( "text.txt" ) # => Fri May 09 10:45:01 -0700 2008

Ruby'de Dizinler

Tüm dosyalar çeşitli dizinlerde bulunur ve Ruby bunları işlemekte de sorun yaşamaz. Oysa Dosya sınıfı kolları dosyaları, dizinleri ile işlenir Dir sınıfında.

Dizinler Arasında Gezinme

Bir Ruby programı içindeki dizini değiştirmek için Dir.chdir'i aşağıdaki gibi kullanın . Bu örnek, mevcut dizini / usr / bin olarak değiştirir .

Dir.chdir("/usr/bin")

Dir.pwd ile mevcut dizinin ne olduğunu öğrenebilirsiniz -

puts Dir.pwd # This will return something like /usr/bin

Dizin girişlerini kullanarak belirli bir dizindeki dosyaların ve dizinlerin bir listesini alabilirsiniz -

puts Dir.entries("/usr/bin").join(' ')

Dir.entries , belirtilen dizindeki tüm girişleri içeren bir dizi döndürür. Dir.foreach aynı özelliği sağlar -

Dir.foreach("/usr/bin") do |entry|
   puts entry
end

Dizin listelerini almanın daha da kısa bir yolu, Dir'in sınıf dizi yöntemini kullanmaktır -

Dir["/usr/bin/*"]

Bir Dizin Oluşturma

Dir.mkdir dizinleri oluşturmak için kullanılabilir -

Dir.mkdir("mynewdir")

Ayrıca mkdir ile yeni bir dizinde (zaten var olan bir dizinde değil) izinleri ayarlayabilirsiniz -

NOTE - Maske 755 sahip, grup, dünya [herkes] izinlerini rwxr-xr-x'e ayarlar; burada r = okuma, w = yazma ve x = yürütme.

Dir.mkdir( "mynewdir", 755 )

Bir Dizini Silme

Dir.delete bir dizin silmek için kullanılabilir. Dir.unlink ve Dir.rmdir gerçekleştirir tam olarak aynı işlevi ve kullanım kolaylığı için temin edilmiştir.

Dir.delete("testdir")

Dosyalar ve Geçici Dizinler Oluşturma

Geçici dosyalar, bir programın yürütülmesi sırasında kısaca oluşturulabilen ancak kalıcı bir bilgi deposu olmayan dosyalardır.

Dir.tmpdir , yöntem varsayılan olarak kullanılamasa da, geçerli sistemdeki geçici dizinin yolunu sağlar. Dir.tmpdir'i kullanılabilir kılmak için gerekli 'tmpdir' kullanmak gerekir.

Sen kullanabilirsiniz Dir.tmpdir ile File.join bir platformdan bağımsız geçici dosya oluşturmak için -

require 'tmpdir'
   tempfilename = File.join(Dir.tmpdir, "tingtong")
   tempfile = File.new(tempfilename, "w")
   tempfile.puts "This is a temporary file"
   tempfile.close
   File.delete(tempfilename)

Bu kod, geçici bir dosya oluşturur, ona veri yazar ve onu siler. Ruby'nin standart kitaplığı ayrıca sizin için geçici dosyalar oluşturabilen Tempfile adlı bir kitaplık içerir -

require 'tempfile'
   f = Tempfile.new('tingtong')
   f.puts "Hello"
   puts f.path
   f.close

Yerleşik İşlevler

Dosyaları ve dizinleri işlemek için Ruby'nin yerleşik işlevleri şunlardır -

• Dosya Sınıfı ve Yöntemleri .

• Dir Sınıfı ve Yöntemleri .

İnfaz ve istisna her zaman birlikte yürür. Var olmayan bir dosyayı açıyorsanız, bu durumu düzgün bir şekilde ele almadıysanız, programınızın kalitesiz olduğu kabul edilir.

Bir istisna olursa program durur. Bu nedenle istisnalar, bir programın yürütülmesi sırasında meydana gelebilecek çeşitli türdeki hataları işlemek ve programı tamamen durdurmak yerine uygun eylemi gerçekleştirmek için kullanılır.

Ruby, istisnaları ele almak için güzel bir mekanizma sağlar. Bir başlangıç / bitiş bloğuna bir istisna oluşturabilecek kodu ekliyoruz ve Ruby'ye işlemek istediğimiz istisna türlerini söylemek için kurtarma cümlecikleri kullanıyoruz .

Sözdizimi

begin  
# -  
rescue OneTypeOfException  
# -  
rescue AnotherTypeOfException  
# -  
else  
# Other exceptions
ensure
# Always will be executed
end

Her şey başlamak için kurtarma korunur. Bu kod bloğunun yürütülmesi sırasında bir istisna meydana gelirse, kontrol, kurtarma ve sonlandırma arasında bloğa geçirilir .

Başlangıç bloğundaki her bir kurtarma cümlesi için Ruby, yükseltilmiş İstisnayı sırayla her bir parametre ile karşılaştırır. Rescue yan tümcesinde belirtilen istisna, o anda atılan istisnanın türüyle aynıysa veya bu istisnanın bir üst sınıfıysa, eşleşme başarılı olacaktır.

Bir istisnanın belirtilen hata türlerinden hiçbiriyle eşleşmemesi durumunda, tüm kurtarma maddelerinden sonra başka bir cümle kullanmamıza izin verilir .

Misal

#!/usr/bin/ruby

begin
   file = open("/unexistant_file")
   if file
      puts "File opened successfully"
   end
rescue
      file = STDIN
end
print file, "==", STDIN, "\n"

Bu, aşağıdaki sonucu verecektir. Bunu görebilirsiniz STDIN için ikame edilir dosyanın çünkü açık başarısız oldu.

#<IO:0xb7d16f84>==#<IO:0xb7d16f84>

Retry İfadesini kullanma

Sen kullanarak istisna yakalayabilir kurtarma blok ve ardından kullanım yeniden deneme yürütmek deyimi başlamak baştan bloğu.

Sözdizimi

begin
   # Exceptions raised by this code will 
   # be caught by the following rescue clause
rescue
   # This block will capture all types of exceptions
   retry  # This will move control to the beginning of begin
end

Misal

#!/usr/bin/ruby

begin
   file = open("/unexistant_file")
   if file
      puts "File opened successfully"
   end
rescue
   fname = "existant_file"
   retry
end

Aşağıdakiler sürecin akışıdır -

• Açılışta bir istisna oluştu.
• Kurtarmaya gitti. fname yeniden atandı.
• Yeniden deneme ile başlangıcın başına gitti.
• Bu zaman dosyası başarıyla açılır.
• Temel süreç devam etti.

NOTE- Yeniden değiştirilmiş ad dosyası yoksa, bu örnek kodun sonsuza kadar yeniden deneneceğine dikkat edin. İstisna süreci için yeniden denemeyi kullanırsanız dikkatli olun .

Yükseltme İfadesini Kullanma

Bir istisna oluşturmak için yükseltme ifadesini kullanabilirsiniz . Aşağıdaki yöntem her çağrıldığında bir istisna oluşturur. İkinci mesaj basılacaktır.

Sözdizimi

raise 

OR

raise "Error Message" 

OR

raise ExceptionType, "Error Message"

OR

raise ExceptionType, "Error Message" condition

İlk biçim, geçerli istisnayı (veya geçerli bir istisna yoksa bir RuntimeError hatası) yeniden yükseltir. Bu, bir istisnayı geçirmeden önce müdahale etmesi gereken istisna işleyicilerinde kullanılır.

İkinci form , mesajını verilen dizeye ayarlayarak yeni bir RuntimeError istisnası oluşturur . Bu istisna daha sonra çağrı yığınını yükseltir.

Üçüncü biçim, bir istisna oluşturmak için ilk bağımsız değişkeni kullanır ve ardından ilişkili mesajı ikinci bağımsız değişkene ayarlar.

Dördüncü formu üçüncü forma benzer ancak sizin gibi koşullu deyimi ekleyebilir sürece bir istisna yükseltmek.

Misal

#!/usr/bin/ruby

begin  
   puts 'I am before the raise.'  
   raise 'An error has occurred.'  
   puts 'I am after the raise.'  
rescue  
   puts 'I am rescued.'  
end  
puts 'I am after the begin block.'

Bu, aşağıdaki sonucu verecektir -

I am before the raise.  
I am rescued.  
I am after the begin block.

Kullanımını gösteren bir örneği daha zam -

#!/usr/bin/ruby

begin  
   raise 'A test exception.'  
rescue Exception => e  
   puts e.message  
   puts e.backtrace.inspect  
end

Bu, aşağıdaki sonucu verecektir -

A test exception.
["main.rb:4"]

Garantiyi kullanma

Bazen, istisna oluşturulmuş olup olmadığına bakılmaksızın, bir kod bloğunun sonunda bazı işlemlerin yapıldığını garanti etmeniz gerekir. Örneğin, bloğa girişte açık bir dosyanız olabilir ve blok çıkarken kapatıldığından emin olmanız gerekir.

Sağlamak fıkra sadece bunu yapar. sure son kurtarma cümlesinden sonra gelir ve blok sona erdiğinde her zaman çalıştırılacak bir kod yığını içerir. Bloğun normal şekilde çıkıp çıkmaması, bir istisnayı artırıp kurtarması veya yakalanmamış bir istisna ile sonlandırılması önemli değildir, garantiye alma bloğu çalışacaktır.

Sözdizimi

begin 
   #.. process 
   #..raise exception
rescue 
   #.. handle error 
ensure 
   #.. finally ensure execution
   #.. This will always execute.
end

Misal

begin
   raise 'A test exception.'
rescue Exception => e
   puts e.message
   puts e.backtrace.inspect
ensure
   puts "Ensuring execution"
end

Bu, aşağıdaki sonucu verecektir -

A test exception.
["main.rb:4"]
Ensuring execution

Else deyimini kullanma

Eğer başka hüküm mevcutsa, bu peşinden gider kurtarma maddeleri ve herhangi önce sağlamak .

Başka bir cümlenin gövdesi, yalnızca ana kod gövdesi tarafından herhangi bir istisna getirilmezse yürütülür.

Sözdizimi

begin 
   #.. process 
   #..raise exception
rescue 
   # .. handle error
else
   #.. executes if there is no exception
ensure 
   #.. finally ensure execution
   #.. This will always execute.
end

Misal

begin
   # raise 'A test exception.'
   puts "I'm not raising exception"
rescue Exception => e
   puts e.message
   puts e.backtrace.inspect
else
   puts "Congratulations-- no errors!"
ensure
   puts "Ensuring execution"
end

Bu, aşağıdaki sonucu verecektir -

I'm not raising exception
Congratulations-- no errors!
Ensuring execution

Hata mesajı $! Kullanılarak yakalanabilir. değişken.

Yakala ve At

Yükseltme ve kurtarmanın istisna mekanizması, işler ters gittiğinde yürütmeyi terk etmek için harika olsa da, bazen normal işlem sırasında derinlemesine iç içe geçmiş bir yapıdan atlayabilmek güzeldir. Bu, yakala ve atmanın işe yaradığı yerdir.

Mandalı (bir sembol veya bir String olabilir) adı verilen ile işaretlenmiş olan bir blok tanımlar. Blok, bir atışla karşılaşılıncaya kadar normal olarak yürütülür.

Sözdizimi

throw :lablename
#.. this will not be executed
catch :lablename do
#.. matching catch will be executed after a throw is encountered.
end

OR

throw :lablename condition
#.. this will not be executed
catch :lablename do
#.. matching catch will be executed after a throw is encountered.
end

Misal

Aşağıdaki örnek, '!' İse kullanıcıyla etkileşimi sonlandırmak için bir fırlatma kullanır. herhangi bir komut istemine yanıt olarak yazılır.

def promptAndGet(prompt)
   print prompt
   res = readline.chomp
   throw :quitRequested if res == "!"
   return res
end

catch :quitRequested do
   name = promptAndGet("Name: ")
   age = promptAndGet("Age: ")
   sex = promptAndGet("Sex: ")
   # ..
   # process information
end
promptAndGet("Name:")

Yukarıdaki programı makinenizde denemelisiniz çünkü manuel etkileşim gerektiriyor. Bu, aşağıdaki sonucu verecektir -

Name: Ruby on Rails
Age: 3
Sex: !
Name:Just Ruby

Sınıf İstisnası

Ruby'nin standart sınıfları ve modülleri istisnaları artırır. Tüm istisna sınıfları, istisna sınıfı en üstte olacak şekilde bir hiyerarşi oluşturur. Sonraki seviye yedi farklı tür içerir -

• Interrupt
• NoMemoryError
• SignalException
• ScriptError
• StandardError
• SystemExit

Bu seviyede başka bir istisna var, Fatal, ancak Ruby yorumlayıcısı bunu yalnızca dahili olarak kullanır.

Hem ScriptError hem de StandardError'ın birkaç alt sınıfı vardır, ancak burada ayrıntılara girmemize gerek yoktur. Önemli olan şu ki, eğer kendi istisna sınıflarımızı yaratırsak, bunların ya İstisna sınıfının ya da onun soyundan birinin alt sınıfları olmaları gerekir.

Bir örneğe bakalım -

class FileSaveError < StandardError
   attr_reader :reason
   def initialize(reason)
      @reason = reason
   end
end

Şimdi, bu istisnayı kullanacak aşağıdaki örneğe bakın -

File.open(path, "w") do |file|
begin
   # Write out the data ...
rescue
   # Something went wrong!
   raise FileSaveError.new($!)
end
end

Buradaki önemli satır, yükseltmek FileSaveError.new ($!) . Bir istisnanın oluştuğunu işaret etmek için yükseltme çağrısı yaparız, buna yeni bir FileSaveError örneği geçiririz, bunun nedeni, belirli istisnanın verilerin yazılmasının başarısız olmasına neden olmasıdır.

Ruby saf bir nesne yönelimli dildir ve her şey Ruby'ye bir nesne olarak görünür. Ruby'deki her değer bir nesnedir, hatta en ilkel şeyler: dizeler, sayılar ve hatta doğru ve yanlış. Bir sınıfın kendisi bile Class sınıfının bir örneği olan bir nesnedir . Bu bölüm sizi Nesne Yönelimli Ruby ile ilgili tüm temel işlevlere götürecektir.

Sınıf, bir nesnenin biçimini belirtmek için kullanılır ve veri gösterimini ve bu verileri tek bir düzgün pakette işlemek için yöntemleri birleştirir. Bir sınıf içindeki veriler ve yöntemler, sınıfın üyeleri olarak adlandırılır.

Ruby Sınıfı Tanımı

Bir sınıf tanımladığınızda, bir veri türü için bir plan tanımlarsınız. Bu aslında herhangi bir veriyi tanımlamaz, ancak sınıf adının ne anlama geldiğini, yani sınıfın bir nesnesinin nelerden oluşacağını ve böyle bir nesne üzerinde hangi işlemlerin gerçekleştirilebileceğini tanımlar.

Bir sınıf tanımı, anahtar kelimeyle başlar class ardından class name ve bir ile sınırlandırılmıştır end. Örneğin, sınıf anahtar kelimesini kullanarak Box sınıfını aşağıdaki gibi tanımladık -

class Box
   code
end

İsim büyük harfle başlamalıdır ve birden fazla kelime içeren kurallara göre isimler her kelime büyük harfle yazılır ve ayırıcı karakterler (CamelCase) kullanılmaz.

Ruby Nesnelerini Tanımlayın

Bir sınıf, nesnelerin planlarını sağlar, bu nedenle temelde bir sınıftan bir nesne oluşturulur. Bir sınıfın nesnelerininewanahtar kelime. Aşağıdaki ifadeler Box sınıfının iki nesnesini bildirir -

box1 = Box.new
box2 = Box.new

Başlatma Yöntemi

initialize method standart bir Ruby sınıfı yöntemidir ve neredeyse aynı şekilde çalışır constructordiğer nesne yönelimli programlama dillerinde çalışır. Başlatma yöntemi, nesne oluşturma sırasında bazı sınıf değişkenlerini başlatmak istediğinizde kullanışlıdır. Bu yöntem bir parametre listesi alabilir ve diğer herhangi bir yakut yöntemi gibi, öncesindedef aşağıda gösterildiği gibi anahtar kelime -

class Box
   def initialize(w,h)
      @width, @height = w, h
   end
end

Örnek Değişkenler

instance variablesbir tür sınıf nitelikleridir ve sınıf kullanılarak nesneler oluşturulduğunda nesnelerin özellikleri haline gelirler. Her nesnenin nitelikleri ayrı ayrı atanır ve diğer nesnelerle hiçbir değeri paylaşmaz. Sınıf içinde @ operatörü kullanılarak erişilir, ancak kullandığımız sınıfın dışında bunlara erişmek içinpublic denilen yöntemler accessor methods. Yukarıda tanımlanan sınıfı alırsakBox @width ve @height, Box sınıfı için örnek değişkenlerdir.

class Box
   def initialize(w,h)
      # assign instance variables
      @width, @height = w, h
   end
end

Erişimci ve ayarlayıcı Yöntemleri

Değişkenleri sınıfın dışından kullanılabilir kılmak için, bunların içinde tanımlanmaları gerekir. accessor methodsbu erişimci yöntemleri aynı zamanda alıcı yöntemler olarak da bilinir. Aşağıdaki örnek, erişimci yöntemlerinin kullanımını göstermektedir -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # accessor methods
   def printWidth
      @width
   end

   def printHeight
      @height
   end
end

# create an object
box = Box.new(10, 20)

# use accessor methods
x = box.printWidth()
y = box.printHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

Yukarıdaki kod çalıştırıldığında, aşağıdaki sonucu verir -

Width of the box is : 10
Height of the box is : 20

Değişkenlerin değerine erişmek için kullanılan erişimci yöntemlerine benzer şekilde, Ruby bu değişkenlerin değerlerini sınıfın dışından ayarlamak için bir yol sağlar. setter methodsaşağıdaki gibi tanımlananlar -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # accessor methods
   def getWidth
      @width
   end
   def getHeight
      @height
   end

   # setter methods
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end

# create an object
box = Box.new(10, 20)

# use setter methods
box.setWidth = 30
box.setHeight = 50

# use accessor methods
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

Yukarıdaki kod çalıştırıldığında, aşağıdaki sonucu verir -

Width of the box is : 30
Height of the box is : 50

Örnek Yöntemler

instance methods aynı zamanda başka herhangi bir yöntemi kullanarak tanımladığımız şekilde tanımlanır defanahtar kelime ve bunlar yalnızca aşağıda gösterildiği gibi bir sınıf örneği kullanılarak kullanılabilir. İşlevleri, örnek değişkenlerine erişimle sınırlı değildir, aynı zamanda ihtiyacınıza göre çok daha fazlasını da yapabilirler.

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"

Yukarıdaki kod çalıştırıldığında, aşağıdaki sonucu verir -

Area of the box is : 200

Sınıf Yöntemler ve Değişkenler

class variablesbir sınıfın tüm örnekleri arasında paylaşılan bir değişkendir. Başka bir deyişle, değişkenin bir örneği vardır ve buna nesne örnekleri tarafından erişilir. Sınıf değişkenlerinin önünde iki @ karakter (@@) bulunur. Bir sınıf değişkeni, aşağıda gösterildiği gibi sınıf tanımı içinde başlatılmalıdır.

Bir sınıf yöntemi kullanılarak tanımlanır def self.methodname(), son sınırlayıcı ile biten ve sınıf adı olarak kullanılarak çağrılacak classname.methodname aşağıdaki örnekte gösterildiği gibi -

#!/usr/bin/ruby -w

class Box
   # Initialize our class variables
   @@count = 0
   def initialize(w,h)
      # assign instance avriables
      @width, @height = w, h

      @@count += 1
   end

   def self.printCount()
      puts "Box count is : #@@count"
   end
end

# create two object
box1 = Box.new(10, 20)
box2 = Box.new(30, 100)

# call class method to print box count
Box.printCount()

Yukarıdaki kod çalıştırıldığında, aşağıdaki sonucu verir -

Box count is : 2

To_s Yöntemi

Tanımladığınız herhangi bir sınıfın bir to_snesnenin dize gösterimini döndürmek için örnek yöntem. Aşağıda, bir Box nesnesini genişlik ve yükseklik açısından temsil etmek için basit bir örnek verilmiştir -

#!/usr/bin/ruby -w

class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # define to_s method
   def to_s
      "(w:#@width,h:#@height)"  # string formatting of the object.
   end
end

# create an object
box = Box.new(10, 20)

# to_s method will be called in reference of string automatically.
puts "String representation of box is : #{box}"

Yukarıdaki kod çalıştırıldığında, aşağıdaki sonucu verir -

String representation of box is : (w:10,h:20)

Giriş kontrolu

Ruby, örnek yöntemleri düzeyinde size üç koruma düzeyi sağlar; public, private, or protected. Ruby, örnek ve sınıf değişkenleri üzerinde herhangi bir erişim denetimi uygulamaz.

• Public Methods- Herkese açık yöntemler herkes tarafından çağrılabilir. Her zaman özel olan başlatma dışında yöntemler varsayılan olarak geneldir.

• Private Methods- Özel yöntemlere erişilemez ve hatta sınıfın dışından görüntülenemez. Özel üyelere yalnızca sınıf yöntemleri erişebilir.

• Protected Methods- Korumalı bir yöntem yalnızca tanımlayıcı sınıfın nesneleri ve alt sınıfları tarafından çağrılabilir. Erişim aile içinde tutulur.

Aşağıda, üç erişim değiştiricinin tümünün sözdizimini gösteren basit bir örnek verilmiştir -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # instance method by default it is public
   def getArea
      getWidth() * getHeight
   end

   # define private accessor methods
   def getWidth
      @width
   end
   def getHeight
      @height
   end
   # make them private
   private :getWidth, :getHeight

   # instance method to print area
   def printArea
      @area = getWidth() * getHeight
      puts "Big box area is : #@area"
   end
   # make it protected
   protected :printArea
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"

# try to call protected or methods
box.printArea()

Yukarıdaki kod çalıştırıldığında aşağıdaki sonucu verir. Burada birinci yöntem başarıyla çağrılırken, ikinci yöntem sorun yaratmıştır.

Area of the box is : 200
test.rb:42: protected method `printArea' called for #
<Box:0xb7f11280 @height = 20, @width = 10> (NoMethodError)

Sınıf Mirası

Nesne yönelimli programlamadaki en önemli kavramlardan biri kalıtımdır. Kalıtım, bir sınıfı başka bir sınıf açısından tanımlamamıza izin verir, bu da bir uygulama oluşturmayı ve sürdürmeyi kolaylaştırır.

Kalıtım ayrıca kod işlevselliğini ve hızlı uygulama süresini yeniden kullanma fırsatı da sağlar, ancak maalesef Ruby birden fazla kalıtım düzeyini desteklemez ancak Ruby destekler mixins. Bir karışım, yalnızca arayüz kısmının miras alındığı çoklu kalıtımın özelleştirilmiş bir uygulaması gibidir.

Bir sınıf oluştururken, tamamen yeni veri üyeleri ve üye işlevler yazmak yerine, programcı yeni sınıfın mevcut bir sınıfın üyelerini miras alması gerektiğini belirleyebilir. Bu mevcut sınıfabase class or superclassve yeni sınıfa, derived class or sub-class.

Ruby ayrıca alt sınıflandırma, yani kalıtım kavramını da destekler ve aşağıdaki örnek kavramı açıklar. Bir sınıfı genişletmenin sözdizimi basittir. Sınıf ifadenize bir <karakteri ve üst sınıfın adını eklemeniz yeterlidir. Örneğin, aşağıdaki bir sınıf BigBox'ı Box'ın bir alt sınıfı olarak tanımlayın -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# define a subclass
class BigBox < Box

   # add a new instance method
   def printArea
      @area = @width * @height
      puts "Big box area is : #@area"
   end
end

# create an object
box = BigBox.new(10, 20)

# print the area
box.printArea()

Yukarıdaki kod çalıştırıldığında, aşağıdaki sonucu verir -

Big box area is : 200

Geçersiz Kılma Yöntemleri

Türetilmiş bir sınıfa yeni işlevler ekleyebilseniz de, ancak bazen bir üst sınıfta önceden tanımlanmış yöntemin davranışını değiştirmek istersiniz. Bunu, yöntem adını aynı tutarak ve aşağıdaki örnekte gösterildiği gibi yöntemin işlevselliğini geçersiz kılarak yapabilirsiniz -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# define a subclass
class BigBox < Box

   # change existing getArea method as follows
   def getArea
      @area = @width * @height
      puts "Big box area is : #@area"
   end
end

# create an object
box = BigBox.new(10, 20)

# print the area using overriden method.
box.getArea()

Operatör Aşırı Yüklemesi

+ Operatörünün + kullanarak iki Box nesnesinin vektör toplamasını, * operatörünün bir Box genişliğini ve yüksekliğini bir skaler ile çarpmasını ve tekli - operatörünün Box'ın genişliğini ve yüksekliğini olumsuzlamasını istiyoruz. Burada, matematiksel işleçlerin tanımlandığı Box sınıfının bir sürümü verilmiştir -

class Box
   def initialize(w,h)     # Initialize the width and height
      @width,@height = w, h
   end

   def +(other)       # Define + to do vector addition
      Box.new(@width + other.width, @height + other.height)
   end

   def -@           # Define unary minus to negate width and height
      Box.new(-@width, -@height)
   end

   def *(scalar)           # To perform scalar multiplication
      Box.new(@width*scalar, @height*scalar)
   end
end

Nesneleri Dondurmak

Bazen bir nesnenin değiştirilmesini önlemek isteriz. Object'teki dondurma yöntemi, bir nesneyi etkin bir şekilde sabit hale getirerek bunu yapmamızı sağlar. Herhangi bir nesne çağırılarak dondurulabilirObject.freeze. Dondurulmuş bir nesne değiştirilemez: onun örnek değişkenlerini değiştiremezsiniz.

Belirli bir nesnenin donmuş olup olmadığını kontrol edebilirsiniz. Object.frozen?yöntem, nesnenin donması durumunda true değerini döndürür, aksi takdirde yanlış bir değer döndürülür. Aşağıdaki örnek kavramı netleştirir -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # accessor methods
   def getWidth
      @width
   end
   def getHeight
      @height
   end

   # setter methods
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end

# create an object
box = Box.new(10, 20)

# let us freez this object
box.freeze
if( box.frozen? )
   puts "Box object is frozen object"
else
   puts "Box object is normal object"
end

# now try using setter methods
box.setWidth = 30
box.setHeight = 50

# use accessor methods
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

Yukarıdaki kod çalıştırıldığında, aşağıdaki sonucu verir -

Box object is frozen object
test.rb:20:in `setWidth=': can't modify frozen object (TypeError)
   from test.rb:39

Sınıf Sabitleri

Bir değişkene, @ veya @@ kullanılmadan tanımlanan bir doğrudan sayısal veya dize değeri atayarak bir sınıf içinde bir sabit tanımlayabilirsiniz. Geleneksel olarak, sabit isimleri büyük harfle tutuyoruz.

Bir sabit tanımlandıktan sonra, değerini değiştiremezsiniz, ancak bir değişkene çok benzer şekilde bir sınıfın içinden doğrudan bir sabite erişebilirsiniz, ancak sınıfın dışındaki bir sabite erişmek istiyorsanız, classname::constant aşağıdaki örnekte gösterildiği gibi.

#!/usr/bin/ruby -w

# define a class
class Box
   BOX_COMPANY = "TATA Inc"
   BOXWEIGHT = 10
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"
puts Box::BOX_COMPANY
puts "Box weight is: #{Box::BOXWEIGHT}"

Yukarıdaki kod çalıştırıldığında, aşağıdaki sonucu verir -

Area of the box is : 200
TATA Inc
Box weight is: 10

Sınıf sabitleri miras alınır ve örnek yöntemleri gibi geçersiz kılınabilir.

Allocate Kullanarak Nesne Oluşturun

Yapıcısını çağırmadan bir nesne oluşturmak istediğinizde bir durum olabilir. initializeör. yeni yöntemi kullanarak, böyle bir durumda ayırmayı çağırabilirsiniz , bu da sizin için aşağıdaki örnekte olduğu gibi başlatılmamış bir nesne yaratacaktır -

#!/usr/bin/ruby -w

# define a class
class Box
   attr_accessor :width, :height

   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end

   # instance method
   def getArea
      @width * @height
   end
end

# create an object using new
box1 = Box.new(10, 20)

# create another object using allocate
box2 = Box.allocate

# call instance method using box1
a = box1.getArea()
puts "Area of the box is : #{a}"

# call instance method using box2
a = box2.getArea()
puts "Area of the box is : #{a}"

Yukarıdaki kod çalıştırıldığında, aşağıdaki sonucu verir -

Area of the box is : 200
test.rb:14: warning: instance variable @width not initialized
test.rb:14: warning: instance variable @height not initialized
test.rb:14:in `getArea': undefined method `*' 
   for nil:NilClass (NoMethodError) from test.rb:29

Sınıf Bilgileri

Sınıf tanımları çalıştırılabilir kodsa, bu onların bir nesne bağlamında yürütüldüğü anlamına gelir: self bir şeye başvurmalıdır. Ne olduğunu öğrenelim.

#!/usr/bin/ruby -w

class Box
   # print class information
   puts "Type of self = #{self.type}"
   puts "Name of self = #{self.name}"
end

Yukarıdaki kod çalıştırıldığında, aşağıdaki sonucu verir -

Type of self = Class
Name of self = Box

Bu, bir sınıf tanımının o sınıfla geçerli nesne olarak yürütüldüğü anlamına gelir. Bu, meta sınıftaki ve üst sınıflarındaki yöntemlerin, yöntem tanımının yürütülmesi sırasında kullanılabilir olacağı anlamına gelir.

Bir düzenli ifade eşleşmesi veya desende düzenlenen bir uzman sözdizimi kullanarak dizeleri diğer dizeleri veya setleri bulmanıza yardımcı karakterlerin özel dizisidir.

Bir normal düz ifade eğik çizgiler arasında ya da aşağıdaki gibi% r ve ardından rasgele ayraçları arasındaki bir kalıptır -

Sözdizimi

/pattern/
/pattern/im    # option can be specified
%r!/usr/local! # general delimited regular expression

Misal

#!/usr/bin/ruby

line1 = "Cats are smarter than dogs";
line2 = "Dogs also like meat";

if ( line1 =~ /Cats(.*)/ )
   puts "Line1 contains Cats"
end
if ( line2 =~ /Cats(.*)/ )
   puts "Line2 contains  Dogs"
end

Bu, aşağıdaki sonucu verecektir -

Line1 contains Cats

Normal İfade Değiştiriciler

Normal ifade değişmezleri, eşleşmenin çeşitli yönlerini kontrol etmek için isteğe bağlı bir değiştirici içerebilir. Değiştirici, daha önce gösterildiği gibi ikinci eğik çizgi karakterinden sonra belirtilir ve bu karakterlerden biriyle gösterilebilir -

Sr.No.	Değiştirici ve Açıklama
1	i Metin eşleştirirken büyük / küçük harf kullanımını göz ardı eder.
2	o # {} Enterpolasyonunu yalnızca bir kez, normal ifade ilk kez değerlendirildiğinde gerçekleştirir.
3	x Boşluğu yok sayar ve normal ifadelerde yorumlara izin verir.
4	m Yeni satırları normal karakterler olarak tanıyarak birden çok satırla eşleşir.
5	u,e,s,n Normal ifadeyi Unicode (UTF-8), EUC, SJIS veya ASCII olarak yorumlar. Bu değiştiricilerden hiçbiri belirtilmezse, normal ifadenin kaynak kodlamasını kullandığı varsayılır.

% Q ile sınırlandırılmış dize değişmezleri gibi, Ruby de normal ifadelerinize% r ve ardından seçtiğiniz bir sınırlayıcı ile başlamanıza izin verir. Bu, tanımladığınız desen kaçmak istemediğiniz çok sayıda eğik çizgi karakteri içerdiğinde kullanışlıdır -

# Following matches a single slash character, no escape required
%r|/|

# Flag characters are allowed with this syntax, too
%r[</(.*)>]i

Normal İfade Kalıpları

Kontrol karakterleri hariç, (+ ? . * ^ $ ( ) [ ] { } | \), tüm karakterler kendileriyle eşleşir. Bir kontrol karakterinin önüne ters eğik çizgi koyarak kaçabilirsiniz.

Aşağıdaki tablo Ruby'de bulunan normal ifade sözdizimini listeler.

Sr.No.	Desen ve Açıklama
1	^ Satırın başıyla eşleşir.
2	$ Satırın sonuyla eşleşir.
3	. Yeni satır hariç herhangi bir tek karakterle eşleşir. M seçeneğini kullanmak, satırsonu ile eşleşmesine de izin verir.
4	[...] Parantez içindeki herhangi bir tek karakterle eşleşir.
5	[^...] Parantez içinde olmayan herhangi bir karakterle eşleşir
6	re* Önceki ifadenin 0 veya daha fazla oluşumuyla eşleşir.
7	re+ Önceki ifadenin 1 veya daha fazla oluşumuyla eşleşir.
8	re? Önceki ifadenin 0 veya 1 oluşumuyla eşleşir.
9	re{ n} Önceki ifadenin tam olarak n sayıda oluşumuyla eşleşir.
10	re{ n,} Önceki ifadenin n veya daha fazla oluşumuyla eşleşir.
11	re{ n, m} Önceki ifadenin en az n ve en çok m oluşumuyla eşleşir.
12	a| b A veya b ile eşleşir.
13	(re) Normal ifadeleri gruplandırır ve eşleşen metni hatırlar.
14	(?imx) Normal bir ifade içinde geçici olarak i, m veya x seçenekleri arasında geçiş yapar. Parantez içindeyse, yalnızca o alan etkilenir.
15	(?-imx) Normal bir ifade içindeki i, m veya x seçeneklerini geçici olarak kapatır. Parantez içindeyse, yalnızca o alan etkilenir.
16	(?: re) Normal ifadeleri eşleşen metni hatırlamadan gruplar.
17	(?imx: re) Parantez içindeki i, m veya x seçeneklerini geçici olarak değiştirir.
18	(?-imx: re) Parantez içindeki i, m veya x seçeneklerini geçici olarak kapatır.
19	(?#...) Yorum Yap.
20	(?= re) Bir model kullanarak konumu belirtir. Aralığı yok.
21	(?! re) Kalıp olumsuzlamasını kullanarak konumu belirtir. Aralığı yok.
22	(?> re) Geriye dönük izleme olmaksızın bağımsız desenle eşleşir.
23	\w Kelime karakterleriyle eşleşir.
24	\W Sözcük olmayan karakterlerle eşleşir.
25	\s Boşluklarla eşleşir. [\ T \ n \ r \ f] ile eşdeğerdir.
26	\S Beyaz olmayan boşlukla eşleşir.
27	\d Rakamlarla eşleşir. [0-9] ile eşdeğerdir.
28	\D Sayı olmayanlarla eşleşir.
29	\A Dizenin başıyla eşleşir.
30	\Z Dizenin sonuyla eşleşir. Bir satırsonu varsa, yeni satırdan hemen önce eşleşir.
31	\z Dizenin sonuyla eşleşir.
32	\G Maçlar son maçın bittiği yeri gösterir.
33	\b Köşeli parantezlerin dışındayken kelime sınırlarıyla eşleşir. Parantez içindeyken geri boşlukla (0x08) eşleşir.
34	\B Kelime olmayan sınırlarla eşleşir.
35	\n, \t, etc. Yeni satırlarla, satır başlarıyla, sekmelerle vb. Eşleşir.
36	\1...\9 N'inci gruplanmış alt ifadeyle eşleşir.
37	\10 Matches nth grouped subexpression if it matched already. Otherwise refers to the octal representation of a character code.

Regular-Expression Examples

Literal Characters

Sr.No.	Example & Description
1	/ruby/ Matches "ruby".
2	¥ Matches Yen sign. Multibyte characters are supported in Ruby 1.9 and Ruby 1.8.

Character Classes

Sr.No.	Example & Description
1	/[Rr]uby/ Matches "Ruby" or "ruby".
2	/rub[ye]/ Matches "ruby" or "rube".
3	/[aeiou]/ Matches any one lowercase vowel.
4	/[0-9]/ Matches any digit; same as /[0123456789]/.
5	/[a-z]/ Matches any lowercase ASCII letter.
6	/[A-Z]/ Matches any uppercase ASCII letter.
7	/[a-zA-Z0-9]/ Matches any of the above.
8	/[^aeiou]/ Matches anything other than a lowercase vowel.
9	/[^0-9]/ Matches anything other than a digit.

Special Character Classes

Sr.No.	Example & Description
1	/./ Matches any character except newline.
2	/./m In multi-line mode, matches newline, too.
3	/\d/ Matches a digit: /[0-9]/.
4	/\D/ Matches a non-digit: /[^0-9]/.
5	/\s/ Matches a whitespace character: /[ \t\r\n\f]/.
6	/\S/ Matches non-whitespace: /[^ \t\r\n\f]/.
7	/\w/ Matches a single word character: /[A-Za-z0-9_]/.
8	/\W/ Matches a non-word character: /[^A-Za-z0-9_]/.

Repetition Cases

Sr.No.	Example & Description
1	/ruby?/ Matches "rub" or "ruby": the y is optional.
2	/ruby*/ Matches "rub" plus 0 or more ys.
3	/ruby+/ Matches "rub" plus 1 or more ys.
4	/\d{3}/ Matches exactly 3 digits.
5	/\d{3,}/ Matches 3 or more digits.
6	/\d{3,5}/ Matches 3, 4, or 5 digits.

Non-greedy Repetition

This matches the smallest number of repetitions −

Sr.No.	Example & Description
1	/<.*>/ Greedy repetition: matches "<ruby>perl>".
2	/<.*?>/ Non-greedy: matches "<ruby>" in "<ruby>perl>".

Grouping with Parentheses

Sr.No.	Example & Description
1	/\D\d+/ No group: + repeats \d
2	/(\D\d)+/ Grouped: + repeats \D\d pair
3	/([Rr]uby(, )?)+/ Match "Ruby", "Ruby, ruby, ruby", etc.

Back References

This matches a previously matched group again −

Sr.No.	Example & Description
1	/([Rr])uby&\1ails/ Matches ruby&rails or Ruby&Rails.
2	/(['"])(?:(?!\1).)*\1/ Single or double-quoted string. \1 matches whatever the 1st group matched . \2 matches whatever the 2nd group matched, etc.

Alternatives

Sr.No.	Example & Description
1	/ruby|rube/ Matches "ruby" or "rube".
2	/rub(y|le))/ Matches "ruby" or "ruble".
3	/ruby(!+|\?)/ "ruby" followed by one or more ! or one ?

Anchors

It needs to specify match position.

Sr.No.	Example & Description
1	/^Ruby/ Matches "Ruby" at the start of a string or internal line.
2	/Ruby$/ Matches "Ruby" at the end of a string or line.
3	/\ARuby/ Matches "Ruby" at the start of a string.
4	/Ruby\Z/ Matches "Ruby" at the end of a string.
5	/\bRuby\b/ Matches "Ruby" at a word boundary.
6	/\brub\B/ \B is non-word boundary: matches "rub" in "rube" and "ruby" but not alone.
7	/Ruby(?=!)/ Matches "Ruby", if followed by an exclamation point.
8	/Ruby(?!!)/ Matches "Ruby", if not followed by an exclamation point.

Special Syntax with Parentheses

Sr.No.	Example & Description
1	/R(?#comment)/ Matches "R". All the rest is a comment.
2	/R(?i)uby/ Case-insensitive while matching "uby".
3	/R(?i:uby)/ Same as above.
4	/rub(?:y|le))/ Group only without creating \1 backreference.

Search and Replace

Some of the most important String methods that use regular expressions are sub and gsub, and their in-place variants sub! and gsub!.

All of these methods perform a search-and-replace operation using a Regexp pattern. The sub & sub! replaces the first occurrence of the pattern and gsub & gsub! replaces all occurrences.

The sub and gsub returns a new string, leaving the original unmodified where as sub! and gsub! modify the string on which they are called.

Following is the example −

#!/usr/bin/ruby

phone = "2004-959-559 #This is Phone Number"

# Delete Ruby-style comments
phone = phone.sub!(/#.*$/, "")   
puts "Phone Num : #{phone}"

# Remove anything other than digits
phone = phone.gsub!(/\D/, "")    
puts "Phone Num : #{phone}"

This will produce the following result −

Phone Num : 2004-959-559
Phone Num : 2004959559

Following is another example −

#!/usr/bin/ruby

text = "rails are rails, really good Ruby on Rails"

# Change "rails" to "Rails" throughout
text.gsub!("rails", "Rails")

# Capitalize the word "Rails" throughout
text.gsub!(/\brails\b/, "Rails")
puts "#{text}"

Bu, aşağıdaki sonucu verecektir -

Rails are Rails, really good Ruby on Rails

Bu bölüm Ruby kullanarak bir veritabanına nasıl erişeceğinizi öğretir. Yakut DBI modülü Perl DBI modülü benzer Ruby komut dosyaları için bir veritabanı bağımsız arayüz sağlar.

DBI, Ruby için Veritabanından Bağımsız Arayüz anlamına gelir; bu, DBI'nın Ruby kodu ile temeldeki veritabanı arasında bir soyutlama katmanı sağladığı ve veritabanı uygulamalarını gerçekten kolayca değiştirmenize izin verdiği anlamına gelir. Kullanılan gerçek veritabanından bağımsız olarak tutarlı bir veritabanı arabirimi sağlayan bir dizi yöntemi, değişkeni ve kuralı tanımlar.

DBI aşağıdakilerle arayüz oluşturabilir -

• ADO (ActiveX Veri Nesneleri)
• DB2
• Frontbase
• mSQL
• MySQL
• ODBC
• Oracle
• OCI8 (Oracle)
• PostgreSQL
• Proxy/Server
• SQLite
• SQLRelay

DBI Uygulamasının Mimarisi

DBI, arka uçta bulunan herhangi bir veritabanından bağımsızdır. Oracle, MySQL veya Informix vb. İle çalışıyor olsanız da DBI kullanabilirsiniz. Bu, aşağıdaki mimari diyagramdan anlaşılır.

Ruby DBI için genel mimari iki katman kullanır -

• Veritabanı arabirimi (DBI) katmanı. Bu katman veritabanından bağımsızdır ve iletişim kurduğunuz veritabanı sunucusunun türüne bakılmaksızın aynı şekilde kullanılan bir dizi ortak erişim yöntemi sağlar.

• Veritabanı sürücüsü (DBD) katmanı. Bu katman veritabanına bağlıdır; farklı sürücüler, farklı veritabanı motorlarına erişim sağlar. MySQL için bir sürücü, PostgreSQL için bir sürücü, InterBase için bir sürücü, Oracle için bir sürücü ve diğerleri vardır. Her sürücü, DBI katmanından gelen istekleri yorumlar ve bunları belirli bir veritabanı sunucusu türüne uygun isteklerle eşler.

Önkoşullar

MySQL veritabanlarına erişmek için Ruby komut dosyaları yazmak istiyorsanız, Ruby MySQL modülünün kurulu olması gerekir.

Bu modül, yukarıda açıklandığı gibi bir DBD görevi görür ve şu adresten indirilebilir: https://www.tmtm.org/en/mysql/ruby/

Ruby / DBI Edinme ve Yükleme

Ruby DBI modülünü aşağıdaki konumdan indirip kurabilirsiniz -

https://imgur.com/NFEuWe4/embed

Bu kuruluma başlamadan önce, root ayrıcalığına sahip olduğunuzdan emin olun. Şimdi, aşağıda verilen adımları izleyin -

Aşama 1

$ tar zxf dbi-0.2.0.tar.gz

Adım 2

Dbi -0.2.0 dağıtım dizinine gidin ve bu dizindeki setup.rb komut dosyasını kullanarak yapılandırın . En genel konfigürasyon komutu, config argümanını takip eden hiçbir argüman olmaksızın buna benzer. Bu komut, dağıtımı varsayılan olarak tüm sürücüleri yükleyecek şekilde yapılandırır.

$ ruby setup.rb config

Daha spesifik olmak gerekirse, dağıtımın kullanmak istediğiniz belirli bölümlerini listeleyen bir --with seçeneği sağlayın. Örneğin, yalnızca ana DBI modülünü ve MySQL DBD düzeyi sürücüyü yapılandırmak için aşağıdaki komutu verin -

$ ruby setup.rb config --with = dbi,dbd_mysql

Aşama 3

Son adım, sürücüyü oluşturmak ve aşağıdaki komutları kullanarak kurmaktır -

$ ruby setup.rb setup $ ruby setup.rb install

Veritabanı Bağlantısı

MySQL veritabanıyla çalışacağımızı varsayarsak, bir veritabanına bağlanmadan önce aşağıdakilerden emin olun -

• Bir TESTDB veritabanı oluşturdunuz.

• TESTDB'de EMPLOYEE oluşturdunuz.

• Bu tablo FIRST_NAME, LAST_NAME, AGE, SEX ve INCOME alanlarına sahip.

• "Testuser" kullanıcı kimliği ve "test123" şifresi TESTDB'ye erişmek için ayarlanmıştır.

• Ruby Module DBI, makinenize doğru bir şekilde kurulmuş.

• MySQL Temellerini anlamak için MySQL eğitiminden geçtiniz.

Aşağıda MySQL veritabanı "TESTDB" ile bağlantı kurma örneği verilmiştir

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   # get server version string and display it
   row = dbh.select_one("SELECT VERSION()")
   puts "Server version: " + row[0]
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Bu betiği çalıştırırken, Linux makinemizde aşağıdaki sonucu verir.

Server version: 5.0.45

Veri kaynağıyla bir bağlantı kurulursa, bir Veritabanı Tutacağı döndürülür ve dbh aksi takdirde daha fazla kullanım için dbhnil değerine ayarlanmıştır ve e.err ve e :: errstr sırasıyla hata kodu ve bir hata dizgesini döndürür.

Son olarak, çıkmadan önce veritabanı bağlantısının kapatıldığından ve kaynakların serbest bırakıldığından emin olun.

INSERT İşlemi

Kayıtlarınızı bir veritabanı tablosunda oluşturmak istediğinizde INSERT işlemi gereklidir.

Bir veritabanı bağlantısı kurulduktan sonra, kullanarak veritabanı tablolarına tablolar veya kayıtlar oluşturmaya hazırız. do yöntem veya prepare ve execute yöntem.

Do İfadesini Kullanma

Satır döndürmeyen ifadeler, doveritabanı işleme yöntemi. Bu yöntem, bir ifade dizesi bağımsız değişkeni alır ve ifadeden etkilenen satırların sayısını döndürür.

dbh.do("DROP TABLE IF EXISTS EMPLOYEE")
dbh.do("CREATE TABLE EMPLOYEE (
   FIRST_NAME  CHAR(20) NOT NULL,
   LAST_NAME  CHAR(20),
   AGE INT,  
   SEX CHAR(1),
   INCOME FLOAT )" );

Benzer şekilde, EMPLOYEE tablosunda bir kayıt oluşturmak için SQL INSERT deyimini çalıştırabilirsiniz .

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   dbh.do( "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
      VALUES ('Mac', 'Mohan', 20, 'M', 2000)" )
   puts "Record has been created"
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Hazırla ve yürüt özelliğini kullanma

SQL ifadesini Ruby kodu aracılığıyla yürütmek için DBI sınıfının hazırlama ve yürütme yöntemlerini kullanabilirsiniz .

Kayıt oluşturma aşağıdaki adımları gerçekleştirir -

• INSERT deyimiyle SQL deyiminin hazırlanması. Bu, kullanılarak yapılacaktır.prepare yöntem.

• Veritabanından tüm sonuçları seçmek için SQL sorgusunun yürütülmesi. Bu, kullanılarak yapılacaktır.execute yöntem.

• Serbest bırakma İfadesi tutamacı. Bu kullanılarak yapılacaktırfinish API

• Her şey yolunda giderse, o zaman commit bu işlem yoksa yapabilirsin rollback tam işlem.

Bu iki yöntemi kullanmak için sözdizimi aşağıdadır -

sth = dbh.prepare(statement)
sth.execute
   ... zero or more SQL operations ...
sth.finish

Bu iki yöntem geçmek için kullanılabilir bindSQL ifadelerine değerler. Girilecek değerlerin önceden verilmediği bir durum olabilir. Böyle bir durumda bağlanma değerleri kullanılır. Bir soru işareti (?) gerçek değerler yerine kullanılır ve ardından gerçek değerler execute () API üzerinden geçirilir.

EMPLOYEE tablosunda iki kayıt oluşturmak için örnek aşağıdadır -

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare( "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
      VALUES (?, ?, ?, ?, ?)" )
   sth.execute('John', 'Poul', 25, 'M', 2300)
   sth.execute('Zara', 'Ali', 17, 'F', 1000)
   sth.finish
   dbh.commit
   puts "Record has been created"
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Bir seferde birden fazla INSERT varsa, o zaman önce bir ifade hazırlamak ve sonra bunu bir döngü içinde birden çok kez yürütmek, döngü boyunca her seferinde çağırmaktan daha etkilidir.

OKUMA İşlemi

Herhangi bir veritabanı üzerinde OKUMA İşlemi, veritabanından bazı yararlı bilgileri almak anlamına gelir.

Veritabanı bağlantımız kurulduktan sonra, bu veritabanına bir sorgulama yapmaya hazırız. İkisini de kullanabilirizdo yöntem veya prepare ve execute bir veritabanı tablosundan değerleri getirme yöntemleri.

Kayıt getirme aşağıdaki adımları gerçekleştirir -

• Gerekli koşullara göre SQL sorgusu hazırlamak. Bu, kullanılarak yapılacaktır.prepare yöntem.

• Veritabanından tüm sonuçları seçmek için SQL sorgusunun yürütülmesi. Bu, kullanılarak yapılacaktır.execute yöntem.

• Tüm sonuçları tek tek almak ve bu sonuçları yazdırmak. Bu, kullanılarak yapılacaktır.fetch yöntem.

• Serbest bırakma İfadesi tutamacı. Bu, kullanılarak yapılacaktır.finish yöntem.

1000'den fazla maaşı olan EMPLOYEE tablosundaki tüm kayıtları sorgulama prosedürü aşağıdadır.

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("SELECT * FROM EMPLOYEE WHERE INCOME > ?")
   sth.execute(1000)

   sth.fetch do |row|
   printf "First Name: %s, Last Name : %s\n", row[0], row[1]
   printf "Age: %d, Sex : %s\n", row[2], row[3]
   printf "Salary :%d \n\n", row[4]
end
   sth.finish
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Bu, aşağıdaki sonucu verecektir -

First Name: Mac, Last Name : Mohan
Age: 20, Sex : M
Salary :2000

First Name: John, Last Name : Poul
Age: 25, Sex : M
Salary :2300

Veritabanından kayıt almak için daha fazla kısa yol yöntemi vardır. Eğer ilgileniyorsanız , Sonucu Getirme bölümüne gidin, aksi takdirde sonraki bölüme geçin.

Güncelleme İşlemi

GÜNCELLEME Herhangi bir veritabanı üzerinde işlem, veritabanında zaten mevcut olan bir veya daha fazla kaydı güncellemek anlamına gelir. Aşağıda, SEX olan tüm kayıtları 'M' olarak güncelleme prosedürü yer almaktadır. Burada tüm erkeklerin YAŞ'ını bir yıl artıracağız. Bu üç adım atacak -

• Gerekli koşullara göre SQL sorgusu hazırlamak. Bu, kullanılarak yapılacaktır.prepare yöntem.

• Veritabanından tüm sonuçları seçmek için SQL sorgusunun yürütülmesi. Bu, kullanılarak yapılacaktır.execute yöntem.

• Serbest bırakma İfadesi tutamacı. Bu, kullanılarak yapılacaktır.finish yöntem.

• Her şey yolunda giderse o zaman commit bu işlem yoksa yapabilirsin rollback tam işlem.

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = ?")
   sth.execute('M')
   sth.finish
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

DELETE İşlemi

Veritabanınızdan bazı kayıtları silmek istediğinizde DELETE işlemi gereklidir. Aşağıda, AGE'nin 20'den fazla olduğu ÇALIŞAN'dan tüm kayıtları silme prosedürü verilmiştir. Bu işlem aşağıdaki adımları gerçekleştirecektir.

• Gerekli koşullara göre SQL sorgusu hazırlamak. Bu, kullanılarak yapılacaktır.prepare yöntem.

• Veritabanından gerekli kayıtları silmek için SQL sorgusunun yürütülmesi. Bu, kullanılarak yapılacaktır.execute yöntem.

• Serbest bırakma İfadesi tutamacı. Bu, kullanılarak yapılacaktır.finish yöntem.

• Her şey yolunda giderse o zaman commit bu işlem yoksa yapabilirsin rollback tam işlem.

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("DELETE FROM EMPLOYEE WHERE AGE > ?")
   sth.execute(20)
   sth.finish
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

İşlemlerin Gerçekleştirilmesi

İşlemler, veri tutarlılığını sağlayan bir mekanizmadır. İşlemler aşağıdaki dört özelliğe sahip olmalıdır -

• Atomicity - Ya bir işlem tamamlanır ya da hiçbir şey olmaz.

• Consistency - Bir işlem tutarlı bir durumda başlamalı ve sistemi tutarlı bir durumda bırakmalıdır.

• Isolation - Bir işlemin ara sonuçları cari işlemin dışında görünmez.

• Durability - Bir işlem yapıldığında, sistem hatasından sonra bile etkiler kalıcıdır.

DBI birine iki yöntem sağlar işlemek veya geri alma işlem. İşlemleri uygulamak için kullanılabilecek işlem adında bir yöntem daha vardır . İşlemleri uygulamak için iki basit yaklaşım vardır -

Yaklaşım I

İlk yaklaşım , işlemi açıkça taahhüt etmek veya iptal etmek için DBI'nın kesinleştirme ve geri alma yöntemlerini kullanır -

dbh['AutoCommit'] = false # Set auto commit to false.
begin
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'John'")
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'Zara'")
   dbh.commit
rescue
   puts "transaction failed"
   dbh.rollback
end
dbh['AutoCommit'] = true

Yaklaşım II

İkinci yaklaşım işlem yöntemini kullanır . Bu daha basittir, çünkü işlemi oluşturan ifadeleri içeren bir kod bloğu alır. İşlem yöntemi, daha sonra başlatır, blok yürütür işlemek veya geri alma bloğu başarılı veya başarısız olmasına bağlı olarak, otomatik olarak -

dbh['AutoCommit'] = false # Set auto commit to false.
dbh.transaction do |dbh|
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'John'")
   dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'Zara'")
end
dbh['AutoCommit'] = true

COMMIT İşlemi

Commit, değişikliklerin sonuçlandırılması için veritabanına yeşil sinyal veren ve bu işlemden sonra hiçbir değişiklik geri alınamayan işlemdir.

İşte aranacak basit bir örnek commit yöntem.

dbh.commit

GERİ DÖNME İşlemi

Değişikliklerden bir veya daha fazlasından memnun değilseniz ve bu değişiklikleri tamamen geri almak istiyorsanız, o zaman rollback yöntem.

İşte aranacak basit bir örnek rollback yöntem.

dbh.rollback

Veritabanının Bağlantısını Kesme

Veritabanı bağlantısını kesmek için bağlantı kesme API'sini kullanın.

dbh.disconnect

Bir veritabanına bağlantı, kullanıcı tarafından bağlantıyı kesme yöntemiyle kapatılırsa, bekleyen tüm işlemler DBI tarafından geri alınır. Bununla birlikte, herhangi bir DBI uygulama detayına bağlı kalmak yerine, uygulamanız kesin olarak commit veya geri alma çağrısı yapmaktan daha iyi olacaktır.

Hataları Yönetme

Birçok hata kaynağı var. Birkaç örnek, yürütülen bir SQL deyimindeki sözdizimi hatası, bir bağlantı hatası veya önceden iptal edilmiş veya bitmiş bir ifade tutamacı için getirme yönteminin çağrılmasıdır.

Bir DBI yöntemi başarısız olursa, DBI bir istisna oluşturur. DBI yöntemleri birkaç istisna türünden herhangi birini ortaya çıkarabilir, ancak en önemli iki istisna sınıfı DBI :: InterfaceError ve DBI :: DatabaseError'dır .

Bu sınıfların istisna nesneleri , hata numarasını, açıklayıcı bir hata dizesini ve standart bir hata kodunu temsil eden err , errstr ve state adlı üç niteliğe sahiptir . Nitelikler aşağıda açıklanmıştır -

• err- DBD tarafından desteklenmiyorsa oluşan hatanın tamsayı gösterimini veya sıfır döndürür. Oracle DBD, ORA-XXXX hata mesajının sayısal bölümünü döndürür .

• errstr - Oluşan hatanın dize gösterimini döndürür.

• state- Oluşan hatanın SQLSTATE kodunu döndürür. SQLSTATE beş karakter uzunluğunda bir dizedir. Çoğu DBD bunu desteklemez ve bunun yerine sıfır döndürür.

Örneklerin çoğunda yukarıdaki kodu gördünüz -

rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Komut dosyanızın çalışırken ne yaptığı hakkında hata ayıklama bilgisi almak için izlemeyi etkinleştirebilirsiniz. Bunu yapmak için, öncelikle dbi / iz modülü yüklemek ve daha sonra çağırmalıdır iz yöntemi olduğunu kontrolleri iz modu ve çıkış hedef -

require "dbi/trace"
..............

trace(mode, destination)

Mod değeri 0 (kapalı), 1, 2 veya 3 olabilir ve hedef bir GÇ nesnesi olmalıdır. Varsayılan değerler sırasıyla 2 ve STDERR'dir.

Yöntemlerle Kod Blokları

Tutamaç oluşturan bazı yöntemler vardır. Bu yöntemler bir kod bloğu ile çağrılabilir. Kod bloğunu yöntemlerle birlikte kullanmanın avantajı, kod bloğuna bir parametre olarak tutamacı sağlaması ve blok sona erdiğinde tutamacı otomatik olarak temizlemesidir. Kavramı anlamak için birkaç örnek var.

• DBI.connect- Bu yöntem bir veritabanı tanıtıcısı oluşturur ve veritabanının bağlantısını kesmek için bloğun sonunda bağlantıyı kesmenin çağrılması önerilir .

• dbh.prepare- Bu yöntem bir ifade tutamacı oluşturur ve bloğun sonunda bitirilmesi önerilir . Blok içinde, ifadeyi yürütmek için yürütme yöntemini çağırmalısınız .

• dbh.execute- Bu yöntem benzerdir, ancak blok içinde çalıştırmayı çağırmamıza gerek yoktur. İfade tutamacı otomatik olarak yürütülür.

örnek 1

DBI.connect bir kod bloğu alabilir, veritabanı tutamacını ona iletebilir ve aşağıdaki gibi bloğun sonundaki tutamacı otomatik olarak keser.

dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123") do |dbh|

Örnek 2

dbh.prepare bir kod bloğu alabilir, deyim tutamacını ona aktarır ve çağrılar otomatik olarak bloğun sonunda aşağıdaki gibi bitirilir.

dbh.prepare("SHOW DATABASES") do |sth|
   sth.execute
   puts "Databases: " + sth.fetch_all.join(", ")
end

Örnek 3

dbh.execute bir kod bloğu alabilir, ifade tutamacını ona iletebilir ve çağrılar otomatik olarak bloğun sonunda aşağıdaki şekilde biter -

dbh.execute("SHOW DATABASES") do |sth|
   puts "Databases: " + sth.fetch_all.join(", ")
end

DBI işlem yöntemi ayrıca yukarıda açıklanan bir kod bloğunu alır.

Sürücüye Özgü İşlevler ve Nitelikler

DBI, veritabanı sürücülerinin , herhangi bir Tutamaç nesnesinin func yöntemi aracılığıyla kullanıcı tarafından çağrılabilen, veritabanına özgü ek işlevler sağlamasına izin verir .

Sürücüye özgü öznitelikler desteklenir ve aşağıdakiler kullanılarak ayarlanabilir veya alınabilir: []= veya [] yöntemler.

DBD :: Mysql aşağıdaki sürücüye özgü işlevleri gerçekleştirir -

Sr.No.	Fonksiyonlar ve Açıklama
1	dbh.func(:createdb, db_name) Yeni bir veritabanı oluşturur.
2	dbh.func(:dropdb, db_name) Bir veritabanı bırakır.
3	dbh.func(:reload) Yeniden yükleme işlemi gerçekleştirir.
4	dbh.func(:shutdown) Sunucuyu kapatır.
5	dbh.func(:insert_id) => Fixnum Bir bağlantı için en son AUTO_INCREMENT değerini döndürür.
6	dbh.func(:client_info) => String MySQL istemci bilgilerini sürüm açısından döndürür.
7	dbh.func(:client_version) => Fixnum Müşteri bilgilerini sürüm açısından döndürür. Bu şuna benzer: client_info, ancak sting yerine bir fixnum döndürür.
8	dbh.func(:host_info) => String Ana bilgisayar bilgilerini döndürür.
9	dbh.func(:proto_info) => Fixnum İletişim için kullanılan protokolü döndürür.
10	dbh.func(:server_info) => String MySQL sunucu bilgilerini sürüm açısından döndürür.
11	dbh.func(:stat) => String Veritabanının mevcut durumunu döndürür.
12	dbh.func(:thread_id) => Fixnum Mevcut iş parçacığı kimliğini döndürür.

Misal

#!/usr/bin/ruby

require "dbi"
begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123") 
   puts dbh.func(:client_info)
   puts dbh.func(:client_version)
   puts dbh.func(:host_info)
   puts dbh.func(:proto_info)
   puts dbh.func(:server_info)
   puts dbh.func(:thread_id)
   puts dbh.func(:stat)
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   dbh.disconnect if dbh
end

Bu, aşağıdaki sonucu verecektir -

5.0.45
50045
Localhost via UNIX socket
10
5.0.45
150621
Uptime: 384981  Threads: 1  Questions: 1101078  Slow queries: 4 \
Opens: 324  Flush tables: 1  Open tables: 64  \
Queries per second avg: 2.860

Ruby genel amaçlı bir dildir; düzgün bir şekilde web dili olarak adlandırılamaz . Yine de, genel olarak web uygulamaları ve web araçları Ruby'nin en yaygın kullanımları arasındadır.

Ruby'de yalnızca kendi SMTP sunucunuzu, FTP arka plan programınızı veya Web sunucunuzu yazmakla kalmaz, aynı zamanda Ruby'yi CGI programlama veya PHP'nin yerine geçme gibi daha genel görevler için de kullanabilirsiniz.

CGI Programlama hakkında daha fazla ayrıntı için lütfen CGI Programlama Eğitimi ile birkaç dakika geçirin .

CGI Komut Dosyaları Yazma

En basit Ruby CGI betiği şuna benzer -

#!/usr/bin/ruby

puts "HTTP/1.0 200 OK"
puts "Content-type: text/html\n\n"
puts "<html><body>This is a test</body></html>"

Bu betiği test.cgi olarak adlandırırsanız ve doğru izinlere sahip Unix tabanlı bir Web barındırma sağlayıcısına yüklediyseniz, onu bir CGI betiği olarak kullanabilirsiniz.

Örneğin, Web siteniz varsa https://www.example.com/bir Linux Web barındırma sağlayıcısında barındırılır ve test.cgi'yi ana dizine yükler ve yürütme izinleri verirsiniz, ardından ziyaret edinhttps://www.example.com/test.cgi yazan bir HTML sayfası döndürmelidir This is a test.

Burada bir Web tarayıcısından test.cgi istendiğinde, Web sunucusu Web sitesinde test.cgi'yi arar ve ardından bunu Ruby yorumlayıcısını kullanarak yürütür. Ruby betiği, temel bir HTTP başlığı döndürür ve ardından temel bir HTML belgesi döndürür.

Cgi.rb kullanma

Ruby, adında özel bir kitaplıkla birlikte gelir cgi bu, önceki CGI betiği ile olanlardan daha karmaşık etkileşimler sağlar.

Cgi kullanan temel bir CGI betiği oluşturalım -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new

puts cgi.header
puts "<html><body>This is a test</body></html>"

Burada bir CGI nesnesi oluşturdunuz ve bunu sizin için başlık satırını yazdırmak için kullandınız.

Form İşleme

CGI sınıfını kullanmak, HTML sorgu parametrelerine iki şekilde erişmenizi sağlar. Bize /cgi-bin/test.cgi?FirstName = Zara & LastName = Ali'nin bir URL'sinin verildiğini varsayalım.

FirstName ve LastName parametrelerine CGI # [] kullanarak aşağıdaki gibi doğrudan erişebilirsiniz -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
cgi['FirstName'] # =>  ["Zara"]
cgi['LastName']  # =>  ["Ali"]

Bu form değişkenlerine erişmenin başka bir yolu var. Bu kod size tüm anahtar ve değerlerin bir karmasını verecektir -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
h = cgi.params  # =>  {"FirstName"=>["Zara"],"LastName"=>["Ali"]}
h['FirstName']  # =>  ["Zara"]
h['LastName']   # =>  ["Ali"]

Tüm anahtarları almak için kod aşağıdadır -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
cgi.keys         # =>  ["FirstName", "LastName"]

Bir form aynı ada sahip birden çok alan içeriyorsa, karşılık gelen değerler koda bir dizi olarak döndürülür. [] Erişimcisi, hepsini almak için these.index'in yalnızca ilkini params yönteminin sonucunu döndürür.

Bu örnekte, formda "ad" adlı üç alan olduğunu ve "Zara", "Huma" ve "Nuha" adlı üç ad girdiğimizi varsayalım -

#!/usr/bin/ruby

require 'cgi'
cgi = CGI.new
cgi['name']        # => "Zara"
cgi.params['name'] # => ["Zara", "Huma", "Nuha"]
cgi.keys           # => ["name"]
cgi.params         # => {"name"=>["Zara", "Huma", "Nuha"]}

NoteRuby, GET ve POST yöntemleriyle otomatik olarak ilgilenecektir. Bu iki farklı yöntemin ayrı bir tedavisi yoktur.

Doğru verileri gönderebilen ilişkili, ancak temel bir form, şu şekilde HTML koduna sahip olacaktır:

<html>
   <body>
      <form method = "POST" action = "http://www.example.com/test.cgi">
         First Name :<input type = "text" name = "FirstName" value = "" />
         <br />
         Last Name :<input type = "text" name = "LastName" value = "" /> 
         <input type = "submit" value = "Submit Data" />
      </form>
   </body>
</html>

Formlar ve HTML Oluşturma

CGI, HTML oluşturmak için kullanılan çok sayıda yöntem içerir. Etiket başına bir yöntem bulacaksınız. Bu yöntemleri etkinleştirmek için, CGI.new'i çağırarak bir CGI nesnesi oluşturmanız gerekir.

Etiket yerleştirmeyi kolaylaştırmak için, bu yöntemler içeriklerini kod blokları olarak alır. Kod blokları , etiketin içeriği olarak kullanılacak bir Dize döndürmelidir . Örneğin -

#!/usr/bin/ruby

require "cgi"
cgi = CGI.new("html4")
cgi.out {
   cgi.html {
      cgi.head { "\n"+cgi.title{"This Is a Test"} } +
      cgi.body { "\n"+
         cgi.form {"\n"+
            cgi.hr +
            cgi.h1 { "A Form: " } + "\n"+
            cgi.textarea("get_text") +"\n"+
            cgi.br +
            cgi.submit
         }
      }
   }
}

NOTE- CGI sınıfının form yöntemi, form gönderimi sırasında kullanılacak HTTP yöntemini (GET, POST, vb.) Ayarlayacak bir yöntem parametresini kabul edebilir. Bu örnekte kullanılan varsayılan POST'tur.

Bu, aşağıdaki sonucu verecektir -

Content-Type: text/html
Content-Length: 302

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Final//EN">

<HTML>
   <HEAD>
      <TITLE>This Is a Test</TITLE>
   </HEAD>
   <BODY>
      <FORM METHOD = "post" ENCTYPE = "application/x-www-form-urlencoded">
         <HR>
         <H1>A Form: </H1>
         <TEXTAREA COLS = "70" NAME = "get_text" ROWS = "10"></TEXTAREA>
         <BR>
         <INPUT TYPE = "submit">
      </FORM>
   </BODY>
</HTML>

Dizeleri Alıntılamak

URL'ler ve HTML kodu ile uğraşırken, belirli karakterleri alıntılamaya dikkat etmelisiniz. Örneğin, eğik çizgi karakteri (/) bir URL'de özel bir anlama sahiptir, bu nedenleescaped yol adının bir parçası değilse.

Örneğin, URL’nin sorgu kısmındaki herhangi bir /,% 2F dizesine çevrilir ve kullanmanız için /’ye geri çevrilmesi gerekir. Boşluk ve ve işareti de özel karakterlerdir. Bunu halletmek için, CGI rutinleri sağlarCGI.escape ve CGI.unescape.

#!/usr/bin/ruby

require 'cgi'
puts CGI.escape(Zara Ali/A Sweet & Sour Girl")

Bu, aşağıdaki sonucu verecektir -

Zara+Ali%2FA Sweet+%26+Sour+Girl")

#!/usr/bin/ruby

require 'cgi'
puts CGI.escapeHTML('<h1>Zara Ali/A Sweet & Sour Girl</h1>')

Bu, aşağıdaki sonucu verecektir -

<h1>Zara Ali/A Sweet & Sour Girl</h1>'

CGI Sınıfında Kullanışlı Yöntemler

İşte CGI sınıfıyla ilgili yöntemlerin listesi -

• Yakut CGI - Standart CGI kütüphaneye ilişkin yöntemler.

Çerezler ve Oturumlar

Bu iki kavramı farklı bölümlerde açıkladık. Lütfen bölümleri takip edin -

• Yakut CGI Çerezler - CGI Çerezler nasıl baş edilir.

• Yakut CGI Sessions - CGI oturumları yönetmek için.

Web Hosting Sunucuları

Web sitenizi Unix tabanlı bir Sunucuda barındırmak için internette aşağıdaki konuyu kontrol edebilirsiniz -

• Unix tabanlı web barındırma

Basit Posta Aktarım Protokolü (SMTP), e-posta göndermeyi ve posta sunucuları arasında e-posta yönlendirmeyi işleyen bir protokoldür.

Ruby, Basit Posta Aktarım Protokolü (SMTP) istemci tarafı bağlantısı için Net :: SMTP sınıfı sağlar ve yeni ve başlangıç ​​olmak üzere iki sınıf yöntemi sağlar .

• new iki parametre alır -

  • Varsayılan olarak localhost olan sunucu adı .

  • Bağlantı noktası numarası, varsayılan olarak iyi bilinen bağlantı noktası 25'e ayarlanır.

• start yöntem bu parametreleri alır -

  • Sunucu - SMTP sunucusunun IP adı, localhost'a varsaymak.

  • Bağlantı noktası - Bağlantı noktası numarası, varsayılan olarak 25'tir.

  • Domain ENV [ "HOSTNAME"] varsaymak posta gönderen Alan, -.

  • Hesap - Kullanıcı adı, varsayılan sıfırdır.

  • Şifre - Kullanıcı parolası, nil varsaymak.

  • Authtype - Yetkilendirme tipi, varsaymak cram_md5 .

Bir SMTP nesnesinin, genellikle bir iletiyi postalama işini yapmak için kullanılan sendmail adlı bir örnek yöntemi vardır. Üç parametre alır -

• Kaynak - Bir ile bir dize veya dizi ya da bir şey her yineleyici bir seferde bir dize dönen.

• Gönderici - görünecektir bir dize gelen e-postanın alanında.

• Alıcıları - bir dize veya alıcıların muhatap (ler) i temsil eden şeritlerinin bir dizi.

Misal

Ruby komut dosyasını kullanarak bir e-posta göndermenin basit bir yolu. Bir kez deneyin -

require 'net/smtp'

message = <<MESSAGE_END
From: Private Person <[email protected]>
To: A Test User <[email protected]>
Subject: SMTP e-mail test

This is a test e-mail message.
MESSAGE_END

Net::SMTP.start('localhost') do |smtp|
  smtp.send_message message, '[email protected]', '[email protected]'
end

Burada, başlıkları doğru şekilde biçimlendirmeye dikkat ederek, bir belge kullanarak mesaja temel bir e-posta yerleştirdiniz. E-postalar için birFrom, To, ve Subject e-postanın gövdesinden boş bir satırla ayrılmış başlık.

Postayı göndermek için, yerel makinedeki SMTP sunucusuna bağlanmak için Net :: SMTP'yi kullanın ve ardından parametre olarak mesaj, gönderen adresi ve hedef adresi ile birlikte send_message yöntemini kullanın (gönderen ve gönderen adresleri e-postanın içinde, bunlar her zaman postayı yönlendirmek için kullanılmaz).

Makinenizde bir SMTP sunucusu çalıştırmıyorsanız, uzak bir SMTP sunucusuyla iletişim kurmak için Net :: SMTP'yi kullanabilirsiniz. Bir web posta hizmeti (Hotmail veya Yahoo! Mail gibi) kullanmadığınız sürece, e-posta sağlayıcınız size aşağıdaki gibi Net :: SMTP'ye sağlayabileceğiniz giden posta sunucusu ayrıntılarını sağlayacaktır -

Net::SMTP.start('mail.your-domain.com')

Bu kod satırı, herhangi bir kullanıcı adı veya parola kullanmadan mail.alanınız.com'un 25 numaralı bağlantı noktasındaki SMTP sunucusuna bağlanır. Gerekirse, bağlantı noktası numarasını ve diğer ayrıntıları belirtebilirsiniz. Örneğin -

Net::SMTP.start('mail.your-domain.com', 
                25, 
                'localhost', 
                'username', 'password' :plain)

Bu örnek, düz metin biçiminde bir kullanıcı adı ve parola kullanarak mail.alanınız.com adresindeki SMTP sunucusuna bağlanır. İstemcinin ana bilgisayar adını localhost olarak tanımlar.

Ruby kullanarak bir HTML e-postası gönderme

Ruby kullanarak bir metin mesajı gönderdiğinizde, tüm içerik basit metin olarak değerlendirilecektir. Metin mesajına HTML etiketleri ekleseniz bile, basit metin olarak görüntülenecek ve HTML etiketleri HTML sözdizimine göre biçimlendirilmeyecektir. Ancak Ruby Net :: SMTP, bir HTML mesajını gerçek HTML mesajı olarak gönderme seçeneği sunar.

Bir e-posta mesajı gönderirken, bir HTML e-postası göndermek için bir Mime sürümü, içerik türü ve karakter seti belirleyebilirsiniz.

Misal

Aşağıda, HTML içeriğini e-posta olarak gönderme örneği verilmiştir. Bir kez deneyin -

require 'net/smtp'

message = <<MESSAGE_END
From: Private Person <[email protected]>
To: A Test User <[email protected]>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP e-mail test

This is an e-mail message to be sent in HTML format

<b>This is HTML message.</b>
<h1>This is headline.</h1>
MESSAGE_END

Net::SMTP.start('localhost') do |smtp|
   smtp.send_message message, '[email protected]', '[email protected]'
end

Ekleri e-posta olarak gönderme

Karışık içerikli bir e-posta göndermek için şunu ayarlamanız gerekir: Content-type başlık multipart/mixed. Ardından metin ve ek bölümleri içinde belirtilebilirboundaries.

E-postanın mesaj bölümünde görünemeyen, iki tire ve ardından benzersiz bir sayı ile bir sınır başlatılır. E-postanın son bölümünü belirten son sınır da iki kısa çizgiyle bitmelidir.

Ekli dosyalar şu şekilde kodlanmalıdır: pack("m") iletimden önce base64 kodlamasına sahip olmak için işlev.

Misal

Bir dosya gönderecek örnek aşağıdadır /tmp/test.txt ek olarak.

require 'net/smtp'

filename = "/tmp/test.txt"
# Read a file and encode it into base64 format
filecontent = File.read(filename)
encodedcontent = [filecontent].pack("m")   # base64

marker = "AUNIQUEMARKER"
body = <<EOF
This is a test email to send an attachement.
EOF

# Define the main headers.
part1 = <<EOF
From: Private Person <[email protected]>
To: A Test User <[email protected]>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary = #{marker}
--#{marker}
EOF

# Define the message action
part2 = <<EOF
Content-Type: text/plain
Content-Transfer-Encoding:8bit

#{body}
--#{marker}
EOF

# Define the attachment section
part3 = <<EOF
Content-Type: multipart/mixed; name = \"#{filename}\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename = "#{filename}"

#{encodedcontent}
--#{marker}--
EOF

mailtext = part1 + part2 + part3

# Let's put our code in safe area
begin 
   Net::SMTP.start('localhost') do |smtp|
      smtp.sendmail(mailtext, '[email protected]', ['[email protected]'])
   end
rescue Exception => e  
   print "Exception occured: " + e  
end

NOTE - Dizi içinde birden çok hedef belirtebilirsiniz, ancak bunlar virgülle ayrılmalıdır.

Ruby, ağ hizmetlerine iki düzeyde erişim sağlar. Düşük bir düzeyde, hem bağlantı odaklı hem de bağlantısız protokoller için istemcileri ve sunucuları uygulamanıza olanak tanıyan temeldeki işletim sistemindeki temel yuva desteğine erişebilirsiniz.

Ruby ayrıca FTP, HTTP vb. Gibi belirli uygulama düzeyindeki ağ protokollerine daha yüksek düzeyde erişim sağlayan kitaplıklara sahiptir.

Bu bölüm size Ağ Oluşturma - Soket Programlama'daki en ünlü kavram hakkında bir fikir verecektir.

Soketler nedir?

Soketler, çift yönlü bir iletişim kanalının uç noktalarıdır. Soketler bir işlem içinde, aynı makinedeki işlemler arasında veya farklı kıtalardaki işlemler arasında iletişim kurabilir.

Soketler, bir dizi farklı kanal türü üzerinden uygulanabilir: Unix etki alanı soketleri, TCP, UDP, vb. Soket ortak taşımaları yanı sıra dinlenme işlemek için genel bir arayüz işlemek için belirli sınıfları sağlar.

Soketlerin kendi kelime dağarcığı vardır -

Sr.No.	Terim ve Açıklama
1	domain Taşıma mekanizması olarak kullanılacak protokol ailesi. Bu değerler, PF_INET, PF_UNIX, PF_X25 ve benzeri gibi sabitlerdir.
2	type İki uç nokta arasındaki iletişim türü, tipik olarak bağlantı odaklı protokoller için SOCK_STREAM ve bağlantısız protokoller için SOCK_DGRAM.
3	protocol Tipik olarak sıfır, bu, bir alan ve tür içindeki bir protokolün bir varyantını tanımlamak için kullanılabilir.
4	hostname Bir ağ arayüzünün tanımlayıcısı - Bir ana bilgisayar adı, noktalı dörtlü bir adres veya iki nokta üst üste (ve muhtemelen nokta) gösteriminde bir IPV6 adresi olabilen bir dize Bir INADDR_BROADCAST adresini belirten bir "<broadcast>" dizesi. INADDR_ANY'yi belirten sıfır uzunluklu bir dize veya Ana bilgisayar bayt sırasına göre ikili adres olarak yorumlanan bir Tamsayı.
5	port Her sunucu, bir veya daha fazla bağlantı noktasını arayan istemcileri dinler. Bir bağlantı noktası, bir Fixnum bağlantı noktası numarası, bir bağlantı noktası numarası içeren bir dize veya bir hizmetin adı olabilir.

Basit Bir Müşteri

Burada, belirli bir bağlantı noktasına ve verilen ana bilgisayara bağlantı açacak çok basit bir istemci programı yazacağız. Ruby sınıfıTCPSocketböyle bir soketi açmak için açık fonksiyon sağlar .

TCPSocket.open(hosname, port )TCP bağlantısı açar hostname üzerinde port .

Bir soket açtıktan sonra, herhangi bir IO nesnesi gibi okuyabilirsiniz. Bittiğinde, bir dosyayı kapatacağınız için onu kapatmayı unutmayın.

Aşağıdaki kod, belirli bir ana bilgisayara ve bağlantı noktasına bağlanan, soketten mevcut verileri okuyan ve ardından çıkan çok basit bir istemcidir -

require 'socket'        # Sockets are in standard library

hostname = 'localhost'
port = 2000

s = TCPSocket.open(hostname, port)

while line = s.gets     # Read lines from the socket
   puts line.chop       # And print with platform line terminator
end
s.close                 # Close the socket when done

Basit Bir Sunucu

İnternet sunucularını yazmak için, TCPServersınıf. Bir TCPServer nesnesi, TCPSocket nesneleri için bir fabrikadır.

Şimdi ara TCPServer.open(hostname, porthizmetiniz için bir bağlantı noktası belirleme ve birTCPServer nesne.

Ardından, döndürülen TCPServer nesnesinin kabul yöntemini çağırın. Bu yöntem, bir istemci belirttiğiniz bağlantı noktasına bağlanıncaya kadar bekler ve ardından bu istemciye bağlantıyı temsil eden bir TCPSocket nesnesi döndürür .

require 'socket'                 # Get sockets from stdlib

server = TCPServer.open(2000)    # Socket to listen on port 2000
loop {                           # Servers run forever
   client = server.accept        # Wait for a client to connect
   client.puts(Time.now.ctime)   # Send the time to the client
   client.puts "Closing the connection. Bye!"
   client.close                  # Disconnect from the client
}

Şimdi, bu sunucuyu arka planda çalıştırın ve ardından sonucu görmek için yukarıdaki istemciyi çalıştırın.

Çok İstemcili TCP Sunucuları

İnternetteki çoğu sunucu, herhangi bir zamanda çok sayıda istemciyle ilgilenecek şekilde tasarlanmıştır.

Ruby'nin Thread sınıfı, istekleri kabul eden ve ana programın daha fazla bağlantı beklemesine izin verirken bağlantıyı işlemek için hemen yeni bir yürütme dizisi oluşturan çok iş parçacıklı bir sunucu oluşturmayı kolaylaştırır.

require 'socket'                 # Get sockets from stdlib

server = TCPServer.open(2000)    # Socket to listen on port 2000
loop {                           # Servers run forever
   Thread.start(server.accept) do |client|
   client.puts(Time.now.ctime)   # Send the time to the client
   client.puts "Closing the connection. Bye!"
   client.close                  # Disconnect from the client
   end
}

Bu örnekte, kalıcı bir döngünüz var ve server.accept yanıt verdiğinde, iş parçacığına iletilen bağlantı nesnesini kullanarak yeni bir iş parçacığı oluşturulur ve yeni kabul edilen bağlantıyı işlemek için hemen başlatılır. Ancak, ana program hemen geri döner ve yeni bağlantılar bekler.

Ruby iş parçacığını bu şekilde kullanmak, kodun taşınabilir olduğu ve Linux, OS X ve Windows'ta aynı şekilde çalışacağı anlamına gelir.

Küçük Bir Web Tarayıcısı

Soket kitaplığını herhangi bir İnternet protokolünü uygulamak için kullanabiliriz. Burada, örneğin, bir web sayfasının içeriğini almak için bir kod var -

require 'socket'
 
host = 'www.tutorialspoint.com'     # The web server
port = 80                           # Default HTTP port
path = "/index.htm"                 # The file we want 

# This is the HTTP request we send to fetch a file
request = "GET #{path} HTTP/1.0\r\n\r\n"

socket = TCPSocket.open(host,port)  # Connect to server
socket.print(request)               # Send request
response = socket.read              # Read complete response
# Split response at first blank line into headers and body
headers,body = response.split("\r\n\r\n", 2) 
print body                          # And display it

Benzer web istemcisini uygulamak için önceden oluşturulmuş bir kitaplık kullanabilirsiniz. Net::HTTPHTTP ile çalışmak için. İşte önceki kodun eşdeğerini yapan kod -

require 'net/http'                  # The library we need
host = 'www.tutorialspoint.com'     # The web server
path = '/index.htm'                 # The file we want 

http = Net::HTTP.new(host)          # Create a connection
headers, body = http.get(path)      # Request the file
if headers.code == "200"            # Check the status code   
   print body                        
else                                
   puts "#{headers.code} #{headers.message}" 
end

Lütfen FTP, SMTP, POP ve IMAP protokolleriyle çalışmak için benzer kitaplıkları kontrol edin.

Diğer Okumalar

Size Soket Programlamaya hızlı bir başlangıç ​​yaptık. Bu büyük bir konudur, bu nedenle daha fazla ayrıntı bulmak için Ruby Soket Kitaplığı ve Sınıf Yöntemlerini incelemeniz önerilir .

XML nedir?

Genişletilebilir Biçimlendirme Dili (XML), HTML veya SGML'ye çok benzer bir biçimlendirme dilidir. Bu, World Wide Web Konsorsiyumu tarafından önerilir ve açık bir standart olarak mevcuttur.

XML, programcıların işletim sistemi ve / veya geliştirme dilinden bağımsız olarak diğer uygulamalar tarafından okunabilen uygulamalar geliştirmesine olanak tanıyan taşınabilir, açık kaynaklı bir dildir.

XML, SQL tabanlı bir omurga gerektirmeden küçük ila orta büyüklükteki verileri izlemek için son derece kullanışlıdır.

XML Ayrıştırıcı Mimarileri ve API'leri

XML ayrıştırıcılar için kullanılabilen iki farklı çeşit vardır -

• SAX-like (Stream interfaces)- Burada, ilgili olaylar için geri aramaları kaydedersiniz ve ardından ayrıştırıcının belge boyunca ilerlemesine izin verirsiniz. Bu, belgeleriniz büyük olduğunda veya bellek sınırlamalarınız olduğunda kullanışlıdır, dosyayı diskten okurken ayrıştırır ve dosyanın tamamı hiçbir zaman bellekte depolanmaz.

• DOM-like (Object tree interfaces) - Bu, tüm dosyanın belleğe okunduğu ve bir XML belgesinin tüm özelliklerini temsil etmek için hiyerarşik (ağaç tabanlı) bir biçimde depolandığı World Wide Web Consortium önerisidir.

SAX, büyük dosyalarla çalışırken DOM'un yapabildiği kadar hızlı bilgiyi işleyemez. Öte yandan, yalnızca DOM'u kullanmak, özellikle çok sayıda küçük dosyada kullanılıyorsa, kaynaklarınızı gerçekten öldürebilir.

SAX salt okunurdur, DOM ise XML dosyasında değişikliklere izin verir. Bu iki farklı API tam anlamıyla birbirini tamamladığından, her ikisini de büyük projelerde kullanamamanız için hiçbir neden yoktur.

Ruby Kullanarak XML Ayrıştırma ve Oluşturma

XML'i işlemenin en yaygın yolu Sean Russell'ın REXML kitaplığıdır. REXML 2002'den beri standart Ruby dağıtımının bir parçası olmuştur.

REXML, XML 1.0 standardına uygun saf bir Ruby XML işlemcisidir. Bu ise olmayan doğrulama OASIS olmayan doğrulama uyumluluk testleri her geçen işlemci.

REXML ayrıştırıcısı, diğer mevcut ayrıştırıcılara göre şu avantajlara sahiptir:

• Ruby'de yüzde 100 yazılmıştır.
• Hem SAX hem de DOM ayrıştırması için kullanılabilir.
• Hafiftir, 2000 satırdan az koddur.
• Yöntemler ve sınıflar gerçekten anlaşılması kolaydır.
• SAX2 tabanlı API ve Tam XPath desteği.
• Ruby kurulumuyla gönderilir ve ayrı bir kurulum gerekmez.

Tüm XML kodu örneklerimiz için, girdi olarak basit bir XML dosyası kullanalım -

<collection shelf = "New Arrivals">
   <movie title = "Enemy Behind">
      <type>War, Thriller</type>
      <format>DVD</format>
      <year>2003</year>
      <rating>PG</rating>
      <stars>10</stars>
      <description>Talk about a US-Japan war</description>
   </movie>
   <movie title = "Transformers">
      <type>Anime, Science Fiction</type>
      <format>DVD</format>
      <year>1989</year>
      <rating>R</rating>
      <stars>8</stars>
      <description>A schientific fiction</description>
   </movie>
   <movie title = "Trigun">
      <type>Anime, Action</type>
      <format>DVD</format>
      <episodes>4</episodes>
      <rating>PG</rating>
      <stars>10</stars>
      <description>Vash the Stampede!</description>
   </movie>
   <movie title = "Ishtar">
      <type>Comedy</type>
      <format>VHS</format>
      <rating>PG</rating>
      <stars>2</stars>
      <description>Viewable boredom</description>
   </movie>
</collection>

DOM benzeri Ayrıştırma

Öncelikle XML verilerimizi ağaç tarzında ayrıştıralım . İsteyerek başlıyoruzrexml/documentkütüphane; genellikle kolaylık sağlamak için üst düzey ad alanına içe aktarmak için bir REXML dahil ederiz.

#!/usr/bin/ruby -w

require 'rexml/document'
include REXML

xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)

# Now get the root element
root = xmldoc.root
puts "Root element : " + root.attributes["shelf"]

# This will output all the movie titles.
xmldoc.elements.each("collection/movie"){ 
   |e| puts "Movie Title : " + e.attributes["title"] 
}

# This will output all the movie types.
xmldoc.elements.each("collection/movie/type") {
   |e| puts "Movie Type : " + e.text 
}

# This will output all the movie description.
xmldoc.elements.each("collection/movie/description") {
   |e| puts "Movie Description : " + e.text 
}

Bu, aşağıdaki sonucu verecektir -

Root element : New Arrivals
Movie Title : Enemy Behind
Movie Title : Transformers
Movie Title : Trigun
Movie Title : Ishtar
Movie Type : War, Thriller
Movie Type : Anime, Science Fiction
Movie Type : Anime, Action
Movie Type : Comedy
Movie Description : Talk about a US-Japan war
Movie Description : A schientific fiction
Movie Description : Vash the Stampede!
Movie Description : Viewable boredom

SAX benzeri Ayrıştırma

Aynı verileri, movies.xml dosyasını, akış odaklı bir şekilde işlemek için , yöntemleri ayrıştırıcıdan gelen geri aramaların hedefi olacak bir dinleyici sınıfı tanımlayacağız .

NOTE - Küçük bir dosya için SAX benzeri ayrıştırmanın kullanılması önerilmez, bu sadece bir demo örneği içindir.

#!/usr/bin/ruby -w

require 'rexml/document'
require 'rexml/streamlistener'
include REXML

class MyListener
   include REXML::StreamListener
   def tag_start(*args)
      puts "tag_start: #{args.map {|x| x.inspect}.join(', ')}"
   end

   def text(data)
      return if data =~ /^\w*$/     # whitespace only
      abbrev = data[0..40] + (data.length > 40 ? "..." : "")
      puts "  text   :   #{abbrev.inspect}"
   end
end

list = MyListener.new
xmlfile = File.new("movies.xml")
Document.parse_stream(xmlfile, list)

Bu, aşağıdaki sonucu verecektir -

tag_start: "collection", {"shelf"=>"New Arrivals"}
tag_start: "movie", {"title"=>"Enemy Behind"}
tag_start: "type", {}
   text   :   "War, Thriller"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Talk about a US-Japan war"
tag_start: "movie", {"title"=>"Transformers"}
tag_start: "type", {}
   text   :   "Anime, Science Fiction"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "A schientific fiction"
tag_start: "movie", {"title"=>"Trigun"}
tag_start: "type", {}
   text   :   "Anime, Action"
tag_start: "format", {}
tag_start: "episodes", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Vash the Stampede!"
tag_start: "movie", {"title"=>"Ishtar"}
tag_start: "type", {}
tag_start: "format", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Viewable boredom"

XPath ve Ruby

XML'i görüntülemenin alternatif bir yolu XPath'dir. Bu, bir XML belgesindeki belirli öğelerin ve özniteliklerin nasıl konumlandırılacağını açıklayan ve bu belgeyi mantıksal sıralı bir ağaç olarak ele alan bir tür sözde dildir.

REXML, XPath sınıfı aracılığıyla XPath desteğine sahiptir . Yukarıda gördüğümüz gibi ağaç temelli ayrıştırmayı (belge nesne modeli) varsayar.

#!/usr/bin/ruby -w

require 'rexml/document'
include REXML

xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)

# Info for the first movie found
movie = XPath.first(xmldoc, "//movie")
p movie

# Print out all the movie types
XPath.each(xmldoc, "//type") { |e| puts e.text }

# Get an array of all of the movie formats.
names = XPath.match(xmldoc, "//format").map {|x| x.text }
p names

Bu, aşağıdaki sonucu verecektir -

<movie title = 'Enemy Behind'> ... </>
War, Thriller
Anime, Science Fiction
Anime, Action
Comedy
["DVD", "DVD", "DVD", "VHS"]

XSLT ve Ruby

Ruby'nin kullanabileceği iki XSLT ayrıştırıcısı vardır. Her birinin kısa bir açıklaması burada verilmiştir.

Ruby-Sablotron

Bu ayrıştırıcı, Masayoshi Takahashi tarafından yazılır ve sürdürülür. Bu, öncelikle Linux işletim sistemi için yazılmıştır ve aşağıdaki kitaplıkları gerektirir -

• Sablot
• Iconv
• Expat

Bu modülü şu adreste bulabilirsiniz: Ruby-Sablotron.

XSLT4R

XSLT4R, Michael Neumann tarafından yazılmıştır ve RAA'da, XML altındaki Kitaplık bölümünde bulunabilir. XSLT4R, basit bir komut satırı arayüzü kullanır, ancak alternatif olarak bir XML belgesini dönüştürmek için üçüncü taraf bir uygulamada da kullanılabilir.

XSLT4R'nin çalışması için, XSLT4R arşivinde bulunan ve aynı zamanda yüzde 100 Ruby modülü olan XMLScan'e ihtiyacı vardır. Bu modüller, standart Ruby kurulum yöntemi (yani, ruby ​​install.rb) kullanılarak kurulabilir.

XSLT4R aşağıdaki sözdizimine sahiptir -

ruby xslt.rb stylesheet.xsl document.xml [arguments]

XSLT4R'yi bir uygulama içinden kullanmak istiyorsanız, XSLT'yi dahil edebilir ve ihtiyacınız olan parametreleri girebilirsiniz. İşte örnek -

require "xslt"

stylesheet = File.readlines("stylesheet.xsl").to_s
xml_doc = File.readlines("document.xml").to_s
arguments = { 'image_dir' => '/....' }
sheet = XSLT::Stylesheet.new( stylesheet, arguments )

# output to StdOut
sheet.apply( xml_doc )

# output to 'str'
str = ""
sheet.output = [ str ]
sheet.apply( xml_doc )

Daha fazla okuma

• REXML Ayrıştırıcı hakkında eksiksiz bir ayrıntı için, lütfen REXML Ayrıştırıcı Belgeleri için standart belgelere bakın .

• XSLT4R'yi RAA Deposundan indirebilirsiniz .

SABUN nedir?

Basit Nesne Erişim Protokolü (SOAP), XML'e ve genellikle (ancak zorunlu olarak değil) HTTP'ye dayalı, çapraz platform ve dilden bağımsız bir RPC protokolüdür.

Uzaktan yordam çağrısını yapan bilgileri kodlamak için XML kullanır ve bu bilgileri bir ağ üzerinden istemcilerden sunuculara ve tersi şekilde taşımak için HTTP kullanır.

SOAP, COM, CORBA vb. Gibi diğer teknolojilere göre çeşitli avantajlara sahiptir: örneğin, nispeten ucuz dağıtım ve hata ayıklama maliyetleri, genişletilebilirliği ve kullanım kolaylığı ve farklı diller ve platformlar için çeşitli uygulamaların varlığı.

Ayrıntılı olarak anlamak için lütfen basit öğretici SABUNumuza bakın .

Bu bölüm, Ruby için SOAP uygulamasına (SOAP4R) aşina olmanızı sağlar. Bu temel bir öğreticidir, bu nedenle derin bir ayrıntıya ihtiyacınız varsa, diğer kaynaklara başvurmanız gerekir.

SOAP4R Kurulumu

SOAP4R, Hiroshi Nakamura tarafından geliştirilen Ruby için SOAP uygulamasıdır ve şu adresten indirilebilir:

NOTE - Bu bileşeni halihazırda yüklemiş olmanız büyük bir olasılık olabilir.

Download SOAP

Eğer farkında iseniz gem yardımcı program daha sonra SOAP4R ve ilgili paketleri yüklemek için aşağıdaki komutu kullanabilirsiniz.

$ gem install soap4r --include-dependencies

Windows üzerinde çalışıyorsanız, yukarıdaki konumdan sıkıştırılmış bir dosya indirmeniz ve ruby install.rb dosyasını çalıştırarak standart kurulum yöntemini kullanarak yüklemeniz gerekir .

SOAP4R Sunucuları Yazma

SOAP4R iki farklı sunucu türünü destekler -

• CGI / FastCGI tabanlı (SOAP :: RPC :: CGIStub)
• Bağımsız (SOAP :: RPC: StandaloneServer)

Bu bölüm, bağımsız bir sunucu yazma hakkında ayrıntılı bilgi verir. Aşağıdaki adımlar, bir SOAP sunucusu yazmakla ilgilidir.

Adım 1 - SOAP :: RPC :: StandaloneServer Sınıfını Devralın

Kendi bağımsız sunucunuzu uygulamak için , aşağıdaki gibi SOAP :: StandaloneServer'ın alt öğesi olacak yeni bir sınıf yazmanız gerekir -

class MyServer < SOAP::RPC::StandaloneServer
  ...............
end

NOTE- FastCGI tabanlı bir sunucu yazmak istiyorsanız, SOAP :: RPC :: CGIStub'u üst sınıf olarak almanız gerekir , prosedürün geri kalanı aynı kalacaktır.

Adım 2 - İşleyici Yöntemlerini Tanımlayın

İkinci adım, dış dünyaya göstermek istediğiniz Web Hizmetleri yöntemlerinizi yazmaktır.

Basit Ruby yöntemleri olarak yazılabilirler. Örneğin, iki sayıyı toplamak ve iki sayıyı bölmek için iki yöntem yazalım -

class MyServer < SOAP::RPC::StandaloneServer
   ...............

   # Handler methods
   def add(a, b)
      return a + b
   end
   def div(a, b) 
      return a / b 
   end
end

Adım 3 - İşleyici Yöntemlerini Açığa Çıkarın

Sonraki adım, tanımladığımız yöntemleri sunucumuza eklemektir. İnitialize yöntem aşağıdaki iki yöntemden biri ile hizmet yöntemleri göstermek için kullanılır -

class MyServer < SOAP::RPC::StandaloneServer
   def initialize(*args)
      add_method(receiver, methodName, *paramArg)
   end
end

İşte parametrelerin açıklaması -

Sr.No.	Parametre ve Açıklama
1	receiver MethodName yöntemini içeren nesne. Bu parametredir, methodDef yöntemi olarak aynı sınıfta hizmet yöntemlerini tanımlar kendini .
2	methodName Bir RPC isteği nedeniyle çağrılan yöntemin adı.
3	paramArg Verildiğinde, parametre adlarını ve parametre modlarını belirtir.

Kullanımını anlamak için inout veya dışarı parametreleri, iki parametre (inParam ve inoutParam), döner bir normal dönüş değeri (retVal) ve iki başka parametre alır aşağıdaki hizmet yöntemini göz önünde bulundurun: inoutParam ve outParam -

def aMeth(inParam, inoutParam)
   retVal = inParam + inoutParam
   outParam = inParam . inoutParam
   inoutParam = inParam * inoutParam
   return retVal, inoutParam, outParam
end

Şimdi, bu yöntemi şu şekilde ortaya çıkarabiliriz -

add_method(self, 'aMeth', [
   %w(in inParam),
   %w(inout inoutParam),
   %w(out outParam),
   %w(retval return)
])

Adım 4 - Sunucuyu Başlatın

Son adım, türetilmiş sınıfın bir örneğini oluşturarak ve bunu çağırarak sunucunuzu başlatmaktır. start yöntem.

myServer = MyServer.new('ServerName', 'urn:ruby:ServiceName', hostname, port)

myServer.start

İşte gerekli parametrelerin açıklaması -

Sr.No.	Parametre ve Açıklama
1	ServerName Bir sunucu adı, en sevdiğiniz şeyi verebilirsiniz.
2	urn:ruby:ServiceName Burada urn: ruby sabittir ancak bu sunucu için benzersiz bir ServisAdı adı verebilirsiniz.
3	hostname Bu sunucunun dinleyeceği ana bilgisayar adını belirtir.
4	port Web hizmeti için kullanılacak mevcut bir bağlantı noktası numarası.

Misal

Şimdi, yukarıdaki adımları kullanarak tek bir bağımsız sunucu yazalım -

require "soap/rpc/standaloneserver"

begin
   class MyServer < SOAP::RPC::StandaloneServer

      # Expose our services
      def initialize(*args)
         add_method(self, 'add', 'a', 'b')
         add_method(self, 'div', 'a', 'b')
      end

      # Handler methods
      def add(a, b)
         return a + b
      end
      def div(a, b) 
         return a / b 
      end
end
   server = MyServer.new("MyServer", 
            'urn:ruby:calculation', 'localhost', 8080)
   trap('INT){
      server.shutdown
   }
   server.start
rescue => err
   puts err.message
end

Yürütüldüğünde, bu sunucu uygulaması localhost'ta bağımsız bir SOAP sunucusu başlatır ve 8080 numaralı bağlantı noktasındaki istekleri dinler. İki parametre alan ve sonucu döndüren add ve div adında bir hizmet yöntemi sunar .

Şimdi, bu sunucuyu aşağıdaki gibi arka planda çalıştırabilirsiniz -

$ ruby MyServer.rb&

SOAP4R İstemcileri Yazma

SABUN :: RPC :: Sürücü sınıf SABUN istemci uygulamaları yazmak için destek sağlar. Bu bölüm, bu sınıfı açıklar ve bir uygulama temelinde kullanımını gösterir.

Bir SOAP servisini aramak için ihtiyaç duyacağınız asgari bilgiler aşağıdadır -

• SOAP hizmetinin URL'si (SOAP Uç Nokta URL'si).
• Hizmet yöntemlerinin ad alanı (Yöntem Ad Alanı URI'si).
• Servis yöntemlerinin isimleri ve parametreleri.

Şimdi yukarıdaki örnekte tanımlanan, add ve div adında servis yöntemlerini çağıran bir SOAP istemcisi yazacağız .

SOAP istemcisi oluşturmanın ana adımları aşağıda verilmiştir.

Adım 1 - Bir SOAP Sürücü Örneği Oluşturun

Yeni metodunu aşağıdaki gibi çağırarak SOAP :: RPC :: Driver örneğini oluşturuyoruz -

SOAP::RPC::Driver.new(endPoint, nameSpace, soapAction)

İşte gerekli parametrelerin açıklaması -

Sr.No.	Parametre ve Açıklama
1	endPoint Bağlanılacak SOAP sunucusunun URL'si.
2	nameSpace Bu SOAP :: RPC :: Driver nesnesiyle yapılan tüm RPC'ler için kullanılacak ad alanı.
3	soapAction HTTP başlığının SOAPAction alanı için bir değer. Eğer nil ise, bu varsayılan olarak boş "" dizgisidir.

Adım 2 - Servis Yöntemleri Ekleyin

SOAP :: RPC :: Driver'a bir SOAP servis metodu eklemek için SOAP :: RPC :: Driver örneğini kullanarak aşağıdaki metodu çağırabiliriz -

driver.add_method(name, *paramArg)

İşte parametrelerin açıklaması -

Sr.No.	Parametre ve Açıklama
1	name Uzak web hizmeti yönteminin adı.
2	paramArg Uzak prosedür parametrelerinin adlarını belirtir.

Adım 3 - SOAP hizmetini çağırın

Son adım, SOAP :: RPC :: Driver örneğini kullanarak SOAP servisini aşağıdaki gibi faturalandırmaktır -

result = driver.serviceMethod(paramArg...)

Burada serviceMethod gerçek web hizmeti yöntemidir ve paramArg ... hizmet yönteminde geçmek için gereken liste parametreleridir.

Example

Yukarıdaki adımlara dayanarak, aşağıdaki gibi bir SOAP istemcisi yazacağız -

#!/usr/bin/ruby -w

require 'soap/rpc/driver'

NAMESPACE = 'urn:ruby:calculation'
URL = 'http://localhost:8080/'

begin
   driver = SOAP::RPC::Driver.new(URL, NAMESPACE)
   
   # Add remote sevice methods
   driver.add_method('add', 'a', 'b')

   # Call remote service methods
   puts driver.add(20, 30)
rescue => err
   puts err.message
end

Diğer Okumalar

Size Ruby ile Web Hizmetlerinin çok temel kavramlarını açıkladım. Daha fazla ayrıntıya inmek isterseniz , Ruby ile Web Hizmetleri hakkında daha fazla ayrıntı bulmak için aşağıdaki bağlantı mevcuttur .

Giriş

Ruby için standart grafik kullanıcı arayüzü (GUI) Tk'dir. Tk, John Ousterhout tarafından geliştirilen Tcl betik dili için GUI olarak başladı.

Tk, platformlar arası tek GUI olma özelliğine sahiptir. Tk, Windows, Mac ve Linux üzerinde çalışır ve her işletim sisteminde yerel bir görünüm ve his sağlar.

Tk tabanlı bir uygulamanın temel bileşenine widget denir. Bir bileşene bazen pencere de denir, çünkü Tk'de "pencere" ve "pencere öğesi" genellikle birbirinin yerine kullanılır.

Tk uygulamaları, herhangi bir sayıda widget'ın başka bir widget'a ve bu widget'ların başka bir widget'a (sonsuza kadar) yerleştirilebildiği bir widget hiyerarşisini takip eder. Bir Tk programındaki ana pencere öğesi, kök pencere öğesi olarak adlandırılır ve TkRoot sınıfının yeni bir örneği oluşturularak oluşturulabilir.

• Çoğu Tk tabanlı uygulama aynı döngüyü izler: pencere öğeleri oluşturun, bunları arabirime yerleştirin ve son olarak, her pencere öğesi ile ilişkili olayları bir yönteme bağlayın.

• Üç geometri yöneticisi vardır; Arayüzdeki her bir parçacığın boyutunu ve konumunu kontrol etmekten sorumlu olan yer, ızgara ve paket .

Kurulum

Ruby Tk bağlamaları Ruby ile dağıtılır ancak Tk ayrı bir kurulumdur. Windows kullanıcıları ActiveState'in ActiveTcl'den tek tıkla Tk kurulumunu indirebilir .

Mac ve Linux kullanıcılarının yüklemesi gerekmeyebilir çünkü işletim sistemi ile birlikte halihazırda kurulu olması büyük bir olasılıktır, ancak yoksa önceden oluşturulmuş paketleri indirebilir veya kaynağı Tcl Developer Xchange'den alabilirsiniz .

Basit Tk Uygulaması

Ruby / Tk programları için tipik bir yapı, ana veya root penceresi (bir TkRoot örneği), kullanıcı arayüzünü oluşturmak için ona widget ekleyin ve ardından ana olay döngüsünü çağırarak başlatın. Tk.mainloop.

Geleneksel Merhaba, Dünya! Ruby / Tk için örnek şuna benzer -

require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
   text 'Hello, World!'
   pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop

Burada tk eklenti modülünü yükledikten sonra TkRoot.new kullanarak kök seviyesinde bir çerçeve oluşturuyoruz . Ardından , kök çerçevenin alt öğesi olarak bir TkLabel parçacığı oluşturarak etiket için birkaç seçenek belirledik. Son olarak, kök çerçeveyi paketliyoruz ve ana GUI olay döngüsüne giriyoruz.

Bu komut dosyasını çalıştırırsanız, aşağıdaki sonucu üretir -

Ruby / Tk Widget Sınıfları

Ruby / Tk kullanarak istenen bir GUI oluşturmak için kullanılabilecek çeşitli Ruby / Tk sınıflarının bir listesi vardır.

• TkFrame Çerçeve parçacıkları oluşturur ve işler .

• TkButton Düğme widget'larını oluşturur ve işler .

• TkLabel Etiket parçacıkları oluşturur ve işler .

• TkEntry Giriş widget'larını oluşturur ve işler .

• TkCheckButton Onay düğmesi widget'larını oluşturur ve işler .

• TkRadioButton radiobutton widget'larını oluşturur ve işler .

• TkListbox Liste kutusu widget'larını oluşturur ve işler .

• TkComboBox Liste kutusu widget'larını oluşturur ve işler .

• TkMenu Menü widget'larını oluşturur ve işler .

• TkMenubutton Menü butonu widget'larını oluşturur ve işler.

• Tk.messageBox Bir mesaj iletişim kutusu oluşturur ve işler .

• TkScrollbar Kaydırma çubuğu widget'larını oluşturur ve işler .

• TkCanvas, tuval widget'larını oluşturur ve işler .

• TkScale Ölçek widget'ları oluşturur ve işler .

• TkText Metin widget'ları oluşturur ve işler .

• TkToplevel Üst düzey widget'ları oluşturur ve işler .

• TkSpinbox Spinbox widget'larını oluşturur ve işler.

• TkProgressBar İlerleme Çubuğu widget'larını oluşturur ve işler .

• İletişim Kutusu İletişim Kutusu widget'larını oluşturur ve işler.

• Tk :: Tile :: Notebook Dizüstü bilgisayar metaforu ile sınırlı bir alanda birkaç pencere görüntüleyin.

• Tk :: Tile :: Paned Dikey veya yatay olarak istiflenmiş bir dizi alt pencere görüntüler.

• Tk :: Tile :: Separator Yatay veya dikey bir ayırıcı çubuk görüntüler.

• Ruby / Tk Yazı Tipi, Renkler ve Görüntüler Ruby / Tk Yazı Tiplerini, Renkleri ve Resimleri Anlama

Standart Yapılandırma Seçenekleri

Tüm widget'ların, genellikle nasıl görüntülendiklerini veya nasıl davrandıklarını kontrol eden bir dizi farklı yapılandırma seçeneği vardır. Kullanılabilen seçenekler elbette widget sınıfına bağlıdır.

Herhangi bir Ruby / Tk parçacığı için geçerli olabilecek tüm standart yapılandırma seçeneklerinin listesi burada.

Widget'larla birlikte açıklanabilecek başka widget'a özgü seçenekler de vardır.

Sr.No.	Seçenekler ve Açıklama
1	activebackground => Dize Aktif elemanları çizerken kullanılacak arka plan rengini belirtir. Fare imleci öğenin üzerindeyse bir öğe etkindir ve bir fare düğmesine basmak bazı eylemlerin gerçekleşmesine neden olur. "Kırmızı", "mavi", "pembe", "sarı" vb. Renk adlarını kullanabilirsiniz.
2	activeborderwidth => Tamsayı Etkin elemanların etrafına çizilen 3-B kenarlığın genişliğini gösteren negatif olmayan bir değer belirtir.
3	activeforeground => Dize Aktif öğeleri çizerken kullanılacak ön plan rengini belirtir.
4	anchor => Dize Bir pencere öğesindeki (örneğin, metin veya bitmap) bilgilerin pencere öğesinde nasıl görüntüleneceğini belirtir. Değerlerden biri olmalın, ne, e, se, s, sw, w, nwveya center. Örneğin,nw bilgileri, sol üst köşesi widget'ın sol üst köşesinde olacak şekilde görüntüleme anlamına gelir.
5	background or bg => Dize Widget görüntülenirken kullanılacak normal arka plan rengini belirtir.
6	bitmap => Bit eşlem Widget'ta görüntülenecek bir bitmap belirtir. Bitmap'in tam olarak görüntülenme şekli, çapa veya yaslama gibi diğer seçeneklerden etkilenebilir.
7	borderwidth or bd => Tamsayı Widget'ın dış çevresine çizilecek 3-B kenarlığın genişliğini belirten negatif olmayan bir değer belirtir.
8	compound => Dize Widget'ın metni ve bitmap'leri / resimleri aynı anda görüntüleyip görüntülemeyeceğini ve öyleyse, bitmap / görüntünün metne göre nereye yerleştirilmesi gerektiğini belirtir. Değerlerden biri olmalınone, bottom, top, left, rightveya center.
9	cursor => Dize Widget için kullanılacak fare imlecini belirtir. Olası değerler "izle", "ok" vb. Olabilir.
10	disabledforeground => Dize Devre dışı bırakılmış bir öğeyi çizerken kullanılacak ön plan rengini belirtir.
11	exportselection => Boole Widget'taki bir seçimin de X seçimi olup olmayacağını belirtir. Değer şunlardan herhangi birine sahip olabilir:true, false, 0, 1, yesveya no. Seçim dışa aktarılırsa, widget'ta seçmek geçerli X seçiminin seçimini kaldırır, widget'ın dışını seçmek herhangi bir widget seçiminin seçimini kaldırır ve widget bir seçime sahip olduğunda seçim alma isteklerine yanıt verir.
12	font => Dize Widget içinde metin çizerken kullanılacak yazı tipini belirtir.
13	foreground or fg => Dize Widget görüntülenirken kullanılacak normal ön plan rengini belirtir.
14	highlightbackground => Dize Widget giriş odağına sahip olmadığında geçiş vurgulama bölgesinde görüntülenecek rengi belirtir.
15	highlightcolor => Dize Giriş odağına sahip olduğunda widget'in etrafına çizilen çapraz vurgu dikdörtgeni için kullanılacak rengi belirtir.
16	highlightthickness => Tamsayı Giriş odağı olduğunda widget'ın dışının çevresine çizilecek vurgu dikdörtgeninin genişliğini belirten negatif olmayan bir değer belirtir.
17	image => Resim Bir görüntü oluşturma ile oluşturulmuş olması gereken, widget'ta görüntülenecek bir görüntüyü belirtir. Tipik olarak, görüntü seçeneği belirtilirse, widget'ta görüntülenecek bir bitmap veya metin değeri belirten diğer seçenekleri geçersiz kılar; görüntü seçeneği, bir bitmap veya metin görüntüsünü yeniden etkinleştirmek için boş bir dizeye sıfırlanabilir.
18	jump => Dize Kaydırma çubukları ve ölçekler gibi bir değeri ayarlamak için sürüklenebilen kaydırıcıya sahip widget'lar için bu seçenek, değerdeki değişikliklerle ilgili bildirimlerin ne zaman yapılacağını belirler. Seçeneğin değeri bir boole olmalıdır. Değer yanlışsa, kaydırıcı sürüklenirken sürekli olarak güncellemeler yapılır. Değer true ise, sürüklemeyi sona erdirmek için fare düğmesi bırakılana kadar güncellemeler ertelenir; bu noktada tek bir bildirim yapılır.
19	justify => Dize Bir pencere öğesinde görüntülenen birden çok metin satırı olduğunda, bu seçenek satırların birbiriyle nasıl hizalanacağını belirler. Biri olmalıleft, centerveya right. Left çizgilerin sol kenarlarının tümü aynı hizada olduğu anlamına gelir, center hatların merkezlerinin hizalandığı ve right çizgilerin sağ kenarlarının aynı hizada olduğu anlamına gelir.
20	offset => Dize Döşemelerin ofsetini belirtir (ayrıca bkz. tileseçenek). İki farklı formata sahip olabiliroffset x,y veya offset side, yan nerede olabilir n, ne, e, se, s, sw, w, nwveya center.
21	orient => Dize Kaydırma çubukları gibi kendilerini yatay veya dikey yönde yerleştirebilen widget'lar için bu seçenek, hangi yönün kullanılması gerektiğini belirler. Biri olmalıhorizontal veya vertical veya bunlardan birinin kısaltması.
22	padx => Tamsayı X yönünde pencere öğesi için ne kadar fazladan alan talep edileceğini belirten negatif olmayan bir değer belirtir.
23	pady => Tamsayı Y yönünde widget için ne kadar fazladan alan talep edileceğini belirten negatif olmayan bir değer belirtir.
24	relief => Tamsayı Widget için istenen 3-D efekti belirtir. Kabul edilebilir değerlerraised, sunken, flat, ridge, ve groove.
25	repeatdelay => Tamsayı Otomatik tekrarlamaya başlamadan önce bir düğmenin veya tuşun basılı tutulması gereken milisaniye sayısını belirtir. Örneğin, kaydırma çubuklarındaki yukarı ve aşağı oklarda kullanılır.
26	repeatinterval => Tamsayı İle birlikte kullanılır repeatdelay: otomatik tekrar başladığında, bu seçenek otomatik tekrarlar arasındaki milisaniye sayısını belirler
27	selectbackground => Dize Seçili öğeleri görüntülerken kullanılacak arka plan rengini belirtir.
28	selectborderwidth => Tamsayı Seçili öğelerin çevresini çizmek için 3-B kenarlığın genişliğini belirten negatif olmayan bir değer belirtir.
29	selectforeground => Dize Seçili öğeleri görüntülerken kullanılacak ön plan rengini belirtir.
30	setgrid => Boole Bu widget'ın, üst düzey penceresi için yeniden boyutlandırma ızgarasını kontrol edip etmediğini belirleyen bir boolean değeri belirtir. Bu seçenek tipik olarak, pencere aracındaki bilgilerin doğal bir boyuta (bir karakterin boyutuna) sahip olduğu ve pencere boyutlarının bu birimlerin tamsayıları olması mantıklı olan metin widget'larında kullanılır.
31	takefocus => Tamsayı Odağı bir pencereden pencereye klavye geçişi yoluyla taşırken kullanılan bilgileri sağlar (örn. Sekme ve Shift-Sekme). Odağı bir pencereye ayarlamadan önce, geçiş komut dosyaları önce pencerenin görüntülenebilir olup olmadığını kontrol eder (pencere ve tüm ataları eşlenir); değilse, pencere atlanır. 0 değeri, bu pencerenin klavye geçişi sırasında tamamen atlanması gerektiği anlamına gelir. 1, bu pencerenin her zaman giriş odağını alması gerektiği anlamına gelir.
32	text => Dize Widget içinde görüntülenecek dizeyi belirtir. Dizenin görüntülenme şekli belirli bir parçacığa bağlıdır ve aşağıdakiler gibi diğer seçenekler tarafından belirlenebilir:anchor veya justify.
33	textvariable => Değişken Bir değişkenin adını belirtir. Değişkenin değeri, pencere öğesinin içinde görüntülenecek bir metin dizesidir; değişken değeri değişirse, pencere öğesi yeni değeri yansıtmak için kendini otomatik olarak güncelleyecektir. Dizenin pencere aracında görüntülenme şekli, belirli pencere aracına bağlıdır ve aşağıdakiler gibi diğer seçenekler tarafından belirlenebilir:anchor veya justify.
34	tile => Resim Widget'ı görüntülemek için kullanılan resmi belirtir. Görüntü boş dizeyse, normal arka plan rengi görüntülenir.
35	troughcolor => Dize Kaydırma çubukları ve ölçekler gibi widget'larda dikdörtgen oluk alanları için kullanılacak rengi belirtir.
36	troughtile => Resim Kaydırma çubukları ve ölçekler gibi widget'larda dikdörtgen çukur alanlarında görüntülenmek için kullanılan görüntüyü belirtir.
37	underline => Tamsayı Widget'ta altı çizilecek bir karakterin tamsayı dizinini belirtir. Bu seçenek, menü düğmeleri ve menü girişleri için klavye geçişini uygulamak için varsayılan bağlamalar tarafından kullanılır. 0, widget'ta görüntülenen metnin ilk karakterine, 1 sonraki karaktere vb. Karşılık gelir.
38	wraplength => Tamsayı Sözcük kaydırma yapabilen gereçler için bu seçenek maksimum satır uzunluğunu belirtir.
39	xscrollcommand => işlev Yatay kaydırma çubuklarıyla iletişim kurmak için kullanılan bir geri aramayı belirtir.
40	yscrollcommand => işlev Dikey kaydırma çubuklarıyla iletişim kurmak için kullanılan bir geri aramayı belirtir.

Ruby / Tk Geometri Yönetimi

Geometri Yönetimi, ihtiyaca göre farklı widget'ların konumlandırılmasıyla ilgilenir. Tk'da geometri yönetimi, ana ve bağımlı pencere öğeleri kavramına dayanır.

Kalıp, ikincil olarak adlandırılan diğer parçacıkları içeren bir parçacık, tipik olarak bir üst düzey pencere veya çerçevedir. Bir geometri yöneticisini ana parçacığın kontrolünü ele geçiriyor ve içinde neyin görüntüleneceğine karar veriyor olarak düşünebilirsiniz.

Geometri yöneticisi, her bir yardımcı parçacığın doğal boyutunu veya ideal olarak görüntülenmesinin ne kadar büyük olmasını istediğini soracaktır. Daha sonra bu bilgiyi alır ve geometri yöneticisinden söz konusu yardımcı parçacığı yönetmesini istediğinde program tarafından sağlanan parametrelerle birleştirir.

Arayüzdeki her bir parçacığın boyutunu ve konumunu kontrol etmekten sorumlu üç geometri yöneticisi yer, ızgara ve paket vardır.

• ızgara Geometri yöneticisi bir ızgarada widget'ları düzenler.

• paket Geometri yöneticisi paketi çevresinde boşluğun kenarları.

• yerleştirmek sabit veya lastik levha yerleştirme için Geometri yöneticisi.

Ruby / Tk Olay İşleme

Ruby / Tk , işletim sisteminden olayları alan olay döngüsünü destekler . Bunlar, düğmeye basma, tuş vuruşları, fare hareketi, pencereyi yeniden boyutlandırma vb. Gibi şeylerdir.

Ruby / Tk bu olay döngüsünü sizin için yönetir. Olayın hangi pencere öğesi için geçerli olduğunu bulacak (kullanıcı bu düğmeye tıkladı mı? Bir tuşa basıldıysa, odak hangi metin kutusuna sahipti?) Ve buna göre gönderecektir. Tek tek widget'lar olaylara nasıl yanıt verileceğini bilir, bu nedenle örneğin bir düğme fare üzerine geldiğinde renk değiştirebilir ve fare çıkınca geri dönebilir.

Daha yüksek bir düzeyde, Ruby / Tk, bir parçacığa önemli bir şey olduğunu belirtmek için programınızda geri aramaları çağırır. Her iki durumda da, uygulamanın olaya veya geri aramaya nasıl yanıt vereceğini belirten bir kod bloğu veya Ruby Proc nesnesi sağlayabilirsiniz.

Temel pencere sistemi olaylarını, onları işleyen Ruby prosedürleriyle ilişkilendirmek için bind yönteminin nasıl kullanılacağına bir göz atalım. Bağlamanın en basit biçimi, girdileri olarak olay adını ve Tk'nin olayı işlemek için kullandığı bir kod bloğunu belirten bir dizge alır.

Örneğin, bir widget'taki ilk fare düğmesi için ButtonRelease olayını yakalamak için şunu yazarsınız:

someWidget.bind('ButtonRelease-1') {
   ....code block to handle this event...
}

Bir olay adı, ek değiştiriciler ve ayrıntılar içerebilir. Değiştirici , değiştirici tuşlardan birine basıldığını belirten Shift , Control veya Alt gibi bir dizedir .

Örneğin, kullanıcı Ctrl tuşunu basılı tutup sağ fare düğmesini tıkladığında oluşturulan olayı yakalamak için .

someWidget.bind('Control-ButtonPress-3', proc { puts "Ouch!" })

Pek çok Ruby / Tk pencere öğesi , kullanıcı bunları etkinleştirdiğinde geri çağrıları tetikleyebilir ve bu gerçekleştiğinde belirli bir kod bloğunun veya prosedürün çağrılacağını belirtmek için geri çağrı komutunu kullanabilirsiniz . Daha önce görüldüğü gibi, widget'ı oluşturduğunuzda komut geri çağırma prosedürünü belirtebilirsiniz -

helpButton = TkButton.new(buttonFrame) {
   text "Help"
   command proc { showHelp }
}

Veya daha sonra, widget'ın komut yöntemini kullanarak atayabilirsiniz -

helpButton.command proc { showHelp }

Komut yöntemi prosedürleri veya kod bloklarını kabul ettiğinden, önceki kod örneğini şu şekilde de yazabilirsiniz:

helpButton = TkButton.new(buttonFrame) {
   text "Help"
   command { showHelp }
}

Ruby / Tk uygulamanızda aşağıdaki temel olay türlerini kullanabilirsiniz -

Sr.No.	Etiket ve Etkinlik Açıklaması
1	"1" (one) Sol fare düğmesine tıklandı.
2	"ButtonPress-1" Sol fare düğmesine tıklandı.
3	"Enter" Fare içeriye taşındı.
4	"Leave" Fare dışarı taşındı.
5	"Double-1" Çift tıklandı.
6	"B3-Motion" Sağ düğme bir konumdan diğerine sürükleyin.
7	Control-ButtonPress-3 Sağ tuşa Ctrl tuşu ile birlikte basılır .
8	Alt-ButtonPress-1 Alt Tuşu ile Let butonuna basılır .

Yapılandırma Yöntemi

Yapılandırmak yöntemi setine kullanılan ve herhangi bir Widget yapılandırma değerleri almak edilebilir. Örneğin, bir düğmenin genişliğini değiştirmek için, istediğiniz zaman aşağıdaki gibi configure yöntemini çağırabilirsiniz -

require "tk"

button = TkButton.new {
   text 'Hello World!'
   pack
}
button.configure('activebackground', 'blue')
Tk.mainloop

Mevcut bir parçacığın değerini almak için, aşağıdaki gibi bir değer olmadan sağlamanız yeterlidir -

color = button.configure('activebackground')

Ayrıca hiçbir seçenek olmadan da configure'ü çağırabilirsiniz, bu size tüm seçeneklerin ve bunların değerlerinin bir listesini verir.

Cget Yöntemi

Basitçe bir seçeneğin değerini almak için, configure betiği genel olarak istediğinizden daha fazla bilgi döndürür. Cget yöntemi yalnızca geçerli değeri döndürür.

color = button.cget('activebackground')

Ruby / LDAP, Ruby için bir uzantı kitaplığıdır. OpenLDAP, UMich LDAP, Netscape SDK, ActiveDirectory gibi bazı LDAP kitaplıklarına arayüz sağlar.

Uygulama geliştirme için ortak API, RFC1823'te açıklanmıştır ve Ruby / LDAP tarafından desteklenir.

Ruby / LDAP Kurulumu

SOURCEFORGE.NET'ten eksiksiz bir Ruby / LDAP paketi indirebilir ve kurabilirsiniz .

Ruby / LDAP'yi kurmadan önce, aşağıdaki bileşenlere sahip olduğunuzdan emin olun -

• Ruby 1.8.x (ldap / control kullanmak istiyorsanız en az 1.8.2).
• OpenLDAP, Netscape SDK, Windows 2003 veya Windows XP.

Artık standart Ruby Kurulum yöntemini kullanabilirsiniz. Başlamadan önce, extconf.rb için mevcut seçenekleri görmek istiyorsanız, '--help' seçeneğiyle çalıştırın.

$ ruby extconf.rb [--with-openldap1|--with-openldap2| \
                   --with-netscape|--with-wldap32]
$ make $ make install

NOTE- Yazılımı Windows üzerinde oluşturuyorsanız , make yerine nmake kullanmanız gerekebilir .

LDAP Bağlantısı Kurun

Bu iki aşamalı bir süreçtir -

Adım 1 - Bağlantı Nesnesi Oluşturun

Aşağıda bir LDAP dizinine bağlantı oluşturmak için sözdizimi verilmiştir.

LDAP::Conn.new(host = 'localhost', port = LDAP_PORT)

• host- Bu, LDAP dizinini çalıştıran ana bilgisayar kimliğidir. Bunu localhost olarak alacağız .

• port- Bu, LDAP hizmeti için kullanılan bağlantı noktasıdır. Standart LDAP bağlantı noktaları 636 ve 389'dur. Sunucunuzda hangi bağlantı noktasının kullanıldığından emin olun, aksi takdirde LDAP :: LDAP_PORT'u kullanabilirsiniz.

Bu çağrı , bağlantı noktası bağlantı noktasındaki sunucuya, ana bilgisayara yeni bir LDAP :: Conn bağlantısı döndürür .

Adım 2 - Bağlama

Bu, genellikle oturumun geri kalanında kullanacağımız kullanıcı adı ve parolayı belirttiğimiz yerdir.

Aşağıda, DN kullanarak bir LDAP bağlantısını bağlamak için sözdizimi verilmiştir, dnkimlik bilgisi, pwdve bağlama yöntemi, method -

conn.bind(dn = nil, password = nil, method = LDAP::LDAP_AUTH_SIMPLE)do
....
end

Aynı yöntemi bir kod bloğu olmadan da kullanabilirsiniz. Bu durumda, bağlantıyı aşağıdaki gibi açıkça çözmeniz gerekir:

conn.bind(dn = nil, password = nil, method = LDAP::LDAP_AUTH_SIMPLE)
....
conn.unbind

Bir kod bloğu verilirse, self bloğa verilir .

Artık uygun izinlere sahip olmamız koşuluyla, bağlama yönteminin bloğu içinde (bağlama ve çözme arasında) arama, ekleme, değiştirme veya silme işlemleri gerçekleştirebiliriz.

Example

Yerel bir sunucu üzerinde çalıştığımızı varsayarsak, uygun ana bilgisayar, etki alanı, kullanıcı kimliği ve şifre vb. İle bir araya getirelim.

#/usr/bin/ruby -w

require 'ldap'

$HOST = 'localhost' $PORT =    LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')
....
conn.unbind

LDAP Girişi Ekleme

Bir LDPA girişi eklemek iki adımlı bir işlemdir -

Adım 1 - LDAP :: Mod nesnesinin oluşturulması

Bir girdi oluşturmak için conn.add yöntemine LDAP :: Mod nesne geçişine ihtiyacımız var . İşte LDAP :: Mod nesnesini oluşturmak için basit bir sözdizimi -

Mod.new(mod_type, attr, vals)

• mod_type - Bir veya daha fazla seçenek LDAP_MOD_ADD, LDAP_MOD_REPLACE veya LDAP_MOD_DELETE.

• attr - üzerinde işlem yapılacak özelliğin adı olmalıdır.

• vals- öznitelik ile ilgili bir değerler dizisidir . Eğer vals iki veriler içeriyor, mod_type LDAP_MOD_BVALUES ile | () mantıksal OR'ed edilmelidir.

Bu çağrı , LDAP :: Conn sınıfındaki Conn # add, Conn # add_ext, Conn # change ve Conn # modify_ext gibi yöntemlere aktarılabilen LDAP :: Mod nesnesini döndürür .

Adım 2 - Conn.add Yönteminin Çağrılması

LDAP :: Mod nesnesiyle hazır olduğumuzda, bir girdi oluşturmak için conn.add yöntemini çağırabiliriz . İşte bu yöntemi çağırmak için bir sözdizimi -

conn.add(dn, attrs)

Bu yöntem DN ile bir giriş ekler dn ve özelliklerini, attrs . Burada, öznitelikler ya bir LDAP :: Mod nesneleri dizisi ya da öznitelik / değer dizi çiftlerinin bir karması olmalıdır.

Example

İşte iki dizin girişi oluşturacak eksiksiz bir örnek -

#/usr/bin/ruby -w

require 'ldap'

$HOST =    'localhost'
$PORT = LDAP::LDAP_PORT $SSLPORT = LDAP::LDAPS_PORT

conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
entry1 = [
   LDAP.mod(LDAP::LDAP_MOD_ADD,'objectclass',['top','domain']),
   LDAP.mod(LDAP::LDAP_MOD_ADD,'o',['TTSKY.NET']),
   LDAP.mod(LDAP::LDAP_MOD_ADD,'dc',['localhost']),
]

entry2 = [
   LDAP.mod(LDAP::LDAP_MOD_ADD,'objectclass',['top','person']),
   LDAP.mod(LDAP::LDAP_MOD_ADD, 'cn', ['Zara Ali']),
   LDAP.mod(LDAP::LDAP_MOD_ADD | LDAP::LDAP_MOD_BVALUES, 'sn', 
                     ['ttate','ALI', "zero\000zero"]),
]

begin
   conn.add("dc = localhost, dc = localdomain", entry1)
   conn.add("cn = Zara Ali, dc = localhost, dc =  localdomain", entry2)
rescue LDAP::ResultError
   conn.perror("add")
   exit
end
conn.perror("add")
conn.unbind

Bir LDAP Girişini Değiştirme

Bir girişi değiştirmek, bir giriş eklemeye benzer. Değiştirilecek niteliklerle eklemek yerine değiştirme yöntemini çağırmanız yeterlidir. İşte değiştirme yönteminin basit bir sözdizimi .

conn.modify(dn, mods)

Bu yöntem, DN, dn ve öznitelikler, modlar ile bir girişi değiştirir . Burada, modlar ya bir LDAP :: Mod nesneleri dizisi ya da bir öznitelik / değer dizisi çiftleri karması olmalıdır.

Misal

Önceki bölümde eklediğimiz girdinin soyadını değiştirmek için şunu yazardık -

#/usr/bin/ruby -w

require 'ldap'

$HOST = 'localhost' $PORT =    LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
entry1 = [
   LDAP.mod(LDAP::LDAP_MOD_REPLACE, 'sn', ['Mohtashim']),
]

begin
   conn.modify("cn = Zara Ali, dc = localhost, dc = localdomain", entry1)
rescue LDAP::ResultError
   conn.perror("modify")
   exit
end
conn.perror("modify")
conn.unbind

Bir LDAP Girişini Silme

Bir girişi silmek için, parametre olarak ayırt edici adı olan silme yöntemini çağırın . İşte silme yönteminin basit bir sözdizimi .

conn.delete(dn)

Bu yöntem, DN, dn ile bir girişi siler .

Misal

Bir önceki bölümde eklediğimiz Zara Mohtashim girişini silmek için şunu yazardık -

#/usr/bin/ruby -w

require 'ldap'

$HOST =    'localhost'
$PORT = LDAP::LDAP_PORT $SSLPORT = LDAP::LDAPS_PORT

conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
begin
   conn.delete("cn = Zara-Mohtashim, dc = localhost, dc = localdomain")
rescue LDAP::ResultError
   conn.perror("delete")
   exit
end
conn.perror("delete")
conn.unbind

Ayırt Edici Adı Değiştirme

Bir girişin ayırt edici adını değiştirme yöntemiyle değiştirmek mümkün değildir . Bunun yerine modrdn yöntemini kullanın . İşte modrdn yönteminin basit sözdizimi -

conn.modrdn(dn, new_rdn, delete_old_rdn)

Bu yöntem, girdinin RDN'sini DN, dn ile değiştirerek ona yeni RDN, new_rdn verir . Eğer delete_old_rdn olduğu doğrudur , eski RDN'de değer girişi silinecektir.

Misal

Aşağıdaki girişe sahip olduğumuzu varsayalım -

dn: cn = Zara Ali,dc = localhost,dc = localdomain
cn: Zara Ali
sn: Ali
objectclass: person

Ardından, ayırt edici adını aşağıdaki kodla değiştirebiliriz -

#/usr/bin/ruby -w

require 'ldap'

$HOST = 'localhost' $PORT =    LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
begin
   conn.modrdn("cn = Zara Ali, dc = localhost, dc = localdomain", "cn = Zara Mohtashim", true)
rescue LDAP::ResultError
   conn.perror("modrdn")
   exit
end
conn.perror("modrdn")
conn.unbind

Arama Yapma

Bir LDAP dizininde arama yapmak için , üç farklı arama modundan biriyle arama yöntemini kullanın -

• LDAP_SCOPE_BASEM - Yalnızca temel düğümü arayın.

• LDAP_SCOPE_ONELEVEL - Temel düğümün tüm alt öğelerini arayın.

• LDAP_SCOPE_SUBTREE - Temel düğüm dahil tüm alt ağacı arayın.

Misal

Burada, kişi nesneleri için dc = localhost, dc = localdomain girişinin tüm alt ağacını arayacağız -

#/usr/bin/ruby -w

require 'ldap'

$HOST =    'localhost'
$PORT = LDAP::LDAP_PORT $SSLPORT = LDAP::LDAPS_PORT

base = 'dc = localhost,dc = localdomain'
scope = LDAP::LDAP_SCOPE_SUBTREE
filter = '(objectclass = person)'
attrs = ['sn', 'cn']

conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
begin
   conn.search(base, scope, filter, attrs) { |entry|
      # print distinguished name
      p entry.dn
      # print all attribute names
      p entry.attrs
      # print values of attribute 'sn'
      p entry.vals('sn')
      # print entry as Hash
      p entry.to_hash
   }
rescue LDAP::ResultError
   conn.perror("search")
   exit
end
conn.perror("search")
conn.unbind

Bu, LDAP girişinin LDAP :: Entry sınıfının bir örneği tarafından temsil edildiği her eşleşen giriş için verilen kod bloğunu çağırır. Son arama parametresi ile, ilgilendiğiniz öznitelikleri, diğerlerini atlayarak belirtebilirsiniz. Buraya nil geçerseniz, tüm öznitelikler ilişkisel veritabanlarında "SELECT *" olarak döndürülür.

LDAP :: Entry sınıfının dn yöntemi (get_dn için takma ad), girdinin ayırt edici adını döndürür ve to_hash yöntemiyle, özniteliklerinin (ayırt edici ad dahil) bir karma temsilini elde edebilirsiniz. Bir girdinin özniteliklerinin bir listesini almak için, attrs yöntemini kullanın (get_attributes için takma ad). Ayrıca, belirli bir özniteliğin değerlerinin listesini almak için vals yöntemini (get_values ​​için takma ad) kullanın.

Hataları Yönetme

Ruby / LDAP iki farklı istisna sınıfı tanımlar -

• Bir hata durumunda, yeni, bağlama veya çözme yöntemleri bir LDAP :: Hata istisnası oluşturur.

• Bir LDAP dizini ekleme, değiştirme, silme veya arama durumunda bir LDAP :: ResultError yükseltin.

Daha fazla okuma

LDAP yöntemleriyle ilgili tüm ayrıntılar için, lütfen LDAP Belgeleri için standart belgelere bakın .

Geleneksel programlar tek bir yürütme iş parçacığına sahiptir , programı oluşturan ifadeler veya talimatlar, program sona erene kadar sırayla yürütülür.

Çok iş parçacıklı bir programın birden fazla yürütme dizisi vardır. Her iş parçacığı içinde ifadeler sırayla yürütülür, ancak evrelerin kendileri örneğin çok çekirdekli bir CPU üzerinde paralel olarak yürütülebilir. Genellikle tek bir CPU makinesinde, birden çok iş parçacığı gerçekte paralel olarak yürütülmez, ancak iş parçacığının yürütülmesini serpiştirerek paralellik simüle edilir.

Ruby, Thread sınıfıyla çok iş parçacıklı programlar yazmayı kolaylaştırır . Ruby iş parçacıkları, kodunuzda eşzamanlılık elde etmenin hafif ve verimli bir yoludur.

Ruby Konuları Oluşturma

Yeni bir iş parçacığı başlatmak için, bir bloğu Thread.new çağrısıyla ilişkilendirmeniz yeterlidir . Bloktaki kodu yürütmek için yeni bir iş parçacığı oluşturulacak ve orijinal iş parçacığı hemen Thread.new'den dönecek ve sonraki deyimle yürütmeye devam edecektir -

# Thread #1 is running here
Thread.new {
   # Thread #2 runs this code
}
# Thread #1 runs this code

Misal

İşte çok iş parçacıklı Ruby programını nasıl kullanabileceğimizi gösteren bir örnek.

#!/usr/bin/ruby

def func1
   i = 0
   while i<=2
      puts "func1 at: #{Time.now}"
      sleep(2)
      i = i+1
   end
end

def func2
   j = 0
   while j<=2
      puts "func2 at: #{Time.now}"
      sleep(1)
      j = j+1
   end
end

puts "Started At #{Time.now}"
t1 = Thread.new{func1()}
t2 = Thread.new{func2()}
t1.join
t2.join
puts "End at #{Time.now}"

Bu, aşağıdaki sonucu verecektir -

Started At Wed May 14 08:21:54 -0700 2008
func1 at: Wed May 14 08:21:54 -0700 2008
func2 at: Wed May 14 08:21:54 -0700 2008
func2 at: Wed May 14 08:21:55 -0700 2008
func1 at: Wed May 14 08:21:56 -0700 2008
func2 at: Wed May 14 08:21:56 -0700 2008
func1 at: Wed May 14 08:21:58 -0700 2008
End at Wed May 14 08:22:00 -0700 2008

İplik Yaşam Döngüsü

Thread.new ile yeni bir konu oluşturulur . Ayrıca Thread.start ve Thread.fork eşanlamlılarını da kullanabilirsiniz .

Oluşturulduktan sonra bir iş parçacığı başlatmaya gerek yoktur, CPU kaynakları kullanılabilir olduğunda otomatik olarak çalışmaya başlar.

Thread sınıfı, çalışırken iş parçacığını sorgulamak ve işlemek için bir dizi yöntem tanımlar. Bir iş parçacığı, Thread.new çağrısıyla ilişkili bloktaki kodu çalıştırır ve ardından çalışmayı durdurur.

Bu bloktaki son ifadenin değeri, evrenin değeridir ve Thread nesnesinin değer yöntemi çağrılarak elde edilebilir . İş parçacığı tamamlanana kadar çalıştıysa, değer hemen iş parçacığının değerini döndürür. Aksi takdirde, değer yöntemi iş parçacığı tamamlanana kadar engeller ve geri dönmez.

Sınıf yöntemi Thread.current , geçerli evreyi temsil eden Thread nesnesini döndürür. Bu, iş parçacığının kendilerini yönetmesine izin verir. Thread.main sınıf yöntemi , ana iş parçacığını temsil eden Thread nesnesini döndürür. Bu, Ruby programı başladığında başlayan ilk yürütme iş parçacığıdır.

Bu iş parçacığının Thread.join yöntemini çağırarak belirli bir iş parçacığının bitmesini bekleyebilirsiniz . Çağıran iş parçacığı, verilen iş parçacığı bitene kadar engellenecektir.

Konular ve İstisnalar

Ana iş parçacığında bir istisna ortaya çıkarsa ve herhangi bir yerde ele alınmazsa, Ruby yorumlayıcısı bir mesaj yazdırır ve çıkar. Ana iş parçacığı dışındaki iş parçacıklarında, işlenmeyen istisnalar iş parçacığının çalışmasının durmasına neden olur.

Bir konu t işlenmemiş bir istisna nedeniyle çıkıyor ve başka bir iş parçacığı st.join veya t.value çağırır , ardından içinde meydana gelen istisnat iplikte yükselir s.

Eğer Thread.abort_on_exception olan sahte , varsayılan durumu, işlenmeyen bir özel durum yalnızca geçerli iş parçacığı öldürür ve her şey çalışmaya devam.

Çıkmak için tercüman neden herhangi dizisindeki herhangi işlenmeyen istisna isterseniz, sınıf yöntemi set Thread.abort_on_exception için gerçek .

t = Thread.new { ... }
t.abort_on_exception = true

Diş Değişkenleri

Bir iş parçacığı, iş parçacığı oluşturulduğunda normalde kapsamda olan tüm değişkenlere erişebilir. Bir iş parçacığının bloğuna yerel değişkenler iş parçacığı için yereldir ve paylaşılmaz.

İş parçacığı sınıfı, iş parçacığı yerel değişkenlerin ada göre oluşturulmasına ve erişilmesine izin veren özel bir düzene sahiptir. Basitçe iş parçacığı nesnesine bir Hash gibi davranırsınız, [] = kullanarak öğelere yazarsınız ve [] kullanarak onları okursunuz.

Bu örnekte, her iş parçacığı, sayım değişkeninin geçerli değerini bir iş parçacığı yerel değişkenine mycount anahtarıyla kaydeder .

#!/usr/bin/ruby

count = 0
arr = []

10.times do |i|
   arr[i] = Thread.new {
      sleep(rand(0)/10.0)
      Thread.current["mycount"] = count
      count += 1
   }
end

arr.each {|t| t.join; print t["mycount"], ", " }
puts "count = #{count}"

Bu, aşağıdaki sonucu verir -

8, 0, 3, 7, 2, 1, 6, 5, 4, 9, count = 10

Ana iş parçacığı, alt iş parçacığının bitmesini bekler ve ardından her biri tarafından yakalanan sayım değerini yazdırır .

Konu Öncelikleri

İş parçacığı zamanlamasını etkileyen ilk faktör iş parçacığı önceliğidir: yüksek öncelikli iş parçacıkları düşük öncelikli iş parçacıklarından önce programlanır. Daha doğrusu, bir iş parçacığı yalnızca çalışmayı bekleyen daha yüksek öncelikli iş parçacığı yoksa CPU zamanı alacaktır.

Öncelik = ve öncelik ile bir Ruby Thread nesnesinin önceliğini ayarlayabilir ve sorgulayabilirsiniz . Yeni oluşturulan bir iş parçacığı, onu oluşturan iş parçacığı ile aynı öncelikte başlar. Ana iş parçacığı 0 önceliğinde başlar.

Çalışmaya başlamadan önce bir iş parçacığının önceliğini ayarlamanın bir yolu yoktur. Bununla birlikte, bir iş parçacığı, yaptığı ilk eylem olarak kendi önceliğini artırabilir veya azaltabilir.

Konu Hariç Tutma

İki iş parçacığı aynı verilere erişimi paylaşırsa ve iş parçacıklarından en az biri bu verileri değiştirirse, hiçbir iş parçacığının tutarsız bir durumda veriyi görmemesini sağlamak için özel dikkat göstermelisiniz. Buna iş parçacığı dışlama denir .

Mutexbazı paylaşılan kaynaklara karşılıklı olarak dışlayıcı erişim için basit bir semafor kilidi uygulayan bir sınıftır. Yani, belirli bir zamanda sadece bir iplik kilidi tutabilir. Diğer iş parçacıkları, kilidin kullanılabilir hale gelmesi için sırada beklemeyi seçebilir veya kilidin mevcut olmadığını belirten anında bir hata almayı seçebilir.

Paylaşılan verilere tüm erişimleri bir muteksin kontrolü altına alarak tutarlılık ve atomik çalışma sağlıyoruz. Örnekleri deneyelim, ilki mutaksız ve ikincisi mutax ile -

Mutax olmadan örnek

#!/usr/bin/ruby
require 'thread'

count1 = count2 = 0
difference = 0
counter = Thread.new do
   loop do
      count1 += 1
      count2 += 1
   end
end
spy = Thread.new do
   loop do
      difference += (count1 - count2).abs
   end
end
sleep 1
puts "count1 :  #{count1}"
puts "count2 :  #{count2}"
puts "difference : #{difference}"

Bu, aşağıdaki sonucu verecektir -

count1 :  1583766
count2 :  1583766
difference : 0

#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new

count1 = count2 = 0
difference = 0
counter = Thread.new do
   loop do
      mutex.synchronize do
         count1 += 1
         count2 += 1
      end
   end
end
spy = Thread.new do
   loop do
      mutex.synchronize do
         difference += (count1 - count2).abs
      end
   end
end
sleep 1
mutex.lock
puts "count1 :  #{count1}"
puts "count2 :  #{count2}"
puts "difference : #{difference}"

Bu, aşağıdaki sonucu verecektir -

count1 :  696591
count2 :  696591
difference : 0

Kilitlenme ile Mücadele

İş parçacığı dışlama için Mutex nesnelerini kullanmaya başladığımızda, kilitlenmeyi önlemek için dikkatli olmalıyız . Kilitlenme, tüm iş parçacığı başka bir iş parçacığı tarafından tutulan bir kaynağı almayı beklediğinde oluşan durumdur. Tüm iş parçacıkları engellendiği için tuttukları kilitleri açamazlar. Ve kilitleri serbest bırakamadıkları için, bu kilitleri başka hiçbir iplik alamaz.

Koşul değişkenleri burada devreye giriyor. Bir koşul değişkeni , basitçe bir kaynakla ilişkili olan ve belirli bir muteksin koruması içinde kullanılan bir semafordur . Kullanılamayan bir kaynağa ihtiyacınız olduğunda, bir koşul değişkenini beklersiniz. Bu eylem, karşılık gelen muteks üzerindeki kilidi kaldırır . Başka bir iş parçacığı kaynağın kullanılabilir olduğunu işaret ettiğinde, orijinal iş parçacığı beklemeden çıkar ve aynı anda kritik bölgedeki kilidi yeniden kazanır.

Misal

#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new

cv = ConditionVariable.new
a = Thread.new {
   mutex.synchronize {
      puts "A: I have critical section, but will wait for cv"
      cv.wait(mutex)
      puts "A: I have critical section again! I rule!"
   }
}

puts "(Later, back at the ranch...)"

b = Thread.new {
   mutex.synchronize {
      puts "B: Now I am critical, but am done with cv"
      cv.signal
      puts "B: I am still critical, finishing up"
   }
}
a.join
b.join

Bu, aşağıdaki sonucu verecektir -

A: I have critical section, but will wait for cv
(Later, back at the ranch...)
B: Now I am critical, but am done with cv
B: I am still critical, finishing up
A: I have critical section again! I rule!

Konu Durumları

Aşağıdaki tabloda gösterildiği gibi beş olası duruma karşılık gelen beş olası dönüş değeri vardır. Durum yöntemi ipliğin durumuna döner.

Konu durumu	Geri dönüş değeri
Runnable	Çalıştırmak
Uyuyor	Uyuyor
İptal	iptal
Normal olarak sonlandırıldı	yanlış
İstisna ile feshedildi	sıfır

İş Parçacığı Sınıf Yöntemleri

Aşağıdaki yöntemler Thread sınıfı tarafından sağlanır ve programda bulunan tüm iş parçacıkları için geçerlidir. Bu yöntemler, aşağıdaki gibi Thread sınıf adı kullanılarak çağrılacaktır -

Thread.abort_on_exception = true

İşte mevcut tüm sınıf yöntemlerinin tam listesi -

Sr.No.	Yöntemler ve Açıklama
1	Thread.abort_on_exception İstisna durumunda genel durdurmanın durumunu döndürür . Varsayılan yanlıştır . İçin ayarlanan zaman gerçek , iptale kadar bütün konuları neden olur istisna herhangi parçacığı büyüdü ise (proses (0) çıkar)
2	Thread.abort_on_exception= Ayarlandığında gerçek bir istisna kaldırılırken, tüm ipler iptal edecek. Yeni durumu döndürür.
3	Thread.critical Global iş parçacığı kritik durumunun durumunu döndürür .
4	Thread.critical= Global iş parçacığı kritik koşulunun durumunu ayarlar ve döndürür. True olarak ayarlandığında , mevcut herhangi bir iş parçacığının planlanmasını engeller. Yeni iş parçacıklarının oluşturulmasını ve çalıştırılmasını engellemez. Belirli iş parçacığı işlemleri (bir iş parçacığını durdurma veya sonlandırma, geçerli iş parçacığında uyku ve bir özel durum oluşturma gibi) kritik bir bölümde olsa bile iş parçacığının programlanmasına neden olabilir.
5	Thread.current Yürütülmekte olan iş parçacığını döndürür.
6	Thread.exit Şu anda çalışan iş parçacığını sonlandırır ve çalıştırılacak başka bir iş parçacığı zamanlar. Bu iş parçacığı zaten öldürülmek üzere işaretlenmişse, çıkış İş Parçacığını döndürür . Bu ana iş parçacığı veya son iş parçacığı ise, işlemden çıkın.
7	Thread.fork { block } Thread.new ile eşanlamlıdır.
8	Thread.kill( aThread ) Verilen bir İş Parçacığının çıkmasına neden olur
9	Thread.list Çalıştırılabilir veya durdurulmuş olan tüm evreler için bir Thread nesneleri dizisi döndürür . Konu.
10	Thread.main İşlem için ana iş parçacığını döndürür.
11	Thread.new( [ arg ]* ) {| args | block } Blokta verilen talimatları yürütmek için yeni bir iş parçacığı oluşturur ve onu çalıştırmaya başlar. Thread.new'e iletilen herhangi bir argüman bloğa aktarılır.
12	Thread.pass Yürütmeyi başka bir iş parçacığına iletmek için iş parçacığı zamanlayıcısını çağırır.
13	Thread.start( [ args ]* ) {| args | block } Temelde Thread.new ile aynı . Bununla birlikte, eğer sınıf İş Parçacığı alt sınıflıysa, o alt sınıfta start çağrısı alt sınıfın başlatma yöntemini çağırmayacaktır .
14	Thread.stop Mevcut iş parçacığının yürütülmesini durdurur, uyku durumuna geçirir ve başka bir iş parçacığının yürütülmesini zamanlar. Kritik koşulu yanlış olarak sıfırlar .

İş Parçacığı Örneği Yöntemleri

Bu yöntemler, bir iş parçacığı örneğine uygulanabilir. Bu yöntemler, aşağıdaki gibi bir İş Parçacığı örneği kullanılarak çağrılacaktır -

#!/usr/bin/ruby

thr = Thread.new do   # Calling a class method new
   puts "In second thread"
   raise "Raise exception"
end
thr.join   # Calling an instance method join

İşte mevcut tüm örnek yöntemlerinin tam listesi -

Sr.No.	Yöntemler ve Açıklama
1	thr[ aSymbol ] Öznitelik Referansı - Bir sembol veya bir Sembol adı kullanarak bir iş parçacığı yerel değişkenin değerini döndürür . Belirtilen değişken yoksa, nil döndürür .
2	thr[ aSymbol ] = Öznitelik Ataması - Bir sembol veya bir dize kullanarak bir iş parçacığı yerel değişkenin değerini ayarlar veya oluşturur.
3	thr.abort_on_exception İade durumu istisna üzerine iptale ilişkin koşul etkinliği gösterenlerden . Varsayılan yanlıştır .
4	thr.abort_on_exception= True olarak ayarlandığında , thr içinde bir istisna ortaya çıkarsa tüm iş parçacıklarının (ana program dahil) iptal edilmesine neden olur . İşlem etkili bir şekilde (0) çıkacaktır .
5	thr.alive? Thr çalışıyorsa veya uyuyorsa doğru döndürür .
6	thr.exit Thr'yi sonlandırır ve çalıştırılacak başka bir iş parçacığı zamanlar. Bu iş parçacığı zaten öldürülmek üzere işaretlenmişse, çıkış İş Parçacığını döndürür . Bu ana iş parçacığıysa veya son iş parçacığı ise, işlemden çıkar.
7	thr.join Çağıran iş parçacığı yürütme askıya alma ve çalışacaktır thr . Thr çıkana kadar geri dönmez . Ana program çıkıldığında, birleştirilmeyen tüm iş parçacıkları öldürülür.
8	thr.key? Verilen dize (veya sembol) bir evre-yerel değişken olarak mevcutsa doğru döndürür .
9	thr.kill İçin Eşanlamlı Thread.exit .
10	thr.priority İade öncelik etkinliği gösterenlerden . Varsayılan sıfırdır; yüksek öncelikli iş parçacıkları, daha düşük öncelikli iş parçacıklarından önce çalışacaktır.
11	thr.priority= Thr önceliğini bir Tamsayı olarak ayarlar . Daha yüksek öncelikli iş parçacıkları, düşük öncelikli iş parçacıklarından önce çalışacaktır.
12	thr.raise( anException ) Bir istisna Artırdı etkinliği gösterenlerden . Arayan olmak zorunda değildir thr .
13	thr.run Uyanır thr zamanlama için elverişli hale. Kritik bir bölümde değilse, zamanlayıcıyı çağırır.
14	thr.safe_level İade için yürürlükte güvenli seviye etkinliği gösterenlerden .
15	thr.status İade durumu thr : uyku halinde thr uyku ya, I / O bekliyor çalıştırmak eğer thr eğer false yürütülürken thr normalde sonlandırıldı ve nil eğer thr bir istisna ile sonlandırıldı.
16	thr.stop? İade gerçek olursa thr ölü ya da uyuyor.
17	thr.value Thr'nin Thread.join aracılığıyla tamamlanmasını bekler ve değerini döndürür.
18	thr.wakeup İşaretler Thr zamanlama için uygun olarak, yine de, ancak, I / O bloke kalabilir.

Yana Çekirdek modülü tarafından dahildir Nesne sınıfının, onun yöntemlerini Yakut programında her yerde kullanılabilir. Alıcı olmadan çağrılabilirler (işlevsel form). Bu nedenle, genellikle işlevler olarak adlandırılırlar.

Yerleşik İşlevlerin tam listesi referansınız için burada verilmiştir -

Sr.No.	Yöntemler ve Açıklama
1	abort Programı sonlandırır. Bir istisna oluşursa (yani, $! Sıfır değilse), hata mesajı görüntülenir.
2	Array( obj) To_ary veya to_a kullanarak bir diziye dönüştürdükten sonra obj'i döndürür.
3	at_exit {...} Program çıktığında yürütülmesi için bir blok kaydeder. END deyimine benzer, ancak END ifadesi bloğu yalnızca bir kez kaydeder.
4	autoload( classname, file) İlk kullanıldığında dosyadan yüklenecek bir sınıf sınıf adı kaydeder. sınıf adı bir dizge veya sembol olabilir.
5	binding Geçerli değişkeni ve yöntem bağlamalarını döndürür. Bağlanma döndürülen nesne geçirilebilmektedir Eval ikinci değişken olarak yöntem.
6	block_given? Yöntem bir blokla çağrıldıysa doğru döndürür .
7	callcc {| c|...} Bloğa bir Devam nesnesi c iletir ve bloğu yürütür. callcc , genel çıkış veya döngü yapısı için kullanılabilir.
8	caller([ n]) File: line formundaki dizelerden oluşan bir dizide geçerli yürütme yığınını döndürür . Eğer n belirtilmişse, n'inci seviyeden aşağıya yığın girişleri döndürür.
9	catch( tag) {...} Bloğunun yürütülmesi sırasında çağrılan bir atışla yerel olmayan bir çıkış yakalar.
10	chomp([ rs = $/]) Değişkenin değerini verir $_ with the ending newline removed, assigning the result back to $_. Yeni satır dizesinin değeri rs ile belirtilebilir.
11	chomp!([ rs = $/]) Dizeyi yerinde değiştirerek $ _ 'dan yeni satırı kaldırır.
12	chop Değerini verir $_ with its last character (one byte) removed, assigning the result back to $_.
13	chop! Dizeyi yerinde değiştirerek $ _ 'dan son karakteri kaldırır.
14	eval( str[, scope[, file, line]]) Çalıştırır str Yakut kodu olarak. Değerlendirmenin gerçekleştirileceği bağlayıcı kapsam ile belirtilebilir . Kod dosya ve satır numarası kullanılarak belirlenebilir derlenecek dosya ve hat.
15	exec( cmd[, arg...]) Cmd komutunu çalıştırarak mevcut işlemi değiştirir . Birden fazla argüman belirtilirse, komut kabuk genişletmesi olmadan yürütülür.
16	exit([ result = 0]) Durum kodu döndürülen sonuçla birlikte programdan çıkar .
17	exit!([ result = 0]) Taşıma programı bypass exit öldürür gibi sağlamak , vb
18	fail(...) Yükseltmeye bakın (...)
19	Float( obj) Şamandıraya dönüştürdükten sonra obj'i döndürür. Sayısal nesneler doğrudan dönüştürülür; nil, 0.0'a dönüştürülür; dizeler 0x, 0b radix öneki dikkate alınarak dönüştürülür. Geri kalanlar obj.to_f kullanılarak dönüştürülür.
20	fork fork {...} Bir çocuk süreç yaratır. nil , alt süreçte döndürülür ve alt sürecin kimliği (tamsayı) üst süreçte döndürülür. Bir blok belirtilirse, alt süreçte çalıştırılır.
21	format( fmt[, arg...]) Sprintf bakın.
22	gets([ rs = $/]) Komut satırında belirtilen dosya adını veya standart girişten bir satır okur. Kayıt ayırıcı dizesi açıkça rs ile belirtilebilir.
23	global_variables Global değişken isimlerinden oluşan bir dizi döndürür.
24	gsub( x, y) gsub( x) {...} İçinde x ile eşleşen tüm dizeleri değiştirir $_ with y. If a block is specified, matched strings are replaced with the result of the block. The modified result is assigned to $_.
25	gsub!( x, y) gsub!( x) {...} Dizenin yerinde değiştirilmesi dışında gsub ile aynı ikameyi gerçekleştirir.
26	Integer( obj) Tam sayıya dönüştürdükten sonra obj'i döndürür. Sayısal nesneler doğrudan dönüştürülür; nil, 0'a dönüştürülür; dizeler 0x, 0b radix öneki dikkate alınarak dönüştürülür. Geri kalanlar obj.to_i kullanılarak dönüştürülür.
27	lambda {| x|...} proc {| x|...} lambda proc Bir bloğu bir Proc nesnesine dönüştürür . Blok belirtilmezse, çağırma yöntemiyle ilişkili blok dönüştürülür.
28	load( file[, private = false]) Bir Ruby programını yükler dosyası . Aksine gerektirir , bu uzantı kütüphaneleri yüklemez. Eğer özel bir gerçek , program, böylece çağıran programının ad koruyarak anonim modül yüklenir.
29	local_variables Yerel değişken isimlerinden oluşan bir dizi döndürür.
30	loop {...} Bir kod bloğunu tekrar eder.
31	open( path[, mode = "r"]) open( path[, mode = "r"]) {| f|...} Bir dosya açar . Bir blok belirtilirse, blok argüman olarak iletilen açık akımla yürütülür. Blok çıktığında dosya otomatik olarak kapatılır. Eğer yolu bir boru ile başlar | aşağıdaki dize komut olarak çalıştırılan ve bu işlemle ilişkili akışı döndürülür.
32	p( obj) Objeyi inspect yöntemini kullanarak görüntüler (genellikle hata ayıklama için kullanılır).
33	print([ arg...]) Baskılar $ defout için argüman . Hiçbir bağımsız değişken belirtilmezse, $ _ değeri yazdırılır.
34	printf( fmt[, arg...]) Biçimleri göre ARG FMT kullanarak sprintf'i ve sonucu yazdırır $ defout . Biçimlendirme özellikleri için ayrıntılar için sprintf'e bakın.
35	proc {| x|...} proc Lamda'ya bakın.
36	putc( c) Varsayılan çıktıya bir karakter yazdırır ( $ defout ).
37	puts([ str]) Dizeyi varsayılan çıktıya yazdırır ( $ defout ). Dize bir satırsonu ile bitmiyorsa, dizeye bir satırsonu eklenir.
38	raise(...) fail(...) Bir istisna oluşturur. Herhangi bir istisna sınıfı belirtilmezse RuntimeError değerini varsayar . Bir kurtarma cümlesinde argümansız zam çağırmak istisnayı yeniden yükseltir. Bunu bir kurtarma yan tümcesi dışında yapmak, mesajsız bir RuntimeError hatası oluşturur .fail zam için kullanılmayan bir isimdir.
39	rand([ max = 0]) 0'a eşit veya 0'dan büyük ve maks'dan küçük bir sözde rastgele sayı üretir. Max belirtilmezse veya 0'a ayarlanırsa, rasgele bir sayı, 0'a eşit veya 0'dan büyük ve 1'den küçük bir kayan nokta sayısı olarak döndürülür. Srand , sözde rasgele akışı başlatmak için kullanılabilir.
40	readline([ rs = $/]) EOF okumada bir EOFError istisnası ortaya çıkarması dışında, gets'a eşdeğerdir.
41	readlines([ rs = $/]) Komut satırı bağımsız değişkenleri olarak belirtilen dosya adlarını veya standart girdinin içeriğini tutan bir dizi dizisi döndürür.
42	require( lib) Yükler (uzatma kütüphaneleri dahil) kütüphane lib ilk denir zaman. required aynı kitaplığı birden fazla yüklemeyecektir. Hiçbir uzantı belirtilirse lib , kendisine vb .bu, .rb eklemek için çalışır gerektirir.
43	scan( re) scan( re) {|x|...} $ _. Scan ile eşdeğerdir.
44	select( reads[, writes = nil[, excepts = nil[, timeout = nil]]]) GÇ nesnelerinin dizileri olarak iletilen üç tür GÇ nesnesi girişi, çıkışı ve istisnasının durumundaki değişiklikleri denetler. nil , kontrol edilmesi gerekmeyen argümanlar için geçirilir. Durumunda değişiklikler olan GÇ nesnelerinin dizilerini içeren üç öğeli bir dizi döndürülür. nil zaman aşımına uğradığında döndürülür.
45	set_trace_func( proc) İzleme için bir işleyici ayarlar. proc bir dizge veya proc nesnesi olabilir. set_trace_func , hata ayıklayıcı ve profil oluşturucu tarafından kullanılır.
46	sleep([ sec]) Programın yürütülmesini saniye saniye askıya alır. Sn belirtilmezse, program sonsuza kadar askıya alınır.
47	split([ sep[, max]]) $ _. Split'e eşdeğerdir.
48	sprintf( fmt[, arg...]) format( fmt[, arg...]) Arg'nin fmt'ye göre biçimlendirildiği bir dize döndürür. Biçimlendirme spesifikasyonları esasen C programlama dilinde sprintf için olanlarla aynıdır. Fmt'deki dönüşüm tanımlayıcıları (% ve ardından dönüşüm alanı tanımlayıcısı ) , karşılık gelen bağımsız değişkenin biçimlendirilmiş dizesiyle değiştirilir. Dosyalanan dönüşüm listesi aşağıda bir sonraki bölümde verilmiştir.
49	srand([ seed]) Bir rastgele sayı dizisini başlatır. Eğer tohum belirtilmemişse, başlatma zamanı ve tohum için diğer sistem bilgilerini kullanarak gerçekleştirilir.
50	String( obj) Obj.to_s kullanarak onu bir dizeye dönüştürdükten sonra obj'i döndürür.
51	syscall( sys[, arg...]) Number sys ile belirtilen bir işletim sistemi çağrı işlevini çağırır . Sys'nin sayıları ve anlamı sisteme bağlıdır.
52	system( cmd[, arg...]) Çalıştırır cmd komut satırına çağrısı olarak. Birden fazla argüman belirtilirse, komut kabuk genişletmesi olmadan doğrudan çalıştırılır. Dönüş durumu 0 ise (başarılı) doğru döndürür .
53	sub( x, y) sub( x) {...} $ _ İçindeki x ile eşleşen ilk dizeyi y ile değiştirir. Bir blok belirtilirse, eşleşen dizeler bloğun sonucuyla değiştirilir. Değiştirilen sonuç $ _'a atanır.
54	sub!( x, y) sub!( x) {...} Dizenin yerinde değiştirilmesi dışında sub ile aynı değişimi gerçekleştirir.
55	test( test, f1[, f2]) Karakter testi tarafından belirtilen çeşitli dosya testlerini gerçekleştirir . Okunabilirliği iyileştirmek için, bu işlev yerine File sınıfı yöntemlerini (örneğin File :: readable?) Kullanmalısınız. Bir sonraki bölümde argümanların bir listesi aşağıda verilmiştir.
56	throw( tag[, value = nil]) Sembol veya dizge etiketiyle bekleyen catch işlevine atlar . değer, catch tarafından kullanılacak dönüş değeridir .
57	trace_var( var, cmd) trace_var( var) {...} Global bir değişken için izlemeyi ayarlar. Değişken adı bir sembol olarak belirtilir. cmd bir dize veya Proc nesnesi olabilir.
58	trap( sig, cmd) trap( sig) {...} Bir sinyal işleyici ayarlar. sig bir dize (SIGUSR1 gibi) veya bir tam sayı olabilir. SIG, sinyal adından çıkarılabilir. EXIT sinyali için sinyal işleyici veya sinyal numarası 0, işlemin sonlandırılmasından hemen önce çağrılır.
59	untrace_var( var[, cmd]) Global değişken için izlemeyi kaldırır. Eğer cmd belirtilirse, yalnızca bu komut kaldırılır.

Sayılar için İşlevler

Numarayla ilgili Yerleşik İşlevlerin listesi aşağıdadır. Aşağıdaki gibi kullanılmalıdır -

#!/usr/bin/ruby

num = 12.40
puts num.floor      # 12
puts num + 10       # 22.40
puts num.integer?   # false  as num is a float.

Bu, aşağıdaki sonucu verecektir -

12
22.4
false

Varsayarsak, n bir sayıdır -

Sr.No.	Yöntemler ve Açıklama
1	n + num n - num n * num n / num Aritmetik işlemler gerçekleştirir: toplama, çıkarma, çarpma ve bölme.
2	n % num N modülünü verir.
3	n ** num Üs alma.
4	n.abs N'nin mutlak değerini döndürür.
5	n.ceil N'den büyük veya n'ye eşit en küçük tamsayıyı döndürür.
6	n.coerce( num) Her ikisi de muhtemelen karşılıklı olarak çalıştırılmalarına izin veren bir türe dönüştürülmüş num ve n içeren bir dizi döndürür. Sayısal operatörlerde otomatik tür dönüştürmede kullanılır.
7	n.divmod( num) N'nin num'a bölünmesinden elde edilen bölümü ve modülü içeren bir dizi döndürür.
8	n.floor N'den küçük veya n'ye eşit en büyük tamsayıyı döndürür.
9	n.integer? N bir tamsayı ise doğru döndürür.
10	n.modulo( num) N'nin sayıya bölünmesi ve bölümün floor ile yuvarlanmasıyla elde edilen modülü verir
11	n.nonzero? Sıfır değilse n, aksi takdirde nil döndürür.
12	n.remainder( num) Bölünerek elde edilen kalanı verir n tarafından numve ondalık sayıları bölümden çıkarma. result ve n hep aynı işaret var.
13	n.round Returns n rounded to the nearest integer.
14	n.truncate Returns n as an integer with decimals removed.
15	n.zero? Returns zero if n is 0.
16	n & num n | num n ^ num Bitwise operations: AND, OR, XOR, and inversion.
17	n << num n >> num Bitwise left shift and right shift.
18	n[num] Returns the value of the numth bit from the least significant bit, which is n[0].
19	n.chr Returns a string containing the character for the character code n.
20	n.next n.succ Returns the next integer following n. Equivalent to n + 1.
21	n.size Returns the number of bytes in the machine representation of n.
22	n.step( upto, step) {|n| ...} Iterates the block from n to upto, incrementing by step each time.
23	n.times {|n| ...} Iterates the block n times.
24	n.to_f Converts n into a floating point number. Float conversion may lose precision information.
25	n.to_int Returns n after converting into interger number.

Functions for Float

Here is a list of Ruby Built-in functions especially for float numbers. Assuming we have a float number f −

Sr.No.	Methods & Description
1	Float::induced_from(num) Returns the result of converting num to a floating-point number.
2	f.finite? Returns true if f isn't infinite and f.nan is false.
3	f.infinite? Returns 1 if f is positive infinity, -1 if negative infinity, or nil if anything else.
4	f.nan? Returns true if f isn't a valid IEEE floating point number.

Functions for Math

Here is a list of Ruby Built-in math functions −

Sr.No.	Methods & Description
1	atan2( x, y) Calculates the arc tangent.
2	cos( x) Calculates the cosine of x.
3	exp( x) Calculates an exponential function (e raised to the power of x).
4	frexp( x) Returns a two-element array containing the nominalized fraction and exponent of x.
5	ldexp( x, exp) Returns the value of x times 2 to the power of exp.
6	log( x) Calculates the natural logarithm of x.
7	log10( x) Calculates the base 10 logarithm of x.
8	sin( x) Calculates the sine of x.
9	sqrt( x) Returns the square root of x. x must be positive.
10	tan( x) Calculates the tangent of x.

Conversion Field Specifier

The function sprintf( fmt[, arg...]) and format( fmt[, arg...]) returns a string in which arg is formatted according to fmt. Formatting specifications are essentially the same as those for sprintf in the C programming language. Conversion specifiers (% followed by conversion field specifier) in fmt are replaced by formatted string of corresponding argument.

The following conversion specifiers are supported by Ruby's format −

Sr.No.	Specifier & Description
1	b Binary integer
2	c Single character
3	d,i Decimal integer
4	e Exponential notation (e.g., 2.44e6)
5	E Exponential notation (e.g., 2.44E6)
6	f Floating-point number (e.g., 2.44)
7	g use %e if exponent is less than -4, %f otherwise
8	G use %E if exponent is less than -4, %f otherwise
9	o Octal integer
10	s String or any object converted using to_s
11	u Unsigned decimal integer
12.	x Hexadecimal integer (e.g., 39ff)
13	X Hexadecimal integer (e.g., 39FF)

Following is the usage example −

#!/usr/bin/ruby

str = sprintf("%s\n", "abc")   # => "abc\n" (simplest form)
puts str 

str = sprintf("d=%d", 42)      # => "d=42" (decimal output)
puts str 

str = sprintf("%04x", 255)     # => "00ff" (width 4, zero padded)
puts str 

str = sprintf("%8s", "hello")  # => " hello" (space padded)
puts str 

str = sprintf("%.2s", "hello") # => "he" (trimmed by precision)
puts str

This will produce the following result −

abc
d = 42
00ff
   hello
he

Test Function Arguments

The function test( test, f1[, f2]) performs one of the following file tests specified by the character test. In order to improve readability, you should use File class methods (for example, File::readable?) rather than this function.

Here are the file tests with one argument −

Sr.No.	Argument & Description
1	?r Is f1 readable by the effective uid of caller?
2	?w Is f1 writable by the effective uid of caller?
3	?x Is f1 executable by the effective uid of caller?
4	?o Is f1 owned by the effective uid of caller?
5	?R Is f1 readable by the real uid of caller?
6	?W Is f1 writable by the real uid of caller?
7	?X Is f1 executable by the real uid of caller?
8	?O Is f1 owned by the real uid of caller?
9	?e Does f1 exist?
10	?z Does f1 have zero length?
11	?s File size of f1(nil if 0)
12	?f Is f1 a regular file?
13	?d Is f1 a directory?
14	?l Is f1 a symbolic link?
15	?p Is f1 a named pipe (FIFO)?
16	?S Is f1 a socket?
17	?b Is f1 a block device?
18	?c Is f1 a character device?
19	?u Does f1 have the setuid bit set?
20	?g Does f1 have the setgid bit set?
21	?k Does f1 have the sticky bit set?
22	?M Last modification time for f1.
23	?A Last access time for f1.
24	?C Last inode change time for f1.

File tests with two arguments are as follows −

Sr.No.	Argument & Description
1	?= Are modification times of f1 and f2 equal?
2	?> Is the modification time of f1 more recent than f2 ?
3	?< Is the modification time of f1 older than f2 ?
4	?- Is f1 a hard link to f2 ?

Following is the usage example. Assuming main.rb exist with read, write and not execute permissions −

#!/usr/bin/ruby

puts test(?r, "main.rb" )   # => true
puts test(?w, "main.rb" )   # => true
puts test(?x, "main.rb" )   # => false

This will produce the following result −

true
false
false

Ruby - Predefined Variables

Ruby's predefined variables affect the behavior of the entire program, so their use in libraries is not recommended.

The values in most predefined variables can be accessed by alternative means.

Following table lists all the Ruby's predefined variables.

Sr.No.	Variable Name & Description
1	$! The last exception object raised. The exception object can also be accessed using => in rescue clause.
2	$@ The stack backtrace for the last exception raised. The stack backtrace information can retrieved by Exception#backtrace method of the last exception.
3	$/ The input record separator (newline by default). gets, readline, etc., take their input record separator as optional argument.
4	$\ The output record separator (nil by default).
5	$, The output separator between the arguments to print and Array#join (nil by default). You can specify separator explicitly to Array#join.
6	$; The default separator for split (nil by default). You can specify separator explicitly for String#split.
7	$. The number of the last line read from the current input file. Equivalent to ARGF.lineno.
8	$< Synonym for ARGF.
9	$> Synonym for $defout.
10	$0 The name of the current Ruby program being executed.
11	$$ The process pid of the current Ruby program being executed.
12	$? The exit status of the last process terminated.
13	$: Synonym for $LOAD_PATH.
14	$DEBUG True if the -d or --debug command-line option is specified.
15	$defout The destination output for print and printf ($stdout by default).
16	$F The variable that receives the output from split when -a is specified. This variable is set if the -a command-line option is specified along with the -p or -n option.
17	$FILENAME The name of the file currently being read from ARGF. Equivalent to ARGF.filename.
18	$LOAD_PATH An array holding the directories to be searched when loading files with the load and require methods.
19	$SAFE The security level 0 → No checks are performed on externally supplied (tainted) data. (default) 1 → Potentially dangerous operations using tainted data are forbidden. 2 → Potentially dangerous operations on processes and files are forbidden. 3 → All newly created objects are considered tainted. 4 → Modification of global data is forbidden.
20	$stdin Standard input (STDIN by default).
21	$stdout Standard output (STDOUT by default).
22	$stderr Standard error (STDERR by default).
23	$VERBOSE True if the -v, -w, or --verbose command-line option is specified.
24	$- x The value of interpreter option -x (x=0, a, d, F, i, K, l, p, v). These options are listed below
25	$-0 The value of interpreter option -x and alias of $/.
26	$-a The value of interpreter option -x and true if option -a is set. Read-only.
27	$-d The value of interpreter option -x and alias of $DEBUG
28	$-F The value of interpreter option -x and alias of $;.
29	$-i The value of interpreter option -x and in in-place-edit mode, holds the extension, otherwise nil. Can enable or disable in-place-edit mode.
30	$-I The value of interpreter option -x and alias of $:.
31	$-l The value of interpreter option -x and true if option -lis set. Read-only.
32	$-p The value of interpreter option -x and true if option -pis set. Read-only.
33	$_ The local variable, last string read by gets or readline in the current scope.
34	$~ The local variable, MatchData relating to the last match. Regex#match method returns the last match information.
35	$ n ($1, $2, $3...) The string matched in the nth group of the last pattern match. Equivalent to m[n], where m is a MatchData object.
36	$& The string matched in the last pattern match. Equivalent to m[0], where m is a MatchData object.
37	$` The string preceding the match in the last pattern match. Equivalent to m.pre_match, where m is a MatchData object.
38	$' The string following the match in the last pattern match. Equivalent to m.post_match, where m is a MatchData object.
39	$+ The string corresponding to the last successfully matched group in the last pattern match.

Ruby - Predefined Constants

The following table lists all the Ruby's Predefined Constants −

NOTE − TRUE, FALSE, and NIL are backward-compatible. It's preferable to use true, false, and nil.

Sr.No.	Constant Name & Description
1	TRUE Synonym for true.
2	FALSE Synonym for false.
3	NIL Synonym for nil.
4	ARGF An object providing access to virtual concatenation of files passed as command-line arguments or standard input if there are no command-line arguments. A synonym for $<.
5	ARGV An array containing the command-line arguments passed to the program. A synonym for $*.
6	DATA An input stream for reading the lines of code following the __END__ directive. Not defined if __END__ isn't present in code.
7	ENV A hash-like object containing the program's environment variables. ENV can be handled as a hash.
8	RUBY_PLATFORM A string indicating the platform of the Ruby interpreter.
9	RUBY_RELEASE_DATE A string indicating the release date of the Ruby interpreter
10	RUBY_VERSION A string indicating the version of the Ruby interpreter.
11	STDERR Standard error output stream. Default value of $stderr.
12	STDIN Standard input stream. Default value of $stdin.
13	STDOUT Standard output stream. Default value of $stdout.
14	TOPLEVEL_BINDING A binding object at Ruby's top level.

Ruby - Associated Tools

Standard Ruby Tools

The standard Ruby distribution contains useful tools along with the interpreter and standard libraries −

These tools help you debug and improve your Ruby programs without spending much effort. This tutorial will give you a very good start with these tools.

• RubyGems −

  RubyGems is a package utility for Ruby, which installs Ruby software packages and keeps them up-to-date.

• Ruby Debugger −

  To help deal with bugs, the standard distribution of Ruby includes a debugger. This is very similar to gdb utility, which can be used to debug complex programs.

• Interactive Ruby (irb) −

  irb (Interactive Ruby) was developed by Keiju Ishitsuka. It allows you to enter commands at the prompt and have the interpreter respond as if you were executing a program. irb is useful to experiment with or to explore Ruby.

• Ruby Profiler −

  Ruby profiler helps you to improve the performance of a slow program by finding the bottleneck.

Additional Ruby Tools

There are other useful tools that don't come bundled with the Ruby standard distribution. However, you do need to install them yourself.

• eRuby: Embeded Ruby −

  eRuby stands for embedded Ruby. It's a tool that embeds fragments of Ruby code in other files, such as HTML files similar to ASP, JSP and PHP.

• ri: Ruby Interactive Reference −

  When you have a question about the behavior of a certain method, you can invoke ri to read the brief explanation of the method.

For more information on Ruby tool and resources, have a look at Ruby Useful Resources.