Készítette Enyedi Tamás A Ruby programozási nyelv Készítette Enyedi Tamás

Bevezetés Nyílt forráskódú, interpretált, objektumorientált, általános célú programozási nyelv Dinamikus scriptnyelv (mint pl.: Python, Perl, Lisp) Multiparadigmák: funkcionális, objektumorientált, imperatív, reflektív Dinamikus típusosság Automatikus memóriakezelés Sok platformon működik Webes alkalmazások: Ruby on Rails

Nyelvi elemek Oda kell figyelni a tagolásra! Jelkészlet: ASCII karakterek, de lehetőség van Ucinode karakterek használatára is Azonosítók: (A-Za-z0-9_) Kommentek # egysoros komment (a sor végéig) Beágyazott dokumentáció: =begin Ezek között több sorba is írhatunk kommenteket. Azonban az első oszlopban kell kezdődnie. Beljebb kezdve már nem működik =end Literálok: numerikus, string(„”) és karakter(‘ ’) Minden változó, literál, vezérlési szerkezet, stb.. kifejezésnek minősül

Változók és konstansok Lokális változók Kisbetűvel (a-z), vagy (_) jellel kezdődnek Csak azon a blokkon belül érhetők el, ahol inicializálták Példányváltozók @ jellel kezdődnek pl.: @foo Magához az objektumhoz (self) tartoznak A nem inicializált példányváltozóknak az értéke nil Osztályváltozók @@ jellel kezdődnek pl.: @@foo Az osztály összes leszármazottja eléri Problémát okozhat, ha 2 leszármazottba ugyanazt a nevű osztályváltozót deklaráljuk (származási fa *first*)

Változók és konstansok /folytatás/ Globális változók $ karakterrel kezdődnek: $foo A program futási ideje alatt bárhol elérhetők Konstansok Csupa nagybetűvel írjuk, pl.: FOOBAR Többszörös értékadás lehetséges => warning Minden osztály konstans Ha nem inicializáljuk => NameError Pszeudó változók: self, nil, true, false, $1..$9 Vannak még előre definiált változók és konstansok is…

Típusok - Számok A Numeric osztályból származnak Minden Numeric típusú objektum megváltoztathatatlan Szokásos műveletek ( + , - , * , / , ** (hatványozás) ) Egész számok (Integer) Fixnum Bignum: nincs határa A _ jel elválasztásra szolgál, az interpreter nem veszi figyelembe pl: 1_234_567_890… Automatikus konvertálás Fixnum - Bignum között (oda-vissza) => nem fordulhat elő túlcsordulási hiba Megadhatjuk még: oktális formában (0-val kezdődik, pl: 05674) Bináris formában (0b… vagy 0B…, pl: 0b010110) Hexadecimális formában (0x… vagy 0X…, pl: 0xAF16B)

Típusok - Számok Valós számok (Float) Komplex számok BigDecimal A Ruby először Integer-ként akarja értelmezni a szám literálokat, ezért a felismerés érdekében legalább egy pontot, vagy egy exponenst kell írnunk a számba pl: 0.5, 1e0, stb. A . elé mindenképp kell írni számot (pl: a .5 nem értelmezett) Komplex számok BigDecimal tetszőleges pontosságú decimális szám Racionális számok Két Integer objektumból áll össze

Típusok - Stringek A Numerikus típusokkal ellentétben megváltoztathatók 2 azonos string literál – 2 különböző objektum 1.9-es verziótól Unicode kezelés Stringek aposztrófok között ‘valami’ escape karakter kell az ‘ (és opcionálisan) a \ jel elé Pl: ‘this is a string between two \’’ több soros is lehet, nem kell minden sor végén ‘ jel (automatikusan tartalmazni fogja a sortöréseket), csak a string legvégén

Típusok - Stringek Stringek idézőjelek között „valami” \n, \t, \u (Unicode karakterek), stb. Behelyettesítés (Interpolation): #{Ruby kifejezés} segítségével tetszőleges Ruby kifejezést behelyettesíthetünk a string-be példa: „1 + 2 = #{1+2}” => ”1 + 2 = 3” 2. példa: foobar = "blah” "the value of foobar is #{foobar}„ => "the value of foobar is blah"

Típusok - Stringek Stringek tetszőleges határoló karakterek között %q, vagy %Q karakter utáni első karakterrel kell lezárni a stringet Pl: %q_ezt a stringet \_ határolja_ A páros határoló karakterek ( () , [] , {} , <> ) csak a megfelelő irányban működnek (nem lehet )( , ][ , }{ , >< a sorrend) További annotációk: Modifier Meaning %r[ ] Interpolated Regexp (flags can appear after the closing delimiter) %i[ ] Non-interpolated Array of symbols, separated by whitespace (after Ruby 2.0) %I[ ] Interpolated Array of symbols, separated by whitespace (after Ruby 2.0) %w[ ] Non-interpolated Array of words, separated by whitespace %W[ ] Interpolated Array of words, separated by whitespace %x[ ] Interpolated shell command

