A Ruby adattípusainak áttekintése

Preslav Dobrev2022-10-24 · 11 min read

Ruby egy jól ismert programozási nyelv. Célja az egyszerűség és a termelékenység növelése. Emellett egy teljesen objektumorientált programozási nyelv is. Ráadásul a Ruby olyan elegáns szintaxissal rendelkezik, amelyet természetes olvasni és könnyű írni.

Minden programozás megköveteli a különböző adattípusok kezelését. Az adattípus az adatok egy meghatározott osztályát írja le. Megmondja a gépnek, hogyan kell kezelnie az adatokat a programban. Az adattípusok döntő fontosságúak annak meghatározásában, hogy mit lehet tenni az adatokkal (beleértve az elvégezhető műveleteket is). Ebben az útmutatóban mélyebben elmerülünk a Ruby-ban elérhető adattípusokban. Megvizsgáljuk a dinamikus típusosságot is. Ezzel a funkcióval a Ruby automatikusan meg tudja határozni egy változó adattípusát anélkül, hogy azt kifejezetten deklarálnánk. Kezdjük el!

Előfeltételek

Az ebben az útmutatóban bemutatott lépések gyakorlásához és megvalósításához a következő összetevőkre lesz szüksége:

Egy megfelelően konfigurált Linux rendszer. Tudjon meg többet a(z) személyes Ubuntu szerver beállításáról a CloudSigma-n.
Egy megfelelően konfigurált Ruby fejlesztői környezet. Tekintse meg a(z) hivatalos dokumentációt a Ruby Ubuntu-ra történő telepítéséről (APT használatával).

Adattípusok a Ruby-ban

A Ruby tartalmazza az összes olyan gyakori adattípust, amellyel bármely programozási nyelvben találkozhat: egészek, lebegőpontos számok, karakterláncok, tömbök, szimbólumok, hashek stb. A következőkben áttekintést nyújtunk arról, hogyan dolgozhat a Ruby különböző adattípusaival.

1. lépés – Egész számok

A matematikához hasonlóan az egész számok a számítógépes programozásban egész számok. Az érték lehet pozitív, negatív vagy 0. Az értéktartomány a következő:

 {-∞, …, -1, 0, 1, …, ∞}

1	{-∞, …, -1, 0, 1, …, ∞}

Itt az ideje, hogy kipróbálja az egész számokat a Ruby-ban. Az első példa egy egyszerű egész szám kiíratása a képernyőre:

print 99
print "\n"

1 2	print 99 print "\n"

Ezután egy egész változóval fogunk dolgozni. Itt a(z) sample_int változó egy egész értéket (99) tartalmaz, és a print függvény kiírja a változó értékét a képernyőre:

sample_int = 99
print sample_int
print "\n"

sample_int = 99

print sample_int

print "\n"

Matematikai műveleteket is végezhetünk egész számokkal. A következő példa két egész szám egyszerű összeadását mutatja be:

sample_int = 99 + 100
print sample_int
print "\n"

sample_int = 99 + 100

print sample_int

print "\n"

Amikor nagy számokkal dolgozunk, gyakran használunk vesszőket (,) az olvashatóság megkönnyítésére. Például az egymilliót (1000000) a jobb olvashatóság érdekében 1,000,000-ként írjuk. Bár a vesszők használata tilos, a Ruby lehetővé teszi az aláhúzásjelek ( _) használatát elválasztóként. Tekintse meg a következő példát:

sample_int = 1_000_999
print sample_int
print "\n"

sample_int = 1_000_999

print sample_int

print "\n"

Az aláhúzásjelek használata javítja a kód olvashatóságát, különösen nagy egész értékek esetén.

2. lépés – Lebegőpontos számok

A lebegőpontos szám (vagy röviden float) egy valós számot képvisel. A matematikai definícióhoz hasonlóan a valós számok lehetnek racionálisak vagy irracionálisak. A Ruby-ban a float alapvetően egy tizedespontot tartalmazó szám.

Próbáljunk meg kiíratni egy lebegőpontos értéket a képernyőre:

print 55.66
print "\n"

1 2	print 55.66 print "\n"

A következő példa egy lebegőpontos változó deklarálását mutatja be:

sample_float = 55.66
print sample_float
print "\n"

sample_float = 55.66

print sample_float

print "\n"

Különböző matematikai műveleteket is végezhetünk a lebegőpontos értékeken és változókon. A következő példa két lebegőpontos szám egyszerű összeadását mutatja be:

