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
nullwww.ruby-lang.org/

Ruby to interpretowany, w pełni obiektowy oraz dynamicznie typowany język programowania zbudowany 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, z reguły 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 wedle statystyk sklepu Amazon dwie najpopularniejsze książki na temat Ruby oraz Ruby On Rails były najlepiej sprzedawanymi pozycjami z kategorii Programowanie.

30 stycznia 2009 roku była wydana wersja 1.9.1. Poprawia ona m.in. obsługę Unicode oraz 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 oraz 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 oraz 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 przeistoczenie albo dodanie metody do instancji danej klasy
• bloki oraz lambdy (closures) - wygodne przekazywanie funkcji jako parametrów
• "Duck typing" - rozpoznawanie typów na podstawie ich zachowania, a nie deklaracji
• moduły - odmiana wielodziedziczenia pozwalający włączyć gotową implementację zbioru metod do danej klasy
• możliwość zmiany praktycznie wszystkiego - dodanie dodatkowych metod do klasy Array, czy przeistoczenie 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ą wielokrotnie mniejsze niż analogiczne programy w Perlu, zachowując przy tym czytelność. Osiągnięte było to z reguły dzięki wszechobecnej obiektowej składni. Np. program, który wyświetla liczbę wielorakich 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 oraz 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 da się 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 oraz 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(*b1..-1)+b0
    end
end
 
print reverse_array("!\n","ld","wor",", ","llo","He")

Argumenty domyślne

Argumenty funkcji potrafią posiadać 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 da się 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 ma zasięg leksykalny zakresu, w którym było zbudowane (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 da się zamrozić stan danego zakresu leksykalnego oraz 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 albo 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 są kontynuacje (obiekty zachowujące adres kontekstu wykonania), pozwalają one na nielokalne skoki oraz powroty (np. da się wskoczyć w środek metody z całkowicie 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 da się po prostu zrzucić do łańcucha tekstowego, wysłać go albo 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

Sprawdź także

• Ruby on Rails

Linki zewnętrzne

Sprawdź publikację na Wikibooks:
Ruby

Strony o Ruby

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

Pomoce do nauki

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