Típusok - Stringek ‘Here Documents’ Karakter literálok (1.9-től) << jellel kezdődik és rögtön a kívánt határoló követi <<- jellel is kezdődhet, ilyenkor a lezáró határoló esetén figyelmen kívül hagyja a whitespace-eket Karakter literálok (1.9-től) x_karakter = ?x Vagyis a ?x == „x” string = <<END on the one ton temple bell a moon-moth, folded into sleep, sits still. END string = <<-END on the one ton temple bell a moon moth, folded into sleep, sits still. END

Típusok - Stringek Operátorok A konkatenáció a + jellel történik. Nincs automatikus konvertálás (to_s-t meg kell hívni) Pl: „Ez egy ” + „ konkatenáció.” A << jel összefűzést jelent, ilyenkor a balkifejezést megváltoztatja. Itt sincs automatikus konvertálás (to_s szükséges) Pl: N-szeres összefűzés: * operátorral concat = „konkatenáció” string = „Ez egy ” string << concat => „Ez egy konkactenáció” Str = „Foo” * 2 => „FooFoo”

Típusok - Stringek Karakterek és rész stringek manipulálása A [] operátor segítségével lehet elérni a string egyes részeit Negatív számot is megadhatunk, ilyenkor a végétől számítva adja vissza a nekünk kellő karaktert. Utolsó karakter: s[-1] Karakter megváltoztatása (string-et is kaphat értékül): s = „valami”, s[4]=„k” => s = „valaki”; ha s[4]=„mim”, akkor s=„valamimi” Rész string str[x,y]: x a pozíció (negatív is lehet), y pedig a kívánt hossz str[x..y]: x és y által meghatározott intervallumon lévő rész string Indexelés Stringgel is történhet Eredmény: az indexnek használt string első előfurdulása (ha nem fordul elő: nil) str=„ez egy valami”, str[„valami”]

A string és a Shell script kapcsolata A backquote karakterekkel határolt szöveget az interpreter mint egy shell scriptet végrehajtja és behelyettesíti az adott változóba var = `ls` esetén a var változóba bekerül az ls parancs eredménye

Reguláris kifejezések Stringek egy bizonyos halmazának a meghatározását segítik A Ruby-ba beépítve találjuk a ~ kezelését, nagyon megkönnyíti a mintaillesztést és a string-ek kezelését Létrehozásuk Konstruktor meghívásával: a = Regexp.new(‘minta’) b = /minta/ c = %r{minta} Mintaillesztés: Regexp.match metódusával Vagy az =~ (pozitív illeszkedés), vagy a !~ (negatív illeszkedés) operátor segítségével (pozíció, vagy nil visszatérési érték)

Típusok - Szimbólum Névvel ellátott azonosító Értékük nem változtatható meg Jelölés: :szimbólumnév :”több szóból álló szimbólum” Azonos nevű szimbólumok mindig azonos objektumot jelölnek Alkalmazhatóak minden olyan esetben, amikor valami álland dolgot akarunk átadni (pl: hashek kulcsai, enumok értékei)

Típusok – Tömbök Array osztály Az indexelés 0-tól kezdődik Létrehozás tomb = Array.new ( vagy röviden: tomb = [] ) Műveletek tomb = [„a”, „b”, „c”] tomb[0] # => „a” tomb[-2] # => „b” tomb[1,2] # => [„b”, „c”] tomb[0..1] # => [„a”, „b”] tomb[0…1] # => [„a”] #nem foglalja magába az intervallum végét array_one = [„apple”, „orange”, „pear”] # => ["apple", "orange", "pear"] array_two = 'apple orange pear'.split # => ["apple", "orange", "pear"] array_one == array_two # => true

Típusok - Hash Hash, azaz asszociatív tömb Indexelésükre tetszőleges objektum használható, azaz kulcs-érték párokat tartalmaz Létrehozás hash = Hash.new ( vagy röviden: hash = {} ) Műveletek hash_one = {"a" => 1, "b" => 2, "c" => 3} #=> {"a"=>1, "b"=>2, "c"=>3} a = { :a => 1, :b => 2, :c => 3} #=> {:b=>2, :c=>3, :a=>1} a = { a: 1, b: 2, c: 3} #=> {:b=>2, :c=>3, :a=>1} a.Keys # végig iterál a-n és megmutatja a kulcsokat => [:a, :b, :c] a.delete(:b) a[:b] = 435 # akkor :b a végére kerül => [:a, :c, :b]

Típusok - Range Az összes lehetséges értéket megadja egy kezdő és egy végpont között. Pl: Minden Integer 0 és 5 között: r1 = 0..5 Minden szám 0 és 1 között (1 már nem): r2 = 0.0…1.0 Minden karakter s és u között: r3 = ‘s’..’u’ Benne van-e az intervallumban az x érték? Az === operátor megmondja. r = 0..5 puts r === 4 # => true puts r === 7 # => false

