Ruby

A Wikipédiából, a szabad enciklopédiából.

(Ruby programozási nyelv szócikkből átirányítva)

A Ruby egy teljesen objektum-orientált interpretált nyelv. Minden komolyabb platformon működik (természetesen interpretere telepítése után). Ingyenes (free software), nyilvános forrású (open source). Egyebek mellett alkalmas ablakos alkalmazások készítésére (a Tcl/Tk segítségével), és webes alkalmazásokra is (Ruby on Rails).

Tartalomjegyzék

[szerkesztés] Filozófia, ízelítő

Alapjellegét a célirányos objektumorientáltsága határozza meg. Minden objektum. Még egy szám is. Pl. az, hogy 5, ez egy objektum, s mint ilyennek, vannak saját függvényei, eljárásai. Pl. ha az 5-öt, mint egész számot (ami ugye objektum!), át akarod alakítani szöveggé (ez esetenként igen fontos, hiszen a nyelv alapvetően típusos), akkor pl. nem ilyen jellegű függvényt kell használni: IntToStr(5) – ahol az 5 bemeneti paraméter, hanem 5.to_s.

A nyelv típusossága ellenére azonban függvénydefiníciókor nem kell meghatározni a bemeneti (és kimeneti) változók típusát. Egy függvény definíciója pl így nézhet ki:

def osszeadas a, b
  return a + b
end

Ennek meghívása így történhet:

osszeadas 1, 2            => 3

Talán feltűnik az is, hogy a függvény definíciójánál és meghívásánál a paramétereket nem kell zárójelbe tenni. Pontosabban ez opcionális lehetőség, értelme ott van, amikor egyébként nem lehetne eldönteni, hogy a paraméterek mely függvényhez tartoznak. pl.

osszeadas 1, 2 * 3        => 7

de

osszeadas(1, 2) * 3       => 9

(Ilyenkor azonban erősen javallják, hogy a függvény neve és a paramétereit tartalmazó zárójel között ne maradjon szóköz)

További sajátossága (típusosságából adódóan) az, hogy nem végez automatikus típuskonverziót. Még számok között sem. Pl.:

1 / 2                     => 0

mert ő úgy gondolja, hogy ha az osztandó és az osztó is egész, akkor a hányados is az kell legyen, tehát kerekít. De:

1.0 / 2                   => 0.5
1 / 2.0                   => 0.5

Ha egy változóval van bajunk, amiről nem tudjuk ránézésre, hogy milyen típusú, de törtté akarjuk osztani, a legelegánsabb megoldás ez:

a = 1
a.to_f / 2                => 0.5

Itt ugye a to_f függvény valós számmá alakította az a változót.

Ami a változókat illeti: nem kell deklarálni őket, bárhol be lehet vezetni, és a láthatósági tartományokon belül elérhetőek. A változók elé nem kell semmilyen speciális karaktert tenni (mint php-ben a $), viszont a nagybetűvel kezdődő kifejezéseket szigorúan konstansnak vagy osztálynak akarja felfogni. Pl.

A = 3                     => ez rendben van, rögzített egy A konstanst
A = 4                     => idézem: „warning: already initialized constant A”

A sorokat nem kell pontosvesszővel lezárni, de lehet. Ennek akkor van értelme, ha több utasítás van ugyanabban a sorban. Ekkor a pontosvessző utasításelválasztóként fungál.

[szerkesztés] Telepítése

[szerkesztés] Linux

Tapasztalatok szerint alapból benne van, de ha mégse, akkor

sudo apt-get install ruby

Ha alapból nem tenné fel, érdemes továbbá telepíteni az irb-t is, ami egy igen kellemes parancssori interpreter.

[szerkesztés] Windows

Le kell tölteni a telepítőállományt a http://rubyforge.org/frs/?group_id=167 oldalról, és futtatni kell.

[szerkesztés] Mac OSX

Feltelepítve tartalmazza az operációs rendszer.

[szerkesztés] IRB - az Interaktív Ruby Shell

Gyors és egyszerű módját nyújtja kisebb Ruby kódok kipróbálásának. Minden soremelés(enter) vagy ciklus vége (end) után elvégzi a beírt kód kiértékelését és eredményét kiírja a szabványos kimenetre.

[szerkesztés] Meghívása

Unix alapú rendszerekben parancsorból az irb paranccsal:

>irb
irb(main):001:0> p (1/2).class
Fixnum
=> nil

