RUBY EĞİTİM

$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.