Vezérlési szerkezetek - Elágazás Az if kifejezés Az if negálása helyett: az unless kifejezés if <feltétel> [then] # igaz ág end <kifejezés> if <feltétel> a = 5 a = 7 if a == 4 print a # 5-öt ír ki unless <feltétel> [then] end <kifejezés> unless <feltétel> a = 5 a = 7 unless a == 4 print a # 7-et ír ki

Vezérlési szerkezetek - Elágazás 2 If-elsif-else if kifejezés rövid formában if <kifejezés> <kód blokk> elsif <kifejezés> else end result = (feltétel) ? (kifejezés, ha igaz) : (kifejezés, ha hamis)

Vezérlési szerkezetek - Elágazás 3 Case szerkezet Szelektora egy Ruby kifejezés lehet A kifejezéseket az === operátorral értékeli ki (típus- és értékegyenlőséget vizsgál) case <kif.> when <kif.> then <kif.> [when <kif.> then <kif.> else <kif.> #default] end

Vezérlési szerkezetek - Ciklusok x.times (nem igazi ciklus) Elöltesztelős ciklus (while) until (addig fut, ameddig a kifejezés értéke hamis) Ciklusfeltétel csak logikai típusú lehet x.times do <kifejezés> end while <kifejezés> <kód blokk> end until <kifejezés> <kód blokk> end

Vezérlési szerkezetek – Ciklusok 2 A nyelvben van for ciklus, de ez kicsit más, mint a megszokott A ciklusmag a collection minden elemére lefut egyszer A collection lehet Range, tömb, stb. Végtelen ciklust while(true)… módon tudunk létrehozni for i in collection ... end

Kivételkezelés Szintaxisa a Javaéhoz hasonlít A kivételek paramétere egy string lehet to_s, to_str, vagy message metódussal kinyerhető a string paraméter Saját kivételt az Exception osztályból való származtatással/örökléssel tudunk létrehozni

Kivételek kiváltása Nem kell megvárni, míg a Ruby kiváltja a kivételeket Mi magunk is válthatunk ki kivételeket a raise kulcsszóval Paraméterei Paraméter nélkül az utolsó kivétel ismételt kiváltását eredményezi String paraméterrel Runtime Errort kapunk Kivételosztály, majd egy string Kivétel kiváltásakor a $! Változóba kerül az adott Exception példányra mutató hivatkozás def i_must_have_truth(value) raise TypeError, 'You must give me truth' if value == false end   i_must_have_truth false => `i_must_have_truth': You must give me truth (TypeError)

Kivételek kezelése A kivételek kezelése blokkszinten működik (begin-end között) A blokk végére írhatunk egy rescue részt, ezzel az előtte kiváltódott kivételeket tudjuk kezelni Az itt megadott raise újra kiváltja a kivételt ($!) A rescue után írt ensure tartalmazza a mindenképp végrehajtandó kódot (ha nincs kivétel, else ág) Begin 1/0 p 'I should never get executed’ rescue p 'I am rescuing an exception and can do what I want!’ End => "I am rescuing an exception and can do what I want!"

Metódusok A metódus Ruby-ban kifejezések halmaza, ami visszaad egy értéket. Explicit módon return-nel visszatérhetünk (megj.: return blokkban) Vagy az utoljára kiértékelt kifejezés értékével tér vissza (nil is lehet) Paraméterátadás: csak érték szerinti van Hívás idejű a paraméterek (és a függvényeinek) vizsgálata Azaz 2 azonos interfészű objektum egymással helyettesíthető (pl: print) még akkor is, ha nem a közös interfész alapján hivatkozunk rájuk Nincs túlterhelés

Metódusok 2 Metódus definiálása Metódushívás A paramétereknek adhatunk default értéket is Például: def add(x,y) x + y End add(5,6) => 11 def method_name(params) <kifejezés(ek)> end method_name(parameter1, parameter2,…) method_name def some_method(value='default', arr=[]) puts value puts arr.length end some_method('something') =>something

Metódusok 2 A * operátor A metódus utolsó paraméterét elláthatjuk *-gal, ekkor a megadott paramétereken felül megadhatunk plusz paramétereket meghíváskor A plusz paraméterek egy tömbbe kerülnek def calculate_value(x, y, *otherValues) puts otherValues end calculate_value(1,2,'a','b','c') ['a', 'b', 'c'] Ugyanezt kapjuk ezen a módon is: arr = ['a','b','c'] calculate_value(*arr)

Metódusok 3 Az & operátor A metódus paraméterét elláthatjuk & jellel, ekkor egy blokkot vár A blokkot átalakítja Proc-cá (Procedure). def describe(&block) "The block that was passed has parameters: #{block.parameters}” end describe{ |a,b| } => "The block that was passed has parameters: [[:opt, :a], [:opt, :b]]"

Metódusok 5 – Proc(edúra) Többször is fel szeretnénk használni ugyanazt a blokkot? Akkor használjunk Proc-okat! A procedúra tulajdonképpen egy blokk azzal a különbséggel, hogy a procedúrákat változókba tudjuk menteni, ezáltal többször is fel tudjuk használni def method_call yield end method_call(&someBlock)

Köszönöm a figyelmet! Vége