sample_float = 55.66 + 99.222
print sample_float
print "\n"

sample_float = 55.66 + 99.222

print sample_float

print "\n"

Mi történik, ha egy lebegőpontos számot és egy egész számot adunk össze? A kapott érték lebegőpontos lesz. A következő példában annak ellenére, hogy az 55.0 egy egész szám, lebegőpontosként kezelendő:

sample_float = 55.0 + 10
print sample_float
print "\n"

sample_float = 55.0 + 10

print sample_float

print "\n"

3. lépés – Logikai típus (Boolean)

A logikai értékek (Boolean) a matematika logikai ágának igazságértékeit képviselik. A Ruby-ban a logikai adattípusokat két érték képviseli: true és false:

Nagyobb, mint
- 100 > 99: true
- 99 > 100: false
Kisebb, mint
- 500 < 999: true
- 999 < 500: false
Egyenlő
- 10 == 10: true
- 9 == 99: false

A számokhoz hasonlóan tárolhatunk egy true vagy false értéket egy változóban. A következő példa bemutatja ezt a funkciót:

result = 9 == 99
print result
print "\n"

result = 9 == 99

print result

print "\n"

4. lépés – Karakterláncok

A programozásban a karakterlánc karakterek (betűk, számok és szimbólumok) sorozataként jelenik meg. Ruby-ban a karakterláncok egyszeres idézőjelek ( ') vagy dupla idézőjelek ( ") között állnak. Már részletesen foglalkoztunk a karakterláncok használatával Ruby-ban, így ez egy rövid szakasz lesz.

A következő példa egy egyszerű hello world program Ruby-ban:

print "hello world!\n"

1	print "hello world!\n"

A karakterláncokat változókban is tárolhatjuk. A következő példa a karakterláncok összefűzését is bemutatja:

username = "Cloudsigma"
print "hello, " + username + "!\n"

1 2	username = "Cloudsigma" print "hello, " + username + "!\n"

5. lépés – Tömbök

A tömb egy olyan adatszerkezet, amely azonos adattípusú elemek rögzített méretű gyűjteményét képes tárolni. Úgy is elképzelhető, mint azonos adattípusú változók gyűjteménye. Ez az egyik legalapvetőbb adatszerkezet a legtöbb modern programozási nyelvben.

Ruby-ban a tömböt a következőképpen definiáljuk:

[value_1, value_2, …, value_N]

1	[value_1, value_2, …, value_N]

Lehetséges tömböt létrehozni bármely más, eddig tárgyalt adattípusból is (egész szám, lebegőpontos szám és karakterlánc). Íme néhány példa:

Egész szám: [-5, 0, 5]
Lebegőpontos szám: [-9.99, -6.99, -3.99, 0, 3.99]
Karakterlánc: [“the”, “quick”, “brown”, “fox”]

A következő példa mindezen tömbtípusokat megvalósítja:

print [-5, 0, 5]
print "\n"
print [-9.99, -6.99, -3.99, 0, 3.99]
print "\n"
print ["the", "quick", "brown", "fox"]
print "\n"

print [-5, 0, 5]

print "\n"

print [-9.99, -6.99, -3.99, 0, 3.99]

print "\n"

print ["the", "quick", "brown", "fox"]

print "\n"

Vegye figyelembe, hogy amikor a print függvény tömbbel találkozik, a teljes tömböt kiírja a képernyőre. A nagyobb kényelem érdekében a tömbökkel gyakran változókként fog találkozni. Frissítsük a kódot:

array_int = [-5, 0, 5]

print array_int
print "\n"
array_float = [-9.99, -6.99, -3.99, 0, 3.99]
print array_float
print "\n"
array_string = ["the", "quick", "brown", "fox"]
print array_string
print "\n"

array_int = [-5, 0, 5]

print array_int

print "\n"

array_float = [-9.99, -6.99, -3.99, 0, 3.99]

print array_float

print "\n"

array_string = ["the", "quick", "brown", "fox"]

print array_string

print "\n"

Most már dolgozhatunk a tömbök egyes elemeivel:

array_int = [-5, 0, 5]
print array_int[2]
print "\n"
array_float = [-9.99, -6.99, -3.99, 0, 3.99]
print array_float[1]
print "\n"
array_string = ["the", "quick", "brown", "fox"]
print array_string[3]
print "\n"

array_int = [-5, 0, 5]

print array_int[2]

print "\n"

array_float = [-9.99, -6.99, -3.99, 0, 3.99]

print array_float[1]

print "\n"

array_string = ["the", "quick", "brown", "fox"]

print array_string[3]

print "\n"

Vegye figyelembe, hogy Ruby-ban a tömbök indexelése 0-val kezdődik.

A kényelem érdekében a Ruby tömbjei rendelkeznek a .first és a .last metódusokkal, amelyek kiírják az első és az utolsó elemet:

array_float = [-9.99, -6.99, -3.99, 0, 3.99]
puts array_float.first
puts array_float.last
print "\n"

array_float = [-9.99, -6.99, -3.99, 0, 3.99]

puts array_float.first

puts array_float.last

print "\n"

A Ruby-ban a tömböknek van egy másik érdekes tulajdonságuk is. Egyszerre különböző típusú adatokat is tartalmazhatnak. Például tárolhat bennük karakterláncokat, szimbólumokat és akár más tömböket is:

mixed_array = [
        "hello",
        99.99,
        "world",
        [
            "the",
            "quick",
            "brown",
            "fox"
        ]
    ]

print mixed_array
print "\n"

print mixed_array[3]
print "\n"

mixed_array = [

"hello",

99.99,

"world",

[

"the",

"quick",

"brown",

"fox"

]

print mixed_array

print "\n"

print mixed_array[3]

print "\n"

6. lépés – Szimbólumok

A Rubyban a szimbólum egy speciális adattípus, amely címkeként vagy azonosítóként működik. A szimbólumok megváltoztathatatlanok, ami azt jelenti, hogy nem módosíthatók. A szimbólumok úgy jelennek meg, mintha érték nélküli változókat deklarálnánk.

Íme egy példa egy szimbólumra:

:time_zone

1	:time_zone

Általában a szimbólumokat valami fontos azonosítására használják. Más helyzetekben azonban a karakterláncok is bőségesen elegendőek.

A Ruby, mint objektumorientált nyelv, mindent objektumként kezel (beleértve a karakterláncokat is) saját egyedi memóriahelyével, még akkor is, ha a karakterláncok azonosak. Amikor azonban egy szimbólumra hivatkozik, az a programban mindenhol ugyanaz az objektum, ugyanaz a memóriahely.

7. lépés – Hashek

A hash kulcsok és értékek szótárszerű gyűjteménye. A hasheket gyakran használják kapcsolódó adatok tárolására, például egy felhasználó adataira.

Íme egy gyors példa egy hash-re. Létrehoztunk egy user_info hasht, amely egy felhasználó felhasználónevét és jelszavát tartalmazza:

user_info = {
"username" => "HelloWorld999",
"password" => "password123"
}
print user_info
print "\n"

user_info = {

"username" => "HelloWorld999",

"password" => "password123"

}

print user_info

print "\n"

Egy kulcs-érték pár értékeinek lekéréséhez a kulcsot kell használnunk. A következő példa ezt a folyamatot mutatja be:

user_info = {
"username" => "HelloWorld999",
"password" => "password123"
}

print user_info["username"]
print "\n"

user_info = {

"username" => "HelloWorld999",

"password" => "password123"

}

print user_info["username"]

print "\n"

A Ruby lehetővé teszi a hash definiálását kissé eltérő szintaxisokkal is ( : ahelyett, hogy =>):

user_info = {
username: "HelloWorld999",
password: "password123"
}
print user_info[:password]
print "\n"

user_info = {

username: "HelloWorld999",

password: "password123"

}

print user_info[:password]

print "\n"

Ez a szintaktikai szerkezet hasonló a más nyelvekben használt szintaxishoz, például a JavaScript nyelvben. Ebben a szintaktikai szerkezetben a kulcsok szimbólumként vannak definiálva. Ezért ahelyett, hogy a "username" kulcsot használnánk, a következőt használjuk: username az érték eléréséhez.

Dynamic Typing

Már észrevehette, hogy egy változó deklarálásakor nem kell kifejezetten adattípust hozzárendelnünk. Ehelyett a változó értéke határozza meg az adattípust. A Ruby dynamic typing használ, ahol a típusellenőrzés futási időben történik. Ezzel szemben a static typing programozási nyelvekben (például C/C++) az adattípusok a fordítás során dőlnek el.

A következő példában a dyn_var változóhoz rendelt összes érték érvényes:

dyn_var = 123
dyn_var = 456.789
dyn_var = true
dyn_var = "the quick brown fox"
dyn_var

dyn_var = 123

dyn_var = 456.789

dyn_var = true

dyn_var = "the quick brown fox"

dyn_var

A dinamikusan típusos nyelvekben szabadon újrahasználhatunk egy meglévő változót különböző adattípusok tárolására. Itt az előző példát frissítettük, hogy bemutassuk ezt a jelenséget:

dyn_var = 123
puts dyn_var
dyn_var = 456.789
dyn_var = true
dyn_var = "the quick brown fox"
puts dyn_var
dyn_var

dyn_var = 123

puts dyn_var

dyn_var = 456.789

dyn_var = true

dyn_var = "the quick brown fox"

puts dyn_var

dyn_var

Amint ez a példa mutatja, minden alkalommal, amikor új értéket rendelünk hozzá, az menet közben megváltoztatja a dyn_var adattípusát. Ez hasznos, amikor egyik adattípust konvertáljuk egy másikra. A következő példa ezt mutatja be:

print "enter length: "
length = gets.chop
length = length.to_f
puts length

print "enter length: "

length = gets.chop

length = length.to_f

puts length

Itt,

Mivel a billentyűzetről érkező bemenetek karakterláncok, a length először egy karakterlánc.
Mivel a kívánt értékünk egy lebegőpontos szám (float), a karakterlánc értékét lebegőpontos számmá konvertáljuk a to_f metódus segítségével.
Az érték változása miatt a length változó a float adattípust kapja. Ezt látjuk, amikor kiíratjuk az értékét a képernyőre.

Mi történne, ha két különböző adattípust próbálnánk meg keverni? A Ruby hibát fog dobni. Nézze meg:

print 9 + "77"

1	print 9 + "77"

Adattípus azonosítása

A Rubyban mindent objektumként kezelünk. Minden objektum a Rubyban rendelkezik a class. Meghívásakor ez a metódus megmondja, hogy mi a forrás adattípusa. Íme néhány példa a class metódus használatára:

puts 55.class
puts (55.55).class
puts true.class
puts nil.class

puts 55.class

puts (55.55).class

puts true.class

puts nil.class

Az adattípus meghatározásának egy másik módja a kind_of? metódus használata. Ez összehasonlítja az objektum adattípusát a kért adattípussal, és egy Boolean értéket ad vissza. Nézd meg a következő példában:

puts 55.kind_of?(Float)
puts 55.kind_of?(Integer)

1 2	puts 55.kind_of?(Float) puts 55.kind_of?(Integer)

Hasonlóképpen, létezik egy másik metódus is, a is_a?, amely összehasonlítja az adattípust, és egy Boolean értéket ad vissza. Az egyetlen különbség a metódus neve. Ez azonban előnyösebb lehet, mert a fejlesztők számára kicsit könnyebben olvasható és értelmezhető. Frissítsd az előző példát a is_a?:

puts 55.is_a?(Float)
puts 55.is_a?(Integer)

1 2	puts 55.is_a?(Float) puts 55.is_a?(Integer)

Záró gondolatok

Bármely programozási nyelvvel való munka megköveteli az általa támogatott adattípusok jó megértését. Ebben az útmutatóban a Ruby programozásban leggyakrabban használt adattípusokat jártuk körül. Megbeszéltük és bemutattuk az egészeket (integer), lebegőpontos számokat (float), karakterláncokat (string), szimbólumokat (symbol), logikai értékeket (Boolean) és hasheket (példákkal).

Tekintsd meg blogunk további oktatóanyagait, amelyek segítenek a Ruby felfedezésében:

Kellemes kódolást!

Preslav Dobrev

Szerző · CloudSigma

Preslav Dobrev a CloudSigma kreatív tervezője, aki hagyományos és innovatív marketingcsatornák segítségével következetes vállalati identitás kialakítására összpontosít. Kiemelkedően képes ötvözni a művészi látásmódot a stratégiai marketinggel, hogy hatásos márkatörténeteket hozzon létre.

A Ruby adattípusainak áttekintése

Előfeltételek

Adattípusok a Ruby-ban

1. lépés – Egész számok

2. lépés – Lebegőpontos számok

3. lépés – Logikai típus (Boolean)

4. lépés – Karakterláncok

5. lépés – Tömbök

6. lépés – Szimbólumok

7. lépés – Hashek

Dynamic Typing

Adattípus azonosítása

Záró gondolatok

Preslav Dobrev

Hozzászólások