[szerkesztés] A nyelvről szakszerűen

[szerkesztés] Osztályok

Az osztályok nevét mindig nagybetűvel kell kezdeni, mivel konstansoknak számítanak

Példa osztály létrehozására:

class HelloClass
 def koszontes
  puts "Helló világ!"
 end
end

Minden létrehozott osztály egy ősosztályból, az Object-ből származik, így örökli ezen metódusait.

[szerkesztés] Példányosítás, Objektumok létrehozása

Az osztályok konstruktorának mindig az initialize metódus számít:

class CreateObject
 def initialize
  puts "Objektum létrehozása"
 end
end

Objektum létrehozása a new metódussal. A fenti példánál maradva:

A = CreateObject.new() => "Objektum létrehozása"

[szerkesztés] Osztálymetódusok létrehozása, meghívása

A létrehozott osztályunk metódusai alapesetben példányosítás nélkül nem hívhatóak meg, ezt írhatjuk felül a metódus elé tett "self." jelölővel.

class InkrementaloOsztaly
 def self.inkrementald szam
  szam += 1
 end
end

puts InkrementaloOsztaly.inkrementald(5) => 6

[szerkesztés] A létrehozott osztályok bármikor kibővíthetőek, metódusaik felülbírálhatóak

class A
 def self.b
  p "valami"
 end
end
A.b => "valami"

class A
 def self.b 
  p "inkabb mas"
 end
end
 A.b => "inkabb mas".

[szerkesztés] Feltételes szerkezete, ciklusok

[szerkesztés] If (ha)

A más nyelvekben megszokotthoz hasonlóan is lehet használni, pl:

if a < b then
   c = -1
elsif a == b
   c = 0
else
   c = 1
end

Szintaktikai jellemzők:

  • a feltételvizsgálatot nem kötelező zárójelbe tenni, persze ha összetett, az egyértelműség kedvéért érdemes csoportosítani
  • a then szót nem kötelező kiírni, csak akkor, ha a végrehajtandó utasítás azonos sorban van (az end ekkor is kötelező)

Megjegyzés: a fenti példa kizárólag didaktikai célra használandó. Ugyanis ugyanezt a tevékenységet elvégzi a <=> összehasonlító operátor is, amely három értéket adhat vissza (-1, ha a bal oldal kisebb, 0, ha egyenlő, 1, ha nagyobb).

1 <=> 0                   => 1
1 <=> 1                   => 0
1 <=> 2                   => -1

Alternatív használat: a feltételt a végrehajtandó utasítás után is írhatjuk!

puts 'de jó' if 1 > 0     => de jó

Ha arra van szükségünk, a feltételvizsgálat értéket is tud visszaadni, például:

kimenet = if a < b then
              -1
          elsif a == b
              0
          else
              1
          end

Ha viszont csak ha-különben esettel van dolgunk, van ennek egy rövidített formája is:

kimenet = a < b ? a : b

(a feltételt a ? zárja, a két lehetséges kimenetet pedig : választja el, ezen belül persze bármilyen kifejezés szerepelhet, ami kimenetet produkál, akár függvényhívás is)

[szerkesztés] Unless (ha nem)

Létezik az if fordítottja is, az unless is. Ez értelemszerűen akkor fut le, ha a vizsgált kifejezés hamis. Példák:

unless 1 < 2
    er = 1
else
    er = 2
end

A unless után is használhatjuk a then-t, ha ugyanabban a sorban akarjuk folytatni (egyébként nem kötelező).

kim = unless 1 < 0 then 1 else 2 end

Nyílván az unless is használható az utasítás után.

a = 1 unless a == 1

Ez persze ekvivalens ezzel:

a = 1 if a != 1

Kinek melyik tetszik jobban!

[szerkesztés] While (amíg)

Amíg a feltétel igaz, végrehajtja a végrehajtani valót. Szerkezete igen egyszerű:

a = 0
while a < 10
  a += 1
  puts a
end

=> 1 2 3 4 5 6 7 8 9 10

[szerkesztés] Kivételkezelés

[szerkesztés] Beépített osztályok

[szerkesztés] A nyelv alkalmazása

[szerkesztés] Külső hivatkozások

[szerkesztés] Angolul

[szerkesztés] Magyarul

A lap eredeti címe: „http://hu.wikipedia.org/wiki/Ruby”
Személyes eszközök