| Ruby | |
 | |
| Pojawienie się | 1995 |
| Paradygmat | wieloparadygmatowy |
| Typowanie | dynamiczne (duck typing) |
| Implementacje | Ruby MRI, YARV, JRuby, Rubinius, IronRuby |
| Aktualna wersja stabilna | 1.9.2-p290 15 sierpnia 2010 |
| Twórca | Yukihiro Matsumoto |
| Licencja | Ruby, GNU GPL |
| Platforma sprzętowa | wieloplatformowy |
| Platforma systemowa | wieloplatformowy |
| http://www.ruby-lang.org/ | |
Ruby to interpretowany, w pełni obiektowy i dynamicznie typowany język programowania stworzony w 1995 roku przez Yukihiro Matsumoto (pseudonim Matz). W języku angielskim ruby oznacza rubin.
Spis treści |
Od roku 2003 lawinowo zdobywa nowych zwolenników, głównie za sprawą popularnego frameworku do tworzenia aplikacji webowych o nazwie Ruby on Rails, tworzonego przez grupę programistów pod kierownictwem Davida Heinemeiera Hanssona.
W roku 2005 według statystyk sklepu Amazon dwie najpopularniejsze książki na temat Ruby i Ruby On Rails były najlepiej sprzedawanymi pozycjami z kategorii Programowanie.
30 stycznia 2009 roku została wydana wersja 1.9.1. Poprawia ona m.in. obsługę Unicode i wydajność interpretera, dzięki wprowadzeniu nowego mechanizmu o nazwie YARV (ang. Yet Another Ruby VM).
Ruby bazuje na wielu językach, takich jak CLU, Eiffel, Lisp, Perl, Python czy Smalltalk. Składnia jest zorientowana liniowo i oparta na składni CLU oraz, w mniejszym stopniu, Perla.
Ruby posiada:
Podobnie jak w Perlu, programy napisane w Ruby są małe - ten sam program, który w C czy Javie zajmie setki linijek, w Ruby czy Perlu zajmie zwykle kilkadziesiąt. W Ruby programy są często mniejsze niż analogiczne programy w Perlu, zachowując przy tym czytelność. Osiągnięte zostało to głównie dzięki wszechobecnej obiektowej składni. Np. program, który wyświetla liczbę różnych linijek bez względu na rozmiar liter, wygląda tak:
puts STDIN.map{|s| s.downcase}.uniq.size
Programy pisane w Ruby charakteryzują się wysoką przenośnością pomiędzy platformami (istnieją implementacje na wiele systemów Uniksowych, DOS, Windows, Mac OS X, BeOS itd.).
Ruby jest rozwijany jako otwarte oprogramowanie i dostępny na licencji GPL oraz na własnej licencji wymagającej zmiany nazw plików wykonywalnych w przypadku zamknięcia kodu.
Ruby ma bardzo ciekawy sposób przekazywania zmiennej liczby argumentów do funkcji. Ostatni parametr można zacząć od znaku *, co oznacza, że dowolna liczba parametrów zostanie przekształcona w tablicę. Można też w drugą stronę - tablicę przekształcić w listę argumentów (zarówno dla funkcji o stałej jak i dla funkcji o zmiennej liczbie argumentów) umieszczając znak * na początku:
def reverse_array(*b) if b.size == 1 return b else return reverse_array(*b[1..-1])+[b[0]] endend print reverse_array("!\n","ld","wor",", ","llo","He")
Argumenty funkcji mogą mieć domyślne wartości. W poniższym przykładzie pierwszy parametr - greeted - ma nadpisaną wartość "people", a drugi - greeting - zostaje z domyślnym "Hello".
def greet(greeted="world",greeting="Hello") greeting + ", " + greeted + "!\n"end print greet("people")
W Ruby można konstruować anonimowe funkcje za pomocą wyrażeń lambda. Wywołuje się je za pomocą metody call.
add2 = lambda {|x| x+2} print add2.call(10), "\n" # 12 def addX(x) lambda {|y| y+x}end add3=addX(3)print add3.call(10), "\n" # 13
Każde wyrażenie lambda posiada zasięg leksykalny zakresu, w którym zostało stworzone (tak więc jeśli w bloku domknięcia użyjemy zmiennej lokalnej, będzie ona istnieć do chwili destrukcji samego wyrażenia lambda).
def fun a=0 # zmienna lokalna lambda{p a+=1} # uchwycenie zmiennej lokalnej w domknięciuend f=fun f.call # 1f.call # 2
W Ruby w każdej chwili można zamrozić stan danego zakresu leksykalnego i zachować referencję do niego. Następnie możemy odwołać się do wartości zmiennych (nawet lokalnych), które już dawno zmieniły swój stan lub przestały istnieć (leksykalnie)
def fun arg # w tym zakresie mamy zmienną lokalną arg return bindingend b1 = fun 10b2 = fun 20 p eval("arg",b1) # 10p eval("arg",b2) # 20
W Ruby istnieją kontynuacje (obiekty zachowujące adres kontekstu wykonania), pozwalają one na nielokalne skoki i powroty (np. można wskoczyć w środek metody z zupełnie innego kontekstu)
def fun arg p "fun called" callcc{|$cc|} # zachowujemy kontekst wykonania arg.shift end tab=[1,2,3,4,5] fun tab $cc.call if tab.size > 2 # nielokalny skok p tab output: "fun called" [3,4,5]
W Ruby nawet bardzo skomplikowane dane można po prostu zrzucić do łańcucha tekstowego, wysłać go lub zachować do pliku, po czym wczytać ponownie. b w poniższym przykładzie to zwykły łańcuch tekstowy.
a=["hello",["world"]]b=Marshal.dump ac=Marshal.load b print a.inspect, "\n"print c.inspect, "\n"
Każdy obiekt może nadpisać metody danej klasy - właściwie każdy obiekt jest pseudoklasą (tzw. singleton class). W poniższym przykładzie metoda greet obiektu y zostaje nadpisana.
class Foo def greet print "Hello, world!\n" endend x=Foo.newy=Foo.new class << y def greet print "Goodbye, world!\n" endend x.greety.greet
| ||||||||||||||||||||||||||||||||||||||||||||||||||
