Ruby (język programowania)

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.

Rozwój języka

Yukihiro Matsumoto, twórca Ruby

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

Składnia

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.

Cechy szczególne

Ruby posiada:

• automatyczne odśmiecanie pamięci
• iteratory
• przeciążanie operatorów (ang. operator overloading)
• normalne i zaawansowane właściwości zorientowania obiektowego (klasa, metoda ...)
• obsługa wyjątków (ang. exception handling)
• wyrażenia regularne wbudowane w składnię
• liczby całkowite o dowolnych rozmiarach
• dodawanie metod do instancji klasy - możliwa jest zmiana lub dodanie metody do instancji danej klasy
• bloki i lambdy (closures) - wygodne przekazywanie funkcji jako parametrów
• "Duck typing" - rozpoznawanie typów na podstawie ich zachowania, a nie deklaracji
• moduły - rodzaj wielodziedziczenia pozwalający włączyć gotową implementację zbioru metod do danej klasy
• możliwość zmiany praktycznie wszystkiego - dodanie dodatkowych metod do klasy Array, czy zmiana sposobu drukowania liczb całkowitych są niezmiernie proste.
• zmienne leksykalne modyfikowalne w czasie działania programu

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.

Przykłady

Zmienna liczba argumentów funkcji

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]]
    end
end
 
print reverse_array("!\n","ld","wor",", ","llo","He")

Argumenty domyślne

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")

Wyrażenia lambda

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

Domknięcia

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ęciu
end
 
f=fun
 
f.call      # 1
f.call      # 2

Bindings

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 binding
end
 
b1 = fun 10
b2 = fun 20
 
p eval("arg",b1)    # 10
p eval("arg",b2)    # 20

Kontynuacje

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]

Marshalling

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 a
c=Marshal.load b
 
print a.inspect, "\n"
print c.inspect, "\n"

Metody dodawane do obiektu

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"
    end
end
 
x=Foo.new
y=Foo.new
 
class << y
    def greet
        print "Goodbye, world!\n"
    end
end
 
x.greet
y.greet

Zobacz także

• Ruby on Rails

Linki zewnętrzne

Strony o Ruby

• Witryna projektu Ruby
• Witryna projektu Ruby - Polskie tłumaczenie
• Witryna poświęcona dokumentacji języka (ang. i inne)

Pomoce do nauki

• Wiki na temat języka Ruby (ang.)
• Ruby on Rails - platforma tworzenia aplikacji webowych w języku Ruby (ang.)
• Polska społeczność Ruby On Rails (pol.)
• Ruby on Rails PL - polski serwis poświęcony Ruby on Rails (pol.)