RUBY
Ruby, Matz olarak da bilinen Yukihiro Matsumoto tarafından tasarlanmış bir betik dili. Windows, Mac OS ve UNIX’in çeşitli sürümleri gibi çeşitli platformlarda çalışır.
Ruby saf bir nesne yönelimli programlama dalıdır. 1993 yılında Japonya’nın Yukihiro Matsumoto tarafından kuruldu.
Yukihiro Matsumoto ismini Ruby posta listesinde www.ruby-lang.org adresinde bulabilirsiniz. Matsumoto, Ruby topluluğunda Matz olarak da bilinir.
Ruby “Bir Programcının En İyi Arkadaşı” dır.
Ruby, Smalltalk, Perl ve Python’a benzer özelliklere sahiptir. Perl, Python ve Smalltalk, komut dosyası dilleri. Smalltalk, gerçek nesne yönelimli bir dildir. Smalltalk gibi Ruby, nesne yönelimli mükemmel bir dildir. Ruby sözdizimini kullanmak Smalltalk sözdizimini kullanmaktan çok daha kolaydır.
Ruby’nin Özellikleri
Ruby açık kaynaktır ve Web üzerinde özgürce bulunur, ancak bir lisansa tabidir.
Ruby genel amaçlı, yorumlanmış bir programlama dilidir.
Ruby gerçek nesne yönelimli bir programlama dilidir.
Ruby, Python ve PERL’ye benzer bir sunucu tarafı komut dosyası dili.
Ruby Ortak Ağ Geçidi Arabirimi (CGI) komut dosyalarını yazmak için kullanılabilir.
Ruby, Köprü Metni İşaretleme Dili (HTML) içine gömülebilir.
Ruby, yeni bir geliştiricinin çok hızlı ve kolay bir şekilde öğrenmesine olanak tanıyan temiz ve kolay bir sözdizimine sahiptir.
Ruby, C ++ ve Perl gibi birçok programlama dilinin benzer sözdizimine sahiptir.
Ruby çok ölçeklenebilir ve Ruby’de yazılan büyük programlar kolayca bakım yapılabilir.
Ruby, İnternet ve intranet uygulamalarını geliştirmek için kullanılabilir.
Ruby, Windows ve POSIX ortamlarına yüklenebilir.
Ruby, Tcl / Tk, GTK ve OpenGL gibi birçok GUI aracını desteklemektedir.
Ruby, DB2, MySQL, Oracle ve Sybase’ye kolayca bağlanabilir.
Ruby, doğrudan Ruby betiklerinde kullanılabilen zengin yerleşik işlevler kümesine sahiptir.
İhtiyacınız Olacak Araçlar
Bu yazıda ele alınan örnekleri gerçekleştirmek için en az 2GB RAM (4GB RAM önerilir) ile Intel Core i3 veya i5 gibi en yeni bir bilgisayara ihtiyacınız olacaktır. Ayrıca aşağıdaki yazılıma ihtiyaç duyacaksınız –
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 üstü Web tarayıcısı.
Ruby 1.8.5
Bu ders, Ruby’yi 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 katıştırma hakkında konuşacağız.
Sırada ne var?
Bir sonraki bölüm size Ruby’yi nereden indirebileceğinizi ve belgelerine yönlendirir. Son olarak, Ruby’yi nasıl kuracağınıza ve Ruby uygulamaları geliştirmeye yönelik bir ortam hazırlamanız konusunda size bilgi veriyor.
Yerel Çevre Kurulumu
Halen Ruby programlama dili için ortamınızı hazırlamak istiyorsanız, o zaman devam edelim. Bu eğitim size çevre kurulumuyla ilgili tüm önemli konuları öğretecektir. Size öncelikle aşağıdaki konuları incelemenizi ve daha sonra devam etmenizi öneririz –
• Linux / Unix üzerinde Ruby Kurulumu – Geliştirme ortamınızı Linux / Unix Machine üzerinde kurmayı planlıyorsanız, bu bölümden geçin.
• Windows’ta Ruby Kurulumu – Geliştirme ortamınızı Windows Machine’de kurmayı planlıyorsanız bu bölümden geçin.
• 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 Yorumcusu’nun çalışması için ayarlanacak tüm önemli ortam değişkenlerinin bir listesi bulunmaktadı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 Düzen artı gibi basit herhangi bir metin düzenleyiciyi kullanabilirsiniz.
• VIM (Vi IMproved) çok basit bir metin editörüdür. Bu, hemen hemen tüm Unix makinelerinde ve şimdi de Windows’ta mevcuttur. Aksi takdirde, Ruby programlarını yazmak için favori vi düzenleyicinizi kullanabilirsiniz.
• RubyWin , Windows için Ruby Integrated Development Environment (IDE) ‘dir.
• Ruby Geliştirme Ortamı (RDE) , Windows kullanıcıları için de çok iyi bir IDE.
İnteraktif Ruby (IRb)
Etkileşimli Ruby (IRb) deney için bir kabuk sağlar. IRb kabuğunda, ifade sonuçlarını çizgi ile hemen görüntüleyebilirsiniz.
Bu araç, Ruby kurulumu ile birlikte gelir; bu nedenle, IRb’nin çalışması için fazladan bir şey yapmanız gerekmez.
Sadece komut istemine irb yazın ve aşağıda verilen gibi bir İnteraktif 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ı merak etme. 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ı hazırlamış olduğunuzu varsayıyoruz. Bir sonraki bölümde Ruby programlarının nasıl yazacağınız anlatılacaktır.
Ruby’de basit bir program yazalım. Tüm ruby dosyalarının uzantısı .rbolacaktır . Bu nedenle, aşağıdaki kaynak kodu bir test.rb dosyasına yerleştirin.
#!/usr/bin/ruby -w
puts “Hello, Ruby!”;
Burada, / usr / bin dizininde Ruby yorumlayıcısının bulunduğunu varsaydık. Şimdi, bu programı aşağıdaki gibi çalıştırmayı deneyin –
$ ruby test.rb
Bu, aşağıdaki sonuca neden olacaktır:
Hello, Ruby!
Basit bir Ruby programı gördünüz, şimdi bize 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ünmeleri dışında genellikle Ruby kodunda dikkate alınmaz. Ancak bazen belirsiz ifadeleri yorumlamak için kullanılırlar. Bu tür yorumlar, -w seçeneği etkinken uyarı verirler.
Örnek
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 yeni satır karakterlerini bir bildirimin bitişi olarak yorumluyor. Bununla birlikte, Ruby bir satırın sonundaki +, – veya ters eğik çizgi gibi operatörlerle karşılaşırsa, bir bildirimin devam ettiğini gösterirler.
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ı, alfasayısal karakterlerden ve alt çizgi karakterinden (_) oluşabilir.
Ayrılmış kelimeler
Aşağıdaki liste, Ruby’deki ayrılmış kelimeleri göstermektedir. Bu ayrılmış kelimeler sabit veya değişken isimler olarak kullanılamaz. Bununla birlikte, bunlar yöntem adları olarak kullanılabilir.
BAŞLA yap Sonraki sonra
SON Başka sıfır doğru
takma ad elsif değil undef
ve son veya olmadıkça
başla sağlamak yeniden yapmak a kadar
mola yanlış kurtarmak ne zaman
dava için yeniden denemek süre
sınıf Eğer dönüş süre
def içinde öz __DOSYA__
tanımlanmış? modül Süper __HAT__
Burada Ruby’de Belge
“Here Document”, dizeleri birden çok satıra inşa etmektir. Bir << dizgisini takip ettikten sonra, dize değişmezini sona erdirmek için bir dize veya tanımlayıcı belirtebilir ve geçerli satırı sonlandırıcıya kadar takip eden tüm satırlar dizedeki değerlerdir.
Sonlandırıcı alıntılanırsa, tırnak işareti türü satır yönelimli dize değişmezinin türünü belirler. << ve 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", < ile yerleştirerek oluşturulur. Arka virgül yoksayıldı.
Örnek
#!/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 sonuca neden olacaktır:
red is 3840
green is 240
blue is 15
Ruby Hashes hakkında daha ayrıntılı bilgi için Ruby Hashes’ü inceleyin .
Ruby Aralığı
Aralık, başlangıç ve bitiş olmak üzere bir aralığı temsil eder. Aralıklar s..e ve s … e harfleri kullanılarak veya Range.new ile oluşturulabilir.
Kullanılarak yapılan aralıklar baştan sona dahil edilmiştir. Kullanarak yaratılanlar son değeri hariç tutarlar. Yineleyici olarak kullanıldığında, aralıklar, dizideki her değeri döndürür.
Bir aralık (1..5), 1, 2, 3, 4, 5 değerleri ve bir aralık (1 … 5) anlamına gelir; 1, 2, 3, 4 değerleri içeriyor demektir.
Örnek
#!/usr/bin/ruby
(10..15).each do |n|
print n, ‘ ‘
end
Bu, aşağıdaki sonuca neden olacaktır:
10 11 12 13 14 15
Ruby, modern bir dilden bekleyebileceğiniz gibi zengin operatörler 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şkeniyle belirtilen nesnedeki + yöntemi , argümanı olarak b ile çağrılır .
Her operatör için (+ – * /% ** & | ^ <> && ||), kısaltılmış atama işleci (+ = – = vb.) Karşılık gelen bir biçimi vardır.
Ruby Aritmetik Operatörler
Değişken a 10, değişken b 20,
Şebeke Açıklama Örnek
+ Toplama – Operatörün her iki tarafına değerler ekler. a + b 30
– Çıkarma – Sağdaki işlenen, soldan işlenen çıkarılır. a – b verir -10
* Çarpma – Operatörün her iki yanında çarpım değerleri. a * b 200 verir
/ Division – Sağdaki işlenen tarafından soldaki işlenen bölünür. b / a 2 verir
% Modulus – Sol el işleneni sağdaki işlenen tarafından bölünür ve kalan kısmı geri getirir. b% a 0 verecek
** Üs – Operatörler üzerinde üstel (güç) hesaplama yapar. a ** b gücü 10’a 10 verecek
Ruby Karşılaştırma Operatörleri
Değişken a 10, değişken b 20,
Şebeke Açıklama Örnek
== İki işlenenin değerinin eşit olup olmadığını denetler, evet ise durum geçerlidir. (a == b) doğru değil.
! = İki işlenenin değerinin eşit olup olmadığını kontrol eder, eğer değerler eşit değilse durum geçerlidir. (a! = b) doğrudur.
> Sol işlenen değeri sağ işlenen değerinden büyük olup olmadığını kontrol eder, evet ise koşul geçerlidir. (a> b) doğru değil.
< Sol işlenen değeri sağ işlenen değerinden küçük olup olmadığını kontrol eder, evet ise koşul geçerlidir. (a = Sol işlenen değeri sağ işlenen değerinden büyük veya eşit olup olmadığını kontrol eder, evet ise koşul geçerlidir. (a> = b) doğru değil.
<= Sol işlenen değeri sağ işlenen değerinden küçük veya ona eşit olup olmadığını kontrol eder, evet ise durum geçerlidir. (a <= b) doğrudur.
Kombine karşılaştırma operatörü. İlk işlenen saniye değerine eşitse, 0, ikinci işleçten büyükse 1, iş parçacığı saniyeden küçükse -1 döndürür. (a b) -1 döndürür.
=== Dava bildiriminin when deyiminde eşitliğin denenmesi için kullanılır . (1 … 10) === 5 doğru döndürür.
.eql? Alıcı ve argüman aynı türde ve eşit değerlere sahipse doğrudur. 1 == 1.0 true döndürür, ancak 1.eql? (1.0) yanlış olur.
eşit? Alıcı ve argüman aynı nesne kimliğine sahipse doğrudur. aObj, bObj’nin kopyası ise aObj == bObj doğruysa, a.equal? bObj yanlış, ancak a.equal? aObj doğrudur.
Ruby Atama Operatörleri
Değişken a 10, değişken b 20,
Şebeke Açıklama Örnek
= Basit atama işleci, sağdaki işlenenlerden soldaki işlenenlere değer atar. c = a + b, a + b değerini c’ye atar
+ = VE atama işleci ekleyin, sol işlenen için sağ işlenen ekleyin ve sonucu sol işlenen için atayın. c + = a, c = c + a’ya eşdeğerdir
– = VE atama işleci çıkar, soldaki işlenenden sağ işlenen çıkarılır ve sonucu sol işlenen işe atar. c – = a, c = c – a’ya eşdeğerdir
* = AND atama işleci çarpın, sağdaki işlenenle sol işlenenle çarpın ve sonucu sol işlenen kişiye atayın. c * = a, c = c * a’ya eşdeğerdir
/ = AND atama işleci bölün, sol işlenen doğru işlenen ile bölünür ve sonuç sol işlenen 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 işlenenine atar. c% = a, c = c% a’ya eşdeğerdir
** = Üs ve atama operatörü, operatörler üzerinde üstel (güç) hesaplama yapar ve sol operanda değer atar. c ** = a, c = c ** a’ya eşdeğerdir
Ruby Paralel Atama
Ruby değişkenlerin paralel atamasını da desteklemektedir. Bu, tek bir satırlık Ruby kodu ile birden çok değişkenin başlatılmasını sağlar. Örneğin –
a = 10
b = 20
c = 30
Bu paralel atama kullanılarak daha hızlı bir şekilde beyan edilebilir –
a, b, c = 10, 20, 30
Paralel atama, iki değişkende tutulan değerlerin değiştirilmesinde de yararlıdır –
a, b = b, c
Ruby Bitwise Operatörleri
Bitwise işleci, bitler üzerinde çalışır ve biti bit işlemi yapar.
A = 60 mı; ve b = 13; şimdi ikili biçimde onlar şöyle olacak –
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 Örnek
& İkili VE İşleci, her iki işlenen de varsa, sonuca biraz kopyalar. (a & b) 12 verecek, 0000 1100
| İkili VEYA İşleci her iki işlenende varsa bir biti kopyalar. (a | b) 61 verecek, 0011 1101
^ İkili XOR Operatör biti tek bir işlenide ayarlanmışsa, ancak ikisi birden kopyalanmazsa kopyalar. (a ^ b), 0011 0001 olan 49 verecektir
~ İkili Olarak Tamamlayıcı Operatör teklidir ve ‘çevirme’ bitlerinin etkisi vardır. (~ a) işaretli bir ikili sayıya bağlı olarak 2’nin tamamlayıcı formunda 1100 0011 olan -61 verecektir.
<< İkili Soldalı Vardiya Operatörü. Sol işlenen değeri, sağ işlenen tarafından belirtilen bit sayısına göre sola taşınır. bir <> İkili Sağa Vuruşlu Operatör. Sol işlenen değer sağ işlenen tarafından belirtilen bit sayısına göre sağa taşınır. a >> 2, 15 verecek, 0000 1111
Ruby Mantıksal Operatörler
Aşağıdaki mantıksal operatörler Ruby dili tarafından desteklenmektedir
Değişken a 10, değişken b 20,
Şebeke Açıklama Örnek
ve Mantıksal VE operatörü olarak anılır. Her iki işlenen de doğruysa durum geçerlidir. (a ve b) doğrudur.
veya Mantıksal VEYA Operatör olarak adlandırılır. İki işlenenden herhangi biri sıfır değilse durum geçerlidir. (a veya b) doğrudur.
&& Mantıksal VE operatörü olarak anılır. Her iki işlenen sıfırdan farklı ise, durum geçerlidir. (a && b) doğrudur.
|| Mantıksal VEYA Operatör olarak adlandırılır. İki işlenenden herhangi biri sıfır değilse durum geçerlidir. (a || b) doğrudur.
! Mantıksal Operatör Değil olarak adlandırılır. İşlenenin mantıksal durumunu ters çevirmek için kullanın. Bir koşul doğruysa, Mantıksal DEĞİL operatörü yanlış yapacaktır. ! (a && b) yanlıştır.
değil Mantıksal Operatör Değil olarak adlandırılır. İşlenenin mantıksal durumunu ters çevirmek için kullanın. Bir koşul doğruysa, Mantıksal DEĞİL operatörü yanlış yapacaktır. değil (a && b) yanlış.
Ruby Üçlü Operatörü
Ternary Operator adlı bir operatör daha var. İlk önce bir ifadeyi doğru veya yanlış bir değer olarak değerlendirir ve daha sonra değerlendirmenin sonuçlarına bağlı olarak verilen iki ifadeden birisini uygular. Koşullu operatörün sözdizimi var –
Şebeke Açıklama Örnek
? : Koşullu İfade Durum doğruysa? Sonra X değeri: Aksi takdirde Y değeri
Ruby Aralığı Operatörleri
Ruby’deki dizi aralıkları, bir başlangıç değeri, bir bitiş değeri ve aralarındaki bir dizi aralıktan oluşan bir dizi ardışık değer oluşturmak için kullanılır.
Ruby’de bu diziler “..” ve “…” aralık operatörlerini kullanarak oluşturulur. İki nokta formu kapsayıcı bir aralık oluştururken üç nokta formu belirtilen yüksek değeri hariç tutan bir aralık oluşturur.
Şebeke Açıklama Örnek
.. Başlangıç noktasından bitiş noktasına kadar 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’den 9’a kadar bir aralık oluşturur.
Ruby tanımladı mı? Operatörler
tanımlanmış? geçirilen ifadenin tanımlı olup olmadığını belirlemek için bir yöntem çağrısı biçimini alan özel bir operatöre aittir. Ifadenin bir açıklama dizesini döndürür, aksi takdirde ifade tanımlı değilse nil döndürür .
Tanımlanmış çeşitli kullanımlar var mı? Şebeke
Kullanım 1
defined? variable # True if variable is initialized
Örneğin
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
Örneğin
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
Örneğin
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
Örneğin
defined? yield # => “yield” (if there is a block passed)
defined? yield # => nil (if there is no block)
Ruby Dot “.” ve Çift Kolonlu “::” Operatörler
Adından modülün adını ve bir dönemi öne alarak bir modül yöntemi çağırırsınız ve modül adını ve iki iki nokta üst üste işaretini kullanarak bir sabiti referans alırsınız.
:: sağlayan bir tekli bir operatördür: bir sınıf veya modül içinde tanımlanan sabit, örneğin yöntemleri ve sınıf yöntemleri, herhangi bir yerde bir sınıf veya modül dışından erişilebilir.
Unutmayın Ruby’de sınıflar ve yöntemler sabitler olarak da düşünülmüş olabilir.
:: Const_name öneki yalnızca uygun sınıfı veya modül nesnesini döndüren bir ifade ile gerekir .
Önek ifadesi kullanılmazsa, varsayılan Object 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
İkinci Örnek
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 tabloda, tüm operatörlerin en yüksek önceliği en düşük sıraya göre listelenmektedir.
Yöntem Şebeke Açıklama
Evet :: Sabit çözünürlük operatörü
Evet [] [] = Öğe başvuru, öğe kümesi
Evet ** Üssel (güç artışı)
Evet ! ~ + – Değil, tamamlayıcı, tek artı ve eksi (son iki metot adı + @ ve – @ ‘dır)
Evet * /% Çarp, böl ve modulo
Evet + – Toplama ve çıkarma
Evet >> << Sağ ve sol bitwise shift
Evet & Bitwise 'AND'
Evet ^ | Bitwise özel 'OR' ve normal 'OR'
Evet <= > = Karşılaştırma operatörleri
Evet ===! = = ~! ~ Eşitlik ve model eşleme operatörleri (! = Ve! ~ Metod olarak tanımlanamaz)
&& Mantıksal ‘AND’
|| Mantıksal ‘VEYA’
.. … Aralık (dahil ve özel)
? : Üçlü if-then-else
=% = {/ = – = + = | = & = >> = < 2
puts “x is greater than 2”
elsif x =2
puts “x is less than 2”
else
puts “x is greater than 2”
end
Bu, aşağıdaki sonuca neden olacaktır:
x is less than 2
Değiştirici olmadıkça Ruby
Sözdizimi
code unless conditional
Yürütür kod eğer koşullu yanlıştır.
Örnek
#!/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 sonuca neden olacaktır:
1 — Value is set
3 — Value is set
Ruby case Bildirimi
Sözdizimi
case expression
[when expression [, expression …] [then]
code ]…
[else
code ]
end
Büyük / küçük harf ile belirtilen ifadeyi ve === işleci kullanılırken belirtilen ifadeyi karşılaştırır ve eşleşen when yan tümcenin kodunu yürütür .
Sentezleme zaman maddesi ile belirtilen sola işlenen olarak değerlendirilir. Hiçbir zaman yan tümcesi eşleşmiyorsa, case başka cümlecik kodunu yürütür .
Bir when ifadesinin ifadesi, daha sonra ayrılmış olan sözcük, bir satırsonu karakteri veya noktalı virgülle koddan ayrılır. Böylece –
case expr0
when expr1, expr2
stmt1
when expr3, expr4
stmt2
else
stmt3
end
temel olarak aşağıdakine benzer:
_tmp = expr0
if expr1 === _tmp || expr2 === _tmp
stmt1
elsif expr3 === _tmp || expr4 === _tmp
stmt2
else
stmt3
end
Örnek
#!/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 sonuca neden olacaktır:
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ü deyimlerini ayrıntılı olarak anlatmaktadır.
Ruby while Bildirimi
Sözdizimi
while conditional [do]
code
end
Yürütür kod ise koşullu doğrudur. Bir süre döngüsü en koşullu ayrılır kodkelimesiyle yapmak, bir satır, eğik çizgi \ ya da bir noktalı virgül ile;.
Örnek
#!/usr/bin/ruby
$i = 0
$num = 5
while $i < $num do
puts("Inside the loop i = #$i" )
$i +=1
end
Bu, aşağıdaki sonuca neden olacaktır:
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 sırasında Ruby
Sözdizimi
code while condition
OR
begin
code
end while conditional
Yürütür kod ise koşullu doğrudur.
Bir süre değiştirici bir kurtarma veya sağlama maddesi içermeyen bir begindeyimini izlerse, koşullu değerlendirme yapılmadan önce kod bir kez çalıştırılır.
Örnek
#!/usr/bin/ruby
$i = 0
$num = 5
begin
puts("Inside the loop i = #$i" )
$i +=1
end while $i $num do
puts(“Inside the loop i = #$i” )
$i +=1;
end
Bu, aşağıdaki sonuca neden olacaktır:
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ştirene kadar Ruby
Sözdizimi
code until conditional
OR
begin
code
end until conditional
Yürütür kod ise koşullu yanlıştır.
Bir until değiştirici kurtarma ya da koşulları sağlamaz bir begin deyimini izlerse, koşullu değerlendirmeden önce kod bir kez çalıştırılır .
Örnek
#!/usr/bin/ruby
$i = 0
$num = 5
begin
puts(“Inside the loop i = #$i” )
$i +=1;
end until $i > $num
Bu, aşağıdaki sonuca neden olacaktır:
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
Açıklama için Ruby
Sözdizimi
for variable [, variable …] in expression [do]
code
end
Çalıştırır kodu her bir eleman için bir kere ifadesi .
Örnek
#!/usr/bin/ruby
for i in 0..5
puts “Value of local variable is #{i}”
end
Burada, 0..5 aralığını tanımladık. Için deyim i 0..5 yılında sağlayacak ı (5 dahil), 0 ile 5 arasında değerler almaya. Bu, aşağıdaki sonuca neden olacaktır:
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 loop neredeyse tam olarak aşağıdakine eşdeğerdir –
(expression).each do |variable[, variable…]| code end
ancak for döngüsü yerel değişkenler için yeni bir kapsam oluşturmaz. Bir içindöngüsünün ifade ayrılır kod kelimesiyle yapmak, bir satır ya da bir noktalı virgül ile.
Örnek
#!/usr/bin/ruby
(0..5).each do |i|
puts “Value of local variable is #{i}”
end
Bu, aşağıdaki sonuca neden olacaktır:
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 Bildirimi
Sözdizimi
break
En iç döngüyü sonlandırır. Blok içinde çağrılırsa, bir yöntemi ilişkili bir blokla sona erdirir (yöntem nil döndürürken).
Örnek
#!/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 sonuca neden olacaktır:
Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Ruby next Statement
Sözdizimi
next
En iç döngünün bir sonraki yinelemesine atlar. Bir bloğun içinde çağrıldığında bir bloğun yürütülmesini sona erdirir ( verim veya çağrı nil döndürerek).
Örnek
#!/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 sonuca neden olacaktır:
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 Yinelenen Açıklama
Sözdizimi
redo
Döngü koşulunu kontrol etmeden, en iç döngü yinelemesini yeniden başlatır. Bir blokta çağrılırsa getiriyi veya çağrıyı yeniden başlatır .
Örnek
#!/usr/bin/ruby
for i in 0..5
if i 2
puts “Value of local variable is #{i}”
end
Bu, aşağıdaki sonucu üretecek ve sonsuz bir döngüye gidecek –
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 birime paketlemek için kullanılır.
Yöntem adları küçük harfle başlamalıdır. Bir yöntem adını büyük harfle başlatırsanız, Ruby bunun bir sabit olduğunu düşünebilir ve bu nedenle çağrıyı yanlış bir şekilde çözümleyebilir.
Yöntemler onları çağırmadan önce tanımlanmalıdır, aksi halde Ruby tanımlanmamış metot çağrısı için bir istisna oluşturacaktır.
Sözdizimi
def method_name [( [arg [= default]]…[, * arg [, &expr ]])]
expr..
end
Yani, basit bir yöntem şu şekilde tanımlayabilirsiniz:
def method_name
expr..
end
Bunun gibi parametreleri kabul eden bir yöntemi temsil edebilirsin –
def method_name (var1, var2)
expr..
end
Gerekli parametreleri geçirmeden metod çağrılırsa kullanılacak parametreler için varsayılan değerler ayarlayabilirsiniz –
def method_name (var1 = value1, var2 = value2)
expr..
end
Basit yöntemi çağırdığınızda, yalnızca yöntem adını aşağıdaki gibi yazarsınız –
method_name
Bununla birlikte, parametreleri olan 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 birlikte kullanmanın en önemli dezavantajı, böyle yöntemleri çağırdığınızda parametre sayısını hatırlamanız gerektiğidir. Örneğin, bir yöntem üç parametre kabul ediyorsa ve yalnızca iki geçerse, Ruby bir hata görüntüler.
Örnek
#!/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 sonuca neden olacaktır:
The programming language is C
The programming language is C++
The programming language is Ruby
The programming language is Perl
Yöntemlerden Dönüş Değerleri
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 son bildirilen k değişkenini 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…]]
İfadeden fazla ifade verilirse, bu değerleri içeren dizi dönüş değeri olacaktır. Hiçbir ifade verilmezse, dönüş değeri olacaktır.
Örnek
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 sonuca neden olacaktır:
100
200
300
Değişken Parametre Sayısı
İki parametre alan bir yöntem bildirdiğiniz varsayalım, bu yöntemi çağırdığınızda onunla birlikte iki parametre iletmeniz gerekir.
Bununla birlikte, Ruby değişken sayıda parametreyle çalışan yöntemleri bildirmenizi sağlar. Şimdi 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 testi kabul eden bir yöntem örneği bildirmişsinizdir. Bununla birlikte, bu parametre değişken bir parametredir. Bu, bu parametrenin herhangi bir sayıda değişken alabileceği anlamına gelir. Yani, 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
Bir yöntem sınıf tanımının dışında 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 public olarak işaretlenir. Varsayılan görünürlük ve yöntemlerin özel işareti , Modülün public veya private tarafından 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ı başlatmadan bir yöntemle erişmenin bir yolunu sunar. Bir sınıf yönteminin nasıl ilan edildiğine ve erişildiğine bakalım –
class Accounts
def reading_charge
end
def Accounts.return_date
end
end
Return_date yönteminin nasıl bildirildiğini öğrenin. Sınıf adı ve onu takip eden metodun ardından bir nokta ile bildirilir. Bu sınıf yöntemine doğrudan aşağıdaki şekilde erişebilirsiniz –
Accounts.return_date
Bu metoda erişmek için, Sınıflar Hesapları nesneleri oluşturmanız gerekmez.
Ruby alias Bildirimi
Bu, yöntemlere veya genel değişkenlere takma ad verir. Diğer adlar, yöntemin gövdesi içinde tanımlanamaz. Yöntemin takma adı, yöntemlerin geçersiz kılınmış olsa bile yöntemin geçerli tanımını korur.
Numaralandırılmış genel değişkenler ($ 1, $ 2, …) için takma adlar kullanılması 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
Örnek
alias foo bar
alias $MATCH $&
Burada bar için foo takma adını tanımladık ve $ MATCH, $ &
Ruby undef Bildirimi
Bu yöntem tanımını iptal eder. Bir undef , yöntem gövdesinde görünemez.
Undef ve alias kullanarak sınıfın arabirimi bağımsız olarak üst sınıfdan değiştirilebilir, ancak kendine ait dahili yöntem çağrısı ile parçalanmış programlar olduğuna dikkat edin.
Sözdizimi
undef method-name
Örnek
Bar adında bir yöntemi tanımlamak için aşağıdakileri yapın:
undef bar
Ruby’nin ifadelerin sayısını koyabileceğiniz yöntemleri nasıl tanımladığını ve bu yöntemi çağırdığını gördünüz. Benzer şekilde, Ruby’nin Blok kavramı var.
• Bir blok, bir sürü koddan oluşur.
• Bir bloğa bir ad atarsınız.
• Bloktaki kod daima parantez içine alınır ({}).
• Bir blok her zaman, bloğun adı ile aynı ismi olan bir işlevden çağrılır. Bu , test adı olan bir bloğunuz varsa , bu bloğu çağırmak için testişlevini kullanırsınız demektir .
• Sen kullanarak bir blok çağırmak verim deyimi.
Sözdizimi
block_name {
statement1
statement2
……….
}
Burada, basit bir getiri ifadesi kullanarak bir blok oluşturmayı öğreneceksiniz . Ayrıca , bir bloğu çağırmak için parametreler içeren bir verim bildirimi kullanmayı da öğreneceksiniz . Her iki yield ifadesi türüyle birlikte örnek kod kontrol edeceksiniz .
Verim Bildirimi
Verim beyanına bir örnek inceleyelim –
#!/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 sonuca neden olacaktır:
You are in the method
You are in the block
You are again back to the method
You are in the block
Verim beyanı ile 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 sonuca neden olacaktır:
You are in the block 5
You are in the method test
You are in the block 100
Burada, getiri beyanı parametreler tarafından izlenir. Hatta birden fazla parametre iletebilirsiniz. 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, aşağıdaki ifadeye bakın –
test {|i| puts “You are in the block #{i}”}
Burada, değer 5 değişken alınırsa i . Şimdi, şunlara dikkat koyar deyimini –
puts “You are in the block #{i}”
Bu puts deyiminin çıktısı –
You are in the block 5
Birden fazla parametreyi iletmek isterseniz verim ifadesi –
yield a, b
ve blok –
test {|a, b| statement}
Parametreler virgülle ayrılmış olacak.
Bloklar ve Yöntemler
Bir blok ve metodun birbirleriyle nasıl ilişkilendirildiğini gördünüz. Normalde, bloğun adıyla aynı olan bir yöntemden getiri ifadesini kullanarak bir bloğu çağırırsınız. Bu nedenle, sen –
#!/usr/bin/ruby
def test
yield
end
test{ puts “Hello world”}
Bu örnek, bir bloğun uygulanmasının en basit yoludur. Verim deyimini kullanarak test bloğunu çağırırsınız .
Ancak, bir yöntemin son argümanı & ile geliyorsa, o zaman bu metoda bir blok geçirebilir ve bu blok son parametreye atanır. Argüman 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 sonuca neden olacaktır:
Hello World!
BEGIN ve END Blokları
Her Ruby kaynak dosyası, dosya yüklenirken (BEGIN blokları) ve programın yürütülmesini tamamladıktan 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 fazla 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. Yukarıdaki program çalıştırıldığında aşağıdaki sonucu verir:
BEGIN code block
MAIN code block
END code block
Modüller, yöntemleri, sınıfları ve sabitlerle birlikte gruplandırmanın bir yoludur. Modüller size iki önemli yararlar sağlar.
• Modüller bir isim alanı sağlar ve isim çakışmalarını önler.
• Modüller mixin özelliğini uygularlar .
Modüller, yöntem ve sabitlerinizin diğer yöntemler ve sabitlerle basmak konusunda endişelenmenize gerek kalmadan çalabileceği bir ad alanı tanımlar.
Sözdizimi
module Identifier
statement1
statement2
………..
end
Modül sabitlerine sınıf sabitleri gibi adları büyük harfle yazılır. Yöntem tanımları da benzer: Modül yöntemleri sınıf yöntemleri gibi tanımlanır.
Sınıf yöntemlerinde olduğu gibi, adının önüne modül adını ve bir dönemi ekleyerek bir modül yöntemi çağırırsınız ve modül adını ve iki iki nokta üst üste işaretini kullanarak bir sabiti referans alırsınız.
Örnek
#!/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ıyla ancak farklı işlevler için bir tane daha modül 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ı bir nokta ve ardından yöntem adı belirtebilirsiniz.
Ruby, Açıklama Gerektirir
Require deyimi C ve C ++ include deyimine ve Java’nın import deyimine benzer. Üçüncü bir program herhangi bir tanımlanmış modülü kullanmak istiyorsa, sadece Ruby require deyimini kullanarak modül dosyalarını yükleyebilir –
Sözdizimi
require filename
Burada, bir dosya adı ile birlikte .rb uzantısı vermek gerekli değildir .
Örnek
$LOAD_PATH << '.'
require 'trig.rb'
require 'moral'
y = Trig.sin(Trig::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)
Burada $ LOAD_PATH << 'kullanıyoruz.' Ruby'ye, içerilen dosyaların geçerli dizinde aranması gerektiğinin farkına varması için. $ LOAD_PATH kullanmak istemiyorsanız relative dizinde bulunan dosyaları eklemek için require_relative komutunu kullanabilirsiniz .
ÖNEMLİ – Burada, her iki dosya aynı işlev adını içerir. Yani, çağıran programa dahilken bu, kod belirsizliğine neden olur, ancak modüller bu kod belirsizliğini önler ve modül adını kullanarak uygun fonksiyon çağırırız.
Ruby include deyimi
Bir sınıfa bir modülü katıştırabilirsiniz. Bir sınıfa bir modül katıştırmak için sınıfdaki include deyimini kullanın –
Sözdizimi
include modulename
Bir modül ayrı bir dosyada tanımlandıysa, modülün bir sınıfa yerleştirilmesinden önce require deyimini kullanarak bu dosyayı eklemeniz gerekir .
Örnek
Aşağıdaki modülü support.rb dosyasında yazmış olarak 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 sonuca neden olacaktır:
Sunday
You have four weeks in a month
You have 52 weeks in a year
Sunday
120
Ruby'de Mixins
Bu bölümden geçmeden önce Nesne Odaklı Kavramlar bilgisine sahip olduğunuzu varsayıyoruz.
Bir sınıf birden fazla ana sınıfın özelliklerini devredebilirse, sınıfın çoklu miras göstermesi beklenir.
Ruby doğrudan çoklu miras desteklememektedir ancak Ruby Modülleri başka harika bir kullanıma sahiptir. Bir kontrolde , mixin adı verilen bir tesis sağlayarak, çoklu devralma ihtiyacını ortadan kaldırıyorlar .
Mixins, sınıflara işlevsellik kazandırmanın mükemmel kontrollü bir yolunu sunar. Bununla birlikte, gerçek gücü, mixin'deki kod onu kullanan sınıftaki kodla etkileşime geçtiğinde 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. Sınıf Örneği, A ve B modüllerini içerir. Sınıf Örneği, a1, a2, b1 ve b2 gibi dört yöntemden her birine erişebilir. Bu nedenle, sınıf örneğinin her iki modülden devraldığını görebilirsiniz. Böylece, sınıf örneğinde çoklu miras veya bir mixin olduğunu söyleyebilirsiniz .
Ruby'deki bir String nesnesi, bir veya daha fazla bayttan oluşan ve genellikle insan dilini temsil eden karakterleri temsil eden keyfi bir diziyi tutar ve bunları düzenler.
En basit dize değişmezleri tek tırnak işaretleriyle (kesme işareti karakteri) bulunur. Tırnak işaretleri içindeki metin dizedeki değerdir –
'This is a simple Ruby string literal'
Tek tırnaklı bir dize değişmezinde bir kesme işareti koymanız gerekiyorsa, önce bir ters eğik çizgi kullanın, 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 kendisinin bir çıkış karakteri olarak yorumlanmaz.
Dize ile ilgili Ruby özellikleri aşağıda verilmiştir.
İfade Değiştirme
İfade ikamesi, # {ve} – komutunu kullanarak herhangi bir Ruby ifadesinin değerini bir dize içine götürmenin bir aracıdır –
#!/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 sonuca neden olacaktır:
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, keyfi ayırıcı karakterlerle uyuşan bir çiftin içinde, örneğin,!, (, {, [“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 tamsayı dizine eklenmiş koleksiyonları olarak sıralanır. Bir dizideki her öğe bir dizinle ilişkilendirilir ve bu dizin tarafından yönlendirilir.
Dizi endeksleme, C veya Java’daki gibi 0’dan başlar. Dizinin sonuna göre negatif bir dizin varsayılır – yani -1 dizininde dizinin son öğesi, -2 dizideki son öğenin yanında vb. Olur.
Ruby dizileri String, Integer, Fixnum, Hash, Symbol, hatta diğer Array nesneleri gibi nesneleri tutabilir. Ruby dizileri, diğer dillerdeki diziler kadar katı değildir. Onlara elemanlar eklerken Ruby dizileri otomatik olarak büyür.
Diziler Oluşturma
Bir diziyi yaratmanın veya başlatmanın birçok yolu vardır. Bir yol yeni sınıf yöntemiyle –
names = Array.new
Dizinin oluşturulduğu sırada bir dizinin boyutunu ayarlayabilirsiniz –
names = Array.new(20)
Dizi adlarının artık boyutları veya uzunluğu 20 öğedir. Bir dizinin boyutunu, boyut veya uzunluk yöntemleriyle döndürebilirsiniz –
#! / Usr / bin / yakut
names = Array.new (20)= Dizi . yeni ( 20 )
puts names.size # Bu 20 döndürür. size # Bu 20 döndürür
puts names.length # Ayrıca 20 döndürür. length # Bu aynı zamanda 20
Bu, aşağıdaki sonuca neden olacaktır:
20
20
Dizideki her bir öğeye aşağıdaki gibi bir değer atayabilirsiniz:
#!/usr/bin/ruby
names = Array.new(4, “mac”)
puts “#{names}”
Bu, aşağıdaki sonuca neden olacaktır:
[“mac”, “mac”, “mac”, “mac”]
Ayrıca bir bloğu yeni ile doldurabilir, bloğun değerlendiği şeylerle her bir öğeyi doldurabilirsiniz –
#!/usr/bin/ruby
nums = Array.new(10) { |e| e = e * 2 }
puts “#{nums}”
Bu, aşağıdaki sonuca neden olacaktır:
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
Başka bir Array yöntemi [] vardır. Bu şekilde çalışır –
nums = Array.[](1, 2, 3, 4,5)
Bir dizi daha dizi oluşturma aşağıdaki gibidir –
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 dizi basamak dizisi oluşturmak için bir argüman olarak bir aralık alır –
#!/usr/bin/ruby
digits = Array(0..9)
puts “#{digits}”
Bu, aşağıdaki sonuca neden olacaktır:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Dize Yerleşik Yöntemler
Bir Array yöntemini çağırmak için Array nesnesinin bir örneğini edinmeliyiz. Gördüğümüz gibi, aşağıdaki Array nesnesinin bir örneğini oluşturma yoludur –
Array.[](…) [or] Array[…] [or] […]
Bu, verilen nesnelerle doldurulan yeni bir dizi döndürecektir. Şimdi oluşturulan nesneyi kullanarak mevcut tüm örnek yöntemlerini çağırabiliriz. Örneğin –
#!/usr/bin/ruby
digits = Array(0..9)
num = digits.at(6)
puts “#{num}”
Bu, aşağıdaki sonuca neden olacaktır:
6
Halka açık dizi yöntemleri (dizinin bir dizi nesnesi olduğu varsayılarak) –
Dizi paketi Yönergeleri
Aşağıdaki tabloda, Array # paketiyle birlikte kullanılmak üzere paket yönergeleri listelenmiştir.
Örnek
Çeşitli verileri toplamak için aşağıdaki örnekte 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 sonuca neden olacaktır:
a b c
abc
ABC
Hash, bunun gibi anahtar / değer çiftlerinin bir toplamıdır: “çalışan” => “maaş”. Dizinleme, tamsayı dizin değil, herhangi bir nesne türünün keyfi tuşları ile yapılması dışında bir Array’a benzer.
Bir karmayı ya anahtarıyla ya da değere getirme sırası keyfi görünebilir ve genellikle ekleme sırasına göre 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 yaratmanın çeşitli yolları vardır. Yeni sınıf yöntemiyle boş karma yaratabilirsiniz –
months = Hash.new
Varsayılan değer olan bir karma oluşturmak için new seçeneğini de kullanabilirsiniz , aksi takdirde sadece nil –
months = Hash.new( “month” )
or
months = Hash.new “month”
Varsayılan bir değeri olan bir karma dosyadaki herhangi bir anahtara eriştiğinizde, anahtarı veya değeri 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 sonuca neden olacaktır:
month
month
#!/usr/bin/ruby
H = Hash[“a” => 100, “b” => 200]
puts “#{H[‘a’]}”
puts “#{H[‘b’]}”
Bu, aşağıdaki sonuca neden olacaktır:
100
200
Herhangi bir Ruby nesnesini bir anahtar veya değer, hatta bir dizi olarak kullanabilirsiniz, böylece aşağıdaki örnek geçerlidir:
[1,”jan”] => “January”
Dahili Hash Yöntemleri
Hash yöntemini çağırmak için Hash nesnesinin bir örneğine ihtiyacımız var. Gördüğümüz gibi, aşağıdaki Hash nesnesinin bir örneğini oluşturma yoludur –
Hash[[key =>|, value]* ] or
Hash.new [or] Hash.new(obj) [or]
Hash.new { |hash, key| block }
Bu, verilen nesnelerle doldurulan yeni bir karma değerini döndürür. Şimdi oluşturulan nesneyi kullanarak, mevcut tüm örnek yöntemlerini ç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 sonuca neden olacaktır:
[“1”, “2”]
Aşağıdaki genel karma yöntemleri (varsayarak karma bir dizi nesnedir) –
Sr.No. Yöntemler ve Tanım
1 karma == other_hash
Aynı sayıda anahtar / değer çifti olup olmadığına ve anahtar / değer çiftlerinin her karmada karşılık gelen çiftle eşleşip uyuşmadığına bağlı olarak, iki karmaşanın eşit olup olmadığını denetler.
2 kare tuşu]
Bir anahtar kullanarak hash’den bir değere başvurur. Anahtar bulunmazsa, varsayılan değeri döndürür.
3 karma [anahtar] = değer
Değerin verdiği değeri tuşla verilen anahtara ilişkilendirir .
4 hash.clear
Tüm anahtar / değer çiftlerini karma değerden kaldırır.
5 hash.default (anahtar = yok)
Için varsayılan değeri döndürür karma default = belirlediği takdirde nil. ([] anahtar karma yoksa varsayılan değeri döndürür .)
6 hash.default = obj
Karma için varsayılan bir değer ayarlar .
7 hash.default_proc
Karma bir blok tarafından oluşturulduysa bir blok döndürür .
8 hash.delete (anahtar) [veya]
dizi.delete (anahtar) {| anahtar | engellemek
Bir anahtar-değer çifti siler karma göre anahtar . Eğer blok kullanılırsa, çift bulunamazsa bir bloğun sonucunu döndürür. Delete_if ile karşılaştır .
9 hash.delete_if {| anahtar, değer | engellemek
Blokun doğru olarak değerlendirdiği her çifti için karma bir anahtar / değer çifti siler .
10 hash.each {| anahtar, değer | engellemek
Yineler karma , her bir anahtar için bir kez blok çağrı iki öğeli bir dizi olarak anahtar değerini gönderir.
11 hash.each_key {| anahtar | engellemek
Karmayı bir anahtarla bir parametre olarak geçirerek, her bir anahtar için bir kez çağırarak karmayı tekrarlar .
12 hash.each_key {| key_value_array | engellemek
Yineler karma , her biri için bir kez blok çağrı anahtar , geçen anahtar ve değer parametreleri.
13 hash.each_key {| değer | engellemek
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ş (anahtar-değer çifti içermez) olup olmadığını denetler; doğru veya yanlış döndürür .
15 hash.fetch (anahtar [, varsayılan]) [veya]
hash.fetch (anahtar) {| anahtar | engellemek
Verilen anahtar için karma 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? (anahtar) [veya] hash.include? (anahtar) [veya]
hash.key? (anahtar) [veya] hash.member? (anahtar)
Belirli bir anahtarın karma değerde olup olmadığını sınar , true veya false döndürür .
17 hash.has_value? (değer)
Karmanın verilen değeri içerdiğini test eder .
18 hash.index (değer)
İade anahtarı verildi için değer karma, nil eşleşen değer bulunursa.
19 hash.indexes (tuşlar)
Verilen anahtarlar için değerlerden oluşan yeni bir dizi döndürür. Bulunmayan anahtarlar için varsayılan değeri ekleyecektir. Bu yöntem önerilmemektedir. Seç’i kullanın.
20 hash.indices (tuşlar)
Verilen anahtarlar için değerlerden oluşan yeni bir dizi döndürür. Bulunmayan anahtarlar için varsayılan değeri ekleyecektir. Bu yöntem önerilmemektedir. Seç’i kullanın.
21 hash.inspect
Karmanın güzel bir basılı dize sürümünü döndürür.
22 hash.invert
Yeni bir oluşturur karma tersini, anahtarlar ve değerler gelen karma; yani yeni karma, gelen anahtarlar karma değerler ve değerler tuşları haline olurlar.
23 hash.keys
Karma anahtarlarıyla yeni bir dizi oluşturur .
24 hash.length
Boyutunu veya uzunluğunu döndürür karma bir tam sayı olarak.
25 hash.merge (diğer_hash) [veya]
hash.merge (other_hash) {| anahtar, eski değerli, yeni değerli | engellemek
Karma ve other_hash içeriğini içeren yeni bir karmayı döndürür , hash’taki çiftleri yinelenen anahtarlarla other_hash’ten olanlar üzerine yazar .
26 hash.merge! (diğer_hash) [veya]
hash.merge! (other_hash) {| anahtar, eski değerli, yeni değerli | engellemek
Birleştirme işlemi ile aynı işlem, ancak değişiklikler yerine getirilir.
27 hash.rehash
Yeniden Yapıyor karma her biri için geçerli değerlere dayalı tuşu . Değerler eklenildikten sonra değişmişse, bu yöntem karmayıyeniden görüntüler .
28 hash.reject {| anahtar, değer | engellemek
Blokun gerçek olarak değerlendirdiği her çift için yeni bir karmaoluşturur
29 hash.reject! {| anahtar, değer | engellemek
Reddetmekle aynı şey , ancak değişiklikler yapılır.
30 hash.replace (other_hash)
Içeriğini değiştirir karma içeriğiyle other_hash .
31 hash.select {| anahtar, değer | engellemek
Anahtar değeri çiftlerinden oluşan yeni bir dizi döner karma olan blok döner doğru .
32 hash.shift
Bir anahtar / değer çifti karışıklıktan kaldırır ve iki öğeli bir dizi olarak döndürür.
33 hash.size
İade boyutu ya da uzunluğunu karma bir tam sayı olarak.
34 hash.sort
Dönüştürür karma sonra, anahtar değer çiftleri dizileri içeren iki boyutlu bir dizisi bir dizi olarak sıralar.
35 hash.store (anahtar, değer)
Karma bir anahtar / değer çifti saklar .
36 hash.to_a
Karma değerden 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
Karma değerini 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) [veya]
hash.update (other_hash) {| anahtar, eski değerli, yeni değerli | blok}
Içeriğini içeren yeni karma döndürür karma ve other_hash , içinde çiftleri üzerine yazmasını karma gelenler ile yinelenen anahtarlar ile other_hash .
40 hash.value? (değer)
Olmadığını test karma verilen içeren bir değer .
41 hash.values
Tüm karma değerlerini içeren yeni bir dizi döndürür .
42 hash.values_at (obj, …)
Verilen anahtarlarla ilişkili olan hash değerlerini içeren yeni bir dizi döndürür .
Zaman sınıf Ruby tarihleri ve saatleri temsil eder. İşletim sistemi tarafından sağlanan sistem tarih ve saat işlevselliğinin üzerinde ince bir katmandır. Bu sınıf, sisteminizde 1970 öncesinde veya 2038’den sonra tarihleri temsil edemiyor olabilir.
Bu bölüm size tarih ve saatte en çok aranan tüm kavramları tanıyor.
Geçerli Tarih ve Saat Almak
Aşağıdaki, geçerli tarih ve saati almak için basit bir örnektir –
#!/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 sonuca neden olacaktır:
Current Time : Mon Jun 02 12:02:39 -0700 2008
Current Time : Mon Jun 02 12:02:39 -0700 2008
Bir Tarih ve Saat Bileşenlerini Almak
Saat nesnesini tarih ve saatin çeşitli bileşenlerini elde etmek için kullanabiliriz . Aşağıda, aynı şeyi gösteren örnek verilmiştir –
#!/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 sonuca neden olacaktır:
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ğıdaki dizideki tüm bileşenleri aşağıdaki biçimde almak için örnek:
[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 sonuca neden olacaktır:
[26, 10, 12, 2, 6, 2008, 1, 154, false, “MST”]
Bu dizi Time.utc veya Time.local işlevlerine aşağıdaki gibi farklı tarih biçimlerini elde etmek için iletilebilir :
#!/usr/bin/ruby -w
time = Time.new
values = time.to_a
puts Time.utc(*values)
Bu, aşağıdaki sonuca neden olacaktır:
Mon Jun 02 12:15:36 UTC 2008
Aşağıda, (platforma bağımlı) çağdan beri zamanı dahili olarak saniye olarak 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
Zaman Dilimleri ve Yaz Saati Uygulaması
Saat dilimi ve gün ışığı tasarrufu ile ilgili tüm bilgileri aşağıdaki gibi elde etmek 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
Biçimlendirme Süreleri ve Tarihleri
Tarih ve saat biçimlendirmenin çeşitli yolları vardır. İşte birkaç örnek 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 sonuca neden olacaktır:
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
Saat Biçimlendirme Yönergeleri
Aşağıdaki tablodaki bu yönergeler, Time.strftime yöntemi ile kullanılır .
Sr.No. Direktif ve Tanım
1 % bir
Kısaltılmış hafta içi adı (Güneş).
2 % A
Haftanın tam adı (Pazar).
3 % b
Kısaltılmış ay adı (Jan).
4 % B
Tam ayın adı (Ocak).
5 % c
Tercih edilen yerel tarih ve saat gösterimi.
6 % D
Ayın günü (01 ila 31).
7 % H,
Günün saati, 24 saatlik saat (00 – 23).
8 %BEN
Günün saati, 12 saatlik saat (01-12).
9 % j
Yılın günü (001 – 366).
10 % m
Yılın ayı (01-12).
11 % M
Dakika saati (00 – 59).
12 % p
Meridyen göstergesi (AM veya PM).
13 % S
Dakikanın ikinci (00 – 60).
14 % U
İlk haftanın ilk günü olarak ilk Pazartan başlamak üzere, cari yılın hafta numarası (00 – 53).
15 % W
İlk haftanın ilk günü olan ilk Pazartesi ile başlayan (00 – 53), cari yılın hafta numarası.
16 % ağırlık
Haftanın günü (Pazar 0, 0 ila 6).
17 % x
Yalnız tarih için tercih edilen temsili, zaman yok.
18 % X,
Yalnız zaman için tercih edilen temsili, tarih yok.
19 % y
Yüzyıl olmadan geçen yıl (00 ila 99).
20 % Y’nin
Yüzyıl ile yıl.
21 % Z
Saat dilimi adı.
22 %%
Literal% karakteri.
Zaman Aritmetiği
Zamanla basit aritmetiği şu şekilde 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 – now # => 10 Time – Time => number of seconds
puts diff
Bu, aşağıdaki sonuca neden olacaktır:
Thu Aug 01 20:57:05 -0700 2013
Thu Aug 01 20:56:55 -0700 2013
Thu Aug 01 20:57:15 -0700 2013
10.0
Aralıklar her yerde görülür: Ocak – Aralık, 0 – 9, 50 – 67 satırlar vb. Ruby aralıkları destekler ve çeşitli yollarla aralıkları kullanmamızı sağlar –
• Diziler Aralığı
• Koşullar olarak aralıklar
• Aralıklar Olarak Aralıklar
Diziler Aralığı
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 üretmenin bir yolu vardır.
Ruby, ” .. ” ve ” … ” aralık operatörlerini kullanarak bu dizileri oluşturur . İki nokta formu kapsayıcı bir aralık oluştururken üç nokta formu 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 referans içeren bir Range nesnesi olarak tutulur . Gerekirse to_a yöntemini kullanarak bir aralığı bir 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 sonuca neden olacaktır:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[“bar”, “bas”, “bat”]
Aralıklar, yinelemenizi ve içeriğini çeşitli şekillerde test etmenizi sağlayan yöntemleri 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 true
# a file
File::directory?( “file.rb” ) # => false
Aşağıdaki komut, dosyanın okunabilir, yazılabilir veya yürütülebilir olup olmadığını 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 sıfır büyüklüğünde 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, karakterSpecial, blockSpecial, fifo, link, soket veya bilinmeyen karakterlerden 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 son 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’deki dizinler
Tüm dosyalar çeşitli dizinlerde bulunur ve Ruby’nin bunları da ele almanın bir problemi yoktur. Oysa Dosya sınıfı dosyalarını işleme, rehberler ile işlenir Dirsınıfında.
Dizinler Arasında Gezinme
Bir Ruby programı içinde dizini değiştirmek için, Dir.chdir’yi aşağıdaki gibi kullanın . Bu örnek geçerli dizini / usr / bin olarak değiştirir .
Dir.chdir(“/usr/bin”)
Geçerli dizininin Dir.pwd ile ne olduğunu öğrenebilirsiniz –
puts Dir.pwd # This will return something like /usr/bin
Dir.entries’i kullanarak belirli bir dizindeki dosyaların ve dizinlerin bir listesini alabilirsiniz –
puts Dir.entries(“/usr/bin”).join(‘ ‘)
Dir.entries , belirtilen dizindeki tüm girdileri 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 almak için daha da özlü bir yol Dir’in sınıf dizisi yöntemini kullanmaktır –
Dir[“/usr/bin/*”]
Bir Dizin Oluşturma
Dir.mkdir dizinleri oluşturmak için kullanılabilir –
Dir.mkdir(“mynewdir”)
Mkdir ile yeni bir dizin (zaten mevcut değil) üzerinde izinler de ayarlayabilirsiniz –
NOT – 755 maskesi, izin sahibi, grup, dünya [kimse] rwxr-xr-x’ye r = okunur, w = yaz ve x = yürütmeye izin verir.
Dir.mkdir( “mynewdir”, 755 )
Bir Dizini Silme
Dir.delete bir dizin silmek için kullanılabilir. Dir.unlink ve Dir.rmdir tam olarak aynı işlevi yerine ve kolaylık olması için verilmiştir.
Dir.delete(“testdir”)
Dosyaları ve Geçici Dizinleri Oluşturma
Geçici dosyalar, bir program yürütülürken kısaca oluşturulmuş ancak sürekli bir bilgi deposu olmayan dosyalardır.
Yöntem varsayılan olarak mevcut olmasa da, Dir.tmpdir geçerli sistemdeki geçici dizinin yolunu sağlar. Dir.tmpdir’i kullanılabilir kılmak için require ‘tmpdir’ kullanmanız gerekir.
Platformdan bağımsız bir geçici dosya oluşturmak için File.join ile Dir.tmpdirkullanabilirsiniz –
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, veriyi ona yazar ve siler. Ruby’nin standart kütüphanesinde geçici dosyalar oluşturabilen Tempfile adlı bir kitaplık da bulunur –
require ‘tempfile’
f = Tempfile.new(‘tingtong’)
f.puts “Hello”
puts f.path
f.close
Dahili İşlevler
Dosya ve dizinleri işlemek için yerleşik ruby işlevleri şunlardır:
• Dosya Sınıfı ve Yöntemleri .
• Sınıf Sınıfı ve Yöntemleri .
İSTİSNALAR
İcra ve istisna her zaman birlikte hareket eder. Var olmayan bir dosyayı açıyorsanız, o zaman bu durumu düzgün bir şekilde ele almadıysanız, programınızın kötü kalitede olduğu kabul edilir.
Bir istisna oluşursa program durur. Dolayısıyla, bir program yürütülürken oluşabilecek çeşitli hataları işlemek ve programı tamamen durdurmak yerine uygun işlemi yapmak için istisnalar kullanılır.
Ruby istisnaları işlemek için güzel bir mekanizma sağlar. Bir başlangıç / bitişbloğunda bir istisna oluşturabilecek kodu çevirdik ve işlemek istediğimiz istisna türlerini Ruby’ye anlatmak için kurtarma yan tümcelerini kullandık .
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ırmaarasındaki bloğa iletilir .
Başlama bloğundaki her kurtarma maddesi için Ruby, yükseltilmiş İstisna’yi sırasıyla parametrelerin her birine karşı karşılaştırır. Kurtarma maddesinin adı verilen istisna şu anda atılmış olan istisna türü ile aynı veya bu istisnanın bir üst sınıfıysa, maç başaracaktır.
Bir istisnanın belirtilen hata türlerinden hiçbiriyle eşleşmediği bir durumda, tüm kurtarma cümlelerinden sonra else cümlecik kullanmaya müsaade edilir .
Örnek
#!/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 sonuca neden olacaktır. Bunu görebilirsiniz STDIN için ikame edilir dosyası nedeniyle açık başarısız oldu.
#==#
Yeniden deneme deyimini kullanma
Kurtarma bloğu’nu kullanarak bir istisna yakalayabilir ve baştan başlamabloğunu uygulamak için tekrar deneme deyimini kullanabilirsiniz .
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
Örnek
#!/usr/bin/ruby
begin
file = open(“/unexistant_file”)
if file
puts “File opened successfully”
end
rescue
fname = “existant_file”
retry
end
Sürecin akış şudur:
• Açık bir istisna meydana geldi.
• Kurtarmaya gitti. fname yeniden atandı.
• Baştan başa tekrar denemek başlıyordu.
• Bu zaman dosyası başarıyla açılıyor.
• Gerekli işlemi devam ettirdi.
NOT – Yeniden değiştirilen adın dosyası yoksa, bu örnek kod sonsuza kadar yeniden denenecektir. İstisna işlemi için yeniden denemeyi kullanırsanız dikkatli olun .
Raise bildirimini kullanma
İstisna yükseltmek için raise ifadesini kullanabilirsiniz . Aşağıdaki yöntem çağrıldığında her zaman 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 form, geçerli istisnayı (veya mevcut bir istisna yoksa bir RuntimeError) yeniden yükseltir. Bu, bir istisnayı geçmeden önce kesmesi gereken istisna işleyicilerinde kullanılır.
İkinci form , iletisini verilen dizeye ayarlayan yeni bir RuntimeError istisnası oluşturur . Bu istisna daha sonra çağrı yığıtı yukarı kaldırılır.
Üçüncü form bir istisna oluşturmak için birinci argümanı kullanır ve ardından ilişkili iletiyi ikinci argümana ayarlar.
Dördüncü form, üçüncü forma benzer ancak bir istisna getirmediğiniz süreceherhangi bir koşullu ifade de ekleyebilirsiniz .
Örnek
#!/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 sonuca neden olacaktır:
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 sonuca neden olacaktır:
A test exception.
[“main.rb:4”]
Emin ifadesini kullanma
Bazı durumlarda, bir istisna olup olmadığına bakılmaksızın, bir kod bloğunun sonunda bazı işlemlerin yapıldığını garanti etmeniz gerekebilir. Örneğin, bloğun girişinde açık bir dosyanız olabilir ve blok çıktıkça kapandığından emin olmanız gerekir.
Sağlamak fıkra sadece bunu yapar. emin olun , son kurtarma maddesinden sonra gider ve blok sona erdiğinde daima çalıştırılacak bir yığın kod içerir. O yükseltir ve bir istisna kurtarır, ya da yakalanmamış istisna sonlandırılır eğer, eğer blok, normal bir şekilde çıkıldığında önemli değildir sağlamak koşmak alacak bloğu.
Sözdizimi
begin
#.. process
#..raise exception
rescue
#.. handle error
ensure
#.. finally ensure execution
#.. This will always execute.
end
Örnek
begin
raise ‘A test exception.’
rescue Exception => e
puts e.message
puts e.backtrace.inspect
ensure
puts “Ensuring execution”
end
Bu, aşağıdaki sonuca neden olacaktır:
A test exception.
[“main.rb:4”]
Ensuring execution
Else Beyanı kullanma
Eğer başka deyiminin varlığında, bu peşinden gider kurtarma maddeleri ve herhangi önce sağlamak .
Else cümlecikinin gövdesi, yalnızca kodun ana gövdesi tarafından herhangi bir istisna ortaya atılmadığında 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
Örnek
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 sonuca neden olacaktır:
I’m not raising exception
Congratulations– no errors!
Ensuring execution
Yükseltilmiş 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 bırakmak için harika olsa da, bazen normal işleme sırasında derin iç içe geçmiş bazı yapılardan atlamak mümkün olabilir. Burası yakalamak ve atmak kullanışlı oluyor.
Mandalı (bir sembol veya bir String olabilir) adı verilen ile işaretlenmiş olan bir blok tanımlar. Blok, atışla karşılaşılana kadar normal şekilde 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
Örnek
Aşağıdaki örnek, ‘!’ Ile kullanıcıyla etkileşimi sona erdirmek için bir atkı kullanır. herhangi bir 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:”)
Manuel olarak etkileşime girmesi gerektiği için yukarıdaki programı makinenizde denemelisiniz. Bu, aşağıdaki sonuca neden olacaktır:
Name: Ruby on Rails
Age: 3
Sex: !
Name:Just Ruby
Sınıf Özelliği
Ruby’nin standart sınıfları ve modülleri istisnaları artırır. Tüm istisna sınıfları, en üstteki İstisna sınıfıyla bir hiyerarşi oluştururlar. Bir sonraki seviye yedi farklı türü içeriyor –
• Kesmek
• NoMemoryError
• SignalException
• ScriptError
• Standart hata
• SystemExit
Bu seviyede Ölümcül başka bir istisna daha var ancak Ruby yorumlayıcısı bunu yalnızca dahili olarak kullanıyor.
ScriptError ve StandardError’da bir takım alt sınıflar vardır, ancak burada ayrıntılara girmeye gerek yoktur. Önemli olan, kendi istisna sınıflarımızı oluşturursak, ister istisna gerekse alt sınıflarından birinin alt sınıfları olması gerekir.
Bir örnek inceleyelim –
class FileSaveError < StandardError
attr_reader :reason
def initialize(reason)
@reason = reason
end
end
Şimdi, bu istisnayı kullanacak olan 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 çizgi, FileSaveError.new ($!) 'U yükseltmektir . Raise özel durumunun verilerin başarısız olmasına neden olmasının sebebi ile raise özelliğini bir FileSaveError örneğine geçirerek bildiririz.